Initial commit

270 files changed, 205567 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..ee7098f
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+zig-out/
+zig-cache/
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..bc8b574
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) dec05eba
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..d0ea23e
--- /dev/null
+++ b/README.md
@@ -0,0 +1 @@
+libxcb build for zig. Includes libxcb source code which is compiled from source. If you include this library in your zig project and build with `zig build -Doptimize=ReleaseSmall -Dtarget=native-linux-musl -Dcpu=baseline` then it will create a very small (75kb) static executable that is redistributable.
\ No newline at end of file
diff --git a/build.zig b/build.zig
new file mode 100644
index 0000000..0eaabc7
--- /dev/null
+++ b/build.zig
@@ -0,0 +1,184 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const lib = b.addStaticLibrary(.{
+        .name = "zig-xcb",
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const single_threaded = true;
+    const libXcb = buildXcb(b, &target, optimize, single_threaded);
+
+    lib.linkLibrary(libXcb);
+    lib.addIncludePath(.{ .path = "depends/libxcb/include" });
+    lib.addIncludePath(.{ .path = "depends/libxcb-keysyms" });
+    lib.addIncludePath(.{ .path = "depends/libxcb/depends/xorgproto/include" });
+    lib.addIncludePath(.{ .path = "depends/libxcb-render-util" });
+    lib.linkLibC();
+    lib.strip = optimize != std.builtin.OptimizeMode.Debug;
+    lib.want_lto = optimize != std.builtin.OptimizeMode.Debug;
+    lib.single_threaded = single_threaded;
+
+    lib.installHeadersDirectory("depends/libxcb/include", ".");
+    lib.installHeadersDirectoryOptions(.{
+        .source_dir = .{ .path = "depends/libxcb-keysyms" },
+        .install_dir = .header,
+        .install_subdir = ".",
+        .exclude_extensions = &.{ ".c" },
+    });
+    lib.installHeadersDirectoryOptions(.{
+        .source_dir = .{ .path = "depends/libxcb-render-util" },
+        .install_dir = .header,
+        .install_subdir = ".",
+        .exclude_extensions = &.{ ".c" },
+    });
+    lib.installHeadersDirectory("depends/libxcb/depends/xorgproto/include", ".");
+    b.installArtifact(lib);
+}
+
+fn buildXau(b: *std.Build, target: *const std.zig.CrossTarget, optimize: std.builtin.OptimizeMode, single_threaded: bool) *std.Build.Step.Compile {
+    const lib = b.addStaticLibrary(.{
+        .name = "libxau",
+        .target = target.*,
+        .optimize = optimize,
+    });
+
+    lib.addCSourceFiles(&[_][]const u8{
+        "depends/libxcb/depends/libxau/AuDispose.c",
+        "depends/libxcb/depends/libxau/AuFileName.c",
+        "depends/libxcb/depends/libxau/AuGetAddr.c",
+        "depends/libxcb/depends/libxau/AuGetBest.c",
+        "depends/libxcb/depends/libxau/AuLock.c",
+        "depends/libxcb/depends/libxau/AuRead.c",
+        "depends/libxcb/depends/libxau/AuUnlock.c",
+        "depends/libxcb/depends/libxau/AuWrite.c",
+    }, &[_][]const u8{
+        "-DHAVE_CONFIG_H",
+    });
+
+    lib.addIncludePath(.{ .path = "depends/libxcb/depends/libxau" });
+    lib.addIncludePath(.{ .path = "depends/libxcb/depends/libxau/include" });
+    lib.addIncludePath(.{ .path = "depends/libxcb/depends/libxdmcp/include" });
+    lib.addIncludePath(.{ .path = "depends/libxcb/depends/xorgproto/include" });
+    lib.linkLibC();
+    lib.strip = optimize != std.builtin.OptimizeMode.Debug;
+    lib.want_lto = optimize != std.builtin.OptimizeMode.Debug;
+    lib.single_threaded = single_threaded;
+
+    return lib;
+}
+
+fn buildXdmcp(b: *std.Build, target: *const std.zig.CrossTarget, optimize: std.builtin.OptimizeMode, single_threaded: bool) *std.Build.Step.Compile {
+    const lib = b.addStaticLibrary(.{
+        .name = "libxdmcp",
+        .target = target.*,
+        .optimize = optimize,
+    });
+
+    var flags = std.ArrayList([]const u8).init(b.allocator);
+    flags.append("-DHAVE_CONFIG_H") catch @panic("OOM");
+    if (target.abi) |abi| {
+        if (abi.isMusl()) {
+            flags.append("-D__MUSL__") catch @panic("OOM");
+        }
+    }
+
+    lib.addCSourceFiles(&[_][]const u8{
+        "depends/libxcb/depends/libxdmcp/Array.c",
+        "depends/libxcb/depends/libxdmcp/Fill.c",
+        "depends/libxcb/depends/libxdmcp/Flush.c",
+        "depends/libxcb/depends/libxdmcp/Key.c",
+        "depends/libxcb/depends/libxdmcp/Read.c",
+        "depends/libxcb/depends/libxdmcp/Unwrap.c",
+        "depends/libxcb/depends/libxdmcp/Wrap.c",
+        "depends/libxcb/depends/libxdmcp/Wraphelp.c",
+        "depends/libxcb/depends/libxdmcp/Write.c",
+    }, flags.items);
+
+    lib.addIncludePath(.{ .path = "depends/libxcb/depends/libxdmcp" });
+    lib.addIncludePath(.{ .path = "depends/libxcb/depends/libxdmcp/include" });
+    lib.addIncludePath(.{ .path = "depends/libxcb/depends/xorgproto/include" });
+    lib.linkLibC();
+    lib.strip = optimize != std.builtin.OptimizeMode.Debug;
+    lib.want_lto = optimize != std.builtin.OptimizeMode.Debug;
+    lib.single_threaded = single_threaded;
+
+    return lib;
+}
+
+fn buildXcb(b: *std.Build, target: *const std.zig.CrossTarget, optimize: std.builtin.OptimizeMode, single_threaded: bool) *std.Build.Step.Compile {
+    const libXau = buildXau(b, target, optimize, single_threaded);
+    const libXdmcp = buildXdmcp(b, target, optimize, single_threaded);
+
+    const libXcb = b.addStaticLibrary(.{
+        .name = "libxcb",
+        .target = target.*,
+        .optimize = optimize,
+    });
+
+    libXcb.linkLibrary(libXau);
+    libXcb.linkLibrary(libXdmcp);
+
+    libXcb.addCSourceFiles(&[_][]const u8{
+        "depends/libxcb/src/bigreq.c",
+        "depends/libxcb/src/composite.c",
+        "depends/libxcb/src/damage.c",
+        "depends/libxcb/src/dpms.c",
+        "depends/libxcb/src/dri2.c",
+        "depends/libxcb/src/dri3.c",
+        "depends/libxcb/src/ge.c",
+        "depends/libxcb/src/glx.c",
+        "depends/libxcb/src/present.c",
+        "depends/libxcb/src/randr.c",
+        "depends/libxcb/src/record.c",
+        "depends/libxcb/src/render.c",
+        "depends/libxcb/src/res.c",
+        "depends/libxcb/src/screensaver.c",
+        "depends/libxcb/src/shape.c",
+        "depends/libxcb/src/shm.c",
+        "depends/libxcb/src/sync.c",
+        "depends/libxcb/src/xcb_auth.c",
+        "depends/libxcb/src/xcb_conn.c",
+        "depends/libxcb/src/xcb_ext.c",
+        "depends/libxcb/src/xcb_in.c",
+        "depends/libxcb/src/xcb_list.c",
+        "depends/libxcb/src/xcb_out.c",
+        "depends/libxcb/src/xcb_util.c",
+        "depends/libxcb/src/xcb_xid.c",
+        "depends/libxcb/src/xc_misc.c",
+        "depends/libxcb/src/xevie.c",
+        "depends/libxcb/src/xf86dri.c",
+        "depends/libxcb/src/xfixes.c",
+        "depends/libxcb/src/xinerama.c",
+        "depends/libxcb/src/xinput.c",
+        "depends/libxcb/src/xkb.c",
+        "depends/libxcb/src/xprint.c",
+        "depends/libxcb/src/xproto.c",
+        "depends/libxcb/src/xselinux.c",
+        "depends/libxcb/src/xtest.c",
+        "depends/libxcb/src/xv.c",
+        "depends/libxcb/src/xvmc.c",
+
+        // libxcb-keysyms
+        "depends/libxcb-keysyms/xcb/keysyms.c",
+    }, &[_][]const u8{
+        "-DHAVE_CONFIG_H",
+    });
+
+    libXcb.addIncludePath(.{ .path = "depends/libxcb/src" });
+    libXcb.addIncludePath(.{ .path = "depends/libxcb/depends/libxau/include" });
+    libXcb.addIncludePath(.{ .path = "depends/libxcb/depends/libxdmcp/include" });
+    libXcb.addIncludePath(.{ .path = "depends/libxcb/depends/xorgproto/include" });
+    libXcb.addIncludePath(.{ .path = "depends/libxcb/include/xcb" });
+    libXcb.addIncludePath(.{ .path = "depends/libxcb/include" });
+    libXcb.linkLibC();
+    libXcb.strip = optimize != std.builtin.OptimizeMode.Debug;
+    libXcb.want_lto = optimize != std.builtin.OptimizeMode.Debug;
+    libXcb.single_threaded = single_threaded;
+
+    return libXcb;
+}
diff --git a/depends/libxcb-keysyms/xcb/keysyms.c b/depends/libxcb-keysyms/xcb/keysyms.c
new file mode 100644
index 0000000..419c58b
--- /dev/null
+++ b/depends/libxcb-keysyms/xcb/keysyms.c
@@ -0,0 +1,505 @@
+/*
+ * Copyright © 2008 Ian Osgood <iano@quirkster.com>
+ * Copyright © 2008 Jamey Sharp <jamey@minilop.net>
+ * Copyright © 2008 Josh Triplett <josh@freedesktop.org>
+ * Copyright © 2008 Ulrich Eckhardt <doomster@knuut.de>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the names of the authors or
+ * their institutions shall not be used in advertising or otherwise to
+ * promote the sale, use or other dealings in this Software without
+ * prior written authorization from the authors.
+ */
+
+#include <stdlib.h>
+
+#include <xcb/xcb.h>
+#define XK_MISCELLANY
+#define XK_XKB_KEYS
+#define XK_LATIN1
+#define XK_LATIN2
+#define XK_LATIN3
+#define XK_LATIN4
+#define XK_CYRILLIC
+#define XK_GREEK
+#define XK_ARMENIAN
+#include <X11/keysymdef.h>
+
+#include "xcb_keysyms.h"
+
+/* Private declaration */
+enum tag_t {
+  TAG_COOKIE,
+  TAG_VALUE
+};
+
+struct _XCBKeySymbols
+{
+  xcb_connection_t *c;
+  enum tag_t     tag;
+  union {
+    xcb_get_keyboard_mapping_cookie_t cookie;
+    xcb_get_keyboard_mapping_reply_t *reply;
+  } u;
+};
+
+static void xcb_convert_case(xcb_keysym_t  sym,
+			   xcb_keysym_t *lower,
+			   xcb_keysym_t *upper);
+
+static void xcb_key_symbols_get_reply (xcb_key_symbols_t    *syms,
+				   xcb_generic_error_t **e);
+
+/* public implementation */
+
+xcb_key_symbols_t *
+xcb_key_symbols_alloc (xcb_connection_t *c)
+{
+  xcb_key_symbols_t *syms;
+  xcb_keycode_t     min_keycode;
+  xcb_keycode_t     max_keycode;
+
+  if (!c || xcb_connection_has_error(c))
+    return NULL;
+
+  syms = malloc (sizeof (xcb_key_symbols_t));
+  if (!syms)
+    return NULL;
+
+  syms->c = c;
+  syms->tag = TAG_COOKIE;
+
+  min_keycode = xcb_get_setup (c)->min_keycode;
+  max_keycode = xcb_get_setup (c)->max_keycode;
+  
+  syms->u.cookie = xcb_get_keyboard_mapping(c,
+					 min_keycode,
+					 max_keycode - min_keycode + 1);
+  
+  return syms;
+}
+
+void
+xcb_key_symbols_free (xcb_key_symbols_t *syms)
+{
+  if (syms)
+    {
+      if (syms->tag == TAG_VALUE)
+	free (syms->u.reply);
+      free (syms);
+      syms = NULL;
+    }
+}
+
+/*  Use of the 'col' parameter:
+
+A list of KeySyms is associated with each KeyCode. The list is intended
+to convey the set of symbols on the corresponding key. If the list
+(ignoring trailing NoSymbol entries) is a single KeySym ``K'', then the
+list is treated as if it were the list ``K NoSymbol K NoSymbol''. If the
+list (ignoring trailing NoSymbol entries) is a pair of KeySyms ``K1
+K2'', then the list is treated as if it were the list ``K1 K2 K1 K2''.
+If the list (ignoring trailing NoSymbol entries) is a triple of KeySyms
+``K1 K2 K3'', then the list is treated as if it were the list ``K1 K2 K3
+NoSymbol''. When an explicit ``void'' element is desired in the list,
+the value VoidSymbol can be used.
+
+The first four elements of the list are split into two groups of
+KeySyms. Group 1 contains the first and second KeySyms; Group 2 contains
+the third and fourth KeySyms. Within each group, if the second element
+of the group is NoSymbol , then the group should be treated as if the
+second element were the same as the first element, except when the first
+element is an alphabetic KeySym ``K'' for which both lowercase and
+uppercase forms are defined. In that case, the group should be treated
+as if the first element were the lowercase form of ``K'' and the second
+element were the uppercase form of ``K.''
+
+The standard rules for obtaining a KeySym from a KeyPress event make use
+of only the Group 1 and Group 2 KeySyms; no interpretation of other
+KeySyms in the list is given. Which group to use is determined by the
+modifier state. Switching between groups is controlled by the KeySym
+named MODE SWITCH, by attaching that KeySym to some KeyCode and
+attaching that KeyCode to any one of the modifiers Mod1 through Mod5.
+This modifier is called the group modifier. For any KeyCode, Group 1 is
+used when the group modifier is off, and Group 2 is used when the group
+modifier is on.
+
+The Lock modifier is interpreted as CapsLock when the KeySym named
+XK_Caps_Lock is attached to some KeyCode and that KeyCode is attached to
+the Lock modifier. The Lock modifier is interpreted as ShiftLock when
+the KeySym named XK_Shift_Lock is attached to some KeyCode and that
+KeyCode is attached to the Lock modifier. If the Lock modifier could be
+interpreted as both CapsLock and ShiftLock, the CapsLock interpretation
+is used.
+
+The operation of keypad keys is controlled by the KeySym named
+XK_Num_Lock, by attaching that KeySym to some KeyCode and attaching that
+KeyCode to any one of the modifiers Mod1 through Mod5 . This modifier is
+called the numlock modifier. The standard KeySyms with the prefix
+``XK_KP_'' in their name are called keypad KeySyms; these are KeySyms
+with numeric value in the hexadecimal range 0xFF80 to 0xFFBD inclusive.
+In addition, vendor-specific KeySyms in the hexadecimal range 0x11000000
+to 0x1100FFFF are also keypad KeySyms.
+
+Within a group, the choice of KeySym is determined by applying the first
+rule that is satisfied from the following list:
+
+* The numlock modifier is on and the second KeySym is a keypad KeySym. In
+  this case, if the Shift modifier is on, or if the Lock modifier is on
+  and is interpreted as ShiftLock, then the first KeySym is used,
+  otherwise the second KeySym is used.
+
+* The Shift and Lock modifiers are both off. In this case, the first
+  KeySym is used.
+
+* The Shift modifier is off, and the Lock modifier is on and is
+  interpreted as CapsLock. In this case, the first KeySym is used, but
+  if that KeySym is lowercase alphabetic, then the corresponding
+  uppercase KeySym is used instead.
+
+* The Shift modifier is on, and the Lock modifier is on and is
+  interpreted as CapsLock. In this case, the second KeySym is used, but
+  if that KeySym is lowercase alphabetic, then the corresponding
+  uppercase KeySym is used instead.
+
+* The Shift modifier is on, or the Lock modifier is on and is
+  interpreted as ShiftLock, or both. In this case, the second KeySym is
+  used.
+
+*/
+
+xcb_keysym_t xcb_key_symbols_get_keysym (xcb_key_symbols_t *syms,
+				  xcb_keycode_t     keycode,
+				  int            col)
+{
+  xcb_keysym_t *keysyms;
+  xcb_keysym_t  keysym_null = { XCB_NO_SYMBOL };
+  xcb_keysym_t  lsym;
+  xcb_keysym_t  usym;
+  xcb_keycode_t min_keycode;
+  xcb_keycode_t max_keycode;
+  int        per;
+  
+  if (!syms || xcb_connection_has_error(syms->c))
+    return keysym_null;
+  
+  xcb_key_symbols_get_reply (syms, NULL);
+
+  if (!syms->u.reply)
+    return keysym_null;
+  
+  keysyms = xcb_get_keyboard_mapping_keysyms (syms->u.reply);
+  min_keycode = xcb_get_setup (syms->c)->min_keycode;
+  max_keycode = xcb_get_setup (syms->c)->max_keycode;
+
+  per = syms->u.reply->keysyms_per_keycode;
+  if ((col < 0) || ((col >= per) && (col > 3)) ||
+      (keycode < min_keycode) ||
+      (keycode > max_keycode))
+    return keysym_null;
+
+  keysyms = &keysyms[(keycode - min_keycode) * per];
+  if (col < 4)
+    {
+      if (col > 1)
+	{
+	  while ((per > 2) && (keysyms[per - 1] == XCB_NO_SYMBOL))
+	    per--;
+	  if (per < 3)
+	    col -= 2;
+	}
+      if ((per <= (col|1)) || (keysyms[col|1] == XCB_NO_SYMBOL))
+	{
+	  xcb_convert_case(keysyms[col&~1], &lsym, &usym);
+	  if (!(col & 1))
+	    return lsym;
+	  else if (usym == lsym)
+	    return keysym_null;
+	  else
+	    return usym;
+	}
+    }
+  return keysyms[col];
+}
+
+xcb_keycode_t *
+xcb_key_symbols_get_keycode(xcb_key_symbols_t *syms,
+                            xcb_keysym_t      keysym)
+{
+  xcb_keysym_t ks;
+  int j, nresult = 0;
+  xcb_keycode_t i, min, max, *result = NULL, *result_np = NULL;
+
+  if(syms && !xcb_connection_has_error(syms->c))
+  {
+      xcb_key_symbols_get_reply (syms, NULL);
+      min = xcb_get_setup(syms->c)->min_keycode;
+      max = xcb_get_setup(syms->c)->max_keycode;
+
+      if (!syms->u.reply)
+        return NULL;
+
+      for(i = min; i && i <= max; i++)
+          for(j = 0; j < syms->u.reply->keysyms_per_keycode; j++)
+          {
+              ks = xcb_key_symbols_get_keysym(syms, i, j);
+              if(ks == keysym)
+              {
+                  nresult++;
+                  result_np = realloc(result,
+                                      sizeof(xcb_keycode_t) * (nresult + 1));
+
+                  if(result_np == NULL)
+                  {
+                      free(result);
+                      return NULL;
+                  }
+
+                  result = result_np;
+                  result[nresult - 1] = i;
+                  result[nresult] = XCB_NO_SYMBOL;
+                  break;
+              }
+          }
+  }
+  
+  return result;
+}
+
+xcb_keysym_t
+xcb_key_press_lookup_keysym (xcb_key_symbols_t    *syms,
+			 xcb_key_press_event_t *event,
+			 int               col)
+{
+  return xcb_key_symbols_get_keysym (syms, event->detail, col);
+}
+
+xcb_keysym_t
+xcb_key_release_lookup_keysym (xcb_key_symbols_t      *syms,
+			   xcb_key_release_event_t *event,
+			   int                 col)
+{
+  return xcb_key_symbols_get_keysym (syms, event->detail, col);
+}
+
+int
+xcb_refresh_keyboard_mapping (xcb_key_symbols_t         *syms,
+			   xcb_mapping_notify_event_t *event)
+{
+  if (event->request == XCB_MAPPING_KEYBOARD && syms && !xcb_connection_has_error(syms->c)) {
+    if (syms->tag == TAG_VALUE) {
+      xcb_keycode_t     min_keycode;
+      xcb_keycode_t     max_keycode;
+
+      if (syms->u.reply) {
+	free (syms->u.reply);
+	syms->u.reply = NULL;
+      }
+      syms->tag = TAG_COOKIE;
+      min_keycode = xcb_get_setup (syms->c)->min_keycode;
+      max_keycode = xcb_get_setup (syms->c)->max_keycode;
+  
+      syms->u.cookie = xcb_get_keyboard_mapping(syms->c,
+					     min_keycode,
+					     max_keycode - min_keycode + 1);
+      
+    }
+    return 1;
+  } 
+  return 0;
+}
+
+
+/* Tests for classes of symbols */
+
+int
+xcb_is_keypad_key (xcb_keysym_t keysym)
+{
+  return ((keysym >= XK_KP_Space) && (keysym <= XK_KP_Equal));
+}
+
+int
+xcb_is_private_keypad_key (xcb_keysym_t keysym)
+{
+  return ((keysym >= 0x11000000) && (keysym <= 0x1100FFFF));
+}
+
+int
+xcb_is_cursor_key (xcb_keysym_t keysym)
+{
+  return ((keysym >= XK_Home) && (keysym <= XK_Select));
+}
+
+int
+xcb_is_pf_key (xcb_keysym_t keysym)
+{
+  return ((keysym >= XK_KP_F1) && (keysym <= XK_KP_F4));
+}
+
+int
+xcb_is_function_key (xcb_keysym_t keysym)
+{
+  return ((keysym >= XK_F1) && (keysym <= XK_F35));
+}
+
+int
+xcb_is_misc_function_key (xcb_keysym_t keysym)
+{
+  return ((keysym >= XK_Select) && (keysym <= XK_Break));
+}
+
+int
+xcb_is_modifier_key (xcb_keysym_t keysym)
+{
+  return  (((keysym >= XK_Shift_L)  && (keysym <= XK_Hyper_R)) ||
+	   ((keysym >= XK_ISO_Lock) && (keysym <= XK_ISO_Level5_Lock)) ||
+	   (keysym == XK_Mode_switch) ||
+	   (keysym == XK_Num_Lock));
+}
+
+/* private functions */
+
+void
+xcb_convert_case(xcb_keysym_t  sym,
+	       xcb_keysym_t *lower,
+	       xcb_keysym_t *upper)
+{
+  *lower = sym;
+  *upper = sym;
+
+  switch(sym >> 8)
+    {
+    case 0: /* Latin 1 */
+      if ((sym >= XK_A) && (sym <= XK_Z))
+	*lower += (XK_a - XK_A);
+      else if ((sym >= XK_a) && (sym <= XK_z))
+	*upper -= (XK_a - XK_A);
+      else if ((sym >= XK_Agrave) && (sym <= XK_Odiaeresis))
+	*lower += (XK_agrave - XK_Agrave);
+      else if ((sym >= XK_agrave) && (sym <= XK_odiaeresis))
+	*upper -= (XK_agrave - XK_Agrave);
+      else if ((sym >= XK_Ooblique) && (sym <= XK_Thorn))
+	*lower += (XK_oslash - XK_Ooblique);
+      else if ((sym >= XK_oslash) && (sym <= XK_thorn))
+	*upper -= (XK_oslash - XK_Ooblique);
+      break;
+    case 1: /* Latin 2 */
+      /* Assume the KeySym is a legal value (ignore discontinuities) */
+      if (sym == XK_Aogonek)
+	*lower = XK_aogonek;
+      else if (sym >= XK_Lstroke && sym <= XK_Sacute)
+	*lower += (XK_lstroke - XK_Lstroke);
+      else if (sym >= XK_Scaron && sym <= XK_Zacute)
+	*lower += (XK_scaron - XK_Scaron);
+      else if (sym >= XK_Zcaron && sym <= XK_Zabovedot)
+	*lower += (XK_zcaron - XK_Zcaron);
+      else if (sym == XK_aogonek)
+	*upper = XK_Aogonek;
+      else if (sym >= XK_lstroke && sym <= XK_sacute)
+	*upper -= (XK_lstroke - XK_Lstroke);
+      else if (sym >= XK_scaron && sym <= XK_zacute)
+	*upper -= (XK_scaron - XK_Scaron);
+      else if (sym >= XK_zcaron && sym <= XK_zabovedot)
+	*upper -= (XK_zcaron - XK_Zcaron);
+      else if (sym >= XK_Racute && sym <= XK_Tcedilla)
+	*lower += (XK_racute - XK_Racute);
+      else if (sym >= XK_racute && sym <= XK_tcedilla)
+	*upper -= (XK_racute - XK_Racute);
+      break;
+    case 2: /* Latin 3 */
+      /* Assume the KeySym is a legal value (ignore discontinuities) */
+      if (sym >= XK_Hstroke && sym <= XK_Hcircumflex)
+	*lower += (XK_hstroke - XK_Hstroke);
+      else if (sym >= XK_Gbreve && sym <= XK_Jcircumflex)
+	*lower += (XK_gbreve - XK_Gbreve);
+      else if (sym >= XK_hstroke && sym <= XK_hcircumflex)
+	*upper -= (XK_hstroke - XK_Hstroke);
+      else if (sym >= XK_gbreve && sym <= XK_jcircumflex)
+	*upper -= (XK_gbreve - XK_Gbreve);
+      else if (sym >= XK_Cabovedot && sym <= XK_Scircumflex)
+	*lower += (XK_cabovedot - XK_Cabovedot);
+      else if (sym >= XK_cabovedot && sym <= XK_scircumflex)
+	*upper -= (XK_cabovedot - XK_Cabovedot);
+      break;
+    case 3: /* Latin 4 */
+      /* Assume the KeySym is a legal value (ignore discontinuities) */
+      if (sym >= XK_Rcedilla && sym <= XK_Tslash)
+	*lower += (XK_rcedilla - XK_Rcedilla);
+      else if (sym >= XK_rcedilla && sym <= XK_tslash)
+	*upper -= (XK_rcedilla - XK_Rcedilla);
+      else if (sym == XK_ENG)
+	*lower = XK_eng;
+      else if (sym == XK_eng)
+	*upper = XK_ENG;
+      else if (sym >= XK_Amacron && sym <= XK_Umacron)
+	*lower += (XK_amacron - XK_Amacron);
+      else if (sym >= XK_amacron && sym <= XK_umacron)
+	*upper -= (XK_amacron - XK_Amacron);
+      break;
+    case 6: /* Cyrillic */
+      /* Assume the KeySym is a legal value (ignore discontinuities) */
+      if (sym >= XK_Serbian_DJE && sym <= XK_Serbian_DZE)
+	*lower -= (XK_Serbian_DJE - XK_Serbian_dje);
+      else if (sym >= XK_Serbian_dje && sym <= XK_Serbian_dze)
+	*upper += (XK_Serbian_DJE - XK_Serbian_dje);
+      else if (sym >= XK_Cyrillic_YU && sym <= XK_Cyrillic_HARDSIGN)
+	*lower -= (XK_Cyrillic_YU - XK_Cyrillic_yu);
+      else if (sym >= XK_Cyrillic_yu && sym <= XK_Cyrillic_hardsign)
+	*upper += (XK_Cyrillic_YU - XK_Cyrillic_yu);
+      break;
+    case 7: /* Greek */
+      /* Assume the KeySym is a legal value (ignore discontinuities) */
+      if (sym >= XK_Greek_ALPHAaccent && sym <= XK_Greek_OMEGAaccent)
+	*lower += (XK_Greek_alphaaccent - XK_Greek_ALPHAaccent);
+      else if (sym >= XK_Greek_alphaaccent && sym <= XK_Greek_omegaaccent &&
+	       sym != XK_Greek_iotaaccentdieresis &&
+	       sym != XK_Greek_upsilonaccentdieresis)
+	*upper -= (XK_Greek_alphaaccent - XK_Greek_ALPHAaccent);
+      else if (sym >= XK_Greek_ALPHA && sym <= XK_Greek_OMEGA)
+	*lower += (XK_Greek_alpha - XK_Greek_ALPHA);
+      else if (sym >= XK_Greek_alpha && sym <= XK_Greek_omega &&
+	       sym != XK_Greek_finalsmallsigma)
+	*upper -= (XK_Greek_alpha - XK_Greek_ALPHA);
+      break;
+    case 0x14: /* Armenian */
+      if (sym >= XK_Armenian_AYB && sym <= XK_Armenian_fe) {
+	*lower = sym | 1;
+	*upper = sym & ~1;
+      }
+      break;
+    }
+}
+
+void
+xcb_key_symbols_get_reply (xcb_key_symbols_t    *syms,
+		       xcb_generic_error_t **e)
+{
+  if (!syms)
+    return;
+
+  if (syms->tag == TAG_COOKIE)
+    {
+      syms->tag = TAG_VALUE;
+      syms->u.reply = xcb_get_keyboard_mapping_reply(syms->c,
+						 syms->u.cookie,
+						 e);
+    }
+}
diff --git a/depends/libxcb-keysyms/xcb/xcb_keysyms.h b/depends/libxcb-keysyms/xcb/xcb_keysyms.h
new file mode 100644
index 0000000..9d34a50
--- /dev/null
+++ b/depends/libxcb-keysyms/xcb/xcb_keysyms.h
@@ -0,0 +1,71 @@
+#ifndef __XCB_KEYSYMS_H__
+#define __XCB_KEYSYMS_H__
+
+#include <xcb/xcb.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef struct _XCBKeySymbols xcb_key_symbols_t;
+
+xcb_key_symbols_t *xcb_key_symbols_alloc        (xcb_connection_t         *c);
+
+void           xcb_key_symbols_free         (xcb_key_symbols_t         *syms);
+
+xcb_keysym_t      xcb_key_symbols_get_keysym    (xcb_key_symbols_t         *syms,
+					  xcb_keycode_t             keycode,
+					  int                    col);
+
+/**
+ * @brief Get the keycodes attached to a keysyms.
+ * There can be several value, so what is returned is an array of keycode
+ * terminated by XCB_NO_SYMBOL. You are responsible to free it.
+ * Be aware that this function can be slow. It will convert all
+ * combinations of all available keycodes to keysyms to find the ones that
+ * match.
+ * @param syms Key symbols.
+ * @param keysym The keysym to look for.
+ * @return A XCB_NO_SYMBOL terminated array of keycode, or NULL if nothing is found.
+ */
+xcb_keycode_t * xcb_key_symbols_get_keycode(xcb_key_symbols_t *syms,
+                                            xcb_keysym_t keysym);
+
+xcb_keysym_t      xcb_key_press_lookup_keysym   (xcb_key_symbols_t         *syms,
+					  xcb_key_press_event_t      *event,
+					  int                    col);
+
+xcb_keysym_t      xcb_key_release_lookup_keysym (xcb_key_symbols_t         *syms,
+					  xcb_key_release_event_t    *event,
+					  int                    col);
+
+int            xcb_refresh_keyboard_mapping (xcb_key_symbols_t         *syms,
+					  xcb_mapping_notify_event_t *event);
+
+/* TODO:  need XLookupString equivalent */
+
+/* Tests for classes of symbols */
+
+int xcb_is_keypad_key        (xcb_keysym_t keysym);
+
+int xcb_is_private_keypad_key (xcb_keysym_t keysym);
+
+int xcb_is_cursor_key        (xcb_keysym_t keysym);
+
+int xcb_is_pf_key            (xcb_keysym_t keysym);
+
+int xcb_is_function_key      (xcb_keysym_t keysym);
+
+int xcb_is_misc_function_key  (xcb_keysym_t keysym);
+
+int xcb_is_modifier_key      (xcb_keysym_t keysym);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* __XCB_KEYSYMS_H__ */
diff --git a/depends/libxcb-render-util/xcb/cache.c b/depends/libxcb-render-util/xcb/cache.c
new file mode 100644
index 0000000..c04fb50
--- /dev/null
+++ b/depends/libxcb-render-util/xcb/cache.c
@@ -0,0 +1,234 @@
+/* Copyright © 2006 Jamey Sharp.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the names of the authors or their
+ * institutions shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the authors.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include "xcb_renderutil.h"
+#include <stdlib.h>
+#include <pthread.h>
+
+typedef struct connection_cache {
+    struct connection_cache      *next;		/* keep a linked list */
+    xcb_connection_t                *c;		/* which display this is */
+    xcb_render_query_version_reply_t     *version;
+    xcb_render_query_pict_formats_reply_t *formats;
+} connection_cache;
+
+static struct {
+    pthread_mutex_t   lock;
+    connection_cache *head;           /* start of the list */
+    connection_cache *cur;            /* most recently used */
+} connections = { PTHREAD_MUTEX_INITIALIZER };
+
+/*
+ * If the server is missing support for any of the required depths on
+ * any screen, tell the application that Render is not present.
+ */
+
+#define DEPTH_MASK(d)	(1U << ((d) - 1))
+    
+/*
+ * Render requires support for depth 1, 4, 8, 24 and 32 pixmaps
+ */
+
+#define REQUIRED_DEPTHS	(DEPTH_MASK(1) | \
+			 DEPTH_MASK(4) | \
+			 DEPTH_MASK(8) | \
+			 DEPTH_MASK(24) | \
+			 DEPTH_MASK(32))
+
+/* Test each depth not explicitly advertised to see if pixmap creation
+ * succeeds: if it does, that depth is usable. */
+static int
+pixmap_depths_usable (xcb_connection_t *c, uint32_t missing, xcb_pixmap_t pixmap, xcb_drawable_t root)
+{
+    xcb_void_cookie_t create_cookie[32] = { { 0 } };
+    xcb_void_cookie_t free_cookie[32]   = { { 0 } };
+    int d;
+    int success = 1;
+    for (d = 1; d <= 32; d++)
+	if (missing & DEPTH_MASK(d))
+	{
+	    create_cookie[d - 1] = xcb_create_pixmap_checked (c, d, pixmap, root, 1, 1);
+	    free_cookie[d - 1] = xcb_free_pixmap_checked (c, pixmap);
+	    if (!create_cookie[d - 1].sequence || !free_cookie[d - 1].sequence)
+	    {
+		success = 0;
+		break;
+	    }
+	}
+    for (d = 0; d < 32; d++)
+	if (create_cookie[d].sequence || free_cookie[d].sequence)
+	{
+	    xcb_generic_error_t *create_error = xcb_request_check (c, create_cookie[d]);
+	    xcb_generic_error_t *free_error = xcb_request_check (c, free_cookie[d]);
+	    success = success && !create_error;
+	    free(create_error);
+	    free(free_error);
+	}
+    return success;
+}
+
+static int
+has_required_depths (xcb_connection_t *c)
+{
+    xcb_screen_iterator_t screens;
+    xcb_pixmap_t pixmap = { -1 };
+    for (screens = xcb_setup_roots_iterator(xcb_get_setup(c)); screens.rem; xcb_screen_next(&screens))
+    {
+	xcb_depth_iterator_t depths;
+	uint32_t missing = REQUIRED_DEPTHS;
+	xcb_drawable_t root;
+
+	for (depths = xcb_screen_allowed_depths_iterator(screens.data); depths.rem; xcb_depth_next(&depths))
+	    missing &= ~DEPTH_MASK(depths.data->depth);
+	if (!missing)
+	    continue;
+
+	/*
+	 * Ok, this is ugly.  It should be sufficient at this
+	 * point to just return false, but Xinerama is broken at
+	 * this point and only advertises depths which have an
+	 * associated visual.  Of course, the other depths still
+	 * work, but the only way to find out is to try them.
+	 */
+	if (pixmap == -1)
+	    pixmap = xcb_generate_id(c);
+	root = screens.data->root;
+	if (!pixmap_depths_usable (c, missing, pixmap, root))
+	    return 0;
+    }
+    return 1;
+}
+
+static connection_cache *
+find_or_create_display (xcb_connection_t *c)
+{
+    connection_cache *info;
+    xcb_render_query_version_cookie_t version_cookie;
+    xcb_render_query_pict_formats_cookie_t formats_cookie;
+    int present;
+
+    /*
+     * look for display in list
+     */
+    for (info = connections.head; info; info = info->next)
+        if (info->c == c) {
+            connections.cur = info;     /* cache most recently used */
+	    return info;
+        }
+
+    /*
+     * don't already have this display: add it.
+     */
+    info = malloc (sizeof (connection_cache));
+    if (!info)
+	return NULL;
+    info->c = c;
+
+    version_cookie = xcb_render_query_version(c, 0, 10);
+    formats_cookie = xcb_render_query_pict_formats(c);
+    xcb_flush(c);
+    present = has_required_depths (c);
+    info->version = xcb_render_query_version_reply(c, version_cookie, 0);
+    info->formats = xcb_render_query_pict_formats_reply(c, formats_cookie, 0);
+
+    if (!present || !info->version || !info->formats)
+    {
+	free(info->version);
+	info->version = 0;
+	free(info->formats);
+	info->formats = 0;
+    }
+    /* Check for the lack of sub-pixel data */
+    else if (info->version->major_version == 0 && info->version->minor_version < 6)
+	info->formats->num_subpixel = 0;
+
+    /*
+     * now, chain it onto the list
+     */
+    info->next = connections.head;
+    connections.head = info;
+    connections.cur = info;
+
+    return info;
+}
+
+static connection_cache *
+find_display (xcb_connection_t *c)
+{
+    connection_cache *info;
+
+    /*
+     * see if this was the most recently accessed display
+     */
+    if ((info = connections.cur) && info->c == c) 
+        return info;
+
+    pthread_mutex_lock(&connections.lock);
+    info = find_or_create_display (c);
+    pthread_mutex_unlock(&connections.lock);
+    return info;
+}
+
+const xcb_render_query_version_reply_t *
+xcb_render_util_query_version (xcb_connection_t *c)
+{
+    connection_cache *info = find_display (c);
+    if (!info)
+	return 0;
+    return info->version;
+}
+
+const xcb_render_query_pict_formats_reply_t *
+xcb_render_util_query_formats (xcb_connection_t *c)
+{
+    connection_cache *info = find_display (c);
+    if (!info)
+	return 0;
+    return info->formats;
+}
+
+int
+xcb_render_util_disconnect (xcb_connection_t *c)
+{
+    connection_cache **prev, *cur = NULL;
+    pthread_mutex_lock(&connections.lock);
+    for(prev = &connections.head; *prev; prev = &(*prev)->next)
+	if((*prev)->c == c)
+	{
+	    cur = *prev;
+	    *prev = cur->next;
+	    if(cur == connections.cur)
+		connections.cur = NULL;  /* flush cache */
+	    free(cur->version);
+	    free(cur->formats);
+	    free(cur);
+	    break;
+	}
+    pthread_mutex_unlock(&connections.lock);
+    return cur != NULL;
+}
diff --git a/depends/libxcb-render-util/xcb/glyph.c b/depends/libxcb-render-util/xcb/glyph.c
new file mode 100644
index 0000000..d19fba6
--- /dev/null
+++ b/depends/libxcb-render-util/xcb/glyph.c
@@ -0,0 +1,293 @@
+/* Copyright © 2006 Ian Osgood
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the names of the authors or their
+ * institutions shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the authors.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "xcb_renderutil.h"
+
+typedef struct _glyph_header_t {
+	uint8_t count;
+	uint8_t pad0[3];
+	int16_t dx, dy;
+} _glyph_header_t;
+
+/* implementation of the opaque stream */
+struct xcb_render_util_composite_text_stream_t {
+	/* state info */
+	uint32_t glyph_size;		/* 0 for unset, 1/2/4 for 8/16/32 */
+	xcb_render_glyphset_t initial_glyphset;
+	xcb_render_glyphset_t current_glyphset;
+
+	/* dynamically allocated stream */
+	/* contents are 32-bit aligned, network byte order */
+	size_t stream_len;
+	uint32_t *stream;
+	uint32_t *current;
+};
+
+#define CURRENT_LEN(s) (((char *)s->current - (char *)s->stream))
+
+xcb_render_util_composite_text_stream_t *
+xcb_render_util_composite_text_stream (
+	xcb_render_glyphset_t initial_glyphset,
+	uint32_t              total_glyphs,
+	uint32_t              total_glyphset_changes )
+{
+	xcb_render_util_composite_text_stream_t *stream;
+	size_t size = 32;
+
+	/* assume worst case: each glyph has its own dx,dy */
+	if (total_glyphs || total_glyphset_changes) {
+		size = total_glyphs * 3 * sizeof(uint32_t)
+		     + total_glyphset_changes * 3 * sizeof(uint32_t);
+	}
+
+	stream = malloc(sizeof(xcb_render_util_composite_text_stream_t));
+	if (!stream)
+		return NULL;
+
+	stream->glyph_size = 0;
+	stream->initial_glyphset = initial_glyphset;
+	stream->current_glyphset = initial_glyphset;
+
+	stream->stream_len = size;
+	stream->stream = malloc(size);
+	stream->current = stream->stream;
+
+	return stream;
+}
+
+static void
+_grow_stream( xcb_render_util_composite_text_stream_t *stream, size_t increase )
+{
+	size_t current_len = CURRENT_LEN(stream);
+	if (current_len + increase > stream->stream_len) {
+		uint32_t *s = realloc(stream->stream, 2 * stream->stream_len);
+		if (s != NULL) {
+			stream->stream_len *= 2;
+			stream->stream = s;
+			stream->current = stream->stream + (current_len>>2);
+		}
+	}
+}
+
+void
+xcb_render_util_glyphs_8 (
+	xcb_render_util_composite_text_stream_t *stream,
+	int16_t  dx,
+	int16_t  dy,
+	uint32_t count,
+	const uint8_t *glyphs )
+{
+	_glyph_header_t header = { count, {0,0,0}, dx, dy };
+
+	if (count > 252) return; /* FIXME */
+
+	if (stream->glyph_size != sizeof(*glyphs)) {
+		if (stream->glyph_size != 0)
+			return;
+		stream->glyph_size = sizeof(*glyphs);
+	}
+	_grow_stream(stream, sizeof(header) + count+3);
+
+	memcpy(stream->current, &header, sizeof(header));
+	stream->current += 2;
+
+	memcpy(stream->current, glyphs, header.count);
+	stream->current += ((int)header.count+3)>>2;
+}
+
+void
+xcb_render_util_glyphs_16 (
+	xcb_render_util_composite_text_stream_t *stream,
+	int16_t  dx,
+	int16_t  dy,
+	uint32_t count,
+	const uint16_t *glyphs )
+{
+	_glyph_header_t header = { count, {0,0,0}, dx, dy };
+
+	if (count > 254) return; /* FIXME */
+
+	if (stream->glyph_size != sizeof(*glyphs)) {
+		if (stream->glyph_size != 0)
+			return;
+		stream->glyph_size = sizeof(*glyphs);
+	}
+	_grow_stream(stream, sizeof(header) + count*sizeof(*glyphs)+1);
+
+	memcpy(stream->current, &header, sizeof(header));
+	stream->current += 2;
+
+	memcpy(stream->current, glyphs, header.count*sizeof(*glyphs));
+	stream->current += ((int)header.count*sizeof(*glyphs)+3)>>2;
+}
+
+void
+xcb_render_util_glyphs_32 (
+	xcb_render_util_composite_text_stream_t *stream,
+	int16_t  dx,
+	int16_t  dy,
+	uint32_t count,
+	const uint32_t *glyphs )
+{
+	_glyph_header_t header = { count, {0,0,0}, dx, dy };
+
+	if (count > 254) return; /* FIXME */
+
+	if (stream->glyph_size != sizeof(*glyphs)) {
+		if (stream->glyph_size != 0)
+			return;
+		stream->glyph_size = sizeof(*glyphs);
+	}
+	_grow_stream(stream, sizeof(header) + count*sizeof(*glyphs)+1);
+
+	memcpy(stream->current, &header, sizeof(header));
+	stream->current += 2;
+
+	memcpy(stream->current, glyphs, header.count*sizeof(*glyphs));
+	stream->current += header.count;
+}
+
+/* note: these glyph arrays must be swapped to network byte order */
+
+void
+xcb_render_util_change_glyphset (
+	xcb_render_util_composite_text_stream_t *stream,
+	xcb_render_glyphset_t glyphset )
+{
+	static _glyph_header_t header = { 255, {0,0,0}, 0, 0 };
+
+	if (glyphset == stream->current_glyphset)
+		return;
+
+	_grow_stream(stream, 3*sizeof(uint32_t));
+
+	memcpy(stream->current, &header, sizeof(header));
+	stream->current += 2;
+
+	*stream->current = glyphset;
+	stream->current++;
+
+	stream->current_glyphset = glyphset;
+}
+	
+typedef xcb_void_cookie_t
+(*xcb_render_composite_glyphs_func) (xcb_connection_t        *c,
+	                             uint8_t                  op,
+                                     xcb_render_picture_t     src,
+                                     xcb_render_picture_t     dst,
+                                     xcb_render_pictformat_t  mask_format,
+                                     xcb_render_glyphset_t    glyphset,
+                                     int16_t                  src_x,
+                                     int16_t                  src_y,
+                                     uint32_t                 glyphcmds_len,
+                                     const uint8_t           *glyphcmds);
+
+
+xcb_void_cookie_t
+xcb_render_util_composite_text (
+	xcb_connection_t        *xc,
+	uint8_t                  op,
+	xcb_render_picture_t     src,
+	xcb_render_picture_t     dst,
+	xcb_render_pictformat_t  mask_format,
+	int16_t                  src_x,
+	int16_t                  src_y,
+	xcb_render_util_composite_text_stream_t *stream )
+{
+	xcb_render_composite_glyphs_func f;
+
+	switch (stream->glyph_size)
+	{
+	case 1:
+		f = xcb_render_composite_glyphs_8;
+		break;
+	case 2:
+		f = xcb_render_composite_glyphs_16;
+		break;
+	case 4:
+		f = xcb_render_composite_glyphs_32;
+		break;
+	default: /* uninitialized */
+		return xcb_no_operation(xc);
+	}
+	return f(
+		xc, op, src, dst, mask_format,
+		stream->initial_glyphset,
+		src_x, src_y,
+		CURRENT_LEN(stream),
+		(uint8_t *)stream->stream
+	);
+}
+
+xcb_void_cookie_t
+xcb_render_util_composite_text_checked (
+	xcb_connection_t        *xc,
+	uint8_t                  op,
+	xcb_render_picture_t     src,
+	xcb_render_picture_t     dst,
+	xcb_render_pictformat_t  mask_format,
+	int16_t                  src_x,
+	int16_t                  src_y,
+	xcb_render_util_composite_text_stream_t *stream )
+{
+	xcb_render_composite_glyphs_func f;
+
+	switch (stream->glyph_size)
+	{
+	case 1:
+		f = xcb_render_composite_glyphs_8_checked;
+		break;
+	case 2:
+		f = xcb_render_composite_glyphs_16_checked;
+		break;
+	case 4:
+		f = xcb_render_composite_glyphs_32_checked;
+		break;
+	default: /* uninitialized */
+		return xcb_no_operation_checked(xc);
+	}
+	return f(
+		xc, op, src, dst, mask_format,
+		stream->initial_glyphset,
+		src_x, src_y,
+		CURRENT_LEN(stream),
+		(uint8_t *)stream->stream
+	);
+}
+
+void
+xcb_render_util_composite_text_free (
+	xcb_render_util_composite_text_stream_t *stream )
+{
+	free(stream->stream);
+	free(stream);
+}
diff --git a/depends/libxcb-render-util/xcb/util.c b/depends/libxcb-render-util/xcb/util.c
new file mode 100644
index 0000000..7666c43
--- /dev/null
+++ b/depends/libxcb-render-util/xcb/util.c
@@ -0,0 +1,255 @@
+/* Copyright © 2000 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "xcb_renderutil.h"
+
+xcb_render_pictvisual_t *
+xcb_render_util_find_visual_format (const xcb_render_query_pict_formats_reply_t *formats,
+			       const xcb_visualid_t visual)
+{
+    xcb_render_pictscreen_iterator_t screens;
+    xcb_render_pictdepth_iterator_t depths;
+    xcb_render_pictvisual_iterator_t visuals;
+    if (!formats)
+	return 0;
+    for (screens = xcb_render_query_pict_formats_screens_iterator(formats); screens.rem; xcb_render_pictscreen_next(&screens))
+	for (depths = xcb_render_pictscreen_depths_iterator(screens.data); depths.rem; xcb_render_pictdepth_next(&depths))
+	    for (visuals = xcb_render_pictdepth_visuals_iterator(depths.data); visuals.rem; xcb_render_pictvisual_next(&visuals))
+		if (visuals.data->visual == visual)
+		    return visuals.data;
+    return 0;
+}
+
+xcb_render_pictforminfo_t *
+xcb_render_util_find_format (const xcb_render_query_pict_formats_reply_t	*formats,
+			 unsigned long				mask,
+			 const xcb_render_pictforminfo_t		*ptemplate,
+			 int					count)
+{
+    xcb_render_pictforminfo_iterator_t i;
+    if (!formats)
+	return 0;
+    for (i = xcb_render_query_pict_formats_formats_iterator(formats); i.rem; xcb_render_pictforminfo_next(&i))
+    {
+	if (mask & XCB_PICT_FORMAT_ID)
+	    if (ptemplate->id != i.data->id)
+		continue;
+	if (mask & XCB_PICT_FORMAT_TYPE)
+	    if (ptemplate->type != i.data->type)
+		continue;
+	if (mask & XCB_PICT_FORMAT_DEPTH)
+	    if (ptemplate->depth != i.data->depth)
+		continue;
+	if (mask & XCB_PICT_FORMAT_RED)
+	    if (ptemplate->direct.red_shift != i.data->direct.red_shift)
+		continue;
+	if (mask & XCB_PICT_FORMAT_RED_MASK)
+	    if (ptemplate->direct.red_mask != i.data->direct.red_mask)
+		continue;
+	if (mask & XCB_PICT_FORMAT_GREEN)
+	    if (ptemplate->direct.green_shift != i.data->direct.green_shift)
+		continue;
+	if (mask & XCB_PICT_FORMAT_GREEN_MASK)
+	    if (ptemplate->direct.green_mask != i.data->direct.green_mask)
+		continue;
+	if (mask & XCB_PICT_FORMAT_BLUE)
+	    if (ptemplate->direct.blue_shift != i.data->direct.blue_shift)
+		continue;
+	if (mask & XCB_PICT_FORMAT_BLUE_MASK)
+	    if (ptemplate->direct.blue_mask != i.data->direct.blue_mask)
+		continue;
+	if (mask & XCB_PICT_FORMAT_ALPHA)
+	    if (ptemplate->direct.alpha_shift != i.data->direct.alpha_shift)
+		continue;
+	if (mask & XCB_PICT_FORMAT_ALPHA_MASK)
+	    if (ptemplate->direct.alpha_mask != i.data->direct.alpha_mask)
+		continue;
+	if (mask & XCB_PICT_FORMAT_COLORMAP)
+	    if (ptemplate->colormap != i.data->colormap)
+		continue;
+	if (count-- == 0)
+	    return i.data;
+    }
+    return 0;
+}
+
+xcb_render_pictforminfo_t *
+xcb_render_util_find_standard_format (const xcb_render_query_pict_formats_reply_t	*formats,
+				 xcb_pict_standard_t					format)
+{
+    static const struct {
+	xcb_render_pictforminfo_t templ;
+	unsigned long	      mask;
+    } standardFormats[] = {
+	/* XCB_PICT_STANDARD_ARGB_32 */
+	{
+	    {
+		0,			    /* id */
+		XCB_RENDER_PICT_TYPE_DIRECT,    /* type */
+		32,			    /* depth */
+		{ 0 },			    /* pad */
+		{			    /* direct */
+		    16,			    /* direct.red */
+		    0xff,		    /* direct.red_mask */
+		    8,			    /* direct.green */
+		    0xff,		    /* direct.green_mask */
+		    0,			    /* direct.blue */
+		    0xff,		    /* direct.blue_mask */
+		    24,			    /* direct.alpha */
+		    0xff,		    /* direct.alpha_mask */
+		},
+		0,			    /* colormap */
+	    },
+	    XCB_PICT_FORMAT_TYPE | 
+	    XCB_PICT_FORMAT_DEPTH |
+	    XCB_PICT_FORMAT_RED |
+	    XCB_PICT_FORMAT_RED_MASK |
+	    XCB_PICT_FORMAT_GREEN |
+	    XCB_PICT_FORMAT_GREEN_MASK |
+	    XCB_PICT_FORMAT_BLUE |
+	    XCB_PICT_FORMAT_BLUE_MASK |
+	    XCB_PICT_FORMAT_ALPHA |
+	    XCB_PICT_FORMAT_ALPHA_MASK,
+	},
+	/* XCB_PICT_STANDARD_RGB_24 */
+	{
+	    {
+		0,			    /* id */
+		XCB_RENDER_PICT_TYPE_DIRECT,    /* type */
+		24,			    /* depth */
+		{ 0 },			    /* pad */
+		{			    /* direct */
+		    16,			    /* direct.red */
+		    0xff,		    /* direct.red_MASK */
+		    8,			    /* direct.green */
+		    0xff,		    /* direct.green_MASK */
+		    0,			    /* direct.blue */
+		    0xff,		    /* direct.blue_MASK */
+		    0,			    /* direct.alpha */
+		    0x00,		    /* direct.alpha_MASK */
+		},
+		0,			    /* colormap */
+	    },
+	    XCB_PICT_FORMAT_TYPE | 
+	    XCB_PICT_FORMAT_DEPTH |
+	    XCB_PICT_FORMAT_RED |
+	    XCB_PICT_FORMAT_RED_MASK |
+	    XCB_PICT_FORMAT_GREEN |
+	    XCB_PICT_FORMAT_GREEN_MASK |
+	    XCB_PICT_FORMAT_BLUE |
+	    XCB_PICT_FORMAT_BLUE_MASK |
+	    XCB_PICT_FORMAT_ALPHA_MASK,
+	},
+	/* XCB_PICT_STANDARD_A_8 */
+	{
+	    {
+		0,			    /* id */
+		XCB_RENDER_PICT_TYPE_DIRECT,    /* type */
+		8,			    /* depth */
+		{ 0 },			    /* pad */
+		{			    /* direct */
+		    0,			    /* direct.red */
+		    0x00,		    /* direct.red_MASK */
+		    0,			    /* direct.green */
+		    0x00,		    /* direct.green_MASK */
+		    0,			    /* direct.blue */
+		    0x00,		    /* direct.blue_MASK */
+		    0,			    /* direct.alpha */
+		    0xff,		    /* direct.alpha_MASK */
+		},
+		0,			    /* colormap */
+	    },
+	    XCB_PICT_FORMAT_TYPE | 
+	    XCB_PICT_FORMAT_DEPTH |
+	    XCB_PICT_FORMAT_RED_MASK |
+	    XCB_PICT_FORMAT_GREEN_MASK |
+	    XCB_PICT_FORMAT_BLUE_MASK |
+	    XCB_PICT_FORMAT_ALPHA |
+	    XCB_PICT_FORMAT_ALPHA_MASK,
+	},
+	/* XCB_PICT_STANDARD_A_4 */
+	{
+	    {
+		0,			    /* id */
+		XCB_RENDER_PICT_TYPE_DIRECT,    /* type */
+		4,			    /* depth */
+		{ 0 },			    /* pad */
+		{			    /* direct */
+		    0,			    /* direct.red */
+		    0x00,		    /* direct.red_MASK */
+		    0,			    /* direct.green */
+		    0x00,		    /* direct.green_MASK */
+		    0,			    /* direct.blue */
+		    0x00,		    /* direct.blue_MASK */
+		    0,			    /* direct.alpha */
+		    0x0f,		    /* direct.alpha_MASK */
+		},
+		0,			    /* colormap */
+	    },
+	    XCB_PICT_FORMAT_TYPE | 
+	    XCB_PICT_FORMAT_DEPTH |
+	    XCB_PICT_FORMAT_RED_MASK |
+	    XCB_PICT_FORMAT_GREEN_MASK |
+	    XCB_PICT_FORMAT_BLUE_MASK |
+	    XCB_PICT_FORMAT_ALPHA |
+	    XCB_PICT_FORMAT_ALPHA_MASK,
+	},
+	/* XCB_PICT_STANDARD_A_1 */
+	{
+	    {
+		0,			    /* id */
+		XCB_RENDER_PICT_TYPE_DIRECT,    /* type */
+		1,			    /* depth */
+		{ 0 },			    /* pad */
+		{			    /* direct */
+		    0,			    /* direct.red */
+		    0x00,		    /* direct.red_MASK */
+		    0,			    /* direct.green */
+		    0x00,		    /* direct.green_MASK */
+		    0,			    /* direct.blue */
+		    0x00,		    /* direct.blue_MASK */
+		    0,			    /* direct.alpha */
+		    0x01,		    /* direct.alpha_MASK */
+		},
+		0,			    /* colormap */
+	    },
+	    XCB_PICT_FORMAT_TYPE | 
+	    XCB_PICT_FORMAT_DEPTH |
+	    XCB_PICT_FORMAT_RED_MASK |
+	    XCB_PICT_FORMAT_GREEN_MASK |
+	    XCB_PICT_FORMAT_BLUE_MASK |
+	    XCB_PICT_FORMAT_ALPHA |
+	    XCB_PICT_FORMAT_ALPHA_MASK,
+	},
+    };
+
+    if (format < 0 || format >= sizeof(standardFormats) / sizeof(*standardFormats))
+	return 0;
+
+    return xcb_render_util_find_format (formats, 
+				    standardFormats[format].mask,
+				    &standardFormats[format].templ,
+				    0);
+}
diff --git a/depends/libxcb-render-util/xcb/xcb_renderutil.h b/depends/libxcb-render-util/xcb/xcb_renderutil.h
new file mode 100644
index 0000000..77c5b7f
--- /dev/null
+++ b/depends/libxcb-render-util/xcb/xcb_renderutil.h
@@ -0,0 +1,150 @@
+/* Copyright © 2006 Jamey Sharp.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the names of the authors or their
+ * institutions shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the authors.
+ */
+
+#ifndef XCB_RENDERUTIL
+#define XCB_RENDERUTIL
+#include <xcb/render.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum xcb_pict_format_t {
+	XCB_PICT_FORMAT_ID         = (1 << 0),
+	XCB_PICT_FORMAT_TYPE       = (1 << 1),
+	XCB_PICT_FORMAT_DEPTH      = (1 << 2),
+	XCB_PICT_FORMAT_RED        = (1 << 3),
+	XCB_PICT_FORMAT_RED_MASK   = (1 << 4),
+	XCB_PICT_FORMAT_GREEN      = (1 << 5),
+	XCB_PICT_FORMAT_GREEN_MASK = (1 << 6),
+	XCB_PICT_FORMAT_BLUE       = (1 << 7),
+	XCB_PICT_FORMAT_BLUE_MASK  = (1 << 8),
+	XCB_PICT_FORMAT_ALPHA      = (1 << 9),
+	XCB_PICT_FORMAT_ALPHA_MASK = (1 << 10),
+	XCB_PICT_FORMAT_COLORMAP   = (1 << 11)
+} xcb_pict_format_t;
+
+typedef enum xcb_pict_standard_t {
+	XCB_PICT_STANDARD_ARGB_32,
+	XCB_PICT_STANDARD_RGB_24,
+	XCB_PICT_STANDARD_A_8,
+	XCB_PICT_STANDARD_A_4,
+	XCB_PICT_STANDARD_A_1
+} xcb_pict_standard_t;
+
+
+xcb_render_pictvisual_t *
+xcb_render_util_find_visual_format (const xcb_render_query_pict_formats_reply_t *formats,
+			       const xcb_visualid_t visual);
+
+xcb_render_pictforminfo_t *
+xcb_render_util_find_format (const xcb_render_query_pict_formats_reply_t	*formats,
+			 unsigned long				mask,
+			 const xcb_render_pictforminfo_t		*ptemplate,
+			 int					count);
+
+xcb_render_pictforminfo_t *
+xcb_render_util_find_standard_format (const xcb_render_query_pict_formats_reply_t	*formats,
+				 xcb_pict_standard_t					format);
+
+const xcb_render_query_version_reply_t *
+xcb_render_util_query_version (xcb_connection_t *c);
+
+const xcb_render_query_pict_formats_reply_t *
+xcb_render_util_query_formats (xcb_connection_t *c);
+
+int
+xcb_render_util_disconnect (xcb_connection_t *c);
+
+/* wrappers for xcb_render_composite_glyphs_8/16/32 */
+
+typedef struct xcb_render_util_composite_text_stream_t xcb_render_util_composite_text_stream_t;
+
+xcb_render_util_composite_text_stream_t *
+xcb_render_util_composite_text_stream (
+	xcb_render_glyphset_t initial_glyphset,
+	uint32_t              total_glyphs,
+	uint32_t              total_glyphset_changes );
+
+void
+xcb_render_util_glyphs_8 (
+	xcb_render_util_composite_text_stream_t *stream,
+	int16_t  dx,
+	int16_t  dy,
+	uint32_t count,
+	const uint8_t *glyphs );
+
+void
+xcb_render_util_glyphs_16 (
+	xcb_render_util_composite_text_stream_t *stream,
+	int16_t  dx,
+	int16_t  dy,
+	uint32_t count,
+	const uint16_t *glyphs );
+
+void
+xcb_render_util_glyphs_32 (
+	xcb_render_util_composite_text_stream_t *stream,
+	int16_t  dx,
+	int16_t  dy,
+	uint32_t count,
+	const uint32_t *glyphs );
+
+void
+xcb_render_util_change_glyphset (
+	xcb_render_util_composite_text_stream_t *stream,
+	xcb_render_glyphset_t glyphset );
+
+xcb_void_cookie_t
+xcb_render_util_composite_text (
+	xcb_connection_t        *xc,
+	uint8_t                  op,
+	xcb_render_picture_t     src,
+	xcb_render_picture_t     dst,
+	xcb_render_pictformat_t  mask_format,
+	int16_t                  src_x,
+	int16_t                  src_y,
+	xcb_render_util_composite_text_stream_t *stream );
+
+xcb_void_cookie_t
+xcb_render_util_composite_text_checked (
+	xcb_connection_t        *xc,
+	uint8_t                  op,
+	xcb_render_picture_t     src,
+	xcb_render_picture_t     dst,
+	xcb_render_pictformat_t  mask_format,
+	int16_t                  src_x,
+	int16_t                  src_y,
+	xcb_render_util_composite_text_stream_t *stream );
+
+void
+xcb_render_util_composite_text_free (
+	xcb_render_util_composite_text_stream_t *stream );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* XCB_RENDERUTIL */
diff --git a/depends/libxcb/depends/libxau/AuDispose.c b/depends/libxcb/depends/libxau/AuDispose.c
new file mode 100644
index 0000000..791232a
--- /dev/null
+++ b/depends/libxcb/depends/libxau/AuDispose.c
@@ -0,0 +1,51 @@
+/*
+
+Copyright 1988, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/Xauth.h>
+#include <stdlib.h>
+
+void
+XauDisposeAuth (Xauth *auth)
+{
+    if (auth) {
+	free (auth->address);
+	free (auth->number);
+	free (auth->name);
+	if (auth->data) {
+#ifdef HAVE_EXPLICIT_BZERO
+	    (void) explicit_bzero (auth->data, auth->data_length);
+#else
+	    (void) bzero (auth->data, auth->data_length);
+#endif
+	    (void) free (auth->data);
+	}
+	free (auth);
+    }
+    return;
+}
diff --git a/depends/libxcb/depends/libxau/AuFileName.c b/depends/libxcb/depends/libxau/AuFileName.c
new file mode 100644
index 0000000..4ccda9d
--- /dev/null
+++ b/depends/libxcb/depends/libxau/AuFileName.c
@@ -0,0 +1,89 @@
+/*
+
+Copyright 1988, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/Xauth.h>
+#include <X11/Xos.h>
+#include <assert.h>
+#include <stdlib.h>
+
+static char *buf = NULL;
+
+static void
+free_filename_buffer(void)
+{
+    free(buf);
+    buf = NULL;
+}
+
+char *
+XauFileName (void)
+{
+    const char *slashDotXauthority = "/.Xauthority";
+    char    *name;
+    static size_t	bsize;
+    static int atexit_registered = 0;
+#ifdef WIN32
+    char    dir[128];
+#endif
+    size_t  size;
+
+    if ((name = getenv ("XAUTHORITY")))
+	return name;
+    name = getenv ("HOME");
+    if (!name) {
+#ifdef WIN32
+	if ((name = getenv("USERNAME"))) {
+	    snprintf(dir, sizeof(dir), "/users/%s", name);
+	    name = dir;
+	}
+	if (!name)
+#endif
+	return NULL;
+    }
+    size = strlen (name) + strlen(&slashDotXauthority[1]) + 2;
+    if ((size > bsize) || (buf == NULL)) {
+	free (buf);
+        assert(size > 0);
+	buf = malloc (size);
+	if (!buf) {
+	    bsize = 0;
+	    return NULL;
+	}
+
+        if (!atexit_registered) {
+            atexit(free_filename_buffer);
+            atexit_registered = 1;
+        }
+
+	bsize = size;
+    }
+    snprintf (buf, bsize, "%s%s", name,
+              slashDotXauthority + (name[0] == '/' && name[1] == '\0' ? 1 : 0));
+    return buf;
+}
diff --git a/depends/libxcb/depends/libxau/AuGetAddr.c b/depends/libxcb/depends/libxau/AuGetAddr.c
new file mode 100644
index 0000000..6f5fe16
--- /dev/null
+++ b/depends/libxcb/depends/libxau/AuGetAddr.c
@@ -0,0 +1,102 @@
+/*
+
+Copyright 1988, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/Xauth.h>
+#include <X11/Xos.h>
+
+#define binaryEqual(a, b, len) (memcmp(a, b, len) == 0)
+
+Xauth *
+XauGetAuthByAddr (
+#if NeedWidePrototypes
+unsigned int	family,
+unsigned int	address_length,
+#else
+unsigned short	family,
+unsigned short	address_length,
+#endif
+_Xconst char*	address,
+#if NeedWidePrototypes
+unsigned int	number_length,
+#else
+unsigned short	number_length,
+#endif
+_Xconst char*	number,
+#if NeedWidePrototypes
+unsigned int	name_length,
+#else
+unsigned short	name_length,
+#endif
+_Xconst char*	name)
+{
+    FILE    *auth_file;
+    char    *auth_name;
+    Xauth   *entry;
+
+    auth_name = XauFileName ();
+    if (!auth_name)
+	return NULL;
+    if (access (auth_name, R_OK) != 0)		/* checks REAL id */
+	return NULL;
+    auth_file = fopen (auth_name, "rb");
+    if (!auth_file)
+	return NULL;
+    for (;;) {
+	entry = XauReadAuth (auth_file);
+	if (!entry)
+	    break;
+	/*
+	 * Match when:
+	 *   either family or entry->family are FamilyWild or
+	 *    family and entry->family are the same and
+	 *     address and entry->address are the same
+	 *  and
+	 *   either number or entry->number are empty or
+	 *    number and entry->number are the same
+	 *  and
+	 *   either name or entry->name are empty or
+	 *    name and entry->name are the same
+	 */
+
+	if ((family == FamilyWild || entry->family == FamilyWild ||
+	     (entry->family == family &&
+	      address_length == entry->address_length &&
+	      binaryEqual (entry->address, address, address_length))) &&
+	    (number_length == 0 || entry->number_length == 0 ||
+	     (number_length == entry->number_length &&
+	      binaryEqual (entry->number, number, number_length))) &&
+	    (name_length == 0 || entry->name_length == 0 ||
+	     (entry->name_length == name_length &&
+	      binaryEqual (entry->name, name, name_length))))
+	    break;
+	XauDisposeAuth (entry);
+    }
+    (void) fclose (auth_file);
+    return entry;
+}
diff --git a/depends/libxcb/depends/libxau/AuGetBest.c b/depends/libxcb/depends/libxau/AuGetBest.c
new file mode 100644
index 0000000..5556559
--- /dev/null
+++ b/depends/libxcb/depends/libxau/AuGetBest.c
@@ -0,0 +1,163 @@
+/*
+
+Copyright 1988, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/Xauth.h>
+#include <X11/Xos.h>
+#ifdef XTHREADS
+#include <X11/Xthreads.h>
+#endif
+#ifdef hpux
+#define X_INCLUDE_NETDB_H
+#define XOS_USE_NO_LOCKING
+#include <X11/Xos_r.h>
+#endif
+
+#define binaryEqual(a, b, len) (memcmp(a, b, len) == 0)
+
+Xauth *
+XauGetBestAuthByAddr (
+#if NeedWidePrototypes
+    unsigned int	family,
+    unsigned int	address_length,
+#else
+    unsigned short	family,
+    unsigned short	address_length,
+#endif
+    _Xconst char*	address,
+#if NeedWidePrototypes
+    unsigned int	number_length,
+#else
+    unsigned short	number_length,
+#endif
+    _Xconst char*	number,
+    int			types_length,
+    char**		types,
+    _Xconst int*	type_lengths)
+{
+    FILE    *auth_file;
+    char    *auth_name;
+    Xauth   *entry;
+    Xauth   *best;
+    int	    best_type;
+    int	    type;
+#ifdef hpux
+    char		*fully_qual_address;
+    unsigned short	fully_qual_address_length;
+#endif
+
+    auth_name = XauFileName ();
+    if (!auth_name)
+	return NULL;
+    if (access (auth_name, R_OK) != 0)		/* checks REAL id */
+	return NULL;
+    auth_file = fopen (auth_name, "rb");
+    if (!auth_file)
+	return NULL;
+
+#ifdef hpux
+    if (family == FamilyLocal) {
+#ifdef XTHREADS_NEEDS_BYNAMEPARAMS
+	_Xgethostbynameparams hparams;
+#endif
+	struct hostent *hostp;
+
+	/* make sure we try fully-qualified hostname */
+	if ((hostp = _XGethostbyname(address,hparams)) != NULL) {
+	    fully_qual_address = hostp->h_name;
+	    fully_qual_address_length = strlen(fully_qual_address);
+	}
+	else
+	{
+	    fully_qual_address = NULL;
+	    fully_qual_address_length = 0;
+	}
+    }
+#endif /* hpux */
+
+    best = NULL;
+    best_type = types_length;
+    for (;;) {
+	entry = XauReadAuth (auth_file);
+	if (!entry)
+	    break;
+	/*
+	 * Match when:
+	 *   either family or entry->family are FamilyWild or
+	 *    family and entry->family are the same and
+	 *     address and entry->address are the same
+	 *  and
+	 *   either number or entry->number are empty or
+	 *    number and entry->number are the same
+	 *  and
+	 *   either name or entry->name are empty or
+	 *    name and entry->name are the same
+	 */
+
+	if ((family == FamilyWild || entry->family == FamilyWild ||
+	     (entry->family == family &&
+	     ((address_length == entry->address_length &&
+	      binaryEqual (entry->address, address, address_length))
+#ifdef hpux
+	     || (family == FamilyLocal &&
+		fully_qual_address_length == entry->address_length &&
+	     	binaryEqual (entry->address, fully_qual_address,
+		    fully_qual_address_length))
+#endif
+	    ))) &&
+	    (number_length == 0 || entry->number_length == 0 ||
+	     (number_length == entry->number_length &&
+	      binaryEqual (entry->number, number, number_length))))
+	{
+	    if (best_type == 0)
+	    {
+		best = entry;
+		break;
+	    }
+	    for (type = 0; type < best_type; type++)
+		if (type_lengths[type] == entry->name_length &&
+		    !(strncmp (types[type], entry->name, entry->name_length)))
+		{
+		    break;
+		}
+	    if (type < best_type)
+	    {
+		if (best)
+		    XauDisposeAuth (best);
+		best = entry;
+		best_type = type;
+		if (type == 0)
+		    break;
+		continue;
+	    }
+	}
+	XauDisposeAuth (entry);
+    }
+    (void) fclose (auth_file);
+    return best;
+}
diff --git a/depends/libxcb/depends/libxau/AuLock.c b/depends/libxcb/depends/libxau/AuLock.c
new file mode 100644
index 0000000..5dfc174
--- /dev/null
+++ b/depends/libxcb/depends/libxau/AuLock.c
@@ -0,0 +1,108 @@
+/*
+
+Copyright 1988, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/Xauth.h>
+#include <X11/Xos.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <time.h>
+#define Time_t time_t
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+#ifdef WIN32
+# include <X11/Xwindows.h>
+# define link rename
+#endif
+
+int
+XauLockAuth (
+_Xconst char *file_name,
+int	retries,
+int	timeout,
+long	dead)
+{
+    char	creat_name[1025], link_name[1025];
+    struct stat	statb;
+    Time_t	now;
+    int		creat_fd = -1;
+
+    if (strlen (file_name) > 1022)
+	return LOCK_ERROR;
+    snprintf (creat_name, sizeof(creat_name), "%s-c", file_name);
+    snprintf (link_name, sizeof(link_name), "%s-l", file_name);
+    if (stat (creat_name, &statb) != -1) {
+	now = time ((Time_t *) 0);
+	/*
+	 * NFS may cause ctime to be before now, special
+	 * case a 0 deadtime to force lock removal
+	 */
+	if (dead == 0 || now - statb.st_ctime > dead) {
+	    (void) remove (creat_name);
+	    (void) remove (link_name);
+	}
+    }
+
+    while (retries > 0) {
+	if (creat_fd == -1) {
+	    creat_fd = open (creat_name, O_WRONLY | O_CREAT | O_EXCL, 0600);
+	    if (creat_fd == -1) {
+		if (errno != EACCES && errno != EEXIST)
+		    return LOCK_ERROR;
+	    } else
+		(void) close (creat_fd);
+	}
+	if (creat_fd != -1) {
+#ifdef HAVE_PATHCONF
+	    /* The file system may not support hard links, and pathconf should tell us that. */
+	    if (1 == pathconf(creat_name, _PC_LINK_MAX)) {
+		if (-1 == rename(creat_name, link_name)) {
+		    /* Is this good enough?  Perhaps we should retry.  TEST */
+		    return LOCK_ERROR;
+		} else {
+		    return LOCK_SUCCESS;
+		}
+	    } else
+#endif
+	    {
+	    	if (link (creat_name, link_name) != -1)
+		    return LOCK_SUCCESS;
+		if (errno == ENOENT) {
+		    creat_fd = -1;	/* force re-creat next time around */
+		    continue;
+	    	}
+	    	if (errno != EEXIST)
+		    return LOCK_ERROR;
+	   }
+	}
+	(void) sleep ((unsigned) timeout);
+	--retries;
+    }
+    return LOCK_TIMEOUT;
+}
diff --git a/depends/libxcb/depends/libxau/AuRead.c b/depends/libxcb/depends/libxau/AuRead.c
new file mode 100644
index 0000000..93774b0
--- /dev/null
+++ b/depends/libxcb/depends/libxau/AuRead.c
@@ -0,0 +1,116 @@
+/*
+
+Copyright 1988, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/Xauth.h>
+#include <stdlib.h>
+
+static int
+read_short (unsigned short *shortp, FILE *file)
+{
+    unsigned char   file_short[2];
+
+    if (fread ((char *) file_short, sizeof (file_short), 1, file) != 1)
+	return 0;
+    *shortp = file_short[0] * 256 + file_short[1];
+    return 1;
+}
+
+static int
+read_counted_string (unsigned short *countp, char **stringp, FILE *file)
+{
+    unsigned short  len;
+    char	    *data;
+
+    if (read_short (&len, file) == 0)
+	return 0;
+    if (len == 0) {
+	data = NULL;
+    } else {
+    	data = malloc ((unsigned) len);
+    	if (!data)
+	    return 0;
+	if (fread (data, sizeof (char), len, file) != len) {
+#ifdef HAVE_EXPLICIT_BZERO
+	    explicit_bzero (data, len);
+#else
+	    bzero (data, len);
+#endif
+	    free (data);
+	    return 0;
+    	}
+    }
+    *stringp = data;
+    *countp = len;
+    return 1;
+}
+
+Xauth *
+XauReadAuth (FILE *auth_file)
+{
+    Xauth   local = { 0, 0, NULL, 0, NULL, 0, NULL, 0, NULL };
+    Xauth   *ret;
+
+    if (read_short (&local.family, auth_file) == 0) {
+	goto fail;
+    }
+    if (read_counted_string (&local.address_length, &local.address, auth_file)
+        == 0) {
+	goto fail;
+    }
+    if (read_counted_string (&local.number_length, &local.number, auth_file)
+        == 0) {
+	goto fail;
+    }
+    if (read_counted_string (&local.name_length, &local.name, auth_file) == 0) {
+	goto fail;
+    }
+    if (read_counted_string (&local.data_length, &local.data, auth_file) == 0) {
+	goto fail;
+    }
+    ret = malloc (sizeof (Xauth));
+    if (ret == NULL) {
+	goto fail;
+    }
+    *ret = local;
+    return ret;
+
+  fail:
+    free (local.address);
+    free (local.number);
+    free (local.name);
+    if (local.data) {
+#ifdef HAVE_EXPLICIT_BZERO
+	explicit_bzero (local.data, local.data_length);
+#else
+	bzero (local.data, local.data_length);
+#endif
+	free (local.data);
+    }
+    return NULL;
+}
diff --git a/depends/libxcb/depends/libxau/AuUnlock.c b/depends/libxcb/depends/libxau/AuUnlock.c
new file mode 100644
index 0000000..b817246
--- /dev/null
+++ b/depends/libxcb/depends/libxau/AuUnlock.c
@@ -0,0 +1,57 @@
+/*
+
+Copyright 1988, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/Xauth.h>
+#include <X11/Xos.h>
+
+int
+XauUnlockAuth (
+_Xconst char *file_name)
+{
+#ifndef WIN32
+    char	creat_name[1025];
+#endif
+    char	link_name[1025];
+
+    if (strlen (file_name) > 1022)
+	return 0;
+#ifndef WIN32
+    snprintf (creat_name, sizeof(creat_name), "%s-c", file_name);
+#endif
+    snprintf (link_name, sizeof(link_name), "%s-l", file_name);
+    /*
+     * I think this is the correct order
+     */
+#ifndef WIN32
+    (void) remove (creat_name);
+#endif
+    (void) remove (link_name);
+
+    return 1;
+}
diff --git a/depends/libxcb/depends/libxau/AuWrite.c b/depends/libxcb/depends/libxau/AuWrite.c
new file mode 100644
index 0000000..1eb38a3
--- /dev/null
+++ b/depends/libxcb/depends/libxau/AuWrite.c
@@ -0,0 +1,68 @@
+/*
+
+Copyright 1988, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/Xauth.h>
+
+static int
+write_short (unsigned short s, FILE *file)
+{
+    unsigned char   file_short[2];
+
+    file_short[0] = (s & (unsigned)0xff00) >> 8;
+    file_short[1] = s & 0xff;
+    if (fwrite ((char *) file_short, sizeof (file_short), 1, file) != 1)
+	return 0;
+    return 1;
+}
+
+static int
+write_counted_string (unsigned short count, char *string, FILE *file)
+{
+    if (write_short (count, file) == 0)
+	return 0;
+    if (fwrite (string, sizeof (char), count, file) != count)
+	return 0;
+    return 1;
+}
+
+int
+XauWriteAuth (FILE *auth_file, Xauth *auth)
+{
+    if (write_short (auth->family, auth_file) == 0)
+	return 0;
+    if (write_counted_string (auth->address_length, auth->address, auth_file) == 0)
+	return 0;
+    if (write_counted_string (auth->number_length, auth->number, auth_file) == 0)
+	return 0;
+    if (write_counted_string (auth->name_length, auth->name, auth_file) == 0)
+	return 0;
+    if (write_counted_string (auth->data_length, auth->data, auth_file) == 0)
+	return 0;
+    return 1;
+}
diff --git a/depends/libxcb/depends/libxau/config.h b/depends/libxcb/depends/libxau/config.h
new file mode 100644
index 0000000..cd08b1f
--- /dev/null
+++ b/depends/libxcb/depends/libxau/config.h
@@ -0,0 +1,185 @@
+/* config.h.  Generated from config.h.in by configure.  */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* Define to 1 if you have the `explicit_bzero' function. */
+#define HAVE_EXPLICIT_BZERO 1
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the <minix/config.h> header file. */
+/* #undef HAVE_MINIX_CONFIG_H */
+
+/* Define to 1 if you have the `pathconf' function. */
+#define HAVE_PATHCONF 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdio.h> header file. */
+#define HAVE_STDIO_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to 1 if you have the <wchar.h> header file. */
+#define HAVE_WCHAR_H 1
+
+/* Define to the sub-directory where libtool stores uninstalled libraries. */
+#define LT_OBJDIR ".libs/"
+
+/* Name of package */
+#define PACKAGE "libXau"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "https://gitlab.freedesktop.org/xorg/lib/libxau/-/issues"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "libXau"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "libXau 1.0.11"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "libXau"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL ""
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "1.0.11"
+
+/* Major version of this package */
+#define PACKAGE_VERSION_MAJOR 1
+
+/* Minor version of this package */
+#define PACKAGE_VERSION_MINOR 0
+
+/* Patch version of this package */
+#define PACKAGE_VERSION_PATCHLEVEL 11
+
+/* Define to 1 if all of the C90 standard headers exist (not just the ones
+   required in a freestanding environment). This macro is provided for
+   backward compatibility; new code need not use it. */
+#define STDC_HEADERS 1
+
+/* Enable extensions on AIX 3, Interix.  */
+#ifndef _ALL_SOURCE
+# define _ALL_SOURCE 1
+#endif
+/* Enable general extensions on macOS.  */
+#ifndef _DARWIN_C_SOURCE
+# define _DARWIN_C_SOURCE 1
+#endif
+/* Enable general extensions on Solaris.  */
+#ifndef __EXTENSIONS__
+# define __EXTENSIONS__ 1
+#endif
+/* Enable GNU extensions on systems that have them.  */
+#ifndef _GNU_SOURCE
+# define _GNU_SOURCE 1
+#endif
+/* Enable X/Open compliant socket functions that do not require linking
+   with -lxnet on HP-UX 11.11.  */
+#ifndef _HPUX_ALT_XOPEN_SOCKET_API
+# define _HPUX_ALT_XOPEN_SOCKET_API 1
+#endif
+/* Identify the host operating system as Minix.
+   This macro does not affect the system headers' behavior.
+   A future release of Autoconf may stop defining this macro.  */
+#ifndef _MINIX
+/* # undef _MINIX */
+#endif
+/* Enable general extensions on NetBSD.
+   Enable NetBSD compatibility extensions on Minix.  */
+#ifndef _NETBSD_SOURCE
+# define _NETBSD_SOURCE 1
+#endif
+/* Enable OpenBSD compatibility extensions on NetBSD.
+   Oddly enough, this does nothing on OpenBSD.  */
+#ifndef _OPENBSD_SOURCE
+# define _OPENBSD_SOURCE 1
+#endif
+/* Define to 1 if needed for POSIX-compatible behavior.  */
+#ifndef _POSIX_SOURCE
+/* # undef _POSIX_SOURCE */
+#endif
+/* Define to 2 if needed for POSIX-compatible behavior.  */
+#ifndef _POSIX_1_SOURCE
+/* # undef _POSIX_1_SOURCE */
+#endif
+/* Enable POSIX-compatible threading on Solaris.  */
+#ifndef _POSIX_PTHREAD_SEMANTICS
+# define _POSIX_PTHREAD_SEMANTICS 1
+#endif
+/* Enable extensions specified by ISO/IEC TS 18661-5:2014.  */
+#ifndef __STDC_WANT_IEC_60559_ATTRIBS_EXT__
+# define __STDC_WANT_IEC_60559_ATTRIBS_EXT__ 1
+#endif
+/* Enable extensions specified by ISO/IEC TS 18661-1:2014.  */
+#ifndef __STDC_WANT_IEC_60559_BFP_EXT__
+# define __STDC_WANT_IEC_60559_BFP_EXT__ 1
+#endif
+/* Enable extensions specified by ISO/IEC TS 18661-2:2015.  */
+#ifndef __STDC_WANT_IEC_60559_DFP_EXT__
+# define __STDC_WANT_IEC_60559_DFP_EXT__ 1
+#endif
+/* Enable extensions specified by ISO/IEC TS 18661-4:2015.  */
+#ifndef __STDC_WANT_IEC_60559_FUNCS_EXT__
+# define __STDC_WANT_IEC_60559_FUNCS_EXT__ 1
+#endif
+/* Enable extensions specified by ISO/IEC TS 18661-3:2015.  */
+#ifndef __STDC_WANT_IEC_60559_TYPES_EXT__
+# define __STDC_WANT_IEC_60559_TYPES_EXT__ 1
+#endif
+/* Enable extensions specified by ISO/IEC TR 24731-2:2010.  */
+#ifndef __STDC_WANT_LIB_EXT2__
+# define __STDC_WANT_LIB_EXT2__ 1
+#endif
+/* Enable extensions specified by ISO/IEC 24747:2009.  */
+#ifndef __STDC_WANT_MATH_SPEC_FUNCS__
+# define __STDC_WANT_MATH_SPEC_FUNCS__ 1
+#endif
+/* Enable extensions on HP NonStop.  */
+#ifndef _TANDEM_SOURCE
+# define _TANDEM_SOURCE 1
+#endif
+/* Enable X/Open extensions.  Define to 500 only if necessary
+   to make mbstate_t available.  */
+#ifndef _XOPEN_SOURCE
+/* # undef _XOPEN_SOURCE */
+#endif
+
+
+/* Version number of package */
+#define VERSION "1.0.11"
+
+/* Whether libXau is compiled with thread support */
+#define XTHREADS 1
+
+/* Whether libXau needs to use MT safe API's */
+#define XUSE_MTSAFE_API 1
+
+/* Number of bits in a file offset, on hosts where this is settable. */
+/* #undef _FILE_OFFSET_BITS */
+
+/* Define for large files, on AIX-style hosts. */
+/* #undef _LARGE_FILES */
diff --git a/depends/libxcb/depends/libxau/include/X11/Xauth.h b/depends/libxcb/depends/libxau/include/X11/Xauth.h
new file mode 100644
index 0000000..a51bc72
--- /dev/null
+++ b/depends/libxcb/depends/libxau/include/X11/Xauth.h
@@ -0,0 +1,149 @@
+/*
+
+Copyright 1988, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+#ifndef _Xauth_h
+#define _Xauth_h
+
+/* struct xauth is full of implicit padding to properly align the pointers
+   after the length fields.   We can't clean that up without breaking ABI,
+   so tell clang not to bother complaining about it. */
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+typedef struct xauth {
+    unsigned short   family;
+    unsigned short   address_length;
+    char    	    *address;
+    unsigned short   number_length;
+    char    	    *number;
+    unsigned short   name_length;
+    char    	    *name;
+    unsigned short   data_length;
+    char   	    *data;
+} Xauth;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#ifndef _XAUTH_STRUCT_ONLY
+
+# include   <X11/Xfuncproto.h>
+# include   <X11/Xfuncs.h>
+
+# include   <stdio.h>
+
+# define FamilyLocal (256)	/* not part of X standard (i.e. X.h) */
+# define FamilyWild  (65535)
+# define FamilyNetname    (254)   /* not part of X standard */
+# define FamilyKrb5Principal (253) /* Kerberos 5 principal name */
+# define FamilyLocalHost (252)	/* for local non-net authentication */
+
+
+_XFUNCPROTOBEGIN
+
+char *XauFileName(void);
+
+Xauth *XauReadAuth(
+FILE*	/* auth_file */
+);
+
+int XauLockAuth(
+_Xconst char*	/* file_name */,
+int		/* retries */,
+int		/* timeout */,
+long		/* dead */
+);
+
+int XauUnlockAuth(
+_Xconst char*	/* file_name */
+);
+
+int XauWriteAuth(
+FILE*		/* auth_file */,
+Xauth*		/* auth */
+);
+
+Xauth *XauGetAuthByAddr(
+#if NeedWidePrototypes
+unsigned int	/* family */,
+unsigned int	/* address_length */,
+#else
+unsigned short	/* family */,
+unsigned short	/* address_length */,
+#endif
+_Xconst char*	/* address */,
+#if NeedWidePrototypes
+unsigned int	/* number_length */,
+#else
+unsigned short	/* number_length */,
+#endif
+_Xconst char*	/* number */,
+#if NeedWidePrototypes
+unsigned int	/* name_length */,
+#else
+unsigned short	/* name_length */,
+#endif
+_Xconst char*	/* name */
+);
+
+Xauth *XauGetBestAuthByAddr(
+#if NeedWidePrototypes
+unsigned int	/* family */,
+unsigned int	/* address_length */,
+#else
+unsigned short	/* family */,
+unsigned short	/* address_length */,
+#endif
+_Xconst char*	/* address */,
+#if NeedWidePrototypes
+unsigned int	/* number_length */,
+#else
+unsigned short	/* number_length */,
+#endif
+_Xconst char*	/* number */,
+int		/* types_length */,
+char**		/* type_names */,
+_Xconst int*	/* type_lengths */
+);
+
+void XauDisposeAuth(
+Xauth*		/* auth */
+);
+
+_XFUNCPROTOEND
+
+/* Return values from XauLockAuth */
+
+# define LOCK_SUCCESS	0	/* lock succeeded */
+# define LOCK_ERROR	1	/* lock unexpectedly failed, check errno */
+# define LOCK_TIMEOUT	2	/* lock failed, timeouts expired */
+
+#endif /* _XAUTH_STRUCT_ONLY */
+
+#endif /* _Xauth_h */
diff --git a/depends/libxcb/depends/libxdmcp/Array.c b/depends/libxcb/depends/libxdmcp/Array.c
new file mode 100644
index 0000000..b7bcc48
--- /dev/null
+++ b/depends/libxcb/depends/libxdmcp/Array.c
@@ -0,0 +1,260 @@
+/*
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ *
+ * Author:  Keith Packard, MIT X Consortium
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/Xos.h>
+#include <X11/X.h>
+#include <X11/Xmd.h>
+#include <X11/Xdmcp.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/*
+ * This variant of malloc does not return NULL if zero size is passed into.
+ */
+static void *
+xmalloc(size_t size)
+{
+    return malloc(size ? size : 1);
+}
+
+/*
+ * This variant of calloc does not return NULL if zero count is passed into.
+ */
+static void *
+xcalloc(size_t n, size_t size)
+{
+    return calloc(n ? n : 1, size);
+}
+
+/*
+ * This variant of realloc does not return NULL if zero size is passed into
+ */
+static void *
+xrealloc(void *ptr, size_t size)
+{
+    return realloc(ptr, size ? size : 1);
+}
+
+int
+XdmcpAllocARRAY8 (ARRAY8Ptr array, int length)
+{
+    /* length defined in ARRAY8 struct is a CARD16 (not CARD8 like the rest) */
+    if ((length > UINT16_MAX) || (length < 0))
+        array->data = NULL;
+    else
+        array->data = xmalloc(length * sizeof (CARD8));
+
+    if (array->data == NULL) {
+	array->length = 0;
+	return FALSE;
+    }
+    array->length = (CARD16) length;
+    return TRUE;
+}
+
+int
+XdmcpAllocARRAY16 (ARRAY16Ptr array, int length)
+{
+    /* length defined in ARRAY16 struct is a CARD8 */
+    if ((length > UINT8_MAX) || (length < 0))
+        array->data = NULL;
+    else
+        array->data = xmalloc(length * sizeof (CARD16));
+
+    if (array->data == NULL) {
+	array->length = 0;
+	return FALSE;
+    }
+    array->length = (CARD8) length;
+    return TRUE;
+}
+
+int
+XdmcpAllocARRAY32 (ARRAY32Ptr array, int length)
+{
+    /* length defined in ARRAY32 struct is a CARD8 */
+    if ((length > UINT8_MAX) || (length < 0))
+        array->data = NULL;
+    else
+        array->data = xmalloc(length * sizeof (CARD32));
+
+    if (array->data == NULL) {
+	array->length = 0;
+	return FALSE;
+    }
+    array->length = (CARD8) length;
+    return TRUE;
+}
+
+int
+XdmcpAllocARRAYofARRAY8 (ARRAYofARRAY8Ptr array, int length)
+{
+    /* length defined in ARRAYofARRAY8 struct is a CARD8 */
+    if ((length > UINT8_MAX) || (length < 0))
+        array->data = NULL;
+    else
+        /*
+         * Use calloc to ensure the pointers are cleared out so we
+         * don't try to free garbage if XdmcpDisposeARRAYofARRAY8()
+         * is called before the caller sets them to valid pointers.
+         */
+        array->data = xcalloc(length, sizeof (ARRAY8));
+
+    if (array->data == NULL) {
+	array->length = 0;
+	return FALSE;
+    }
+    array->length = (CARD8) length;
+    return TRUE;
+}
+
+int
+XdmcpARRAY8Equal (const ARRAY8Ptr array1, const ARRAY8Ptr array2)
+{
+    if (array1->length != array2->length)
+	return FALSE;
+    if (memcmp(array1->data, array2->data, array1->length) != 0)
+	return FALSE;
+    return TRUE;
+}
+
+int
+XdmcpCopyARRAY8 (const ARRAY8Ptr src, ARRAY8Ptr dst)
+{
+    if (!XdmcpAllocARRAY8(dst, src->length))
+	return FALSE;
+    memcpy(dst->data, src->data, src->length * sizeof (CARD8));
+    return TRUE;
+}
+
+int
+XdmcpReallocARRAY8 (ARRAY8Ptr array, int length)
+{
+    CARD8Ptr	newData;
+
+    /* length defined in ARRAY8 struct is a CARD16 (not CARD8 like the rest) */
+    if ((length > UINT16_MAX) || (length < 0))
+	return FALSE;
+
+    newData = (CARD8Ptr) xrealloc(array->data, length * sizeof (CARD8));
+    if (!newData)
+	return FALSE;
+    array->length = (CARD16) length;
+    array->data = newData;
+    return TRUE;
+}
+
+int
+XdmcpReallocARRAYofARRAY8 (ARRAYofARRAY8Ptr array, int length)
+{
+    ARRAY8Ptr	newData;
+
+    /* length defined in ARRAYofARRAY8 struct is a CARD8 */
+    if ((length > UINT8_MAX) || (length < 0))
+	return FALSE;
+
+    newData = (ARRAY8Ptr) xrealloc(array->data, length * sizeof (ARRAY8));
+    if (!newData)
+	return FALSE;
+    if (length > array->length)
+        memset(newData + array->length, 0,
+               (length - array->length) * sizeof (ARRAY8));
+    array->length = (CARD8) length;
+    array->data = newData;
+    return TRUE;
+}
+
+int
+XdmcpReallocARRAY16 (ARRAY16Ptr array, int length)
+{
+    CARD16Ptr	newData;
+
+    /* length defined in ARRAY16 struct is a CARD8 */
+    if ((length > UINT8_MAX) || (length < 0))
+	return FALSE;
+    newData = (CARD16Ptr) xrealloc(array->data, length * sizeof (CARD16));
+    if (!newData)
+	return FALSE;
+    array->length = (CARD8) length;
+    array->data = newData;
+    return TRUE;
+}
+
+int
+XdmcpReallocARRAY32 (ARRAY32Ptr array, int length)
+{
+    CARD32Ptr	newData;
+
+    /* length defined in ARRAY32 struct is a CARD8 */
+    if ((length > UINT8_MAX) || (length < 0))
+	return FALSE;
+
+    newData = (CARD32Ptr) xrealloc(array->data, length * sizeof (CARD32));
+    if (!newData)
+	return FALSE;
+    array->length = (CARD8) length;
+    array->data = newData;
+    return TRUE;
+}
+
+void
+XdmcpDisposeARRAY8 (ARRAY8Ptr array)
+{
+    free(array->data);
+    array->length = 0;
+    array->data = NULL;
+}
+
+void
+XdmcpDisposeARRAY16 (ARRAY16Ptr array)
+{
+    free(array->data);
+    array->length = 0;
+    array->data = NULL;
+}
+
+void
+XdmcpDisposeARRAY32 (ARRAY32Ptr array)
+{
+    free(array->data);
+    array->length = 0;
+    array->data = NULL;
+}
+
+void
+XdmcpDisposeARRAYofARRAY8 (ARRAYofARRAY8Ptr array)
+{
+    if (array->data != NULL) {
+	for (unsigned int i = 0; i < (unsigned int) array->length; i++)
+	    XdmcpDisposeARRAY8 (&array->data[i]);
+	free(array->data);
+    }
+    array->length = 0;
+    array->data = NULL;
+}
diff --git a/depends/libxcb/depends/libxdmcp/Fill.c b/depends/libxcb/depends/libxdmcp/Fill.c
new file mode 100644
index 0000000..61cd974
--- /dev/null
+++ b/depends/libxcb/depends/libxdmcp/Fill.c
@@ -0,0 +1,68 @@
+/*
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ * *
+ * Author:  Keith Packard, MIT X Consortium
+ */
+
+#ifdef WIN32
+#define _WILLWINSOCK_
+#endif
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/Xos.h>
+#include <X11/X.h>
+#include <X11/Xmd.h>
+#include <X11/Xdmcp.h>
+#include <stdlib.h>
+
+#ifdef WIN32
+#include <X11/Xwinsock.h>
+#else
+#include <sys/socket.h>
+#endif
+
+int
+XdmcpFill (int fd, XdmcpBufferPtr buffer, XdmcpNetaddr from, int *fromlen)
+{
+    BYTE    *newBuf;
+
+    if (buffer->size < XDM_MAX_MSGLEN)
+    {
+	newBuf = (BYTE *) malloc(XDM_MAX_MSGLEN);
+	if (newBuf)
+	{
+	    free(buffer->data);
+	    buffer->data = newBuf;
+	    buffer->size = XDM_MAX_MSGLEN;
+	}
+    }
+    buffer->pointer = 0;
+    buffer->count = recvfrom (fd, (char*)buffer->data, buffer->size, 0,
+			      (struct sockaddr *)from, (void *)fromlen);
+    if (buffer->count < 6) {
+	buffer->count = 0;
+	return FALSE;
+    }
+    return TRUE;
+}
diff --git a/depends/libxcb/depends/libxdmcp/Flush.c b/depends/libxcb/depends/libxdmcp/Flush.c
new file mode 100644
index 0000000..1654846
--- /dev/null
+++ b/depends/libxcb/depends/libxdmcp/Flush.c
@@ -0,0 +1,53 @@
+/*
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ * *
+ * Author:  Keith Packard, MIT X Consortium
+ */
+
+#ifdef WIN32
+#define _WILLWINSOCK_
+#endif
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/Xos.h>
+#include <X11/X.h>
+#include <X11/Xmd.h>
+#include <X11/Xdmcp.h>
+
+#ifdef WIN32
+#include <X11/Xwinsock.h>
+#else
+#include <sys/socket.h>
+#endif
+
+int
+XdmcpFlush (int fd, XdmcpBufferPtr buffer, XdmcpNetaddr to, int tolen)
+{
+    int result;
+    result = sendto (fd, (char *)buffer->data, buffer->pointer, 0,
+		     (struct sockaddr *)to, tolen);
+    if (result != buffer->pointer)
+	return FALSE;
+    return TRUE;
+}
diff --git a/depends/libxcb/depends/libxdmcp/Key.c b/depends/libxcb/depends/libxdmcp/Key.c
new file mode 100644
index 0000000..e430eb0
--- /dev/null
+++ b/depends/libxcb/depends/libxdmcp/Key.c
@@ -0,0 +1,140 @@
+/*
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ *
+ * Author:  Keith Packard, MIT X Consortium
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/Xos.h>
+#include <X11/X.h>
+#include <X11/Xmd.h>
+#include <X11/Xdmcp.h>
+
+#ifdef __MUSL__
+#ifdef HAVE_ARC4RANDOM_BUF
+#undef HAVE_ARC4RANDOM_BUF
+#endif /* HAVE_ARC4RANDOM_BUF */
+#endif /* __MUSL__ */
+
+#ifndef HAVE_ARC4RANDOM_BUF
+static void
+getbits (long data, unsigned char *dst)
+{
+    dst[0] = (data      ) & 0xff;
+    dst[1] = (data >>  8) & 0xff;
+    dst[2] = (data >> 16) & 0xff;
+    dst[3] = (data >> 24) & 0xff;
+}
+#endif
+
+#define Time_t time_t
+
+#include <stdlib.h>
+
+#if defined(HAVE_LRAND48) && defined(HAVE_SRAND48)
+#define srandom srand48
+#define random lrand48
+#endif
+#ifdef WIN32
+#include <process.h>
+#define srandom srand
+#define random rand
+#define getpid(x) _getpid(x)
+#endif
+
+#ifndef HAVE_ARC4RANDOM_BUF
+
+/* Solaris 11.3.0 - 11.4.15 only define getentropy() in <sys/random.h> */
+#if HAVE_GETENTROPY && HAVE_SYS_RANDOM_H
+# include <sys/random.h>
+#endif
+
+static void
+insecure_getrandom_buf (unsigned char *auth, int len)
+{
+    long    lowbits, highbits;
+
+    srandom ((int)getpid() ^ time((Time_t *)0));
+    lowbits = random ();
+    highbits = random ();
+    getbits (lowbits, auth);
+    getbits (highbits, auth + 4);
+}
+
+static void
+arc4random_buf (void *auth, int len)
+{
+#if HAVE_GETENTROPY
+    int	    ret;
+
+    /* weak emulation of arc4random through the getentropy libc call */
+    ret = getentropy (auth, len);
+    if (ret == 0)
+	return;
+#endif /* HAVE_GETENTROPY */
+
+    insecure_getrandom_buf (auth, len);
+}
+
+#endif /* !defined(HAVE_ARC4RANDOM_BUF) */
+
+void
+XdmcpGenerateKey (XdmAuthKeyPtr key)
+{
+    arc4random_buf(key->data, 8);
+}
+
+int
+XdmcpCompareKeys (const XdmAuthKeyPtr a, const XdmAuthKeyPtr b)
+{
+    int	i;
+
+    for (i = 0; i < 8; i++)
+	if (a->data[i] != b->data[i])
+	    return FALSE;
+    return TRUE;
+}
+
+void
+XdmcpIncrementKey (XdmAuthKeyPtr key)
+{
+    int	i;
+
+    i = 7;
+    while (++key->data[i] == 0)
+	if (--i < 0)
+	    break;
+}
+
+void
+XdmcpDecrementKey (XdmAuthKeyPtr key)
+{
+    int	i;
+
+    i = 7;
+    while (key->data[i]-- == 0)
+	if (--i < 0)
+	    break;
+}
diff --git a/depends/libxcb/depends/libxdmcp/Read.c b/depends/libxcb/depends/libxdmcp/Read.c
new file mode 100644
index 0000000..7da6163
--- /dev/null
+++ b/depends/libxcb/depends/libxdmcp/Read.c
@@ -0,0 +1,244 @@
+/*
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ *
+ * Author:  Keith Packard, MIT X Consortium
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/Xos.h>
+#include <X11/X.h>
+#include <X11/Xmd.h>
+#include <X11/Xdmcp.h>
+#include <stdlib.h>
+
+int
+XdmcpReadHeader (XdmcpBufferPtr buffer, XdmcpHeaderPtr header)
+{
+    if (XdmcpReadCARD16 (buffer, &header->version) &&
+        XdmcpReadCARD16 (buffer, &header->opcode) &&
+	XdmcpReadCARD16 (buffer, &header->length))
+	return TRUE;
+    return FALSE;
+}
+
+int
+XdmcpReadRemaining (const XdmcpBufferPtr  buffer)
+{
+    return buffer->count - buffer->pointer;
+}
+
+int
+XdmcpReadARRAY8 (XdmcpBufferPtr buffer, ARRAY8Ptr array)
+{
+    int	    i;
+
+    /*
+     * When returning FALSE, guarantee that array->data = 0.
+     * This allows the user to safely call XdmcpDisposeARRAY8(array)
+     * regardless of the return value below.
+     * Note that XdmcpDisposeARRAY*(array) will call free(array->data),
+     * so we must guarantee that array->data is NULL or a malloced pointer.
+     */
+    if (!XdmcpReadCARD16 (buffer, &array->length)) {
+ 	array->data = NULL;
+	return FALSE;
+    }
+    if (!array->length)
+    {
+	array->data = NULL;
+	return TRUE;
+    }
+    array->data = (CARD8 *) malloc(array->length * sizeof (CARD8));
+    if (!array->data)
+	return FALSE;
+    for (i = 0; i < (int)array->length; i++)
+    {
+	if (!XdmcpReadCARD8 (buffer, &array->data[i]))
+	{
+	    free(array->data);
+	    array->data = NULL;
+	    array->length = 0;
+	    return FALSE;
+	}
+    }
+    return TRUE;
+}
+
+int
+XdmcpReadARRAY16 (XdmcpBufferPtr buffer, ARRAY16Ptr array)
+{
+    int	    i;
+
+    /*
+     * When returning FALSE, guarantee that array->data = 0.
+     * This allows the user to safely call XdmcpDisposeARRAY16(array)
+     * regardless of the return value below.
+     * Note that XdmcpDisposeARRAY*(array) will call free(array->data),
+     * so we must guarantee that array->data is NULL or a malloced pointer.
+     */
+    if (!XdmcpReadCARD8 (buffer, &array->length)) {
+	array->data = NULL;
+	return FALSE;
+    }
+    if (!array->length)
+    {
+	array->data = NULL;
+	return TRUE;
+    }
+    array->data = (CARD16 *) malloc(array->length * sizeof (CARD16));
+    if (!array->data)
+	return FALSE;
+    for (i = 0; i < (int)array->length; i++)
+    {
+	if (!XdmcpReadCARD16 (buffer, &array->data[i]))
+	{
+	    free(array->data);
+	    array->data = NULL;
+	    array->length = 0;
+	    return FALSE;
+	}
+    }
+    return TRUE;
+}
+
+int
+XdmcpReadARRAY32 (XdmcpBufferPtr buffer, ARRAY32Ptr array)
+{
+    int	    i;
+
+    /*
+     * When returning FALSE, guarantee that array->data = 0.
+     * This allows the user to safely call XdmcpDisposeARRAY32(array)
+     * regardless of the return value below.
+     * Note that XdmcpDisposeARRAY*(array) will call free(array->data),
+     * so we must guarantee that array->data is NULL or a malloced pointer.
+     */
+    if (!XdmcpReadCARD8 (buffer, &array->length)) {
+	array->data = NULL;
+	return FALSE;
+    }
+    if (!array->length)
+    {
+	array->data = NULL;
+	return TRUE;
+    }
+    array->data = (CARD32 *) malloc(array->length * sizeof (CARD32));
+    if (!array->data)
+	return FALSE;
+    for (i = 0; i < (int)array->length; i++)
+    {
+	if (!XdmcpReadCARD32 (buffer, &array->data[i]))
+	{
+	    free(array->data);
+	    array->data = NULL;
+	    array->length = 0;
+	    return FALSE;
+	}
+    }
+    return TRUE;
+}
+
+int
+XdmcpReadARRAYofARRAY8 (XdmcpBufferPtr buffer, ARRAYofARRAY8Ptr array)
+{
+    CARD8    i;
+
+    /*
+     * When returning FALSE, guarantee that array->data = 0.
+     * This allows the user to safely call XdmcpDisposeARRAYofARRAY8(array)
+     * regardless of the return value below.
+     * Note that XdmcpDisposeARRAY*(array) will call free(array->data),
+     * so we must guarantee that array->data is NULL or a malloced pointer.
+     */
+    if (!XdmcpReadCARD8 (buffer, &array->length)) {
+	array->data = NULL;
+	return FALSE;
+    }
+    if (!array->length)
+    {
+	array->data = NULL;
+	return TRUE;
+    }
+    array->data = (ARRAY8 *) malloc(array->length * sizeof (ARRAY8));
+    if (!array->data)
+	return FALSE;
+    for (i = 0; i < array->length; i++)
+    {
+	if (!XdmcpReadARRAY8 (buffer, &array->data[i]))
+	{
+	    /*
+	     * We must free all of the arrays allocated thus far in the loop
+	     * and free array->data and finally set array->data = 0;
+	     * The easiest way to do this is to reset the length and call
+	     * XdmcpDisposeARRAYofARRAY8(array).
+	     */
+	    array->length = i;
+	    XdmcpDisposeARRAYofARRAY8(array);
+	    return FALSE;
+	}
+    }
+    return TRUE;
+}
+
+int
+XdmcpReadCARD8 (XdmcpBufferPtr buffer, CARD8Ptr valuep)
+{
+    if (buffer->pointer >= buffer->count)
+	return FALSE;
+    *valuep = (CARD8) buffer->data[buffer->pointer++];
+    return TRUE;
+}
+
+int
+XdmcpReadCARD16 (XdmcpBufferPtr buffer, CARD16Ptr valuep)
+{
+    CARD8   high, low;
+
+    if (XdmcpReadCARD8 (buffer, &high) &&
+        XdmcpReadCARD8 (buffer, &low))
+    {
+	*valuep = (((CARD16) high) << 8) | ((CARD16) low);
+	return TRUE;
+    }
+    return FALSE;
+}
+
+int
+XdmcpReadCARD32 (XdmcpBufferPtr buffer, CARD32Ptr valuep)
+{
+    CARD8   byte0, byte1, byte2, byte3;
+    if (XdmcpReadCARD8 (buffer, &byte0) &&
+        XdmcpReadCARD8 (buffer, &byte1) &&
+	XdmcpReadCARD8 (buffer, &byte2) &&
+	XdmcpReadCARD8 (buffer, &byte3))
+    {
+	*valuep = (((CARD32) byte0) << 24) |
+		  (((CARD32) byte1) << 16) |
+		  (((CARD32) byte2) << 8) |
+		  (((CARD32) byte3));
+	return TRUE;
+    }
+    return FALSE;
+}
diff --git a/depends/libxcb/depends/libxdmcp/Unwrap.c b/depends/libxcb/depends/libxdmcp/Unwrap.c
new file mode 100644
index 0000000..82a10ee
--- /dev/null
+++ b/depends/libxcb/depends/libxdmcp/Unwrap.c
@@ -0,0 +1,90 @@
+/*
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ * *
+ * Author:  Keith Packard, MIT X Consortium
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/Xos.h>
+#include <X11/X.h>
+#include <X11/Xmd.h>
+#include <X11/Xdmcp.h>
+
+#ifdef HASXDMAUTH
+
+/*
+ * The following function exists only to demonstrate the
+ * desired functional interface for this routine.  You will
+ * need to add the appropriate algorithm if you wish to
+ * use XDM-AUTHENTICATION-1/XDM-AUTHORIZATION-1.
+ *
+ * The interface for this routine is quite simple.  All three
+ * arguments are arrays of 8 unsigned characters, the first two
+ * are 64 bits of useful data, the last is 56 bits of useful
+ * data packed into 8 bytes, using the low 7 bits of each
+ * byte, filling the high bit with odd parity.
+ *
+ * Examine the XDMCP specification for the correct algorithm
+ */
+
+#include "Wrap.h"
+
+void
+XdmcpUnwrap (
+    unsigned char	*input,
+    unsigned char	*wrapper,
+    unsigned char	*output,
+    int			bytes)
+{
+    int			i, j, k;
+    unsigned char	tmp[8];
+    unsigned char	blocks[2][8];
+    unsigned char	expand_wrapper[8];
+    auth_wrapper_schedule	schedule;
+
+    _XdmcpWrapperToOddParity (wrapper, expand_wrapper);
+    _XdmcpAuthSetup (expand_wrapper, schedule);
+
+    k = 0;
+    for (j = 0; j < bytes; j += 8)
+    {
+	if (bytes - j < 8)
+	    return; /* bad input length */
+	for (i = 0; i < 8; i++)
+	    blocks[k][i] = input[j + i];
+	_XdmcpAuthDoIt ((unsigned char *) (input + j), (unsigned char *) tmp, schedule, 0);
+	/* block chaining */
+	k = (k == 0) ? 1 : 0;
+	for (i = 0; i < 8; i++)
+	{
+	    if (j == 0)
+		output[j + i] = tmp[i];
+	    else
+		output[j + i] = tmp[i] ^ blocks[k][i];
+	}
+    }
+}
+
+#endif /* HASXDMAUTH */
diff --git a/depends/libxcb/depends/libxdmcp/Wrap.c b/depends/libxcb/depends/libxdmcp/Wrap.c
new file mode 100644
index 0000000..f025caf
--- /dev/null
+++ b/depends/libxcb/depends/libxdmcp/Wrap.c
@@ -0,0 +1,128 @@
+/*
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ * *
+ * Author:  Keith Packard, MIT X Consortium
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/Xos.h>
+#include <X11/X.h>
+#include <X11/Xmd.h>
+#include <X11/Xdmcp.h>
+
+#ifdef HASXDMAUTH
+
+/*
+ * The following function exists only to demonstrate the
+ * desired functional interface for this routine.  You will
+ * need to add the appropriate algorithm if you wish to
+ * use XDM-AUTHENTICATION-1/XDM-AUTHORIZATION-1.
+ *
+ * Examine the XDMCP specification for the correct algorithm
+ */
+
+#include "Wrap.h"
+
+void
+XdmcpWrap (
+    unsigned char	*input,
+    unsigned char	*wrapper,
+    unsigned char	*output,
+    int			bytes)
+{
+    int			i, j;
+    int			len;
+    unsigned char	tmp[8];
+    unsigned char	expand_wrapper[8];
+    auth_wrapper_schedule	schedule;
+
+    _XdmcpWrapperToOddParity (wrapper, expand_wrapper);
+    _XdmcpAuthSetup (expand_wrapper, schedule);
+    for (j = 0; j < bytes; j += 8)
+    {
+	len = 8;
+	if (bytes - j < len)
+	    len = bytes - j;
+	/* block chaining */
+	for (i = 0; i < len; i++)
+	{
+	    if (j == 0)
+		tmp[i] = input[i];
+	    else
+		tmp[i] = input[j + i] ^ output[j - 8 + i];
+	}
+	for (; i < 8; i++)
+	{
+	    if (j == 0)
+		tmp[i] = 0;
+	    else
+		tmp[i] = 0 ^ output[j - 8 + i];
+	}
+	_XdmcpAuthDoIt (tmp, (output + j), schedule, 1);
+    }
+}
+
+/*
+ * Given a 56 bit wrapper in XDMCP format, create a 56
+ * bit wrapper in 7-bits + odd parity format
+ */
+
+static int
+OddParity (unsigned char c)
+{
+    c = c ^ (c >> 4);
+    c = c ^ (c >> 2);
+    c = c ^ (c >> 1);
+    return ~c & 0x1;
+}
+
+/*
+ * Spread the 56 bit wrapper among 8 bytes, using the upper 7 bits
+ * of each byte, and storing an odd parity bit in the low bit
+ */
+
+void
+_XdmcpWrapperToOddParity (
+    unsigned char   *in,
+    unsigned char   *out)
+{
+    int		    ashift, bshift;
+    int		    i;
+    unsigned char   c;
+
+    ashift = 7;
+    bshift = 1;
+    for (i = 0; i < 7; i++)
+    {
+	c = ((in[i] << ashift) | (in[i+1] >> bshift)) & 0x7f;
+	out[i] = (c << 1) | OddParity (c);
+	ashift--;
+	bshift++;
+    }
+    c = in[i];
+    out[i] = (c << 1) | OddParity(c);
+}
+
+#endif
diff --git a/depends/libxcb/depends/libxdmcp/Wrap.h b/depends/libxcb/depends/libxdmcp/Wrap.h
new file mode 100644
index 0000000..479da5f
--- /dev/null
+++ b/depends/libxcb/depends/libxdmcp/Wrap.h
@@ -0,0 +1,15 @@
+/*
+ * header file for compatibility with something useful
+ */
+
+typedef unsigned char auth_cblock[8];	/* block size */
+
+typedef struct auth_ks_struct { auth_cblock _; } auth_wrapper_schedule[16];
+
+extern void _XdmcpWrapperToOddParity (unsigned char *in, unsigned char *out);
+
+#ifdef HASXDMAUTH
+extern void _XdmcpAuthSetup (auth_cblock key, auth_wrapper_schedule schedule);
+extern void _XdmcpAuthDoIt (auth_cblock input, auth_cblock output,
+	auth_wrapper_schedule schedule, int edflag);
+#endif
diff --git a/depends/libxcb/depends/libxdmcp/Wraphelp.c b/depends/libxcb/depends/libxdmcp/Wraphelp.c
new file mode 100644
index 0000000..e7b33ec
--- /dev/null
+++ b/depends/libxcb/depends/libxdmcp/Wraphelp.c
@@ -0,0 +1,495 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <sys/types.h>
+#include <X11/Xmd.h>
+#include "Wrap.h"
+
+/* des routines for non-usa - eay 10/9/1991 eay@psych.psy.uq.oz.au
+ * These routines were written for speed not size so they are bigger than
+ * needed.  I have removed some of the loop unrolling, this will reduce
+ * code size at the expense of some speed.
+ * 25/9/1991 eay - much faster _XdmcpAuthSetup (4 times faster).
+ * 19/9/1991 eay - cleaned up the IP and FP code.
+ * 10/9/1991 eay - first release.
+ * The des routines this file has been made from can be found in
+ * ftp.psy.uq.oz.au /pub/DES
+ * This particular version derived from OpenBSD Revision 1.3.
+ */
+
+/*
+ *
+ * Export Requirements.
+ * You may not export or re-export this software or any copy or
+ * adaptation in violation of any applicable laws or regulations.
+ *
+ * Without limiting the generality of the foregoing, hardware, software,
+ * technology or services provided under this license agreement may not
+ * be exported, reexported, transferred or downloaded to or within (or to
+ * a national resident of) countries under U.S. economic embargo
+ * including the following countries:
+ *
+ * Cuba, Iran, Libya, North Korea, Sudan and Syria. This list is subject
+ * to change.
+ *
+ * Hardware, software, technology or services may not be exported,
+ * reexported, transferred or downloaded to persons or entities listed on
+ * the U.S. Department of Commerce Denied Persons List, Entity List of
+ * proliferation concern or on any U.S. Treasury Department Designated
+ * Nationals exclusion list, or to parties directly or indirectly
+ * involved in the development or production of nuclear, chemical,
+ * biological weapons or in missile technology programs as specified in
+ * the U.S. Export Administration Regulations (15 CFR 744).
+ *
+ * By accepting this license agreement you confirm that you are not
+ * located in (or a national resident of) any country under U.S. economic
+ * embargo, not identified on any U.S. Department of Commerce Denied
+ * Persons List, Entity List or Treasury Department Designated Nationals
+ * exclusion list, and not directly or indirectly involved in the
+ * development or production of nuclear, chemical, biological weapons or
+ * in missile technology programs as specified in the U.S. Export
+ * Administration Regulations.
+ *
+ *
+ * Local Country Import Requirements. The software you are about to
+ * download contains cryptography technology. Some countries regulate the
+ * import, use and/or export of certain products with cryptography. The
+ * X.org Foundation makes no claims as to the applicability of local
+ * country import, use and/or export regulations in relation to the
+ * download of this product. If you are located outside the U.S. and
+ * Canada you are advised to consult your local country regulations to
+ * insure compliance.
+ */
+
+static const CARD32 skb[8][64] = {
+	/* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
+	{ 0x00000000,0x00000010,0x20000000,0x20000010,
+	  0x00010000,0x00010010,0x20010000,0x20010010,
+	  0x00000800,0x00000810,0x20000800,0x20000810,
+	  0x00010800,0x00010810,0x20010800,0x20010810,
+	  0x00000020,0x00000030,0x20000020,0x20000030,
+	  0x00010020,0x00010030,0x20010020,0x20010030,
+	  0x00000820,0x00000830,0x20000820,0x20000830,
+	  0x00010820,0x00010830,0x20010820,0x20010830,
+	  0x00080000,0x00080010,0x20080000,0x20080010,
+	  0x00090000,0x00090010,0x20090000,0x20090010,
+	  0x00080800,0x00080810,0x20080800,0x20080810,
+	  0x00090800,0x00090810,0x20090800,0x20090810,
+	  0x00080020,0x00080030,0x20080020,0x20080030,
+	  0x00090020,0x00090030,0x20090020,0x20090030,
+	  0x00080820,0x00080830,0x20080820,0x20080830,
+	  0x00090820,0x00090830,0x20090820,0x20090830 },
+	/* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
+	{ 0x00000000,0x02000000,0x00002000,0x02002000,
+	  0x00200000,0x02200000,0x00202000,0x02202000,
+	  0x00000004,0x02000004,0x00002004,0x02002004,
+	  0x00200004,0x02200004,0x00202004,0x02202004,
+	  0x00000400,0x02000400,0x00002400,0x02002400,
+	  0x00200400,0x02200400,0x00202400,0x02202400,
+	  0x00000404,0x02000404,0x00002404,0x02002404,
+	  0x00200404,0x02200404,0x00202404,0x02202404,
+	  0x10000000,0x12000000,0x10002000,0x12002000,
+	  0x10200000,0x12200000,0x10202000,0x12202000,
+	  0x10000004,0x12000004,0x10002004,0x12002004,
+	  0x10200004,0x12200004,0x10202004,0x12202004,
+	  0x10000400,0x12000400,0x10002400,0x12002400,
+	  0x10200400,0x12200400,0x10202400,0x12202400,
+	  0x10000404,0x12000404,0x10002404,0x12002404,
+	  0x10200404,0x12200404,0x10202404,0x12202404 },
+	/* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
+	{ 0x00000000,0x00000001,0x00040000,0x00040001,
+	  0x01000000,0x01000001,0x01040000,0x01040001,
+	  0x00000002,0x00000003,0x00040002,0x00040003,
+	  0x01000002,0x01000003,0x01040002,0x01040003,
+	  0x00000200,0x00000201,0x00040200,0x00040201,
+	  0x01000200,0x01000201,0x01040200,0x01040201,
+	  0x00000202,0x00000203,0x00040202,0x00040203,
+	  0x01000202,0x01000203,0x01040202,0x01040203,
+	  0x08000000,0x08000001,0x08040000,0x08040001,
+	  0x09000000,0x09000001,0x09040000,0x09040001,
+	  0x08000002,0x08000003,0x08040002,0x08040003,
+	  0x09000002,0x09000003,0x09040002,0x09040003,
+	  0x08000200,0x08000201,0x08040200,0x08040201,
+	  0x09000200,0x09000201,0x09040200,0x09040201,
+	  0x08000202,0x08000203,0x08040202,0x08040203,
+	  0x09000202,0x09000203,0x09040202,0x09040203 },
+	/* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
+	{ 0x00000000,0x00100000,0x00000100,0x00100100,
+	  0x00000008,0x00100008,0x00000108,0x00100108,
+	  0x00001000,0x00101000,0x00001100,0x00101100,
+	  0x00001008,0x00101008,0x00001108,0x00101108,
+	  0x04000000,0x04100000,0x04000100,0x04100100,
+	  0x04000008,0x04100008,0x04000108,0x04100108,
+	  0x04001000,0x04101000,0x04001100,0x04101100,
+	  0x04001008,0x04101008,0x04001108,0x04101108,
+	  0x00020000,0x00120000,0x00020100,0x00120100,
+	  0x00020008,0x00120008,0x00020108,0x00120108,
+	  0x00021000,0x00121000,0x00021100,0x00121100,
+	  0x00021008,0x00121008,0x00021108,0x00121108,
+	  0x04020000,0x04120000,0x04020100,0x04120100,
+	  0x04020008,0x04120008,0x04020108,0x04120108,
+	  0x04021000,0x04121000,0x04021100,0x04121100,
+	  0x04021008,0x04121008,0x04021108,0x04121108 },
+	/* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
+	{ 0x00000000,0x10000000,0x00010000,0x10010000,
+	  0x00000004,0x10000004,0x00010004,0x10010004,
+	  0x20000000,0x30000000,0x20010000,0x30010000,
+	  0x20000004,0x30000004,0x20010004,0x30010004,
+	  0x00100000,0x10100000,0x00110000,0x10110000,
+	  0x00100004,0x10100004,0x00110004,0x10110004,
+	  0x20100000,0x30100000,0x20110000,0x30110000,
+	  0x20100004,0x30100004,0x20110004,0x30110004,
+	  0x00001000,0x10001000,0x00011000,0x10011000,
+	  0x00001004,0x10001004,0x00011004,0x10011004,
+	  0x20001000,0x30001000,0x20011000,0x30011000,
+	  0x20001004,0x30001004,0x20011004,0x30011004,
+	  0x00101000,0x10101000,0x00111000,0x10111000,
+	  0x00101004,0x10101004,0x00111004,0x10111004,
+	  0x20101000,0x30101000,0x20111000,0x30111000,
+	  0x20101004,0x30101004,0x20111004,0x30111004 },
+	/* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */
+	{ 0x00000000,0x08000000,0x00000008,0x08000008,
+	  0x00000400,0x08000400,0x00000408,0x08000408,
+	  0x00020000,0x08020000,0x00020008,0x08020008,
+	  0x00020400,0x08020400,0x00020408,0x08020408,
+	  0x00000001,0x08000001,0x00000009,0x08000009,
+	  0x00000401,0x08000401,0x00000409,0x08000409,
+	  0x00020001,0x08020001,0x00020009,0x08020009,
+	  0x00020401,0x08020401,0x00020409,0x08020409,
+	  0x02000000,0x0A000000,0x02000008,0x0A000008,
+	  0x02000400,0x0A000400,0x02000408,0x0A000408,
+	  0x02020000,0x0A020000,0x02020008,0x0A020008,
+	  0x02020400,0x0A020400,0x02020408,0x0A020408,
+	  0x02000001,0x0A000001,0x02000009,0x0A000009,
+	  0x02000401,0x0A000401,0x02000409,0x0A000409,
+	  0x02020001,0x0A020001,0x02020009,0x0A020009,
+	  0x02020401,0x0A020401,0x02020409,0x0A020409 },
+	/* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */
+	{ 0x00000000,0x00000100,0x00080000,0x00080100,
+	  0x01000000,0x01000100,0x01080000,0x01080100,
+	  0x00000010,0x00000110,0x00080010,0x00080110,
+	  0x01000010,0x01000110,0x01080010,0x01080110,
+	  0x00200000,0x00200100,0x00280000,0x00280100,
+	  0x01200000,0x01200100,0x01280000,0x01280100,
+	  0x00200010,0x00200110,0x00280010,0x00280110,
+	  0x01200010,0x01200110,0x01280010,0x01280110,
+	  0x00000200,0x00000300,0x00080200,0x00080300,
+	  0x01000200,0x01000300,0x01080200,0x01080300,
+	  0x00000210,0x00000310,0x00080210,0x00080310,
+	  0x01000210,0x01000310,0x01080210,0x01080310,
+	  0x00200200,0x00200300,0x00280200,0x00280300,
+	  0x01200200,0x01200300,0x01280200,0x01280300,
+	  0x00200210,0x00200310,0x00280210,0x00280310,
+	  0x01200210,0x01200310,0x01280210,0x01280310 },
+	  /* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */
+	{ 0x00000000,0x04000000,0x00040000,0x04040000,
+	  0x00000002,0x04000002,0x00040002,0x04040002,
+	  0x00002000,0x04002000,0x00042000,0x04042000,
+	  0x00002002,0x04002002,0x00042002,0x04042002,
+	  0x00000020,0x04000020,0x00040020,0x04040020,
+	  0x00000022,0x04000022,0x00040022,0x04040022,
+	  0x00002020,0x04002020,0x00042020,0x04042020,
+	  0x00002022,0x04002022,0x00042022,0x04042022,
+	  0x00000800,0x04000800,0x00040800,0x04040800,
+	  0x00000802,0x04000802,0x00040802,0x04040802,
+	  0x00002800,0x04002800,0x00042800,0x04042800,
+	  0x00002802,0x04002802,0x00042802,0x04042802,
+	  0x00000820,0x04000820,0x00040820,0x04040820,
+	  0x00000822,0x04000822,0x00040822,0x04040822,
+	  0x00002820,0x04002820,0x00042820,0x04042820,
+	  0x00002822,0x04002822,0x00042822,0x04042822 }
+};
+
+
+static const CARD32 SPtrans[8][64] = {
+	/* nibble 0 */
+	{ 0x00410100, 0x00010000, 0x40400000, 0x40410100,
+	  0x00400000, 0x40010100, 0x40010000, 0x40400000,
+	  0x40010100, 0x00410100, 0x00410000, 0x40000100,
+	  0x40400100, 0x00400000, 0x00000000, 0x40010000,
+	  0x00010000, 0x40000000, 0x00400100, 0x00010100,
+	  0x40410100, 0x00410000, 0x40000100, 0x00400100,
+	  0x40000000, 0x00000100, 0x00010100, 0x40410000,
+	  0x00000100, 0x40400100, 0x40410000, 0x00000000,
+	  0x00000000, 0x40410100, 0x00400100, 0x40010000,
+	  0x00410100, 0x00010000, 0x40000100, 0x00400100,
+	  0x40410000, 0x00000100, 0x00010100, 0x40400000,
+	  0x40010100, 0x40000000, 0x40400000, 0x00410000,
+	  0x40410100, 0x00010100, 0x00410000, 0x40400100,
+	  0x00400000, 0x40000100, 0x40010000, 0x00000000,
+	  0x00010000, 0x00400000, 0x40400100, 0x00410100,
+	  0x40000000, 0x40410000, 0x00000100, 0x40010100 },
+
+	/* nibble 1 */
+	{ 0x08021002, 0x00000000, 0x00021000, 0x08020000,
+	  0x08000002, 0x00001002, 0x08001000, 0x00021000,
+	  0x00001000, 0x08020002, 0x00000002, 0x08001000,
+	  0x00020002, 0x08021000, 0x08020000, 0x00000002,
+	  0x00020000, 0x08001002, 0x08020002, 0x00001000,
+	  0x00021002, 0x08000000, 0x00000000, 0x00020002,
+	  0x08001002, 0x00021002, 0x08021000, 0x08000002,
+	  0x08000000, 0x00020000, 0x00001002, 0x08021002,
+	  0x00020002, 0x08021000, 0x08001000, 0x00021002,
+	  0x08021002, 0x00020002, 0x08000002, 0x00000000,
+	  0x08000000, 0x00001002, 0x00020000, 0x08020002,
+	  0x00001000, 0x08000000, 0x00021002, 0x08001002,
+	  0x08021000, 0x00001000, 0x00000000, 0x08000002,
+	  0x00000002, 0x08021002, 0x00021000, 0x08020000,
+	  0x08020002, 0x00020000, 0x00001002, 0x08001000,
+	  0x08001002, 0x00000002, 0x08020000, 0x00021000 },
+
+	/* nibble 2 */
+	{ 0x20800000, 0x00808020, 0x00000020, 0x20800020,
+	  0x20008000, 0x00800000, 0x20800020, 0x00008020,
+	  0x00800020, 0x00008000, 0x00808000, 0x20000000,
+	  0x20808020, 0x20000020, 0x20000000, 0x20808000,
+	  0x00000000, 0x20008000, 0x00808020, 0x00000020,
+	  0x20000020, 0x20808020, 0x00008000, 0x20800000,
+	  0x20808000, 0x00800020, 0x20008020, 0x00808000,
+	  0x00008020, 0x00000000, 0x00800000, 0x20008020,
+	  0x00808020, 0x00000020, 0x20000000, 0x00008000,
+	  0x20000020, 0x20008000, 0x00808000, 0x20800020,
+	  0x00000000, 0x00808020, 0x00008020, 0x20808000,
+	  0x20008000, 0x00800000, 0x20808020, 0x20000000,
+	  0x20008020, 0x20800000, 0x00800000, 0x20808020,
+	  0x00008000, 0x00800020, 0x20800020, 0x00008020,
+	  0x00800020, 0x00000000, 0x20808000, 0x20000020,
+	  0x20800000, 0x20008020, 0x00000020, 0x00808000 },
+
+	/* nibble 3 */
+	{ 0x00080201, 0x02000200, 0x00000001, 0x02080201,
+	  0x00000000, 0x02080000, 0x02000201, 0x00080001,
+	  0x02080200, 0x02000001, 0x02000000, 0x00000201,
+	  0x02000001, 0x00080201, 0x00080000, 0x02000000,
+	  0x02080001, 0x00080200, 0x00000200, 0x00000001,
+	  0x00080200, 0x02000201, 0x02080000, 0x00000200,
+	  0x00000201, 0x00000000, 0x00080001, 0x02080200,
+	  0x02000200, 0x02080001, 0x02080201, 0x00080000,
+	  0x02080001, 0x00000201, 0x00080000, 0x02000001,
+	  0x00080200, 0x02000200, 0x00000001, 0x02080000,
+	  0x02000201, 0x00000000, 0x00000200, 0x00080001,
+	  0x00000000, 0x02080001, 0x02080200, 0x00000200,
+	  0x02000000, 0x02080201, 0x00080201, 0x00080000,
+	  0x02080201, 0x00000001, 0x02000200, 0x00080201,
+	  0x00080001, 0x00080200, 0x02080000, 0x02000201,
+	  0x00000201, 0x02000000, 0x02000001, 0x02080200 },
+
+	/* nibble 4 */
+	{ 0x01000000, 0x00002000, 0x00000080, 0x01002084,
+	  0x01002004, 0x01000080, 0x00002084, 0x01002000,
+	  0x00002000, 0x00000004, 0x01000004, 0x00002080,
+	  0x01000084, 0x01002004, 0x01002080, 0x00000000,
+	  0x00002080, 0x01000000, 0x00002004, 0x00000084,
+	  0x01000080, 0x00002084, 0x00000000, 0x01000004,
+	  0x00000004, 0x01000084, 0x01002084, 0x00002004,
+	  0x01002000, 0x00000080, 0x00000084, 0x01002080,
+	  0x01002080, 0x01000084, 0x00002004, 0x01002000,
+	  0x00002000, 0x00000004, 0x01000004, 0x01000080,
+	  0x01000000, 0x00002080, 0x01002084, 0x00000000,
+	  0x00002084, 0x01000000, 0x00000080, 0x00002004,
+	  0x01000084, 0x00000080, 0x00000000, 0x01002084,
+	  0x01002004, 0x01002080, 0x00000084, 0x00002000,
+	  0x00002080, 0x01002004, 0x01000080, 0x00000084,
+	  0x00000004, 0x00002084, 0x01002000, 0x01000004 },
+
+	/* nibble 5 */
+	{ 0x10000008, 0x00040008, 0x00000000, 0x10040400,
+	  0x00040008, 0x00000400, 0x10000408, 0x00040000,
+	  0x00000408, 0x10040408, 0x00040400, 0x10000000,
+	  0x10000400, 0x10000008, 0x10040000, 0x00040408,
+	  0x00040000, 0x10000408, 0x10040008, 0x00000000,
+	  0x00000400, 0x00000008, 0x10040400, 0x10040008,
+	  0x10040408, 0x10040000, 0x10000000, 0x00000408,
+	  0x00000008, 0x00040400, 0x00040408, 0x10000400,
+	  0x00000408, 0x10000000, 0x10000400, 0x00040408,
+	  0x10040400, 0x00040008, 0x00000000, 0x10000400,
+	  0x10000000, 0x00000400, 0x10040008, 0x00040000,
+	  0x00040008, 0x10040408, 0x00040400, 0x00000008,
+	  0x10040408, 0x00040400, 0x00040000, 0x10000408,
+	  0x10000008, 0x10040000, 0x00040408, 0x00000000,
+	  0x00000400, 0x10000008, 0x10000408, 0x10040400,
+	  0x10040000, 0x00000408, 0x00000008, 0x10040008 },
+
+	/* nibble 6 */
+	{ 0x00000800, 0x00000040, 0x00200040, 0x80200000,
+	  0x80200840, 0x80000800, 0x00000840, 0x00000000,
+	  0x00200000, 0x80200040, 0x80000040, 0x00200800,
+	  0x80000000, 0x00200840, 0x00200800, 0x80000040,
+	  0x80200040, 0x00000800, 0x80000800, 0x80200840,
+	  0x00000000, 0x00200040, 0x80200000, 0x00000840,
+	  0x80200800, 0x80000840, 0x00200840, 0x80000000,
+	  0x80000840, 0x80200800, 0x00000040, 0x00200000,
+	  0x80000840, 0x00200800, 0x80200800, 0x80000040,
+	  0x00000800, 0x00000040, 0x00200000, 0x80200800,
+	  0x80200040, 0x80000840, 0x00000840, 0x00000000,
+	  0x00000040, 0x80200000, 0x80000000, 0x00200040,
+	  0x00000000, 0x80200040, 0x00200040, 0x00000840,
+	  0x80000040, 0x00000800, 0x80200840, 0x00200000,
+	  0x00200840, 0x80000000, 0x80000800, 0x80200840,
+	  0x80200000, 0x00200840, 0x00200800, 0x80000800 },
+
+	/* nibble 7 */
+	{ 0x04100010, 0x04104000, 0x00004010, 0x00000000,
+	  0x04004000, 0x00100010, 0x04100000, 0x04104010,
+	  0x00000010, 0x04000000, 0x00104000, 0x00004010,
+	  0x00104010, 0x04004010, 0x04000010, 0x04100000,
+	  0x00004000, 0x00104010, 0x00100010, 0x04004000,
+	  0x04104010, 0x04000010, 0x00000000, 0x00104000,
+	  0x04000000, 0x00100000, 0x04004010, 0x04100010,
+	  0x00100000, 0x00004000, 0x04104000, 0x00000010,
+	  0x00100000, 0x00004000, 0x04000010, 0x04104010,
+	  0x00004010, 0x04000000, 0x00000000, 0x00104000,
+	  0x04100010, 0x04004010, 0x04004000, 0x00100010,
+	  0x04104000, 0x00000010, 0x00100010, 0x04004000,
+	  0x04104010, 0x00100000, 0x04100000, 0x04000010,
+	  0x00104000, 0x00004010, 0x04004010, 0x04100000,
+	  0x00000010, 0x04104000, 0x00104010, 0x00000000,
+	  0x04000000, 0x04100010, 0x00004000, 0x00104010}
+};
+
+#define ITERATIONS 16
+#define HALF_ITERATIONS 8
+
+#define c2l(c,l)	(l =((CARD32)(*((c)++)))    , \
+			 l|=((CARD32)(*((c)++)))<< 8, \
+			 l|=((CARD32)(*((c)++)))<<16, \
+			 l|=((CARD32)(*((c)++)))<<24)
+
+#define l2c(l,c)	(*((c)++)=(CARD8)(((l)    )&0xff), \
+			 *((c)++)=(CARD8)(((l)>> 8)&0xff), \
+			 *((c)++)=(CARD8)(((l)>>16)&0xff), \
+			 *((c)++)=(CARD8)(((l)>>24)&0xff))
+
+#define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
+	(b)^=(t),\
+	(a)^=((t)<<(n)))
+
+#define HPERM_OP(a,t,n,m) ((t)=((((a)<<(16-(n)))^(a))&(m)),\
+	(a)=(a)^(t)^(t>>(16-(n))))\
+
+static const char shifts2[16] = {0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,0};
+
+void _XdmcpAuthSetup(auth_cblock key, auth_wrapper_schedule schedule)
+{
+	CARD32 c,d,t,s;
+	CARD8 *in;
+	CARD32 *k;
+	int i;
+
+	k=(CARD32 *)schedule;
+	in=(CARD8 *)key;
+
+	c2l(in,c);
+	c2l(in,d);
+
+	/* do PC1 in 60 simple operations */
+	PERM_OP(d,c,t,4,0x0f0f0f0f);
+	HPERM_OP(c,t,-2, 0xcccc0000);
+	HPERM_OP(c,t,-1, 0xaaaa0000);
+	HPERM_OP(c,t, 8, 0x00ff0000);
+	HPERM_OP(c,t,-1, 0xaaaa0000);
+	HPERM_OP(d,t,-8, 0xff000000);
+	HPERM_OP(d,t, 8, 0x00ff0000);
+	HPERM_OP(d,t, 2, 0x33330000);
+	d=((d&0x00aa00aa)<<7)|((d&0x55005500)>>7)|(d&0xaa55aa55);
+	d=(d>>8)|((c&0xf0000000)>>4);
+	c&=0x0fffffff;
+
+	for (i=0; i<ITERATIONS; i++) {
+		if (shifts2[i]) {
+			c=((c>>2)|(c<<26)); d=((d>>2)|(d<<26));
+		} else {
+			c=((c>>1)|(c<<27)); d=((d>>1)|(d<<27));
+		}
+		c&=0x0fffffff;
+		d&=0x0fffffff;
+		/* could be a few less shifts but I am to lazy at this
+		 * point in time to investigate */
+		s=	skb[0][ (c    )&0x3f		    ]|
+			skb[1][((c>> 6)&0x03)|((c>> 7)&0x3c)]|
+			skb[2][((c>>13)&0x0f)|((c>>14)&0x30)]|
+			skb[3][((c>>20)&0x01)|((c>>21)&0x06) |
+					      ((c>>22)&0x38)];
+		t=	skb[4][ (d    )&0x3f		    ]|
+			skb[5][((d>> 7)&0x03)|((d>> 8)&0x3c)]|
+			skb[6][ (d>>15)&0x3f		    ]|
+			skb[7][((d>>21)&0x0f)|((d>>22)&0x30)];
+
+		/* table contained 0213 4657 */
+		*(k++)=((t<<16)|(s&0x0000ffff));
+		s=     ((s>>16)|(t&0xffff0000));
+
+		s=(s<<4)|(s>>28);
+		*(k++)=s;
+	}
+	return;
+}
+
+#define D_ENCRYPT(L,R,S)	\
+	t=(R<<1)|(R>>31); \
+	u=(t^s[S  ]); \
+	t=(t^s[S+1]); \
+	t=(t>>4)|(t<<28); \
+	L^=	SPtrans[1][(t	 )&0x3f]| \
+		SPtrans[3][(t>> 8)&0x3f]| \
+		SPtrans[5][(t>>16)&0x3f]| \
+		SPtrans[7][(t>>24)&0x3f]| \
+		SPtrans[0][(u	 )&0x3f]| \
+		SPtrans[2][(u>> 8)&0x3f]| \
+		SPtrans[4][(u>>16)&0x3f]| \
+		SPtrans[6][(u>>24)&0x3f];
+
+
+void _XdmcpAuthDoIt(auth_cblock input, auth_cblock output,
+    auth_wrapper_schedule ks, int encrypt)
+{
+	CARD32 l,r,t,u;
+	CARD32 *s;
+	CARD8 *in,*out;
+	int i;
+
+	in=(CARD8 *)input;
+	out=(CARD8 *)output;
+	c2l(in,l);
+	c2l(in,r);
+
+	/* do IP */
+	PERM_OP(r,l,t, 4,0x0f0f0f0f);
+	PERM_OP(l,r,t,16,0x0000ffff);
+	PERM_OP(r,l,t, 2,0x33333333);
+	PERM_OP(l,r,t, 8,0x00ff00ff);
+	PERM_OP(r,l,t, 1,0x55555555);
+	/* r and l are reversed - remember that :-) */
+	t=l;
+	l=r;
+	r=t;
+
+	s=(CARD32 *)ks;
+
+	if (encrypt) {
+		for (i=0; i<(ITERATIONS*2); i+=4) {
+			D_ENCRYPT(l,r,	i); /*	1 */
+			D_ENCRYPT(r,l,	i+2); /*  2 */
+		}
+	} else {
+		for (i=(ITERATIONS*2)-2; i >= 0; i-=4) {
+			D_ENCRYPT(l,r,	i); /*	1 */
+			D_ENCRYPT(r,l,	i-2); /*  2 */
+		}
+	}
+
+	/* swap l and r
+	 * we will not do the swap so just remember they are
+	 * reversed for the rest of the subroutine
+	 * luckily by FP fixes this problem :-) */
+
+	PERM_OP(r,l,t, 1,0x55555555);
+	PERM_OP(l,r,t, 8,0x00ff00ff);
+	PERM_OP(r,l,t, 2,0x33333333);
+	PERM_OP(l,r,t,16,0x0000ffff);
+	PERM_OP(r,l,t, 4,0x0f0f0f0f);
+
+	l2c(l,out);
+	l2c(r,out);
+	return;
+}
diff --git a/depends/libxcb/depends/libxdmcp/Write.c b/depends/libxcb/depends/libxdmcp/Write.c
new file mode 100644
index 0000000..8eb9c50
--- /dev/null
+++ b/depends/libxcb/depends/libxdmcp/Write.c
@@ -0,0 +1,151 @@
+/*
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ *
+ * Author:  Keith Packard, MIT X Consortium
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <X11/Xos.h>
+#include <X11/X.h>
+#include <X11/Xmd.h>
+#include <X11/Xdmcp.h>
+#include <stdlib.h>
+
+int
+XdmcpWriteHeader (
+    XdmcpBufferPtr  buffer,
+    const XdmcpHeaderPtr  header)
+{
+    BYTE    *newData;
+
+    if ((int)buffer->size < 6 + (int)header->length)
+    {
+	newData = (BYTE *) malloc(XDM_MAX_MSGLEN * sizeof (BYTE));
+	if (!newData)
+	    return FALSE;
+	free((unsigned long *)(buffer->data));
+	buffer->data = newData;
+	buffer->size = XDM_MAX_MSGLEN;
+    }
+    buffer->pointer = 0;
+    if (!XdmcpWriteCARD16 (buffer, header->version))
+	return FALSE;
+    if (!XdmcpWriteCARD16 (buffer, header->opcode))
+	return FALSE;
+    if (!XdmcpWriteCARD16 (buffer, header->length))
+	return FALSE;
+    return TRUE;
+}
+
+int
+XdmcpWriteARRAY8 (XdmcpBufferPtr buffer, const ARRAY8Ptr array)
+{
+    int	i;
+
+    if (!XdmcpWriteCARD16 (buffer, array->length))
+	return FALSE;
+    for (i = 0; i < (int)array->length; i++)
+	if (!XdmcpWriteCARD8 (buffer, array->data[i]))
+	    return FALSE;
+    return TRUE;
+}
+
+int
+XdmcpWriteARRAY16 (XdmcpBufferPtr buffer, const ARRAY16Ptr array)
+{
+    int	i;
+
+    if (!XdmcpWriteCARD8 (buffer, array->length))
+	return FALSE;
+    for (i = 0; i < (int)array->length; i++)
+	if (!XdmcpWriteCARD16 (buffer, array->data[i]))
+	    return FALSE;
+    return TRUE;
+}
+
+int
+XdmcpWriteARRAY32 (XdmcpBufferPtr buffer, const ARRAY32Ptr array)
+{
+    int	i;
+
+    if (!XdmcpWriteCARD8 (buffer, array->length))
+	return FALSE;
+    for (i = 0; i < (int)array->length; i++)
+	if (!XdmcpWriteCARD32 (buffer, array->data[i]))
+	    return FALSE;
+    return TRUE;
+}
+
+int
+XdmcpWriteARRAYofARRAY8 (XdmcpBufferPtr buffer, ARRAYofARRAY8Ptr array)
+{
+    int	i;
+
+    if (!XdmcpWriteCARD8 (buffer, array->length))
+	return FALSE;
+    for (i = 0; i < (int)array->length; i++)
+	if (!XdmcpWriteARRAY8 (buffer, &array->data[i]))
+	    return FALSE;
+    return TRUE;
+}
+
+int
+XdmcpWriteCARD8 (
+    XdmcpBufferPtr  buffer,
+    unsigned	    value)
+{
+    if (buffer->pointer >= buffer->size)
+	return FALSE;
+    buffer->data[buffer->pointer++] = (BYTE) value;
+    return TRUE;
+}
+
+int
+XdmcpWriteCARD16 (
+    XdmcpBufferPtr  buffer,
+    unsigned	    value)
+{
+    if (!XdmcpWriteCARD8 (buffer, value >> 8))
+	return FALSE;
+    if (!XdmcpWriteCARD8 (buffer, value & 0xff))
+	return FALSE;
+    return TRUE;
+}
+
+int
+XdmcpWriteCARD32 (
+    XdmcpBufferPtr  buffer,
+    unsigned	    value)
+{
+    if (!XdmcpWriteCARD8 (buffer, value >> 24))
+	return FALSE;
+    if (!XdmcpWriteCARD8 (buffer, (value >> 16) & 0xff))
+	return FALSE;
+    if (!XdmcpWriteCARD8 (buffer, (value >> 8) & 0xff))
+	return FALSE;
+    if (!XdmcpWriteCARD8 (buffer, value & 0xff))
+	return FALSE;
+    return TRUE;
+}
diff --git a/depends/libxcb/depends/libxdmcp/config.h b/depends/libxcb/depends/libxdmcp/config.h
new file mode 100644
index 0000000..1704f92
--- /dev/null
+++ b/depends/libxcb/depends/libxdmcp/config.h
@@ -0,0 +1,188 @@
+/* config.h.  Generated from config.h.in by configure.  */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Has Wraphelp.c needed for XDM AUTH protocols */
+#define HASXDMAUTH 1
+
+/* Define to 1 if you have the `arc4random_buf' function. */
+#define HAVE_ARC4RANDOM_BUF 1
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* Define to 1 if you have the `getentropy' function. */
+#define HAVE_GETENTROPY 1
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the `ws2_32' library (-lws2_32). */
+/* #undef HAVE_LIBWS2_32 */
+
+/* Define to 1 if you have the `lrand48' function. */
+#define HAVE_LRAND48 1
+
+/* Define to 1 if you have the <minix/config.h> header file. */
+/* #undef HAVE_MINIX_CONFIG_H */
+
+/* Define to 1 if you have the `srand48' function. */
+#define HAVE_SRAND48 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdio.h> header file. */
+#define HAVE_STDIO_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the <sys/random.h> header file. */
+#define HAVE_SYS_RANDOM_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to 1 if you have the <wchar.h> header file. */
+#define HAVE_WCHAR_H 1
+
+/* Define to the sub-directory where libtool stores uninstalled libraries. */
+#define LT_OBJDIR ".libs/"
+
+/* Name of package */
+#define PACKAGE "libXdmcp"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "https://gitlab.freedesktop.org/xorg/lib/libxdmcp/-/issues"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "libXdmcp"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "libXdmcp 1.1.4"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "libXdmcp"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL ""
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "1.1.4"
+
+/* Major version of this package */
+#define PACKAGE_VERSION_MAJOR 1
+
+/* Minor version of this package */
+#define PACKAGE_VERSION_MINOR 1
+
+/* Patch version of this package */
+#define PACKAGE_VERSION_PATCHLEVEL 4
+
+/* Define to 1 if all of the C90 standard headers exist (not just the ones
+   required in a freestanding environment). This macro is provided for
+   backward compatibility; new code need not use it. */
+#define STDC_HEADERS 1
+
+/* Enable extensions on AIX 3, Interix.  */
+#ifndef _ALL_SOURCE
+# define _ALL_SOURCE 1
+#endif
+/* Enable general extensions on macOS.  */
+#ifndef _DARWIN_C_SOURCE
+# define _DARWIN_C_SOURCE 1
+#endif
+/* Enable general extensions on Solaris.  */
+#ifndef __EXTENSIONS__
+# define __EXTENSIONS__ 1
+#endif
+/* Enable GNU extensions on systems that have them.  */
+#ifndef _GNU_SOURCE
+# define _GNU_SOURCE 1
+#endif
+/* Enable X/Open compliant socket functions that do not require linking
+   with -lxnet on HP-UX 11.11.  */
+#ifndef _HPUX_ALT_XOPEN_SOCKET_API
+# define _HPUX_ALT_XOPEN_SOCKET_API 1
+#endif
+/* Identify the host operating system as Minix.
+   This macro does not affect the system headers' behavior.
+   A future release of Autoconf may stop defining this macro.  */
+#ifndef _MINIX
+/* # undef _MINIX */
+#endif
+/* Enable general extensions on NetBSD.
+   Enable NetBSD compatibility extensions on Minix.  */
+#ifndef _NETBSD_SOURCE
+# define _NETBSD_SOURCE 1
+#endif
+/* Enable OpenBSD compatibility extensions on NetBSD.
+   Oddly enough, this does nothing on OpenBSD.  */
+#ifndef _OPENBSD_SOURCE
+# define _OPENBSD_SOURCE 1
+#endif
+/* Define to 1 if needed for POSIX-compatible behavior.  */
+#ifndef _POSIX_SOURCE
+/* # undef _POSIX_SOURCE */
+#endif
+/* Define to 2 if needed for POSIX-compatible behavior.  */
+#ifndef _POSIX_1_SOURCE
+/* # undef _POSIX_1_SOURCE */
+#endif
+/* Enable POSIX-compatible threading on Solaris.  */
+#ifndef _POSIX_PTHREAD_SEMANTICS
+# define _POSIX_PTHREAD_SEMANTICS 1
+#endif
+/* Enable extensions specified by ISO/IEC TS 18661-5:2014.  */
+#ifndef __STDC_WANT_IEC_60559_ATTRIBS_EXT__
+# define __STDC_WANT_IEC_60559_ATTRIBS_EXT__ 1
+#endif
+/* Enable extensions specified by ISO/IEC TS 18661-1:2014.  */
+#ifndef __STDC_WANT_IEC_60559_BFP_EXT__
+# define __STDC_WANT_IEC_60559_BFP_EXT__ 1
+#endif
+/* Enable extensions specified by ISO/IEC TS 18661-2:2015.  */
+#ifndef __STDC_WANT_IEC_60559_DFP_EXT__
+# define __STDC_WANT_IEC_60559_DFP_EXT__ 1
+#endif
+/* Enable extensions specified by ISO/IEC TS 18661-4:2015.  */
+#ifndef __STDC_WANT_IEC_60559_FUNCS_EXT__
+# define __STDC_WANT_IEC_60559_FUNCS_EXT__ 1
+#endif
+/* Enable extensions specified by ISO/IEC TS 18661-3:2015.  */
+#ifndef __STDC_WANT_IEC_60559_TYPES_EXT__
+# define __STDC_WANT_IEC_60559_TYPES_EXT__ 1
+#endif
+/* Enable extensions specified by ISO/IEC TR 24731-2:2010.  */
+#ifndef __STDC_WANT_LIB_EXT2__
+# define __STDC_WANT_LIB_EXT2__ 1
+#endif
+/* Enable extensions specified by ISO/IEC 24747:2009.  */
+#ifndef __STDC_WANT_MATH_SPEC_FUNCS__
+# define __STDC_WANT_MATH_SPEC_FUNCS__ 1
+#endif
+/* Enable extensions on HP NonStop.  */
+#ifndef _TANDEM_SOURCE
+# define _TANDEM_SOURCE 1
+#endif
+/* Enable X/Open extensions.  Define to 500 only if necessary
+   to make mbstate_t available.  */
+#ifndef _XOPEN_SOURCE
+/* # undef _XOPEN_SOURCE */
+#endif
+
+
+/* Version number of package */
+#define VERSION "1.1.4"
diff --git a/depends/libxcb/depends/libxdmcp/include/X11/Xdmcp.h b/depends/libxcb/depends/libxdmcp/include/X11/Xdmcp.h
new file mode 100644
index 0000000..0b531de
--- /dev/null
+++ b/depends/libxcb/depends/libxdmcp/include/X11/Xdmcp.h
@@ -0,0 +1,181 @@
+/*
+ * Copyright 1989 Network Computing Devices, Inc., Mountain View, California.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose and without fee is hereby granted, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of N.C.D. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  N.C.D. makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ */
+
+#ifndef _XDMCP_H_
+#define _XDMCP_H_
+
+#include <X11/Xmd.h>
+
+#include <X11/Xfuncproto.h>
+
+_XFUNCPROTOBEGIN
+
+#define XDM_PROTOCOL_VERSION	1
+#define XDM_UDP_PORT		177
+
+/* IANA has assigned FF0X:0:0:0:0:0:0:12B as the permanently assigned
+ * multicast addresses for XDMCP, where X in the prefix may be replaced
+ * by any valid scope identifier, such as 1 for Node-Local, 2 for Link-Local,
+ * 5 for Site-Local, and so on.  We set the default here to the Link-Local
+ * version to most closely match the old IPv4 subnet broadcast behavior.
+ * Both xdm and X -query allow specifying a different address if a different
+ * scope is defined.
+ */
+#define XDM_DEFAULT_MCAST_ADDR6	"ff02:0:0:0:0:0:0:12b"
+
+#define XDM_MAX_MSGLEN		8192
+#define XDM_MIN_RTX		2
+#define XDM_MAX_RTX		32
+#define XDM_RTX_LIMIT		7
+#define XDM_KA_RTX_LIMIT	4
+#define XDM_DEF_DORMANCY	(3 * 60)	/* 3 minutes */
+#define XDM_MAX_DORMANCY	(24 * 60 * 60)	/* 24 hours */
+
+typedef enum {
+    BROADCAST_QUERY = 1, QUERY, INDIRECT_QUERY, FORWARD_QUERY,
+    WILLING, UNWILLING, REQUEST, ACCEPT, DECLINE, MANAGE, REFUSE,
+    FAILED, KEEPALIVE, ALIVE
+} xdmOpCode;
+
+typedef enum {
+    XDM_QUERY, XDM_BROADCAST, XDM_INDIRECT, XDM_COLLECT_QUERY,
+    XDM_COLLECT_BROADCAST_QUERY, XDM_COLLECT_INDIRECT_QUERY,
+    XDM_START_CONNECTION, XDM_AWAIT_REQUEST_RESPONSE,
+    XDM_AWAIT_MANAGE_RESPONSE, XDM_MANAGE, XDM_RUN_SESSION, XDM_OFF,
+    XDM_AWAIT_USER_INPUT, XDM_KEEPALIVE, XDM_AWAIT_ALIVE_RESPONSE,
+#if defined(IPv6) && defined(AF_INET6)
+    XDM_MULTICAST, XDM_COLLECT_MULTICAST_QUERY,
+#endif
+    XDM_KEEP_ME_LAST
+} xdmcp_states;
+
+#ifdef NOTDEF
+/* table of hosts */
+
+#define XDM_MAX_STR_LEN 21
+#define XDM_MAX_HOSTS 20
+struct xdm_host_table {
+  struct sockaddr_in sockaddr;
+  char name[XDM_MAX_STR_LEN];
+  char status[XDM_MAX_STR_LEN];
+};
+#endif /* NOTDEF */
+
+typedef CARD8	*CARD8Ptr;
+typedef CARD16	*CARD16Ptr;
+typedef CARD32	*CARD32Ptr;
+
+typedef struct _ARRAY8 {
+    CARD16	length;
+    CARD8Ptr	data;
+} ARRAY8, *ARRAY8Ptr;
+
+typedef struct _ARRAY16 {
+    CARD8	length;
+    CARD16Ptr	data;
+} ARRAY16, *ARRAY16Ptr;
+
+typedef struct _ARRAY32 {
+    CARD8	length;
+    CARD32Ptr	data;
+} ARRAY32, *ARRAY32Ptr;
+
+typedef struct _ARRAYofARRAY8 {
+    CARD8	length;
+    ARRAY8Ptr	data;
+} ARRAYofARRAY8, *ARRAYofARRAY8Ptr;
+
+typedef struct _XdmcpHeader {
+    CARD16  version, opcode, length;
+} XdmcpHeader, *XdmcpHeaderPtr;
+
+typedef struct _XdmcpBuffer {
+    BYTE    *data;
+    int	    size;		/* size of buffer pointed by to data */
+    int	    pointer;		/* current index into data */
+    int	    count;		/* bytes read from network into data */
+} XdmcpBuffer, *XdmcpBufferPtr;
+
+typedef struct _XdmAuthKey {
+    BYTE    data[8];
+} XdmAuthKeyRec, *XdmAuthKeyPtr;
+
+
+/* implementation-independent network address structure.
+   Equiv to sockaddr* for sockets. */
+
+typedef char *XdmcpNetaddr;
+
+extern int XdmcpWriteARRAY16(XdmcpBufferPtr buffer, const ARRAY16Ptr array);
+extern int XdmcpWriteARRAY32(XdmcpBufferPtr buffer, const ARRAY32Ptr array);
+extern int XdmcpWriteARRAY8(XdmcpBufferPtr buffer, const ARRAY8Ptr array);
+extern int XdmcpWriteARRAYofARRAY8(XdmcpBufferPtr buffer, const ARRAYofARRAY8Ptr array);
+extern int XdmcpWriteCARD16(XdmcpBufferPtr buffer, unsigned value);
+extern int XdmcpWriteCARD32(XdmcpBufferPtr buffer, unsigned value);
+extern int XdmcpWriteCARD8(XdmcpBufferPtr buffer, unsigned value);
+extern int XdmcpWriteHeader(XdmcpBufferPtr  buffer, const XdmcpHeaderPtr  header);
+
+extern int XdmcpFlush(int fd, XdmcpBufferPtr buffer, XdmcpNetaddr to, int tolen);
+
+extern int XdmcpReadARRAY16(XdmcpBufferPtr buffer, ARRAY16Ptr array);
+extern int XdmcpReadARRAY32(XdmcpBufferPtr buffer, ARRAY32Ptr array);
+extern int XdmcpReadARRAY8(XdmcpBufferPtr buffer, ARRAY8Ptr array);
+extern int XdmcpReadARRAYofARRAY8(XdmcpBufferPtr buffer, ARRAYofARRAY8Ptr array);
+extern int XdmcpReadCARD16(XdmcpBufferPtr buffer, CARD16Ptr valuep);
+extern int XdmcpReadCARD32(XdmcpBufferPtr buffer, CARD32Ptr valuep);
+extern int XdmcpReadCARD8(XdmcpBufferPtr buffer, CARD8Ptr valuep);
+extern int XdmcpReadHeader(XdmcpBufferPtr buffer, XdmcpHeaderPtr header);
+
+extern int XdmcpFill(int fd, XdmcpBufferPtr buffer, XdmcpNetaddr from, int *fromlen);
+
+extern int XdmcpReadRemaining(const XdmcpBufferPtr buffer);
+
+extern void XdmcpDisposeARRAY8(ARRAY8Ptr array);
+extern void XdmcpDisposeARRAY16(ARRAY16Ptr array);
+extern void XdmcpDisposeARRAY32(ARRAY32Ptr array);
+extern void XdmcpDisposeARRAYofARRAY8(ARRAYofARRAY8Ptr array);
+
+extern int XdmcpCopyARRAY8(const ARRAY8Ptr src, ARRAY8Ptr dst);
+
+extern int XdmcpARRAY8Equal(const ARRAY8Ptr array1, const ARRAY8Ptr array2);
+
+extern void XdmcpGenerateKey (XdmAuthKeyPtr key);
+extern void XdmcpIncrementKey (XdmAuthKeyPtr key);
+extern void XdmcpDecrementKey (XdmAuthKeyPtr key);
+#ifdef HASXDMAUTH
+extern void XdmcpWrap(unsigned char *input, unsigned char *wrapper, unsigned char *output, int bytes);
+extern void XdmcpUnwrap(unsigned char *input, unsigned char *wrapper, unsigned char *output, int bytes);
+#endif
+
+#ifndef TRUE
+#define TRUE	1
+#define FALSE	0
+#endif
+
+extern int XdmcpCompareKeys (const XdmAuthKeyPtr a, const XdmAuthKeyPtr b);
+
+extern int XdmcpAllocARRAY16 (ARRAY16Ptr array, int length);
+extern int XdmcpAllocARRAY32 (ARRAY32Ptr array, int length);
+extern int XdmcpAllocARRAY8 (ARRAY8Ptr array, int length);
+extern int XdmcpAllocARRAYofARRAY8 (ARRAYofARRAY8Ptr array, int length);
+
+extern int XdmcpReallocARRAY16 (ARRAY16Ptr array, int length);
+extern int XdmcpReallocARRAY32 (ARRAY32Ptr array, int length);
+extern int XdmcpReallocARRAY8 (ARRAY8Ptr array, int length);
+extern int XdmcpReallocARRAYofARRAY8 (ARRAYofARRAY8Ptr array, int length);
+
+_XFUNCPROTOEND
+
+#endif /* _XDMCP_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/GL/glxint.h b/depends/libxcb/depends/xorgproto/include/GL/glxint.h
new file mode 100644
index 0000000..87ae6b6
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/GL/glxint.h
@@ -0,0 +1,137 @@
+#ifndef __GLX_glxint_h__
+#define __GLX_glxint_h__
+
+/*
+ * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+ * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice including the dates of first publication and
+ * either this permission notice or a reference to
+ * http://oss.sgi.com/projects/FreeB/
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Silicon Graphics, Inc.
+ * shall not be used in advertising or otherwise to promote the sale, use or
+ * other dealings in this Software without prior written authorization from
+ * Silicon Graphics, Inc.
+ */
+
+#include <X11/X.h>
+#include <X11/Xdefs.h>
+#include "GL/gl.h"
+
+typedef struct __GLXvisualConfigRec __GLXvisualConfig;
+typedef struct __GLXFBConfigRec __GLXFBConfig;
+
+struct __GLXvisualConfigRec {
+    VisualID vid;
+    int class;
+    Bool rgba;
+    int redSize, greenSize, blueSize, alphaSize;
+    unsigned long redMask, greenMask, blueMask, alphaMask;
+    int accumRedSize, accumGreenSize, accumBlueSize, accumAlphaSize;
+    Bool doubleBuffer;
+    Bool stereo;
+    int bufferSize;
+    int depthSize;
+    int stencilSize;
+    int auxBuffers;
+    int level;
+    /* Start of Extended Visual Properties */
+    int visualRating;		/* visual_rating extension */
+    int transparentPixel;	/* visual_info extension */
+				/*    colors are floats scaled to ints */
+    int transparentRed, transparentGreen, transparentBlue, transparentAlpha;
+    int transparentIndex;
+    int multiSampleSize;
+    int nMultiSampleBuffers;
+    int visualSelectGroup;
+};
+
+#define __GLX_MIN_CONFIG_PROPS	18
+#define __GLX_MAX_CONFIG_PROPS	500
+
+#define __GLX_EXT_CONFIG_PROPS 	10
+
+/*
+** Since we send all non-core visual properties as token, value pairs,
+** we require 2 words across the wire. In order to maintain backwards
+** compatibility, we need to send the total number of words that the
+** VisualConfigs are sent back in so old libraries can simply "ignore"
+** the new properties.
+*/
+#define __GLX_TOTAL_CONFIG       (__GLX_MIN_CONFIG_PROPS +      \
+                                    2 * __GLX_EXT_CONFIG_PROPS)
+
+struct __GLXFBConfigRec {
+    int visualType;
+    int transparentType;
+                                /*    colors are floats scaled to ints */
+    int transparentRed, transparentGreen, transparentBlue, transparentAlpha;
+    int transparentIndex;
+
+    int visualCaveat;
+
+    int associatedVisualId;
+    int screen;
+
+    int drawableType;
+    int renderType;
+
+    int maxPbufferWidth, maxPbufferHeight, maxPbufferPixels;
+    int optimalPbufferWidth, optimalPbufferHeight;  /* for SGIX_pbuffer */
+
+    int visualSelectGroup;	/* visuals grouped by select priority */
+
+    unsigned int id;
+
+    GLboolean rgbMode;
+    GLboolean colorIndexMode;
+    GLboolean doubleBufferMode;
+    GLboolean stereoMode;
+    GLboolean haveAccumBuffer;
+    GLboolean haveDepthBuffer;
+    GLboolean haveStencilBuffer;
+
+    /* The number of bits present in various buffers */
+    GLint accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits;
+    GLint depthBits;
+    GLint stencilBits;
+    GLint indexBits;
+    GLint redBits, greenBits, blueBits, alphaBits;
+    GLuint redMask, greenMask, blueMask, alphaMask;
+
+    GLuint multiSampleSize;     /* Number of samples per pixel (0 if no ms) */
+
+    GLuint nMultiSampleBuffers; /* Number of available ms buffers */
+    GLint maxAuxBuffers;
+
+    /* frame buffer level */
+    GLint level;
+
+    /* color ranges (for SGI_color_range) */
+    GLboolean extendedRange;
+    GLdouble minRed, maxRed;
+    GLdouble minGreen, maxGreen;
+    GLdouble minBlue, maxBlue;
+    GLdouble minAlpha, maxAlpha;
+};
+
+#define __GLX_TOTAL_FBCONFIG_PROPS	 35
+
+#endif /* !__GLX_glxint_h__ */
diff --git a/depends/libxcb/depends/xorgproto/include/GL/glxmd.h b/depends/libxcb/depends/xorgproto/include/GL/glxmd.h
new file mode 100644
index 0000000..8ff9c1b
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/GL/glxmd.h
@@ -0,0 +1,54 @@
+#ifndef _GLX_glxmd_h_
+#define _GLX_glxmd_h_
+
+
+/*
+ * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+ * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice including the dates of first publication and
+ * either this permission notice or a reference to
+ * http://oss.sgi.com/projects/FreeB/
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Silicon Graphics, Inc.
+ * shall not be used in advertising or otherwise to promote the sale, use or
+ * other dealings in this Software without prior written authorization from
+ * Silicon Graphics, Inc.
+ */
+
+/*
+** Machine dependent declarations.
+*/
+
+/*
+** Define floating point wire types.  These are in IEEE format on the wire.
+*/
+typedef float FLOAT32;
+typedef double FLOAT64;
+
+/*
+** Like B32, but this is used to store floats in a request.
+**
+** NOTE: Machines that have a native 32-bit IEEE float can define this as
+**       nothing.  Machines that don't might mimic the float with an integer,
+**       and then define this to :32.
+*/
+#define F32
+
+#endif /* _GLX_glxmd_h_ */
diff --git a/depends/libxcb/depends/xorgproto/include/GL/glxproto.h b/depends/libxcb/depends/xorgproto/include/GL/glxproto.h
new file mode 100644
index 0000000..e4dfc10
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/GL/glxproto.h
@@ -0,0 +1,2726 @@
+#ifndef _GLX_glxproto_h_
+#define _GLX_glxproto_h_
+
+/*
+ * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+ * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice including the dates of first publication and
+ * either this permission notice or a reference to
+ * http://oss.sgi.com/projects/FreeB/
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Silicon Graphics, Inc.
+ * shall not be used in advertising or otherwise to promote the sale, use or
+ * other dealings in this Software without prior written authorization from
+ * Silicon Graphics, Inc.
+ */
+
+#include <GL/glxmd.h>
+
+/*****************************************************************************/
+
+/*
+** Errors.
+*/
+#define GLXBadContext		0
+#define GLXBadContextState	1
+#define GLXBadDrawable		2
+#define GLXBadPixmap		3
+#define GLXBadContextTag	4
+#define GLXBadCurrentWindow	5
+#define GLXBadRenderRequest	6
+#define GLXBadLargeRequest	7
+#define GLXUnsupportedPrivateRequest	8
+#define GLXBadFBConfig		9
+#define GLXBadPbuffer		10
+#define GLXBadCurrentDrawable	11
+#define GLXBadWindow		12
+#define GLXBadProfileARB        13
+
+#define __GLX_NUMBER_ERRORS 14
+
+/*
+** Events.
+** __GLX_NUMBER_EVENTS is set to 17 to account for the BufferClobberSGIX
+**  event - this helps initialization if the server supports the pbuffer
+**  extension and the client doesn't.
+*/
+#define GLX_PbufferClobber	0
+#define GLX_BufferSwapComplete	1
+
+#define __GLX_NUMBER_EVENTS 17
+
+#define GLX_EXTENSION_NAME	"GLX"
+#define GLX_EXTENSION_ALIAS	"SGI-GLX"
+
+#define __GLX_MAX_CONTEXT_PROPS 3
+
+#ifndef GLX_VENDOR
+#define GLX_VENDOR		0x1
+#endif
+#ifndef GLX_VERSION
+#define GLX_VERSION		0x2
+#endif
+#ifndef GLX_EXTENSIONS
+#define GLX_EXTENSIONS		0x3
+#endif
+
+/*****************************************************************************/
+
+/*
+** For the structure definitions in this file, we must redefine these types in
+** terms of Xmd.h types, which may include bitfields.  All of these are
+** undef'ed at the end of this file, restoring the definitions in glx.h.
+*/
+#define GLXContextID CARD32
+#define GLXPixmap CARD32
+#define GLXDrawable CARD32
+#define GLXPbuffer CARD32
+#define GLXWindow CARD32
+#define GLXFBConfigID CARD32
+#define GLXFBConfigIDSGIX CARD32
+#define GLXPbufferSGIX CARD32
+
+/*
+** ContextTag is not exposed to the API.
+*/
+typedef CARD32 GLXContextTag;
+
+/*****************************************************************************/
+
+/*
+** Sizes of basic wire types.
+*/
+#define __GLX_SIZE_INT8		1
+#define __GLX_SIZE_INT16	2
+#define __GLX_SIZE_INT32	4
+#define __GLX_SIZE_CARD8	1
+#define __GLX_SIZE_CARD16	2
+#define __GLX_SIZE_CARD32	4
+#define __GLX_SIZE_FLOAT32	4
+#define __GLX_SIZE_FLOAT64	8
+
+/*****************************************************************************/
+
+/* Requests */
+
+/*
+** Render command request.  A bunch of rendering commands are packed into
+** a single X extension request.
+*/
+typedef struct GLXRender {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXContextTag contextTag;
+} xGLXRenderReq;
+#define sz_xGLXRenderReq 8
+
+/*
+** The maximum size that a GLXRender command can be.  The value must fit
+** in 16 bits and should be a multiple of 4.
+*/
+#define __GLX_MAX_RENDER_CMD_SIZE	64000
+
+/*
+** Large render command request.  A single large rendering command
+** is output in multiple X extension requests.	The first packet
+** contains an opcode dependent header (see below) that describes
+** the data that follows.
+*/
+typedef struct GLXRenderLarge {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXContextTag contextTag;
+    CARD16	requestNumber;
+    CARD16	requestTotal;
+    CARD32	dataBytes;
+} xGLXRenderLargeReq;
+#define sz_xGLXRenderLargeReq 16
+
+/*
+** GLX single request.	Commands that go over as single GLX protocol
+** requests use this structure.  The glxCode will be one of the X_GLsop
+** opcodes.
+*/
+typedef struct GLXSingle {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXContextTag contextTag;
+} xGLXSingleReq;
+#define sz_xGLXSingleReq 8
+
+/*
+** glXQueryVersion request
+*/
+typedef struct GLXQueryVersion {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	majorVersion;
+    CARD32	minorVersion;
+} xGLXQueryVersionReq;
+#define sz_xGLXQueryVersionReq 12
+
+/*
+** glXIsDirect request
+*/
+typedef struct GLXIsDirect {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXContextID context;
+} xGLXIsDirectReq;
+#define sz_xGLXIsDirectReq 8
+
+/*
+** glXCreateContext request
+*/
+typedef struct GLXCreateContext {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXContextID context;
+    CARD32	visual;
+    CARD32	screen;
+    GLXContextID shareList;
+    BOOL	isDirect;
+    CARD8	reserved1;
+    CARD16	reserved2;
+} xGLXCreateContextReq;
+#define sz_xGLXCreateContextReq 24
+
+/*
+** glXDestroyContext request
+*/
+typedef struct GLXDestroyContext {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXContextID context;
+} xGLXDestroyContextReq;
+#define sz_xGLXDestroyContextReq 8
+
+/*
+** glXMakeCurrent request
+*/
+typedef struct GLXMakeCurrent {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXDrawable drawable;
+    GLXContextID context;
+    GLXContextTag oldContextTag;
+} xGLXMakeCurrentReq;
+#define sz_xGLXMakeCurrentReq 16
+
+/*
+** glXWaitGL request
+*/
+typedef struct GLXWaitGL {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXContextTag contextTag;
+} xGLXWaitGLReq;
+#define sz_xGLXWaitGLReq 8
+
+/*
+** glXWaitX request
+*/
+typedef struct GLXWaitX {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXContextTag contextTag;
+} xGLXWaitXReq;
+#define sz_xGLXWaitXReq 8
+
+/*
+** glXCopyContext request
+*/
+typedef struct GLXCopyContext {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXContextID source;
+    GLXContextID dest;
+    CARD32	mask;
+    GLXContextTag contextTag;
+} xGLXCopyContextReq;
+#define sz_xGLXCopyContextReq 20
+
+/*
+** glXSwapBuffers request
+*/
+typedef struct GLXSwapBuffers {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXContextTag contextTag;
+    GLXDrawable drawable;
+} xGLXSwapBuffersReq;
+#define sz_xGLXSwapBuffersReq 12
+
+/*
+** glXUseXFont request
+*/
+typedef struct GLXUseXFont {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXContextTag contextTag;
+    CARD32	font;
+    CARD32	first;
+    CARD32	count;
+    CARD32	listBase;
+} xGLXUseXFontReq;
+#define sz_xGLXUseXFontReq 24
+
+/*
+** glXCreateGLXPixmap request
+*/
+typedef struct GLXCreateGLXPixmap {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	screen;
+    CARD32	visual;
+    CARD32	pixmap;
+    GLXPixmap	glxpixmap;
+} xGLXCreateGLXPixmapReq;
+#define sz_xGLXCreateGLXPixmapReq 20
+
+/*
+** glXDestroyGLXPixmap request
+*/
+typedef struct GLXDestroyGLXPixmap {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXPixmap	glxpixmap;
+} xGLXDestroyGLXPixmapReq;
+#define sz_xGLXDestroyGLXPixmapReq 8
+
+/*
+** glXGetVisualConfigs request
+*/
+typedef struct GLXGetVisualConfigs {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	screen;
+} xGLXGetVisualConfigsReq;
+#define sz_xGLXGetVisualConfigsReq 8
+
+/*
+** glXVendorPrivate request.
+*/
+typedef struct GLXVendorPrivate {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	vendorCode;		/* vendor-specific opcode */
+    GLXContextTag contextTag;
+    /*
+    ** More data may follow; this is just the header.
+    */
+} xGLXVendorPrivateReq;
+#define sz_xGLXVendorPrivateReq 12
+
+/*
+** glXVendorPrivateWithReply request
+*/
+typedef struct GLXVendorPrivateWithReply {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	vendorCode;		/* vendor-specific opcode */
+    GLXContextTag contextTag;
+    /*
+    ** More data may follow; this is just the header.
+    */
+} xGLXVendorPrivateWithReplyReq;
+#define sz_xGLXVendorPrivateWithReplyReq 12
+
+/*
+** glXQueryExtensionsString request
+*/
+typedef struct GLXQueryExtensionsString {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	screen;
+} xGLXQueryExtensionsStringReq;
+#define sz_xGLXQueryExtensionsStringReq 8
+
+/*
+** glXQueryServerString request
+*/
+typedef struct GLXQueryServerString {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	screen;
+    CARD32	name;
+} xGLXQueryServerStringReq;
+#define sz_xGLXQueryServerStringReq 12
+
+/*
+** glXClientInfo request
+*/
+typedef struct GLXClientInfo {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	major;
+    CARD32	minor;
+    CARD32	numbytes;
+} xGLXClientInfoReq;
+#define sz_xGLXClientInfoReq 16
+
+/*** Start of GLX 1.3 requests */
+
+/*
+** glXGetFBConfigs request
+*/
+typedef struct GLXGetFBConfigs {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	screen;
+} xGLXGetFBConfigsReq;
+#define sz_xGLXGetFBConfigsReq 8
+
+/*
+** glXCreatePixmap request
+*/
+typedef struct GLXCreatePixmap {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	screen;
+    GLXFBConfigID fbconfig;
+    CARD32	pixmap;
+    GLXPixmap	glxpixmap;
+    CARD32	numAttribs;
+    /* followed by attribute list */
+} xGLXCreatePixmapReq;
+#define sz_xGLXCreatePixmapReq 24
+
+/*
+** glXDestroyPixmap request
+*/
+typedef struct GLXDestroyPixmap {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXPixmap	glxpixmap;
+} xGLXDestroyPixmapReq;
+#define sz_xGLXDestroyPixmapReq 8
+
+/*
+** glXCreateNewContext request
+*/
+typedef struct GLXCreateNewContext {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXContextID context;
+    GLXFBConfigID fbconfig;
+    CARD32	screen;
+    CARD32	renderType;
+    GLXContextID shareList;
+    BOOL	isDirect;
+    CARD8	reserved1;
+    CARD16	reserved2;
+} xGLXCreateNewContextReq;
+#define sz_xGLXCreateNewContextReq 28
+
+/*
+** glXQueryContext request
+*/
+typedef struct GLXQueryContext {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXContextID context;
+} xGLXQueryContextReq;
+#define sz_xGLXQueryContextReq 8
+
+/*
+** glXMakeContextCurrent request
+*/
+typedef struct GLXMakeContextCurrent {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXContextTag oldContextTag;
+    GLXDrawable drawable;
+    GLXDrawable readdrawable;
+    GLXContextID context;
+} xGLXMakeContextCurrentReq;
+#define sz_xGLXMakeContextCurrentReq 20
+
+/*
+** glXCreatePbuffer request
+*/
+typedef struct GLXCreatePbuffer {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	screen;
+    GLXFBConfigID fbconfig;
+    GLXPbuffer	pbuffer;
+    CARD32	numAttribs;
+    /* followed by attribute list */
+} xGLXCreatePbufferReq;
+#define sz_xGLXCreatePbufferReq 20
+
+/*
+** glXDestroyPbuffer request
+*/
+typedef struct GLXDestroyPbuffer {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXPbuffer	pbuffer;
+} xGLXDestroyPbufferReq;
+#define sz_xGLXDestroyPbufferReq 8
+
+/*
+** glXGetDrawableAttributes request
+*/
+typedef struct GLXGetDrawableAttributes {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXDrawable drawable;
+} xGLXGetDrawableAttributesReq;
+#define sz_xGLXGetDrawableAttributesReq 8
+
+/*
+** glXChangeDrawableAttributes request
+*/
+typedef struct GLXChangeDrawableAttributes {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXDrawable drawable;
+    CARD32	numAttribs;
+    /* followed by attribute list */
+} xGLXChangeDrawableAttributesReq;
+#define sz_xGLXChangeDrawableAttributesReq 12
+
+/*
+** glXCreateWindow request
+*/
+typedef struct GLXCreateWindow {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	screen;
+    GLXFBConfigID fbconfig;
+    CARD32	window;
+    GLXWindow	glxwindow;
+    CARD32	numAttribs;
+    /* followed by attribute list */
+} xGLXCreateWindowReq;
+#define sz_xGLXCreateWindowReq 24
+
+/*
+** glXDestroyWindow request
+*/
+typedef struct GLXDestroyWindow {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXWindow	glxwindow;
+} xGLXDestroyWindowReq;
+#define sz_xGLXDestroyWindowReq 8
+
+/* Replies */
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	error;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXGetErrorReply;
+#define sz_xGLXGetErrorReply 32
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    GLXContextTag contextTag;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXMakeCurrentReply;
+#define sz_xGLXMakeCurrentReply 32
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXReadPixelsReply;
+#define sz_xGLXReadPixelsReply 32
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	width;
+    CARD32	height;
+    CARD32	depth;
+    CARD32	pad6;
+} xGLXGetTexImageReply;
+#define sz_xGLXGetTexImageReply 32
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	width;
+    CARD32	height;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXGetSeparableFilterReply;
+#define sz_xGLXGetSeparableFilterReply 32
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	width;
+    CARD32	height;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXGetConvolutionFilterReply;
+#define sz_xGLXGetConvolutionFilterReply 32
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	width;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXGetHistogramReply;
+#define sz_xGLXGetHistogramReply 32
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXGetMinmaxReply;
+#define sz_xGLXGetMinmaxReply 32
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	retval;
+    CARD32	size;
+    CARD32	newMode;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXRenderModeReply;
+#define sz_xGLXRenderModeReply 32
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	majorVersion;
+    CARD32	minorVersion;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXQueryVersionReply;
+#define sz_xGLXQueryVersionReply 32
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	numVisuals;
+    CARD32	numProps;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXGetVisualConfigsReply;
+#define sz_xGLXGetVisualConfigsReply 32
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    BOOL	isDirect;
+    CARD8	pad1;
+    CARD16	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+    CARD32	pad7;
+} xGLXIsDirectReply;
+#define sz_xGLXIsDirectReply	32
+
+/*
+** This reply structure is used for all single replies.  Single replies
+** ship either 1 piece of data or N pieces of data.  In these cases
+** size indicates how much data is to be returned.
+*/
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	retval;
+    CARD32	size;
+    CARD32	pad3;			/* NOTE: may hold a single value */
+    CARD32	pad4;			/* NOTE: may hold half a double */
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXSingleReply;
+#define sz_xGLXSingleReply 32
+
+/*
+** This reply structure is used for all Vendor Private replies. Vendor
+** Private replies can ship up to 24 bytes within the header or can
+** be variable sized, in which case, the reply length field indicates
+** the number of words of data which follow the header.
+*/
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	retval;
+    CARD32	size;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXVendorPrivReply;
+#define sz_xGLXVendorPrivReply 32
+
+/*
+**  QueryExtensionsStringReply
+**  n indicates the number of bytes to be returned.
+*/
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	pad1;
+    CARD32	n;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXQueryExtensionsStringReply;
+#define sz_xGLXQueryExtensionsStringReply 32
+
+/*
+** QueryServerString Reply struct
+** n indicates the number of bytes to be returned.
+*/
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	pad1;
+    CARD32	n;
+    CARD32	pad3;			/* NOTE: may hold a single value */
+    CARD32	pad4;			/* NOTE: may hold half a double */
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXQueryServerStringReply;
+#define sz_xGLXQueryServerStringReply 32
+
+/*** Start of GLX 1.3 replies */
+
+/*
+** glXGetFBConfigs reply
+*/
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	numFBConfigs;
+    CARD32	numAttribs;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXGetFBConfigsReply;
+#define sz_xGLXGetFBConfigsReply 32
+
+/*
+** glXQueryContext reply
+*/
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	n;			/* number of attribute/value pairs */
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXQueryContextReply;
+#define sz_xGLXQueryContextReply 32
+
+/*
+** glXMakeContextCurrent reply
+*/
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    GLXContextTag contextTag;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXMakeContextCurrentReply;
+#define sz_xGLXMakeContextCurrentReply 32
+
+/*
+** glXCreateGLXPbuffer reply
+** This is used only in the direct rendering case on SGIs - otherwise
+**  CreateGLXPbuffer has no reply. It is not part of GLX 1.3.
+*/
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	success;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXCreateGLXPbufferReply;
+#define sz_xGLXCreateGLXPbufferReply 32
+
+/*
+** glXGetDrawableAttributes reply
+*/
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	numAttribs;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXGetDrawableAttributesReply;
+#define sz_xGLXGetDrawableAttributesReply 32
+
+/*
+** glXGetColorTable reply
+*/
+typedef struct {
+    BYTE	type;		       /* X_Reply */
+    CARD8	unused;		       /* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	width;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXGetColorTableReply;
+#define sz_xGLXGetColorTableReply 32
+
+/************************************************************************/
+
+/* GLX extension requests and replies */
+
+/*
+** glXQueryContextInfoEXT request
+*/
+typedef struct GLXQueryContextInfoEXT {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	vendorCode;		/* vendor-specific opcode */
+    CARD32	pad1;	/* unused; corresponds to contextTag in header */
+    GLXContextID context;
+} xGLXQueryContextInfoEXTReq;
+#define sz_xGLXQueryContextInfoEXTReq 16
+
+/*
+** glXQueryContextInfoEXT reply
+*/
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	n;			/* number of attribute/value pairs */
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXQueryContextInfoEXTReply;
+#define sz_xGLXQueryContextInfoEXTReply 32
+
+/*
+** glXMakeCurrentReadSGI request
+*/
+typedef struct GLXMakeCurrentReadSGI {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	vendorCode;		/* vendor-specific opcode */
+    GLXContextTag oldContextTag;
+    GLXDrawable drawable;
+    GLXDrawable readable;
+    GLXContextID context;
+} xGLXMakeCurrentReadSGIReq;
+#define sz_xGLXMakeCurrentReadSGIReq 24
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    GLXContextTag contextTag;
+    CARD32	writeVid;
+    CARD32	writeType;
+    CARD32	readVid;
+    CARD32	readType;
+    CARD32	pad6;
+} xGLXMakeCurrentReadSGIReply;
+#define sz_xGLXMakeCurrentReadSGIReply 32
+
+/*
+** glXGetFBConfigsSGIX request
+*/
+typedef struct GLXGetFBConfigsSGIX {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	vendorCode;		/* vendor-specific opcode */
+    CARD32	pad1;   /* unused; corresponds to contextTag in header */
+    CARD32	screen;
+} xGLXGetFBConfigsSGIXReq;
+#define sz_xGLXGetFBConfigsSGIXReq 16
+
+/*
+** glXCreateContextWithConfigSGIX request
+*/
+
+typedef struct GLXCreateContextWithConfigSGIX {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	vendorCode;		/* vendor-specific opcode */
+    CARD32	pad1;   /* unused; corresponds to contextTag in header */
+    GLXContextID context;
+    GLXFBConfigID fbconfig;
+    CARD32	screen;
+    CARD32	renderType;
+    GLXContextID shareList;
+    BOOL	isDirect;
+    CARD8	reserved1;
+    CARD16	reserved2;
+} xGLXCreateContextWithConfigSGIXReq;
+#define sz_xGLXCreateContextWithConfigSGIXReq 36
+
+/*
+** glXCreatePixmapWithConfigSGIX request
+*/
+
+typedef struct GLXCreateGLXPixmapWithConfigSGIX {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	vendorCode;		/* vendor-specific opcode */
+    CARD32	pad1;   /* unused; corresponds to contextTag in header */
+    CARD32	screen;
+    GLXFBConfigID fbconfig;
+    CARD32	pixmap;
+    GLXPixmap	glxpixmap;
+} xGLXCreateGLXPixmapWithConfigSGIXReq;
+#define sz_xGLXCreateGLXPixmapWithConfigSGIXReq 28
+
+/*
+** glXCreateGLXPbufferSGIX request
+*/
+typedef struct GLXCreateGLXPbufferSGIX {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	vendorCode;		/* vendor-specific opcode */
+    CARD32	pad1;   /* unused; corresponds to contextTag in header */
+    CARD32	screen;
+    GLXFBConfigID fbconfig;
+    GLXPbuffer	pbuffer;
+    CARD32	width;
+    CARD32	height;
+    /* followed by attribute list */
+} xGLXCreateGLXPbufferSGIXReq;
+#define sz_xGLXCreateGLXPbufferSGIXReq 32
+
+/*
+** glXDestroyGLXPbufferSGIX request
+*/
+typedef struct GLXDestroyGLXPbuffer {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	vendorCode;		/* vendor-specific opcode */
+    CARD32	pad1;   /* unused; corresponds to contextTag in header */
+    GLXPbuffer	pbuffer;
+} xGLXDestroyGLXPbufferSGIXReq;
+#define sz_xGLXDestroyGLXPbufferSGIXReq 16
+
+/*
+** glXChangeDrawableAttributesSGIX request
+*/
+typedef struct GLXChangeDrawableAttributesSGIX {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	vendorCode;		/* vendor-specific opcode */
+    CARD32	pad1;   /* unused; corresponds to contextTag in header */
+    GLXDrawable drawable;
+    CARD32	numAttribs;
+    /* followed by attribute list */
+} xGLXChangeDrawableAttributesSGIXReq;
+#define sz_xGLXChangeDrawableAttributesSGIXReq 20
+
+/*
+** glXGetDrawableAttributesSGIX request
+*/
+typedef struct GLXGetDrawableAttributesSGIX {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	vendorCode;		/* vendor-specific opcode */
+    CARD32	pad1;   /* unused; corresponds to contextTag in header */
+    GLXDrawable drawable;
+} xGLXGetDrawableAttributesSGIXReq;
+#define sz_xGLXGetDrawableAttributesSGIXReq 16
+
+/*
+** glXGetDrawableAttributesSGIX reply
+*/
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	numAttribs;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXGetDrawableAttributesSGIXReply;
+#define sz_xGLXGetDrawableAttributesSGIXReply 32
+
+/*
+** glXJoinSwapGroupSGIX request
+*/
+typedef struct GLXJoinSwapGroupSGIX {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	vendorCode;		/* vendor-specific opcode */
+    CARD32 	unused;		/* corresponds to contextTag in hdr */
+    GLXDrawable	drawable;
+    GLXDrawable	member;
+} xGLXJoinSwapGroupSGIXReq;
+#define sz_xGLXJoinSwapGroupSGIXReq 20
+
+/*
+** glXBindSwapBarrierSGIX request
+*/
+typedef struct GLXBindSwapBarrierSGIX {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	vendorCode;		/* vendor-specific opcode */
+    CARD32 	unused;		/* corresponds to contextTag in hdr */
+    GLXDrawable	drawable;
+    CARD32	barrier;
+} xGLXBindSwapBarrierSGIXReq;
+#define sz_xGLXBindSwapBarrierSGIXReq 20
+
+/*
+** glXQueryMaxSwapBarriersSGIX request
+*/
+typedef struct GLXQueryMaxSwapBarriersSGIX {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	vendorCode;		/* vendor-specific opcode */
+    CARD32 	unused;		/* corresponds to contextTag in hdr */
+    CARD32	screen;
+} xGLXQueryMaxSwapBarriersSGIXReq;
+#define sz_xGLXQueryMaxSwapBarriersSGIXReq 16
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	max;
+    CARD32	size;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGLXQueryMaxSwapBarriersSGIXReply;
+#define sz_xGLXQueryMaxSwapBarriersSGIXReply 32
+
+/*
+** glXQueryHyperpipeNetworkSGIX request
+*/
+typedef struct GLXQueryHyperpipeNetworkSGIX {
+    CARD8       reqType;
+    CARD8       glxCode;
+    CARD16      length;
+    CARD32      vendorCode;		/* vendor-specific opcode */
+    CARD32      pad1;   /* unused; corresponds to contextTag in header */
+    CARD32      screen;
+} xGLXQueryHyperpipeNetworkSGIXReq;
+#define sz_xGLXQueryHyperpipeNetworkSGIXReq 16
+
+/*
+** glXQueryHyperpipeNetworkSGIX reply
+*/
+typedef struct {
+    BYTE        type;                   /* X_Reply */
+    CARD8       unused;                 /* not used */
+    CARD16      sequenceNumber;
+    CARD32      length;
+    CARD32      pad1;
+    CARD32      n;
+    CARD32	npipes;			/* NOTE: may hold a single value */
+    CARD32	pad4;			/* NOTE: may hold half a double */
+    CARD32      pad5;
+    CARD32      pad6;
+} xGLXQueryHyperpipeNetworkSGIXReply;
+#define sz_xGLXQueryHyperpipeNetworkSGIXReply 32
+
+/*
+** glXDestroyHyperpipeConfigSGIX request
+*/
+typedef struct GLXDestroyHyperpipeConfigSGIX {
+    CARD8       reqType;
+    CARD8       glxCode;
+    CARD16      length;
+    CARD32      vendorCode;		/* vendor-specific opcode */
+    CARD32      pad1;   /* unused; corresponds to contextTag in header */
+    CARD32      screen;
+    CARD32      hpId;
+    CARD32      pad2;
+    CARD32      pad3;
+    CARD32      pad4;
+} xGLXDestroyHyperpipeConfigSGIXReq;
+#define sz_xGLXDestroyHyperpipeConfigSGIXReq 32
+
+/*
+** glXDestroyHyperpipeConfigSGIX reply
+*/
+typedef struct {
+    BYTE        type;                   /* X_Reply */
+    CARD8       unused;                 /* not used */
+    CARD16      sequenceNumber;
+    CARD32      length;
+    CARD32      pad1;
+    CARD32      n;
+    CARD32      success;		/* NOTE: may hold a single value */
+    CARD32      pad4;			/* NOTE: may hold half a double */
+    CARD32      pad5;
+    CARD32      pad6;
+} xGLXDestroyHyperpipeConfigSGIXReply;
+#define sz_xGLXDestroyHyperpipeConfigSGIXReply 32
+
+/*
+** glXQueryHyperpipeConfigSGIX request
+*/
+typedef struct GLXQueryHyperpipeConfigSGIX {
+    CARD8       reqType;
+    CARD8       glxCode;
+    CARD16      length;
+    CARD32      vendorCode;		/* vendor-specific opcode */
+    CARD32      pad1;   /* unused; corresponds to contextTag in header */
+    CARD32      screen;
+    CARD32      hpId;
+    CARD32      pad2;
+    CARD32      pad3;
+    CARD32      pad4;
+} xGLXQueryHyperpipeConfigSGIXReq;
+#define sz_xGLXQueryHyperpipeConfigSGIXReq 32
+
+/*
+** glXQueryHyperpipeConfigSGIX reply
+*/
+typedef struct {
+    BYTE        type;                   /* X_Reply */
+    CARD8       unused;                 /* not used */
+    CARD16      sequenceNumber;
+    CARD32      length;
+    CARD32      pad1;
+    CARD32      n;
+    CARD32      npipes;
+    CARD32      pad4;
+    CARD32      pad5;
+    CARD32      pad6;
+} xGLXQueryHyperpipeConfigSGIXReply;
+#define sz_xGLXQueryHyperpipeConfigSGIXReply 32
+
+/*
+** glXHyperpipeConfigSGIX request
+*/
+typedef struct {
+    CARD8       reqType;
+    CARD8       glxCode;
+    CARD16      length;
+    CARD32      vendorCode;		/* vendor-specific opcode */
+    CARD32      pad1;   /* unused; corresponds to contextTag in header */
+    CARD32      screen;
+    CARD32      npipes;
+    CARD32      networkId;
+    CARD32      pad2;
+    CARD32      pad3;
+    /* followed by attribute list */
+} xGLXHyperpipeConfigSGIXReq;
+#define sz_xGLXHyperpipeConfigSGIXReq 32
+
+/*
+** glXHyperpipeConfigSGIX reply
+*/
+typedef struct {
+    BYTE        type;                   /* X_Reply */
+    CARD8       unused;                 /* not used */
+    CARD16      sequenceNumber;
+    CARD32      length;
+    CARD32      pad1;
+    CARD32      n;
+    CARD32      npipes;
+    CARD32      hpId;
+    CARD32      pad5;
+    CARD32      pad6;
+} xGLXHyperpipeConfigSGIXReply;
+#define sz_xGLXHyperpipeConfigSGIXReply 32
+
+/**
+ * \name Protocol structures for GLX_ARB_create_context and
+ * GLX_ARB_create_context_profile
+ */
+/*@{*/
+/**
+ * Protocol header for glXSetClientInfoARB
+ *
+ * This structure is followed by \c numVersions * 2 \c CARD32 values listing
+ * the OpenGL versions supported by the client.  The pairs of values are an
+ * OpenGL major version followed by a minor version.  For example,
+ *
+ *      CARD32 versions[4] = { 2, 1, 3, 0 };
+ *
+ * says that the client supports OpenGL 2.1 and OpenGL 3.0.
+ *
+ * These are followed by \c numGLExtensionBytes bytes of \c STRING8 containing
+ * the OpenGL extension string supported by the client and up to 3 bytes of
+ * padding.
+ *
+ * The list of OpenGL extensions is followed by \c numGLXExtensionBytes bytes
+ * of \c STRING8 containing the GLX extension string supported by the client
+ * and up to 3 bytes of padding.
+ *
+ * This protocol replaces \c GLXClientInfo.
+ *
+ * \sa GLXClientInfo, GLXSetClientInfo2ARB
+ */
+typedef struct GLXSetClientInfoARB {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	major;
+    CARD32	minor;
+    CARD32	numVersions;
+    CARD32	numGLExtensionBytes;
+    CARD32	numGLXExtensionBytes;
+    /*
+    ** More data may follow; this is just the header.
+    */
+} xGLXSetClientInfoARBReq;
+#define sz_xGLXSetClientInfoARBReq 24
+
+/**
+ * Protocol head for glXCreateContextAttribsARB
+ *
+ * This protocol replaces \c GLXCreateContext, \c GLXCreateNewContext, and
+ * \c GLXCreateContextWithConfigSGIX.
+ */
+typedef struct GLXCreateContextAttribsARB {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    GLXContextID	context;
+    GLXFBConfigID	fbconfig;
+    CARD32	screen;
+    GLXContextID	shareList;
+    BOOL	isDirect;
+    CARD8	reserved1;
+    CARD16	reserved2;
+    CARD32	numAttribs;
+    /* followed by attribute list */
+} xGLXCreateContextAttribsARBReq;
+#define sz_xGLXCreateContextAttribsARBReq 28
+
+/**
+ * Protocol header for glXSetClientInfo2ARB
+ *
+ * The glXSetClientInfo2ARB protocol differs from glXSetClientInfoARB in that
+ * the list of OpenGL versions supported by the client is 3 \c CARD32 values
+ * per version: major version, minor version, and supported profile mask.
+ *
+ * This protocol replaces \c GLXClientInfo and \c GLXSetClientInfoARB.
+ *
+ * \sa GLXClientInfo, GLXSetClientInfoARB
+ */
+typedef struct GLXSetClientInfo2ARB {
+    CARD8	reqType;
+    CARD8	glxCode;
+    CARD16	length;
+    CARD32	major;
+    CARD32	minor;
+    CARD32	numVersions;
+    CARD32	numGLExtensionBytes;
+    CARD32	numGLXExtensionBytes;
+    /*
+    ** More data may follow; this is just the header.
+    */
+} xGLXSetClientInfo2ARBReq;
+#define sz_xGLXSetClientInfo2ARBReq 24
+/*@}*/
+
+/************************************************************************/
+
+/*
+** Events
+*/
+
+typedef struct {
+    BYTE type;
+    BYTE pad;
+    CARD16 sequenceNumber;
+    CARD16 event_type;  /*** was clobber_class */
+    CARD16 draw_type;
+    CARD32 drawable;
+    CARD32 buffer_mask; /*** was mask */
+    CARD16 aux_buffer;
+    CARD16 x;
+    CARD16 y;
+    CARD16 width;
+    CARD16 height;
+    CARD16 count;
+    CARD32 unused2;
+} xGLXPbufferClobberEvent;
+
+typedef struct {
+    BYTE type;
+    BYTE pad;
+    CARD16 sequenceNumber;
+    CARD16 event_type;
+    CARD32 drawable;
+    CARD32 ust_hi;
+    CARD32 ust_lo;
+    CARD32 msc_hi;
+    CARD32 msc_lo;
+    CARD32 sbc_hi;
+    CARD32 sbc_lo;
+} xGLXBufferSwapComplete;
+
+typedef struct {
+    BYTE type;
+    BYTE pad;
+    CARD16 sequenceNumber;
+    CARD16 event_type;
+    CARD16 pad2;
+    CARD32 drawable;
+    CARD32 ust_hi;
+    CARD32 ust_lo;
+    CARD32 msc_hi;
+    CARD32 msc_lo;
+    CARD32 sbc;
+} xGLXBufferSwapComplete2;
+
+/************************************************************************/
+
+/*
+** Size of the standard X request header.
+*/
+#define __GLX_SINGLE_HDR_SIZE sz_xGLXSingleReq
+#define __GLX_VENDPRIV_HDR_SIZE sz_xGLXVendorPrivateReq
+
+#define __GLX_RENDER_HDR    \
+    CARD16	length;	    \
+    CARD16	opcode
+
+#define __GLX_RENDER_HDR_SIZE 4
+
+typedef struct {
+    __GLX_RENDER_HDR;
+} __GLXrenderHeader;
+
+#define __GLX_RENDER_LARGE_HDR \
+    CARD32	length;	       \
+    CARD32	opcode
+
+#define __GLX_RENDER_LARGE_HDR_SIZE 8
+
+typedef struct {
+    __GLX_RENDER_LARGE_HDR;
+} __GLXrenderLargeHeader;
+
+/*
+** The glBitmap, glPolygonStipple, glTexImage[12]D, glTexSubImage[12]D
+** and glDrawPixels calls all have a pixel header transmitted after the
+** Render or RenderLarge header and before their own opcode specific
+** headers.
+*/
+#define __GLX_PIXEL_HDR		\
+    BOOL	swapBytes;	\
+    BOOL	lsbFirst;	\
+    CARD8	reserved0;	\
+    CARD8	reserved1;	\
+    CARD32	rowLength;	\
+    CARD32	skipRows;	\
+    CARD32	skipPixels;	\
+    CARD32	alignment
+
+#define __GLX_PIXEL_HDR_SIZE 20
+
+typedef struct {
+    __GLX_PIXEL_HDR;
+} __GLXpixelHeader;
+
+/*
+** glTexImage[34]D and glTexSubImage[34]D calls
+** all have a pixel header transmitted after the Render or RenderLarge
+** header and before their own opcode specific headers.
+*/
+#define __GLX_PIXEL_3D_HDR		\
+    BOOL	swapBytes;		\
+    BOOL	lsbFirst;		\
+    CARD8	reserved0;		\
+    CARD8	reserved1;		\
+    CARD32	rowLength;		\
+    CARD32	imageHeight;		\
+    CARD32	imageDepth;		\
+    CARD32	skipRows;		\
+    CARD32	skipImages;		\
+    CARD32	skipVolumes;		\
+    CARD32	skipPixels;		\
+    CARD32	alignment
+
+#define __GLX_PIXEL_3D_HDR_SIZE 36
+
+/*
+** Data that is specific to a glBitmap call.  The data is sent in the
+** following order:
+**	Render or RenderLarge header
+**	Pixel header
+**	Bitmap header
+*/
+#define __GLX_BITMAP_HDR    \
+    CARD32	width;	    \
+    CARD32	height;	    \
+    FLOAT32	xorig F32;  \
+    FLOAT32	yorig F32;  \
+    FLOAT32	xmove F32;  \
+    FLOAT32	ymove F32
+
+typedef struct {
+    __GLX_RENDER_HDR;
+    __GLX_PIXEL_HDR;
+    __GLX_BITMAP_HDR;
+} __GLXbitmapHeader;
+
+typedef struct {
+    __GLX_RENDER_LARGE_HDR;
+    __GLX_PIXEL_HDR;
+    __GLX_BITMAP_HDR;
+} __GLXbitmapLargeHeader;
+
+typedef struct {
+    __GLX_PIXEL_HDR;
+    __GLX_BITMAP_HDR;
+} __GLXdispatchBitmapHeader;
+
+#define __GLX_BITMAP_HDR_SIZE 24
+
+#define __GLX_BITMAP_CMD_HDR_SIZE \
+    (__GLX_RENDER_HDR_SIZE + __GLX_PIXEL_HDR_SIZE + __GLX_BITMAP_HDR_SIZE)
+
+#define __GLX_BITMAP_CMD_DISPATCH_HDR_SIZE \
+    (__GLX_PIXEL_HDR_SIZE + __GLX_BITMAP_HDR_SIZE)
+
+typedef struct {
+    __GLX_RENDER_HDR;
+    __GLX_PIXEL_HDR;
+} __GLXpolygonStippleHeader;
+
+#define __GLX_POLYGONSTIPPLE_CMD_HDR_SIZE \
+    (__GLX_RENDER_HDR_SIZE + __GLX_PIXEL_HDR_SIZE)
+
+/*
+** Data that is specific to a glTexImage1D or glTexImage2D call.  The
+** data is sent in the following order:
+**	Render or RenderLarge header
+**	Pixel header
+**	TexImage header
+** When a glTexImage1D call the height field is unexamined by the server.
+*/
+#define __GLX_TEXIMAGE_HDR	\
+    CARD32	target;		\
+    CARD32	level;		\
+    CARD32	components;	\
+    CARD32	width;		\
+    CARD32	height;		\
+    CARD32	border;		\
+    CARD32	format;		\
+    CARD32	type
+
+#define __GLX_TEXIMAGE_HDR_SIZE 32
+
+#define __GLX_TEXIMAGE_CMD_HDR_SIZE \
+    (__GLX_RENDER_HDR_SIZE + __GLX_PIXEL_HDR_SIZE + __GLX_TEXIMAGE_HDR_SIZE)
+
+#define __GLX_TEXIMAGE_CMD_DISPATCH_HDR_SIZE \
+    (__GLX_PIXEL_HDR_SIZE + __GLX_TEXIMAGE_HDR_SIZE)
+
+typedef struct {
+    __GLX_RENDER_HDR;
+    __GLX_PIXEL_HDR;
+    __GLX_TEXIMAGE_HDR;
+} __GLXtexImageHeader;
+
+typedef struct {
+    __GLX_RENDER_LARGE_HDR;
+    __GLX_PIXEL_HDR;
+    __GLX_TEXIMAGE_HDR;
+} __GLXtexImageLargeHeader;
+
+typedef struct {
+    __GLX_PIXEL_HDR;
+    __GLX_TEXIMAGE_HDR;
+} __GLXdispatchTexImageHeader;
+
+/*
+** Data that is specific to a glTexImage3D or glTexImage4D call.  The
+** data is sent in the following order:
+**	Render or RenderLarge header
+**	Pixel 3D header
+**	TexImage 3D header
+** When a glTexImage3D call the size4d and woffset fields are unexamined
+** by the server.
+** Could be used by all TexImage commands and perhaps should be in the
+** future.
+*/
+#define __GLX_TEXIMAGE_3D_HDR \
+    CARD32	target;		\
+    CARD32	level;		\
+    CARD32	internalformat;	\
+    CARD32	width;		\
+    CARD32	height;		\
+    CARD32	depth;		\
+    CARD32	size4d;		\
+    CARD32	border;		\
+    CARD32	format;		\
+    CARD32	type;		\
+    CARD32	nullimage
+
+#define __GLX_TEXIMAGE_3D_HDR_SIZE 44
+
+#define __GLX_TEXIMAGE_3D_CMD_HDR_SIZE \
+    (__GLX_RENDER_HDR_SIZE + __GLX_PIXEL_3D_HDR_SIZE + \
+		__GLX_TEXIMAGE_3D_HDR_SIZE)
+
+#define __GLX_TEXIMAGE_3D_CMD_DISPATCH_HDR_SIZE \
+    (__GLX_PIXEL_3D_HDR_SIZE + __GLX_TEXIMAGE_3D_HDR_SIZE)
+
+typedef struct {
+    __GLX_RENDER_HDR;
+    __GLX_PIXEL_3D_HDR;
+    __GLX_TEXIMAGE_3D_HDR;
+} __GLXtexImage3DHeader;
+
+typedef struct {
+    __GLX_RENDER_LARGE_HDR;
+    __GLX_PIXEL_3D_HDR;
+    __GLX_TEXIMAGE_3D_HDR;
+} __GLXtexImage3DLargeHeader;
+
+typedef struct {
+    __GLX_PIXEL_3D_HDR;
+    __GLX_TEXIMAGE_3D_HDR;
+} __GLXdispatchTexImage3DHeader;
+
+/*
+** Data that is specific to a glTexSubImage1D or glTexSubImage2D call.	The
+** data is sent in the following order:
+**	Render or RenderLarge header
+**	Pixel header
+**	TexSubImage header
+** When a glTexSubImage1D call is made, the yoffset and height fields
+** are unexamined by the server and are  considered to be padding.
+*/
+#define __GLX_TEXSUBIMAGE_HDR	\
+    CARD32	target;		\
+    CARD32	level;		\
+    CARD32	xoffset;	\
+    CARD32	yoffset;	\
+    CARD32	width;		\
+    CARD32	height;		\
+    CARD32	format;		\
+    CARD32	type;		\
+    CARD32	nullImage	\
+
+#define __GLX_TEXSUBIMAGE_HDR_SIZE 36
+
+#define __GLX_TEXSUBIMAGE_CMD_HDR_SIZE \
+    (__GLX_RENDER_HDR_SIZE + __GLX_PIXEL_HDR_SIZE + __GLX_TEXSUBIMAGE_HDR_SIZE)
+
+#define __GLX_TEXSUBIMAGE_CMD_DISPATCH_HDR_SIZE \
+    (__GLX_PIXEL_HDR_SIZE + __GLX_TEXSUBIMAGE_HDR_SIZE)
+
+typedef struct {
+    __GLX_RENDER_HDR;
+    __GLX_PIXEL_HDR;
+    __GLX_TEXSUBIMAGE_HDR;
+} __GLXtexSubImageHeader;
+
+typedef struct {
+    __GLX_RENDER_LARGE_HDR;
+    __GLX_PIXEL_HDR;
+    __GLX_TEXSUBIMAGE_HDR;
+} __GLXtexSubImageLargeHeader;
+
+typedef struct {
+    __GLX_PIXEL_HDR;
+    __GLX_TEXSUBIMAGE_HDR;
+} __GLXdispatchTexSubImageHeader;
+
+/*
+** Data that is specific to a glTexSubImage3D and 4D calls.  The
+** data is sent in the following order:
+**	Render or RenderLarge header
+**	Pixel 3D header
+**	TexSubImage 3D header
+** When a glTexSubImage3D call is made, the woffset and size4d fields
+** are unexamined by the server and are considered to be padding.
+*/
+#define __GLX_TEXSUBIMAGE_3D_HDR	\
+    CARD32	target;			\
+    CARD32	level;			\
+    CARD32	xoffset;		\
+    CARD32	yoffset;		\
+    CARD32	zoffset;		\
+    CARD32	woffset;		\
+    CARD32	width;			\
+    CARD32	height;			\
+    CARD32	depth;			\
+    CARD32	size4d;			\
+    CARD32	format;			\
+    CARD32	type;			\
+    CARD32	nullImage		\
+
+#define __GLX_TEXSUBIMAGE_3D_HDR_SIZE 52
+
+#define __GLX_TEXSUBIMAGE_3D_CMD_HDR_SIZE \
+    (__GLX_RENDER_HDR_SIZE + __GLX_PIXEL_3D_HDR_SIZE + \
+		__GLX_TEXSUBIMAGE_3D_HDR_SIZE)
+
+#define __GLX_TEXSUBIMAGE_3D_CMD_DISPATCH_HDR_SIZE \
+    (__GLX_PIXEL_3D_HDR_SIZE + __GLX_TEXSUBIMAGE_3D_HDR_SIZE)
+
+typedef struct {
+    __GLX_RENDER_HDR;
+    __GLX_PIXEL_3D_HDR;
+    __GLX_TEXSUBIMAGE_3D_HDR;
+} __GLXtexSubImage3DHeader;
+
+typedef struct {
+    __GLX_RENDER_LARGE_HDR;
+    __GLX_PIXEL_3D_HDR;
+    __GLX_TEXSUBIMAGE_3D_HDR;
+} __GLXtexSubImage3DLargeHeader;
+
+typedef struct {
+    __GLX_PIXEL_3D_HDR;
+    __GLX_TEXSUBIMAGE_3D_HDR;
+} __GLXdispatchTexSubImage3DHeader;
+
+/**
+ * Data that is specific to a \c glCompressedTexImage1D or
+ * \c glCompressedTexImage2D call.  The data is sent in the following
+ * order:
+ *     - Render or RenderLarge header
+ *     - CompressedTexImage header
+ *
+ * When a \c glCompressedTexImage1D call is made, the \c height field is
+ * not examined by the server and is considered padding.
+ */
+
+#define __GLX_COMPRESSED_TEXIMAGE_HDR \
+    CARD32     target;		      \
+    CARD32     level;		      \
+    CARD32     internalFormat;	      \
+    CARD32     width;		      \
+    CARD32     height;		      \
+    CARD32     border;		      \
+    CARD32     imageSize
+
+#define __GLX_COMPRESSED_TEXIMAGE_HDR_SIZE 28
+
+#define __GLX_COMPRESSED_TEXIMAGE_CMD_HDR_SIZE \
+    (__GLX_RENDER_HDR_SIZE + __GLX_COMPRESSED_TEXIMAGE_HDR_SIZE)
+
+#define __GLX_COMPRESSED_TEXIMAGE_DISPATCH_HDR_SIZE \
+    (__GLX_COMPRESSED_TEXIMAGE_HDR_SIZE)
+
+typedef struct {
+    __GLX_RENDER_HDR;
+    __GLX_COMPRESSED_TEXIMAGE_HDR;
+} __GLXcompressedTexImageHeader;
+
+typedef struct {
+    __GLX_RENDER_LARGE_HDR;
+    __GLX_COMPRESSED_TEXIMAGE_HDR;
+} __GLXcompressedTexImageLargeHeader;
+
+typedef struct {
+    __GLX_COMPRESSED_TEXIMAGE_HDR;
+} __GLXdispatchCompressedTexImageHeader;
+
+/**
+ * Data that is specifi to a \c glCompressedTexSubImage1D or
+ * \c glCompressedTexSubImage2D call.  The data is sent in the following
+ * order:
+ *     - Render or RenderLarge header
+ *     - CompressedTexSubImage header
+ *
+ * When a \c glCompressedTexSubImage1D call is made, the \c yoffset and
+ * \c height fields are not examined by the server and are considered padding.
+ */
+
+#define __GLX_COMPRESSED_TEXSUBIMAGE_HDR \
+    CARD32     target;			 \
+    CARD32     level;			 \
+    CARD32     xoffset;			 \
+    CARD32     yoffset;			 \
+    CARD32     width;			 \
+    CARD32     height;			 \
+    CARD32     format;			 \
+    CARD32     imageSize
+
+#define __GLX_COMPRESSED_TEXSUBIMAGE_HDR_SIZE 32
+
+#define __GLX_COMPRESSED_TEXSUBIMAGE_CMD_HDR_SIZE \
+    (__GLX_RENDER_HDR_SIZE + __GLX_COMPRESSED_TEXSUBIMAGE_HDR_SIZE)
+
+#define __GLX_COMPRESSED_TEXSUBIMAGE_DISPATCH_HDR_SIZE \
+    (__GLX_COMPRESSED_TEXSUBIMAGE_HDR_SIZE)
+
+typedef struct {
+    __GLX_RENDER_HDR;
+    __GLX_COMPRESSED_TEXSUBIMAGE_HDR;
+} __GLXcompressedTexSubImageHeader;
+
+typedef struct {
+    __GLX_RENDER_LARGE_HDR;
+    __GLX_COMPRESSED_TEXSUBIMAGE_HDR;
+} __GLXcompressedTexSubImageLargeHeader;
+
+typedef struct {
+    __GLX_COMPRESSED_TEXSUBIMAGE_HDR;
+} __GLXdispatchCompressedTexSubImageHeader;
+
+/**
+ * Data that is specific to a \c glCompressedTexImage3D call.  The data is
+ * sent in the following order:
+ *     - Render or RenderLarge header
+ *     - CompressedTexImage3D header
+ */
+
+#define __GLX_COMPRESSED_TEXIMAGE_3D_HDR \
+    CARD32     target;			 \
+    CARD32     level;			 \
+    CARD32     internalFormat;		 \
+    CARD32     width;			 \
+    CARD32     height;			 \
+    CARD32     depth;			 \
+    CARD32     border;			 \
+    CARD32     imageSize
+
+#define __GLX_COMPRESSED_TEXIMAGE_3D_HDR_SIZE 32
+
+#define __GLX_COMPRESSED_TEXIMAGE_3D_CMD_HDR_SIZE \
+    (__GLX_RENDER_HDR_SIZE + __GLX_COMPRESSED_TEXIMAGE_3D_HDR_SIZE)
+
+#define __GLX_COMPRESSED_TEXIMAGE_3D_DISPATCH_HDR_SIZE \
+    (__GLX_COMPRESSED_TEXIMAGE_3D_HDR_SIZE)
+
+typedef struct {
+    __GLX_RENDER_HDR;
+    __GLX_COMPRESSED_TEXIMAGE_3D_HDR;
+} __GLXcompressedTexImage3DHeader;
+
+typedef struct {
+    __GLX_RENDER_LARGE_HDR;
+    __GLX_COMPRESSED_TEXIMAGE_3D_HDR;
+} __GLXcompressedTexImage3DLargeHeader;
+
+typedef struct {
+    __GLX_COMPRESSED_TEXIMAGE_3D_HDR;
+} __GLXdispatchCompressedTexImage3DHeader;
+
+/**
+ * Data that is specifi to a \c glCompressedTexSubImage3D call.  The data is
+ * sent in the following order:
+ *     - Render or RenderLarge header
+ *     - CompressedTexSubImage3D header
+ */
+
+#define __GLX_COMPRESSED_TEXSUBIMAGE_3D_HDR \
+    CARD32     target;			    \
+    CARD32     level;			    \
+    CARD32     xoffset;			    \
+    CARD32     yoffset;			    \
+    CARD32     zoffset;			    \
+    CARD32     width;			    \
+    CARD32     height;			    \
+    CARD32     depth;			    \
+    CARD32     format;			    \
+    CARD32     imageSize
+
+#define __GLX_COMPRESSED_TEXSUBIMAGE_3D_HDR_SIZE 32
+
+#define __GLX_COMPRESSED_TEXSUBIMAGE_3D_CMD_HDR_SIZE \
+    (__GLX_RENDER_HDR_SIZE + __GLX_COMPRESSED_TEXSUBIMAGE_3D_HDR_SIZE)
+
+#define __GLX_COMPRESSED_TEXSUBIMAGE_3D_DISPATCH_HDR_SIZE \
+    (__GLX_COMPRESSED_TEXSUBIMAGE_3D_HDR_SIZE)
+
+typedef struct {
+    __GLX_RENDER_HDR;
+    __GLX_COMPRESSED_TEXSUBIMAGE_3D_HDR;
+} __GLXcompressedTexSubImage3DHeader;
+
+typedef struct {
+    __GLX_RENDER_LARGE_HDR;
+    __GLX_COMPRESSED_TEXSUBIMAGE_3D_HDR;
+} __GLXcompressedTexSubImage3DLargeHeader;
+
+typedef struct {
+    __GLX_COMPRESSED_TEXSUBIMAGE_3D_HDR;
+} __GLXdispatchCompressedTexSubImage3DHeader;
+
+/*
+** Data that is specific to a glDrawPixels call.  The data is sent in the
+** following order:
+**	Render or RenderLarge header
+**	Pixel header
+**	DrawPixels header
+*/
+#define __GLX_DRAWPIXELS_HDR \
+    CARD32	width;	     \
+    CARD32	height;	     \
+    CARD32	format;	     \
+    CARD32	type
+
+#define __GLX_DRAWPIXELS_HDR_SIZE 16
+
+#define __GLX_DRAWPIXELS_CMD_HDR_SIZE \
+    (__GLX_RENDER_HDR_SIZE + __GLX_PIXEL_HDR_SIZE + __GLX_DRAWPIXELS_HDR_SIZE)
+
+#define __GLX_DRAWPIXELS_CMD_DISPATCH_HDR_SIZE \
+    (__GLX_PIXEL_HDR_SIZE + __GLX_DRAWPIXELS_HDR_SIZE)
+
+typedef struct {
+    __GLX_RENDER_HDR;
+    __GLX_PIXEL_HDR;
+    __GLX_DRAWPIXELS_HDR;
+} __GLXdrawPixelsHeader;
+
+typedef struct {
+    __GLX_RENDER_LARGE_HDR;
+    __GLX_PIXEL_HDR;
+    __GLX_DRAWPIXELS_HDR;
+} __GLXdrawPixelsLargeHeader;
+
+typedef struct {
+    __GLX_PIXEL_HDR;
+    __GLX_DRAWPIXELS_HDR;
+} __GLXdispatchDrawPixelsHeader;
+
+/*
+** Data that is specific to a glConvolutionFilter1D or glConvolutionFilter2D
+** call.  The data is sent in the following order:
+**	Render or RenderLarge header
+**	Pixel header
+**	ConvolutionFilter header
+** When a glConvolutionFilter1D call the height field is unexamined by the server.
+*/
+#define __GLX_CONV_FILT_HDR	\
+    CARD32	target;		\
+    CARD32	internalformat;	\
+    CARD32	width;		\
+    CARD32	height;		\
+    CARD32	format;		\
+    CARD32	type
+
+#define __GLX_CONV_FILT_HDR_SIZE 24
+
+#define __GLX_CONV_FILT_CMD_HDR_SIZE \
+    (__GLX_RENDER_HDR_SIZE + __GLX_PIXEL_HDR_SIZE + __GLX_CONV_FILT_HDR_SIZE)
+
+#define __GLX_CONV_FILT_CMD_DISPATCH_HDR_SIZE \
+    (__GLX_PIXEL_HDR_SIZE + __GLX_CONV_FILT_HDR_SIZE)
+typedef struct {
+    __GLX_RENDER_HDR;
+    __GLX_PIXEL_HDR;
+    __GLX_CONV_FILT_HDR;
+} __GLXConvolutionFilterHeader;
+
+typedef struct {
+    __GLX_RENDER_LARGE_HDR;
+    __GLX_PIXEL_HDR;
+    __GLX_CONV_FILT_HDR;
+} __GLXConvolutionFilterLargeHeader;
+
+typedef struct {
+    __GLX_PIXEL_HDR;
+    __GLX_CONV_FILT_HDR;
+} __GLXdispatchConvolutionFilterHeader;
+
+/*
+** Data that is specific to a glDrawArraysEXT call.  The data is sent in the
+** following order:
+**	Render or RenderLarge header
+**	Draw Arrays header
+**	a variable number of Component headers
+**	vertex data for each component type
+*/
+
+#define __GLX_DRAWARRAYS_HDR \
+    CARD32	numVertexes;   \
+    CARD32	numComponents; \
+    CARD32	primType
+
+#define __GLX_DRAWARRAYS_HDR_SIZE 12
+
+#define __GLX_DRAWARRAYS_CMD_HDR_SIZE \
+    (__GLX_RENDER_HDR_SIZE + __GLX_DRAWARRAYS_HDR_SIZE)
+
+typedef struct {
+    __GLX_RENDER_HDR;
+    __GLX_DRAWARRAYS_HDR;
+} __GLXdrawArraysHeader;
+
+typedef struct {
+    __GLX_RENDER_LARGE_HDR;
+    __GLX_DRAWARRAYS_HDR;
+} __GLXdrawArraysLargeHeader;
+
+typedef struct {
+    __GLX_DRAWARRAYS_HDR;
+} __GLXdispatchDrawArraysHeader;
+
+#define __GLX_COMPONENT_HDR \
+    CARD32	datatype;   \
+    INT32	numVals;    \
+    CARD32	component
+
+typedef struct {
+    __GLX_COMPONENT_HDR;
+} __GLXdispatchDrawArraysComponentHeader;
+
+#define __GLX_COMPONENT_HDR_SIZE 12
+
+/*
+** Data that is specific to a glColorTable call
+**	The data is sent in the following order:
+**	Render or RenderLarge header
+**	Pixel header
+**	ColorTable header
+*/
+
+#define __GLX_COLOR_TABLE_HDR	     \
+    CARD32	target;		     \
+    CARD32	internalformat;	     \
+    CARD32	width;		     \
+    CARD32	format;		     \
+    CARD32	type
+
+#define __GLX_COLOR_TABLE_HDR_SIZE 20
+
+#define __GLX_COLOR_TABLE_CMD_HDR_SIZE \
+    (__GLX_RENDER_HDR_SIZE + __GLX_PIXEL_HDR_SIZE + __GLX_COLOR_TABLE_HDR_SIZE)
+
+typedef struct {
+    __GLX_RENDER_HDR;
+    __GLX_PIXEL_HDR;
+    __GLX_COLOR_TABLE_HDR;
+} __GLXColorTableHeader;
+
+typedef struct {
+    __GLX_RENDER_LARGE_HDR;
+    __GLX_PIXEL_HDR;
+    __GLX_COLOR_TABLE_HDR;
+} __GLXColorTableLargeHeader;
+
+typedef struct {
+    __GLX_PIXEL_HDR;
+    __GLX_COLOR_TABLE_HDR;
+} __GLXdispatchColorTableHeader;
+
+/*
+** Data that is specific to a glColorSubTable call
+**	The data is sent in the following order:
+**	Render or RenderLarge header
+**	Pixel header
+**	ColorTable header
+*/
+
+#define __GLX_COLOR_SUBTABLE_HDR    \
+    CARD32	target;		    \
+    CARD32	start;		    \
+    CARD32	count;		    \
+    CARD32	format;		    \
+    CARD32	type
+
+#define __GLX_COLOR_SUBTABLE_HDR_SIZE 20
+
+#define __GLX_COLOR_SUBTABLE_CMD_HDR_SIZE \
+    (__GLX_RENDER_HDR_SIZE + __GLX_PIXEL_HDR_SIZE + \
+     __GLX_COLOR_SUBTABLE_HDR_SIZE)
+
+typedef struct {
+    __GLX_RENDER_HDR;
+    __GLX_PIXEL_HDR;
+    __GLX_COLOR_SUBTABLE_HDR;
+} __GLXColorSubTableHeader;
+
+typedef struct {
+    __GLX_RENDER_LARGE_HDR;
+    __GLX_PIXEL_HDR;
+    __GLX_COLOR_SUBTABLE_HDR;
+} __GLXColorSubTableLargeHeader;
+
+typedef struct {
+    __GLX_PIXEL_HDR;
+    __GLX_COLOR_SUBTABLE_HDR;
+} __GLXdispatchColorSubTableHeader;
+
+#define GLX_WINDOW_TYPE		1
+#define GLX_PIXMAP_TYPE		2
+#define GLX_VIDEO_SOURCE_TYPE	3
+#define GLX_PBUFFER_TYPE	4
+/* 5 is for DM_PBUFFER */
+#define GLX_GLXWINDOW_TYPE	6
+
+/*****************************************************************************/
+
+/*
+** Restore these definitions back to the typedefs in glx.h
+*/
+#undef GLXContextID
+#undef GLXPixmap
+#undef GLXDrawable
+#undef GLXPbuffer
+#undef GLXWindow
+#undef GLXFBConfigID
+#undef GLXFBConfigIDSGIX
+#undef GLXPbufferSGIX
+
+
+/* Opcodes for GLX commands */
+
+#define X_GLXRender                       1
+#define X_GLXRenderLarge                  2
+#define X_GLXCreateContext                3
+#define X_GLXDestroyContext               4
+#define X_GLXMakeCurrent                  5
+#define X_GLXIsDirect                     6
+#define X_GLXQueryVersion                 7
+#define X_GLXWaitGL                       8
+#define X_GLXWaitX                        9
+#define X_GLXCopyContext                 10
+#define X_GLXSwapBuffers                 11
+#define X_GLXUseXFont                    12
+#define X_GLXCreateGLXPixmap             13
+#define X_GLXGetVisualConfigs            14
+#define X_GLXDestroyGLXPixmap            15
+#define X_GLXVendorPrivate               16
+#define X_GLXVendorPrivateWithReply      17
+#define X_GLXQueryExtensionsString       18
+#define X_GLXQueryServerString           19
+#define X_GLXClientInfo                  20
+#define X_GLXGetFBConfigs                21
+#define X_GLXCreatePixmap                22
+#define X_GLXDestroyPixmap               23
+#define X_GLXCreateNewContext            24
+#define X_GLXQueryContext                25
+#define X_GLXMakeContextCurrent          26
+#define X_GLXCreatePbuffer               27
+#define X_GLXDestroyPbuffer              28
+#define X_GLXGetDrawableAttributes       29
+#define X_GLXChangeDrawableAttributes    30
+#define X_GLXCreateWindow                31
+#define X_GLXDestroyWindow               32
+#define X_GLXSetClientInfoARB            33
+#define X_GLXCreateContextAttribsARB     34
+#define X_GLXSetClientInfo2ARB           35
+
+/* typo compatibility with older headers */
+#define X_GLXCreateContextAtrribsARB     34
+#define X_GLXSetConfigInfo2ARB           35
+
+/* Opcodes for single commands (part of GLX command space) */
+
+#define X_GLsop_NewList                    101
+#define X_GLsop_EndList                    102
+#define X_GLsop_DeleteLists                103
+#define X_GLsop_GenLists                   104
+#define X_GLsop_FeedbackBuffer             105
+#define X_GLsop_SelectBuffer               106
+#define X_GLsop_RenderMode                 107
+#define X_GLsop_Finish                     108
+#define X_GLsop_Flush                      142
+#define X_GLsop_PixelStoref                109
+#define X_GLsop_PixelStorei                110
+#define X_GLsop_ReadPixels                 111
+#define X_GLsop_GetBooleanv                112
+#define X_GLsop_GetClipPlane               113
+#define X_GLsop_GetDoublev                 114
+#define X_GLsop_GetError                   115
+#define X_GLsop_GetFloatv                  116
+#define X_GLsop_GetIntegerv                117
+#define X_GLsop_GetLightfv                 118
+#define X_GLsop_GetLightiv                 119
+#define X_GLsop_GetMapdv                   120
+#define X_GLsop_GetMapfv                   121
+#define X_GLsop_GetMapiv                   122
+#define X_GLsop_GetMaterialfv              123
+#define X_GLsop_GetMaterialiv              124
+#define X_GLsop_GetPixelMapfv              125
+#define X_GLsop_GetPixelMapuiv             126
+#define X_GLsop_GetPixelMapusv             127
+#define X_GLsop_GetPolygonStipple          128
+#define X_GLsop_GetString                  129
+#define X_GLsop_GetTexEnvfv                130
+#define X_GLsop_GetTexEnviv                131
+#define X_GLsop_GetTexGendv                132
+#define X_GLsop_GetTexGenfv                133
+#define X_GLsop_GetTexGeniv                134
+#define X_GLsop_GetTexImage                135
+#define X_GLsop_GetTexParameterfv          136
+#define X_GLsop_GetTexParameteriv          137
+#define X_GLsop_GetTexLevelParameterfv     138
+#define X_GLsop_GetTexLevelParameteriv     139
+#define X_GLsop_IsEnabled                  140
+#define X_GLsop_IsList                     141
+#define X_GLsop_AreTexturesResident        143
+#define X_GLsop_DeleteTextures             144
+#define X_GLsop_GenTextures                145
+#define X_GLsop_IsTexture                  146
+#define X_GLsop_GetColorTable              147
+#define X_GLsop_GetColorTableParameterfv   148
+#define X_GLsop_GetColorTableParameteriv   149
+#define X_GLsop_GetConvolutionFilter       150
+#define X_GLsop_GetConvolutionParameterfv  151
+#define X_GLsop_GetConvolutionParameteriv  152
+#define X_GLsop_GetSeparableFilter         153
+#define X_GLsop_GetHistogram               154
+#define X_GLsop_GetHistogramParameterfv    155
+#define X_GLsop_GetHistogramParameteriv    156
+#define X_GLsop_GetMinmax                  157
+#define X_GLsop_GetMinmaxParameterfv       158
+#define X_GLsop_GetMinmaxParameteriv       159
+#define X_GLsop_GetCompressedTexImage      160
+
+
+/* Opcodes for rendering commands */
+
+#define X_GLrop_CallList                     1
+#define X_GLrop_CallLists                    2
+#define X_GLrop_ListBase                     3
+#define X_GLrop_Begin                        4
+#define X_GLrop_Bitmap                       5
+#define X_GLrop_Color3bv                     6
+#define X_GLrop_Color3dv                     7
+#define X_GLrop_Color3fv                     8
+#define X_GLrop_Color3iv                     9
+#define X_GLrop_Color3sv                    10
+#define X_GLrop_Color3ubv                   11
+#define X_GLrop_Color3uiv                   12
+#define X_GLrop_Color3usv                   13
+#define X_GLrop_Color4bv                    14
+#define X_GLrop_Color4dv                    15
+#define X_GLrop_Color4fv                    16
+#define X_GLrop_Color4iv                    17
+#define X_GLrop_Color4sv                    18
+#define X_GLrop_Color4ubv                   19
+#define X_GLrop_Color4uiv                   20
+#define X_GLrop_Color4usv                   21
+#define X_GLrop_EdgeFlagv                   22
+#define X_GLrop_End                         23
+#define X_GLrop_Indexdv                     24
+#define X_GLrop_Indexfv                     25
+#define X_GLrop_Indexiv                     26
+#define X_GLrop_Indexsv                     27
+#define X_GLrop_Normal3bv                   28
+#define X_GLrop_Normal3dv                   29
+#define X_GLrop_Normal3fv                   30
+#define X_GLrop_Normal3iv                   31
+#define X_GLrop_Normal3sv                   32
+#define X_GLrop_RasterPos2dv                33
+#define X_GLrop_RasterPos2fv                34
+#define X_GLrop_RasterPos2iv                35
+#define X_GLrop_RasterPos2sv                36
+#define X_GLrop_RasterPos3dv                37
+#define X_GLrop_RasterPos3fv                38
+#define X_GLrop_RasterPos3iv                39
+#define X_GLrop_RasterPos3sv                40
+#define X_GLrop_RasterPos4dv                41
+#define X_GLrop_RasterPos4fv                42
+#define X_GLrop_RasterPos4iv                43
+#define X_GLrop_RasterPos4sv                44
+#define X_GLrop_Rectdv                      45
+#define X_GLrop_Rectfv                      46
+#define X_GLrop_Rectiv                      47
+#define X_GLrop_Rectsv                      48
+#define X_GLrop_TexCoord1dv                 49
+#define X_GLrop_TexCoord1fv                 50
+#define X_GLrop_TexCoord1iv                 51
+#define X_GLrop_TexCoord1sv                 52
+#define X_GLrop_TexCoord2dv                 53
+#define X_GLrop_TexCoord2fv                 54
+#define X_GLrop_TexCoord2iv                 55
+#define X_GLrop_TexCoord2sv                 56
+#define X_GLrop_TexCoord3dv                 57
+#define X_GLrop_TexCoord3fv                 58
+#define X_GLrop_TexCoord3iv                 59
+#define X_GLrop_TexCoord3sv                 60
+#define X_GLrop_TexCoord4dv                 61
+#define X_GLrop_TexCoord4fv                 62
+#define X_GLrop_TexCoord4iv                 63
+#define X_GLrop_TexCoord4sv                 64
+#define X_GLrop_Vertex2dv                   65
+#define X_GLrop_Vertex2fv                   66
+#define X_GLrop_Vertex2iv                   67
+#define X_GLrop_Vertex2sv                   68
+#define X_GLrop_Vertex3dv                   69
+#define X_GLrop_Vertex3fv                   70
+#define X_GLrop_Vertex3iv                   71
+#define X_GLrop_Vertex3sv                   72
+#define X_GLrop_Vertex4dv                   73
+#define X_GLrop_Vertex4fv                   74
+#define X_GLrop_Vertex4iv                   75
+#define X_GLrop_Vertex4sv                   76
+#define X_GLrop_ClipPlane                   77
+#define X_GLrop_ColorMaterial               78
+#define X_GLrop_CullFace                    79
+#define X_GLrop_Fogf                        80
+#define X_GLrop_Fogfv                       81
+#define X_GLrop_Fogi                        82
+#define X_GLrop_Fogiv                       83
+#define X_GLrop_FrontFace                   84
+#define X_GLrop_Hint                        85
+#define X_GLrop_Lightf                      86
+#define X_GLrop_Lightfv                     87
+#define X_GLrop_Lighti                      88
+#define X_GLrop_Lightiv                     89
+#define X_GLrop_LightModelf                 90
+#define X_GLrop_LightModelfv                91
+#define X_GLrop_LightModeli                 92
+#define X_GLrop_LightModeliv                93
+#define X_GLrop_LineStipple                 94
+#define X_GLrop_LineWidth                   95
+#define X_GLrop_Materialf                   96
+#define X_GLrop_Materialfv                  97
+#define X_GLrop_Materiali                   98
+#define X_GLrop_Materialiv                  99
+#define X_GLrop_PointSize                  100
+#define X_GLrop_PolygonMode                101
+#define X_GLrop_PolygonStipple             102
+#define X_GLrop_Scissor                    103
+#define X_GLrop_ShadeModel                 104
+#define X_GLrop_TexParameterf              105
+#define X_GLrop_TexParameterfv             106
+#define X_GLrop_TexParameteri              107
+#define X_GLrop_TexParameteriv             108
+#define X_GLrop_TexImage1D                 109
+#define X_GLrop_TexImage2D                 110
+#define X_GLrop_TexEnvf                    111
+#define X_GLrop_TexEnvfv                   112
+#define X_GLrop_TexEnvi                    113
+#define X_GLrop_TexEnviv                   114
+#define X_GLrop_TexGend                    115
+#define X_GLrop_TexGendv                   116
+#define X_GLrop_TexGenf                    117
+#define X_GLrop_TexGenfv                   118
+#define X_GLrop_TexGeni                    119
+#define X_GLrop_TexGeniv                   120
+#define X_GLrop_InitNames                  121
+#define X_GLrop_LoadName                   122
+#define X_GLrop_PassThrough                123
+#define X_GLrop_PopName                    124
+#define X_GLrop_PushName                   125
+#define X_GLrop_DrawBuffer                 126
+#define X_GLrop_Clear                      127
+#define X_GLrop_ClearAccum                 128
+#define X_GLrop_ClearIndex                 129
+#define X_GLrop_ClearColor                 130
+#define X_GLrop_ClearStencil               131
+#define X_GLrop_ClearDepth                 132
+#define X_GLrop_StencilMask                133
+#define X_GLrop_ColorMask                  134
+#define X_GLrop_DepthMask                  135
+#define X_GLrop_IndexMask                  136
+#define X_GLrop_Accum                      137
+#define X_GLrop_Disable                    138
+#define X_GLrop_Enable                     139
+#define X_GLrop_PopAttrib                  141
+#define X_GLrop_PushAttrib                 142
+#define X_GLrop_Map1d                      143
+#define X_GLrop_Map1f                      144
+#define X_GLrop_Map2d                      145
+#define X_GLrop_Map2f                      146
+#define X_GLrop_MapGrid1d                  147
+#define X_GLrop_MapGrid1f                  148
+#define X_GLrop_MapGrid2d                  149
+#define X_GLrop_MapGrid2f                  150
+#define X_GLrop_EvalCoord1dv               151
+#define X_GLrop_EvalCoord1fv               152
+#define X_GLrop_EvalCoord2dv               153
+#define X_GLrop_EvalCoord2fv               154
+#define X_GLrop_EvalMesh1                  155
+#define X_GLrop_EvalPoint1                 156
+#define X_GLrop_EvalMesh2                  157
+#define X_GLrop_EvalPoint2                 158
+#define X_GLrop_AlphaFunc                  159
+#define X_GLrop_BlendFunc                  160
+#define X_GLrop_LogicOp                    161
+#define X_GLrop_StencilFunc                162
+#define X_GLrop_StencilOp                  163
+#define X_GLrop_DepthFunc                  164
+#define X_GLrop_PixelZoom                  165
+#define X_GLrop_PixelTransferf             166
+#define X_GLrop_PixelTransferi             167
+#define X_GLrop_PixelMapfv                 168
+#define X_GLrop_PixelMapuiv                169
+#define X_GLrop_PixelMapusv                170
+#define X_GLrop_ReadBuffer                 171
+#define X_GLrop_CopyPixels                 172
+#define X_GLrop_DrawPixels                 173
+#define X_GLrop_DepthRange                 174
+#define X_GLrop_Frustum                    175
+#define X_GLrop_LoadIdentity               176
+#define X_GLrop_LoadMatrixf                177
+#define X_GLrop_LoadMatrixd                178
+#define X_GLrop_MatrixMode                 179
+#define X_GLrop_MultMatrixf                180
+#define X_GLrop_MultMatrixd                181
+#define X_GLrop_Ortho                      182
+#define X_GLrop_PopMatrix                  183
+#define X_GLrop_PushMatrix                 184
+#define X_GLrop_Rotated                    185
+#define X_GLrop_Rotatef                    186
+#define X_GLrop_Scaled                     187
+#define X_GLrop_Scalef                     188
+#define X_GLrop_Translated                 189
+#define X_GLrop_Translatef                 190
+#define X_GLrop_Viewport                   191
+#define X_GLrop_DrawArrays                 193
+#define X_GLrop_PolygonOffset              192
+#define X_GLrop_CopyTexImage1D             4119
+#define X_GLrop_CopyTexImage2D             4120
+#define X_GLrop_CopyTexSubImage1D          4121
+#define X_GLrop_CopyTexSubImage2D          4122
+#define X_GLrop_TexSubImage1D              4099
+#define X_GLrop_TexSubImage2D              4100
+#define X_GLrop_BindTexture                4117
+#define X_GLrop_PrioritizeTextures         4118
+#define X_GLrop_Indexubv                   194
+#define X_GLrop_BlendColor                 4096
+#define X_GLrop_BlendEquation              4097
+#define X_GLrop_ColorTable                 2053
+#define X_GLrop_ColorTableParameterfv      2054
+#define X_GLrop_ColorTableParameteriv      2055
+#define X_GLrop_CopyColorTable             2056
+#define X_GLrop_ColorSubTable              195
+#define X_GLrop_CopyColorSubTable          196
+#define X_GLrop_ConvolutionFilter1D        4101
+#define X_GLrop_ConvolutionFilter2D        4102
+#define X_GLrop_ConvolutionParameterf      4103
+#define X_GLrop_ConvolutionParameterfv     4104
+#define X_GLrop_ConvolutionParameteri      4105
+#define X_GLrop_ConvolutionParameteriv     4106
+#define X_GLrop_CopyConvolutionFilter1D    4107
+#define X_GLrop_CopyConvolutionFilter2D    4108
+#define X_GLrop_SeparableFilter2D          4109
+#define X_GLrop_Histogram                  4110
+#define X_GLrop_Minmax                     4111
+#define X_GLrop_ResetHistogram             4112
+#define X_GLrop_ResetMinmax                4113
+#define X_GLrop_TexImage3D                 4114
+#define X_GLrop_TexSubImage3D              4115
+#define X_GLrop_CopyTexSubImage3D          4123
+#define X_GLrop_DrawArraysEXT              4116
+
+/* Added for core GL version 1.3 */
+
+#define X_GLrop_ActiveTextureARB            197
+#define X_GLrop_MultiTexCoord1dvARB         198
+#define X_GLrop_MultiTexCoord1fvARB         199
+#define X_GLrop_MultiTexCoord1ivARB         200
+#define X_GLrop_MultiTexCoord1svARB         201
+#define X_GLrop_MultiTexCoord2dvARB         202
+#define X_GLrop_MultiTexCoord2fvARB         203
+#define X_GLrop_MultiTexCoord2ivARB         204
+#define X_GLrop_MultiTexCoord2svARB         205
+#define X_GLrop_MultiTexCoord3dvARB         206
+#define X_GLrop_MultiTexCoord3fvARB         207
+#define X_GLrop_MultiTexCoord3ivARB         208
+#define X_GLrop_MultiTexCoord3svARB         209
+#define X_GLrop_MultiTexCoord4dvARB         210
+#define X_GLrop_MultiTexCoord4fvARB         211
+#define X_GLrop_MultiTexCoord4ivARB         212
+#define X_GLrop_MultiTexCoord4svARB         213
+#define X_GLrop_CompressedTexImage1D        214
+#define X_GLrop_CompressedTexImage2D        215
+#define X_GLrop_CompressedTexImage3D        216
+#define X_GLrop_CompressedTexSubImage1D     217
+#define X_GLrop_CompressedTexSubImage2D     218
+#define X_GLrop_CompressedTexSubImage3D     219
+#define X_GLrop_SampleCoverageARB           229
+
+/* Added for core GL version 1.4 */
+
+#define X_GLrop_WindowPos3fARB              230
+#define X_GLrop_FogCoordfv                  4124
+#define X_GLrop_FogCoorddv                  4125
+#define X_GLrop_PointParameterfARB          2065
+#define X_GLrop_PointParameterfvARB         2066
+#define X_GLrop_SecondaryColor3bv           4126
+#define X_GLrop_SecondaryColor3sv           4127
+#define X_GLrop_SecondaryColor3iv           4128
+#define X_GLrop_SecondaryColor3fv           4129
+#define X_GLrop_SecondaryColor3dv           4130
+#define X_GLrop_SecondaryColor3ubv          4131
+#define X_GLrop_SecondaryColor3usv          4132
+#define X_GLrop_SecondaryColor3uiv          4133
+#define X_GLrop_BlendFuncSeparate           4134
+#define X_GLrop_PointParameteri             4221
+#define X_GLrop_PointParameteriv            4222
+
+/* Added for core GL version 1.5 */
+/* XXX opcodes not defined in the spec */
+
+/* Opcodes for Vendor Private commands */
+
+
+#define X_GLvop_GetConvolutionFilterEXT        1
+#define X_GLvop_GetConvolutionParameterfvEXT   2
+#define X_GLvop_GetConvolutionParameterivEXT   3
+#define X_GLvop_GetSeparableFilterEXT          4
+#define X_GLvop_GetHistogramEXT                5
+#define X_GLvop_GetHistogramParameterfvEXT     6
+#define X_GLvop_GetHistogramParameterivEXT     7
+#define X_GLvop_GetMinmaxEXT                   8
+#define X_GLvop_GetMinmaxParameterfvEXT        9
+#define X_GLvop_GetMinmaxParameterivEXT        10
+#define X_GLvop_AreTexturesResidentEXT         11
+#define X_GLvop_DeleteTexturesEXT              12
+#define X_GLvop_GenTexturesEXT                 13
+#define X_GLvop_IsTextureEXT                   14
+#define X_GLvop_GetCombinerInputParameterfvNV  1270
+#define X_GLvop_GetCombinerInputParameterivNV  1271
+#define X_GLvop_GetCombinerOutputParameterfvNV 1272
+#define X_GLvop_GetCombinerOutputParameterivNV 1273
+#define X_GLvop_GetFinalCombinerOutputParameterfvNV 1274
+#define X_GLvop_GetFinalCombinerOutputParameterivNV 1275
+#define X_GLvop_DeleteFenceNV                  1276
+#define X_GLvop_GenFencesNV                    1277
+#define X_GLvop_IsFenceNV                      1278
+#define X_GLvop_TestFenceNV                    1279
+#define X_GLvop_GetFenceivNV                   1280
+#define X_GLvop_AreProgramsResidentNV          1293
+#define X_GLvop_DeleteProgramARB               1294
+#define X_GLvop_GenProgramsARB                 1295
+#define X_GLvop_GetProgramEnvParameterfvARB    1296
+#define X_GLvop_GetProgramEnvParameterdvARB    1297
+#define X_GLvop_GetProgramEnvParameterivNV     1298
+#define X_GLvop_GetProgramStringNV             1299
+#define X_GLvop_GetTrackMatrixivNV             1300
+#define X_GLvop_GetVertexAttribdvARB           1301
+#define X_GLvop_GetVertexAttribfvARB           1302
+#define X_GLvop_GetVertexAttribivARB           1303
+#define X_GLvop_IsProgramARB                   1304
+#define X_GLvop_GetProgramLocalParameterfvARB  1305
+#define X_GLvop_GetProgramLocalParameterdvARB  1306
+#define X_GLvop_GetProgramivARB                1307
+#define X_GLvop_GetProgramStringARB            1308
+#define X_GLvop_GetProgramNamedParameter4fvNV  1310
+#define X_GLvop_GetProgramNamedParameter4dvNV  1311
+#define X_GLvop_SampleMaskSGIS                 2048
+#define X_GLvop_SamplePatternSGIS              2049
+#define X_GLvop_GetDetailTexFuncSGIS           4096
+#define X_GLvop_GetSharpenTexFuncSGIS          4097
+#define X_GLvop_GetColorTableSGI               4098
+#define X_GLvop_GetColorTableParameterfvSGI    4099
+#define X_GLvop_GetColorTableParameterivSGI    4100
+#define X_GLvop_GetTexFilterFuncSGIS           4101
+#define X_GLvop_GetInstrumentsSGIX             4102
+#define X_GLvop_InstrumentsBufferSGIX          4103
+#define X_GLvop_PollInstrumentsSGIX            4104
+#define X_GLvop_FlushRasterSGIX                4105
+
+/* Opcodes for GLX vendor private commands */
+
+#define X_GLXvop_QueryContextInfoEXT            1024
+#define X_GLXvop_BindTexImageEXT                1330
+#define X_GLXvop_ReleaseTexImageEXT             1331
+#define X_GLXvop_SwapIntervalSGI                65536
+#define X_GLXvop_MakeCurrentReadSGI             65537
+#define X_GLXvop_CreateGLXVideoSourceSGIX       65538
+#define X_GLXvop_DestroyGLXVideoSourceSGIX      65539
+#define X_GLXvop_GetFBConfigsSGIX               65540
+#define X_GLXvop_CreateContextWithConfigSGIX    65541
+#define X_GLXvop_CreateGLXPixmapWithConfigSGIX  65542
+#define X_GLXvop_CreateGLXPbufferSGIX           65543
+#define X_GLXvop_DestroyGLXPbufferSGIX          65544
+#define X_GLXvop_ChangeDrawableAttributesSGIX   65545
+#define X_GLXvop_GetDrawableAttributesSGIX      65546
+#define X_GLXvop_JoinSwapGroupSGIX              65547
+#define X_GLXvop_BindSwapBarrierSGIX            65548
+#define X_GLXvop_QueryMaxSwapBarriersSGIX       65549
+#define X_GLXvop_QueryHyperpipeNetworkSGIX      65550
+#define X_GLXvop_QueryHyperpipeConfigSGIX       65551
+#define X_GLXvop_HyperpipeConfigSGIX            65552
+#define X_GLXvop_DestroyHyperpipeConfigSGIX     65553
+
+/* ARB extension opcodes */
+
+/*  1. GL_ARB_multitexture - see GL 1.2 opcodes */
+/*  5. GL_ARB_multisample - see GL 1.3 opcodes */
+/* 12. GL_ARB_texture_compression - see GL 1.3 opcodes */
+/* 14. GL_ARB_point_parameters - see GL 1.4 opcodees */
+
+/* 15. GL_ARB_vertex_blend */
+#define X_GLrop_WeightbvARB                  220
+#define X_GLrop_WeightubvARB                 221
+#define X_GLrop_WeightsvARB                  222
+#define X_GLrop_WeightusvARB                 223
+#define X_GLrop_WeightivARB                  224
+#define X_GLrop_WeightuivARB                 225
+#define X_GLrop_VertexBlendARB               226
+#define X_GLrop_WeightfvARB                  227
+#define X_GLrop_WeightdvARB                  228
+
+/* 16. GL_ARB_matrix_palette */
+/* XXX opcodes not defined in the spec */
+
+/* 25. GL_ARB_window_pos - see GL 1.4 opcodes */
+
+/* 26. GL_ARB_vertex_program */
+#define X_GLrop_BindProgramARB              4180
+#define X_GLrop_ProgramEnvParameter4fvARB   4184
+#define X_GLrop_ProgramEnvParameter4dvARB   4185
+#define X_GLrop_VertexAttrib1svARB          4189
+#define X_GLrop_VertexAttrib2svARB          4190
+#define X_GLrop_VertexAttrib3svARB          4191
+#define X_GLrop_VertexAttrib4svARB          4192
+#define X_GLrop_VertexAttrib1fvARB          4193
+#define X_GLrop_VertexAttrib2fvARB          4194
+#define X_GLrop_VertexAttrib3fvARB          4195
+#define X_GLrop_VertexAttrib4fvARB          4196
+#define X_GLrop_VertexAttrib1dvARB          4197
+#define X_GLrop_VertexAttrib2dvARB          4198
+#define X_GLrop_VertexAttrib3dvARB          4199
+#define X_GLrop_ProgramLocalParameter4fvARB 4215
+#define X_GLrop_ProgramLocalParameter4dvARB 4216
+#define X_GLrop_ProgramStringARB            4217
+#define X_GLrop_VertexAttrib4dvARB          4200
+#define X_GLrop_VertexAttrib4NubvARB        4201
+#define X_GLrop_VertexAttrib4bvARB          4230
+#define X_GLrop_VertexAttrib4ivARB          4231
+#define X_GLrop_VertexAttrib4ubvARB         4232
+#define X_GLrop_VertexAttrib4usvARB         4233
+#define X_GLrop_VertexAttrib4uivARB         4234
+#define X_GLrop_VertexAttrib4NbvARB         4235
+#define X_GLrop_VertexAttrib4NsvARB         4236
+#define X_GLrop_VertexAttrib4NivARB         4237
+#define X_GLrop_VertexAttrib4NusvARB        4238
+#define X_GLrop_VertexAttrib4NuivARB        4239
+
+/* 27. GL_ARB_fragment_program - see GL_ARB_vertex_program opcodes */
+
+/* 29. GL_ARB_occlusion_query */
+/* XXX opcodes not defined in the spec */
+
+
+/* New extension opcodes */
+
+/* 145. GL_EXT_secondary_color - see GL 1.4 opcodes */
+
+/* 188. GL_EXT_vertex_weighting */
+#define X_GLrop_VertexWeightfvEXT           4135
+
+/* 191. GL_NV_register_combiners */
+#define X_GLrop_CombinerParameterfNV        4136
+#define X_GLrop_CombinerParameterfvNV       4137
+#define X_GLrop_CombinerParameteriNV        4138
+#define X_GLrop_CombinerParameterivNV       4139
+#define X_GLrop_CombinerInputNV             4140
+#define X_GLrop_CombinerOutputNV            4141
+#define X_GLrop_FinalCombinerInputNV        4142
+
+/* 222. GL_NV_fence */
+#define X_GLrop_SetFenceNV                  4143
+#define X_GLrop_FinishFenceNV               4144
+
+/* 227. GL_NV_register_combiners2 */
+/* XXX opcodes not defined in the spec */
+
+/* 233. GL_NV_vertex_program - see also GL_ARB_vertex_program opcodes */
+#define X_GLrop_ExecuteProgramNV            4181
+#define X_GLrop_RequestResidentProgramsNV   4182
+#define X_GLrop_LoadProgamNV                4183
+#define X_GLrop_ProgramParameters4fvNV      4186
+#define X_GLrop_ProgramParameters4dvNV      4187
+#define X_GLrop_TrackMatrixNV               4188
+#define X_GLrop_VertexAttribs1svNV          4202
+#define X_GLrop_VertexAttribs2svNV          4203
+#define X_GLrop_VertexAttribs3svNV          4204
+#define X_GLrop_VertexAttribs4svNV          4205
+#define X_GLrop_VertexAttribs1fvNV          4206
+#define X_GLrop_VertexAttribs2fvNV          4207
+#define X_GLrop_VertexAttribs3fvNV          4208
+#define X_GLrop_VertexAttribs4fvNV          4209
+#define X_GLrop_VertexAttribs1dvNV          4210
+#define X_GLrop_VertexAttribs2dvNV          4211
+#define X_GLrop_VertexAttribs3dvNV          4212
+#define X_GLrop_VertexAttribs4dvNV          4213
+#define X_GLrop_VertexAttribs4ubvNV         4214
+
+/* 261. GL_NV_occlusion_query */
+/* XXX opcodes not defined in the spec */
+
+/* 262. GL_NV_point_sprite - see GL 1.4 opcodes */
+
+/* 268. GL_EXT_stencil_two_side */
+#define X_GLrop_ActiveStencilFaceEXT        4220
+
+/* 282. GL_NV_fragment_program - see also GL_NV_vertex_program and GL_ARB_vertex_program opcodes */
+#define X_GLrop_ProgramNamedParameter4fvNV  4218
+#define X_GLrop_ProgramNamedParameter4dvNV  4219
+
+/* 285. GL_NV_primitive_restart */
+/* XXX opcodes not defined in the spec */
+
+/* 297. GL_EXT_depth_bounds_test */
+#define X_GLrop_DepthBoundsEXT              4229
+
+/* 299. GL_EXT_blend_equation_separate */
+#define X_GLrop_BlendEquationSeparateEXT    4228
+
+/* 310. GL_EXT_framebuffer_object */
+#define X_GLvop_IsRenderbufferEXT                      1422
+#define X_GLvop_GenRenderbuffersEXT                    1423
+#define X_GLvop_GetRenderbufferParameterivEXT          1424
+#define X_GLvop_IsFramebufferEXT                       1425
+#define X_GLvop_GenFramebuffersEXT                     1426
+#define X_GLvop_CheckFramebufferStatusEXT              1427
+#define X_GLvop_GetFramebufferAttachmentParameterivEXT 1428
+
+#endif /* _GLX_glxproto_h_ */
diff --git a/depends/libxcb/depends/xorgproto/include/GL/glxtokens.h b/depends/libxcb/depends/xorgproto/include/GL/glxtokens.h
new file mode 100644
index 0000000..ff3bd45
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/GL/glxtokens.h
@@ -0,0 +1,316 @@
+#ifndef __GLX_glxtokens_h__
+#define __GLX_glxtokens_h__
+
+/*
+ * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+ * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice including the dates of first publication and
+ * either this permission notice or a reference to
+ * http://oss.sgi.com/projects/FreeB/
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Silicon Graphics, Inc.
+ * shall not be used in advertising or otherwise to promote the sale, use or
+ * other dealings in this Software without prior written authorization from
+ * Silicon Graphics, Inc.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define GLX_VERSION_1_1 1
+#define GLX_VERSION_1_2 1
+#define GLX_VERSION_1_3 1
+#define GLX_VERSION_1_4 1
+
+/*
+** Visual Config Attributes (glXGetConfig, glXGetFBConfigAttrib)
+*/
+#define GLX_USE_GL		1	/* support GLX rendering */
+#define GLX_BUFFER_SIZE		2	/* depth of the color buffer */
+#define GLX_LEVEL		3	/* level in plane stacking */
+#define GLX_RGBA		4	/* true if RGBA mode */
+#define GLX_DOUBLEBUFFER	5	/* double buffering supported */
+#define GLX_STEREO		6	/* stereo buffering supported */
+#define GLX_AUX_BUFFERS		7	/* number of aux buffers */
+#define GLX_RED_SIZE		8	/* number of red component bits */
+#define GLX_GREEN_SIZE		9	/* number of green component bits */
+#define GLX_BLUE_SIZE		10	/* number of blue component bits */
+#define GLX_ALPHA_SIZE		11	/* number of alpha component bits */
+#define GLX_DEPTH_SIZE		12	/* number of depth bits */
+#define GLX_STENCIL_SIZE	13	/* number of stencil bits */
+#define GLX_ACCUM_RED_SIZE	14	/* number of red accum bits */
+#define GLX_ACCUM_GREEN_SIZE	15	/* number of green accum bits */
+#define GLX_ACCUM_BLUE_SIZE	16	/* number of blue accum bits */
+#define GLX_ACCUM_ALPHA_SIZE	17	/* number of alpha accum bits */
+/*
+** FBConfig-specific attributes
+*/
+#define GLX_X_VISUAL_TYPE		0x22
+#define GLX_CONFIG_CAVEAT		0x20	/* Like visual_info VISUAL_CAVEAT_EXT */
+#define GLX_TRANSPARENT_TYPE		0x23
+#define GLX_TRANSPARENT_INDEX_VALUE	0x24
+#define GLX_TRANSPARENT_RED_VALUE	0x25
+#define GLX_TRANSPARENT_GREEN_VALUE	0x26
+#define GLX_TRANSPARENT_BLUE_VALUE	0x27
+#define GLX_TRANSPARENT_ALPHA_VALUE	0x28
+#define GLX_DRAWABLE_TYPE		0x8010
+#define GLX_RENDER_TYPE			0x8011
+#define GLX_X_RENDERABLE		0x8012
+#define GLX_FBCONFIG_ID			0x8013
+#define GLX_MAX_PBUFFER_WIDTH		0x8016
+#define GLX_MAX_PBUFFER_HEIGHT		0x8017
+#define GLX_MAX_PBUFFER_PIXELS		0x8018
+#define GLX_VISUAL_ID			0x800B
+
+/* FBConfigSGIX Attributes */
+#define GLX_OPTIMAL_PBUFFER_WIDTH_SGIX	0x8019
+#define GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX	0x801A
+
+/*
+** Error return values from glXGetConfig.  Success is indicated by
+** a value of 0.
+*/
+#define GLX_BAD_SCREEN		1	/* screen # is bad */
+#define GLX_BAD_ATTRIBUTE	2	/* attribute to get is bad */
+#define GLX_NO_EXTENSION	3	/* no glx extension on server */
+#define GLX_BAD_VISUAL		4	/* visual # not known by GLX */
+#define GLX_BAD_CONTEXT		5	/* returned only by import_context EXT? */
+#define GLX_BAD_VALUE		6	/* returned only by glXSwapIntervalSGI? */
+#define GLX_BAD_ENUM		7	/* unused? */
+
+/* FBConfig attribute values */
+
+/*
+** Generic "don't care" value for glX ChooseFBConfig attributes (except
+** GLX_LEVEL)
+*/
+#define GLX_DONT_CARE			0xFFFFFFFF
+
+/* GLX_RENDER_TYPE bits */
+#define GLX_RGBA_BIT			0x00000001
+#define GLX_COLOR_INDEX_BIT		0x00000002
+#define GLX_RGBA_FLOAT_BIT_ARB          0x00000004
+#define GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT 0x00000008
+
+/* GLX_DRAWABLE_TYPE bits */
+#define GLX_WINDOW_BIT			0x00000001
+#define GLX_PIXMAP_BIT			0x00000002
+#define GLX_PBUFFER_BIT			0x00000004
+
+/* GLX_CONFIG_CAVEAT attribute values */
+#define GLX_NONE			0x8000
+#define GLX_SLOW_CONFIG			0x8001
+#define GLX_NON_CONFORMANT_CONFIG	0x800D
+
+/* GLX_X_VISUAL_TYPE attribute values */
+#define GLX_TRUE_COLOR			0x8002
+#define GLX_DIRECT_COLOR		0x8003
+#define GLX_PSEUDO_COLOR		0x8004
+#define GLX_STATIC_COLOR		0x8005
+#define GLX_GRAY_SCALE			0x8006
+#define GLX_STATIC_GRAY			0x8007
+
+/* GLX_TRANSPARENT_TYPE attribute values */
+/* #define GLX_NONE			   0x8000 */
+#define GLX_TRANSPARENT_RGB		0x8008
+#define GLX_TRANSPARENT_INDEX		0x8009
+
+/* glXCreateGLXPbuffer attributes */
+#define GLX_PRESERVED_CONTENTS		0x801B
+#define GLX_LARGEST_PBUFFER		0x801C
+#define GLX_PBUFFER_HEIGHT		0x8040	/* New for GLX 1.3 */
+#define GLX_PBUFFER_WIDTH		0x8041	/* New for GLX 1.3 */
+
+/* glXQueryGLXPBuffer attributes */
+#define GLX_WIDTH			0x801D
+#define GLX_HEIGHT			0x801E
+#define GLX_EVENT_MASK			0x801F
+
+/* glXCreateNewContext render_type attribute values */
+#define GLX_RGBA_TYPE			0x8014
+#define GLX_COLOR_INDEX_TYPE		0x8015
+
+/* glXQueryContext attributes */
+/* #define GLX_FBCONFIG_ID		  0x8013 */
+/* #define GLX_RENDER_TYPE		  0x8011 */
+#define GLX_SCREEN			0x800C
+
+/* glXSelectEvent event mask bits */
+#define GLX_PBUFFER_CLOBBER_MASK	0x08000000
+#define GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK	0x04000000
+
+/* GLXPbufferClobberEvent event_type values */
+#define GLX_DAMAGED			0x8020
+#define GLX_SAVED			0x8021
+#define GLX_EXCHANGE_COMPLETE_INTEL	0x8180
+#define GLX_BLIT_COMPLETE_INTEL		0x8181
+#define GLX_FLIP_COMPLETE_INTEL		0x8182
+
+/* GLXPbufferClobberEvent draw_type values */
+#define GLX_WINDOW			0x8022
+#define GLX_PBUFFER			0x8023
+
+/* GLXPbufferClobberEvent buffer_mask bits */
+#define GLX_FRONT_LEFT_BUFFER_BIT	0x00000001
+#define GLX_FRONT_RIGHT_BUFFER_BIT	0x00000002
+#define GLX_BACK_LEFT_BUFFER_BIT	0x00000004
+#define GLX_BACK_RIGHT_BUFFER_BIT	0x00000008
+#define GLX_AUX_BUFFERS_BIT		0x00000010
+#define GLX_DEPTH_BUFFER_BIT		0x00000020
+#define GLX_STENCIL_BUFFER_BIT		0x00000040
+#define GLX_ACCUM_BUFFER_BIT		0x00000080
+
+/*
+** Extension return values from glXGetConfig.  These are also
+** accepted as parameter values for glXChooseVisual.
+*/
+
+#define GLX_X_VISUAL_TYPE_EXT	0x22	/* visual_info extension type */
+#define GLX_TRANSPARENT_TYPE_EXT 0x23	/* visual_info extension */
+#define GLX_TRANSPARENT_INDEX_VALUE_EXT 0x24	/* visual_info extension */
+#define GLX_TRANSPARENT_RED_VALUE_EXT	0x25	/* visual_info extension */
+#define GLX_TRANSPARENT_GREEN_VALUE_EXT 0x26	/* visual_info extension */
+#define GLX_TRANSPARENT_BLUE_VALUE_EXT	0x27	/* visual_info extension */
+#define GLX_TRANSPARENT_ALPHA_VALUE_EXT 0x28	/* visual_info extension */
+
+/* Property values for visual_type */
+#define GLX_TRUE_COLOR_EXT	0x8002
+#define GLX_DIRECT_COLOR_EXT	0x8003
+#define GLX_PSEUDO_COLOR_EXT	0x8004
+#define GLX_STATIC_COLOR_EXT	0x8005
+#define GLX_GRAY_SCALE_EXT	0x8006
+#define GLX_STATIC_GRAY_EXT	0x8007
+
+/* Property values for transparent pixel */
+#define GLX_NONE_EXT		0x8000
+#define GLX_TRANSPARENT_RGB_EXT		0x8008
+#define GLX_TRANSPARENT_INDEX_EXT	0x8009
+
+/* Property values for visual_rating */
+#define GLX_VISUAL_CAVEAT_EXT		0x20  /* visual_rating extension type */
+#define GLX_SLOW_VISUAL_EXT		0x8001
+#define GLX_NON_CONFORMANT_VISUAL_EXT	0x800D
+
+/* Property values for swap method (GLX_OML_swap_method) */
+#define GLX_SWAP_METHOD_OML                0x8060
+#define GLX_SWAP_EXCHANGE_OML              0x8061
+#define GLX_SWAP_COPY_OML                  0x8062
+#define GLX_SWAP_UNDEFINED_OML             0x8063
+
+/* Property values for multi-sampling */
+#define GLX_VISUAL_SELECT_GROUP_SGIX	0x8028	/* visuals grouped by select priority */
+
+/*
+** Names for attributes to glXGetClientString.
+*/
+#define GLX_VENDOR		0x1
+#define GLX_VERSION		0x2
+#define GLX_EXTENSIONS		0x3
+
+/*
+** Names for attributes to glXQueryContextInfoEXT.
+*/
+#define GLX_SHARE_CONTEXT_EXT	0x800A	/* id of share context */
+#define GLX_VISUAL_ID_EXT	0x800B	/* id of context's visual */
+#define GLX_SCREEN_EXT		0x800C	/* screen number */
+
+/*
+** GLX_EXT_texture_from_pixmap
+*/
+#define GLX_BIND_TO_TEXTURE_RGB_EXT        0x20D0
+#define GLX_BIND_TO_TEXTURE_RGBA_EXT       0x20D1
+#define GLX_BIND_TO_MIPMAP_TEXTURE_EXT     0x20D2
+#define GLX_BIND_TO_TEXTURE_TARGETS_EXT    0x20D3
+#define GLX_Y_INVERTED_EXT                 0x20D4
+
+#define GLX_TEXTURE_FORMAT_EXT             0x20D5
+#define GLX_TEXTURE_TARGET_EXT             0x20D6
+#define GLX_MIPMAP_TEXTURE_EXT             0x20D7
+
+#define GLX_TEXTURE_FORMAT_NONE_EXT        0x20D8
+#define GLX_TEXTURE_FORMAT_RGB_EXT         0x20D9
+#define GLX_TEXTURE_FORMAT_RGBA_EXT        0x20DA
+
+#define GLX_TEXTURE_1D_BIT_EXT             0x00000001
+#define GLX_TEXTURE_2D_BIT_EXT             0x00000002
+#define GLX_TEXTURE_RECTANGLE_BIT_EXT      0x00000004
+
+#define GLX_TEXTURE_1D_EXT                 0x20DB
+#define GLX_TEXTURE_2D_EXT                 0x20DC
+#define GLX_TEXTURE_RECTANGLE_EXT          0x20DD
+
+#define GLX_FRONT_LEFT_EXT                 0x20DE
+#define GLX_FRONT_RIGHT_EXT                0x20DF
+#define GLX_BACK_LEFT_EXT                  0x20E0
+#define GLX_BACK_RIGHT_EXT                 0x20E1
+#define GLX_FRONT_EXT                      GLX_FRONT_LEFT_EXT
+#define GLX_BACK_EXT                       GLX_BACK_LEFT_EXT
+#define GLX_AUX0_EXT                       0x20E2
+#define GLX_AUX1_EXT                       0x20E3
+#define GLX_AUX2_EXT                       0x20E4
+#define GLX_AUX3_EXT                       0x20E5
+#define GLX_AUX4_EXT                       0x20E6
+#define GLX_AUX5_EXT                       0x20E7
+#define GLX_AUX6_EXT                       0x20E8
+#define GLX_AUX7_EXT                       0x20E9
+#define GLX_AUX8_EXT                       0x20EA
+#define GLX_AUX9_EXT                       0x20EB
+
+/*
+ * GLX 1.4 and later:
+ */
+#define GLX_SAMPLE_BUFFERS_SGIS            100000
+#define GLX_SAMPLES_SGIS                   100001
+
+/*
+ * GLX_EXT_framebuffer_SRGB
+ */
+#define GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT   0x20B2
+
+/*
+ * GLX_ARB_create_context
+ * GLX_ARB_create_context_profile
+ * GLX_EXT_create_context_es2_profile
+ */
+#define GLX_CONTEXT_MAJOR_VERSION_ARB      0x2091
+#define GLX_CONTEXT_MINOR_VERSION_ARB      0x2092
+#define GLX_CONTEXT_FLAGS_ARB              0x2094
+#define GLX_CONTEXT_PROFILE_MASK_ARB       0x9126
+
+#define GLX_CONTEXT_DEBUG_BIT_ARB          0x0001
+#define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB          0x0002
+
+#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB   0x0001
+#define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB   0x0002
+#define GLX_CONTEXT_ES2_PROFILE_BIT_EXT    0x0004
+
+/*
+ * GLX_ARB_create_context_robustness
+ */
+#define GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB  0x0004
+#define GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
+#define GLX_NO_RESET_NOTIFICATION_ARB      0x8261
+#define GLX_LOSE_CONTEXT_ON_RESET_ARB      0x8252
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !__GLX_glxtokens_h__ */
diff --git a/depends/libxcb/depends/xorgproto/include/GL/internal/glcore.h b/depends/libxcb/depends/xorgproto/include/GL/internal/glcore.h
new file mode 100644
index 0000000..edcb014
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/GL/internal/glcore.h
@@ -0,0 +1,181 @@
+#ifndef __gl_core_h_
+#define __gl_core_h_
+
+/*
+ * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+ * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice including the dates of first publication and
+ * either this permission notice or a reference to
+ * http://oss.sgi.com/projects/FreeB/
+ * shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Except as contained in this notice, the name of Silicon Graphics, Inc.
+ * shall not be used in advertising or otherwise to promote the sale, use or
+ * other dealings in this Software without prior written authorization from
+ * Silicon Graphics, Inc.
+ */
+
+#if !defined(_WIN32_WCE)
+#include <sys/types.h>
+#endif
+
+#define GL_CORE_SGI  1
+#define GL_CORE_MESA 2
+#define GL_CORE_APPLE 4
+#define GL_CORE_WINDOWS 8
+
+typedef struct __GLcontextRec __GLcontext;
+
+/*
+** This file defines the interface between the GL core and the surrounding
+** "operating system" that supports it (currently the GLX or WGL extensions).
+**
+** Members (data and function pointers) are documented as imported or
+** exported according to how they are used by the core rendering functions.
+** Imported members are initialized by the "operating system" and used by
+** the core functions.  Exported members are initialized by the core functions
+** and used by the "operating system".
+*/
+
+/**
+ * Mode and limit information for a context.  This information is
+ * kept around in the context so that values can be used during
+ * command execution, and for returning information about the
+ * context to the application.
+ *
+ * Instances of this structure are shared by the driver and the loader.  To
+ * maintain binary compatibility, new fields \b must be added only to the
+ * end of the structure.
+ *
+ * \sa _gl_context_modes_create
+ */
+typedef struct __GLcontextModesRec {
+    struct __GLcontextModesRec * next;
+
+    GLboolean rgbMode;
+    GLboolean floatMode;
+    GLboolean colorIndexMode;
+    GLuint doubleBufferMode;
+    GLuint stereoMode;
+
+    GLboolean haveAccumBuffer;
+    GLboolean haveDepthBuffer;
+    GLboolean haveStencilBuffer;
+
+    GLint redBits, greenBits, blueBits, alphaBits;	/* bits per comp */
+    GLuint redMask, greenMask, blueMask, alphaMask;
+    GLint rgbBits;		/* total bits for rgb */
+    GLint indexBits;		/* total bits for colorindex */
+
+    GLint accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits;
+    GLint depthBits;
+    GLint stencilBits;
+
+    GLint numAuxBuffers;
+
+    GLint level;
+
+    GLint pixmapMode;
+
+    /* GLX */
+    GLint visualID;
+    GLint visualType;     /**< One of the GLX X visual types. (i.e.,
+			   * \c GLX_TRUE_COLOR, etc.)
+			   */
+
+    /* EXT_visual_rating / GLX 1.2 */
+    GLint visualRating;
+
+    /* EXT_visual_info / GLX 1.2 */
+    GLint transparentPixel;
+				/*    colors are floats scaled to ints */
+    GLint transparentRed, transparentGreen, transparentBlue, transparentAlpha;
+    GLint transparentIndex;
+
+    /* ARB_multisample / SGIS_multisample */
+    GLint sampleBuffers;
+    GLint samples;
+
+    /* SGIX_fbconfig / GLX 1.3 */
+    GLint drawableType;
+    GLint renderType;
+    GLint xRenderable;
+    GLint fbconfigID;
+
+    /* SGIX_pbuffer / GLX 1.3 */
+    GLint maxPbufferWidth;
+    GLint maxPbufferHeight;
+    GLint maxPbufferPixels;
+    GLint optimalPbufferWidth;   /* Only for SGIX_pbuffer. */
+    GLint optimalPbufferHeight;  /* Only for SGIX_pbuffer. */
+
+    /* SGIX_visual_select_group */
+    GLint visualSelectGroup;
+
+    /* OML_swap_method */
+    GLint swapMethod;
+
+    GLint screen;
+
+    /* EXT_texture_from_pixmap */
+    GLint bindToTextureRgb;
+    GLint bindToTextureRgba;
+    GLint bindToMipmapTexture;
+    GLint bindToTextureTargets;
+    GLint yInverted;
+} __GLcontextModes;
+
+/* Several fields of __GLcontextModes can take these as values.  Since
+ * GLX header files may not be available everywhere they need to be used,
+ * redefine them here.
+ */
+#define GLX_NONE                           0x8000
+#define GLX_SLOW_CONFIG                    0x8001
+#define GLX_TRUE_COLOR                     0x8002
+#define GLX_DIRECT_COLOR                   0x8003
+#define GLX_PSEUDO_COLOR                   0x8004
+#define GLX_STATIC_COLOR                   0x8005
+#define GLX_GRAY_SCALE                     0x8006
+#define GLX_STATIC_GRAY                    0x8007
+#define GLX_TRANSPARENT_RGB                0x8008
+#define GLX_TRANSPARENT_INDEX              0x8009
+#define GLX_NON_CONFORMANT_CONFIG          0x800D
+#define GLX_SWAP_EXCHANGE_OML              0x8061
+#define GLX_SWAP_COPY_OML                  0x8062
+#define GLX_SWAP_UNDEFINED_OML             0x8063
+
+#define GLX_DONT_CARE                      0xFFFFFFFF
+
+#define GLX_RGBA_BIT                       0x00000001
+#define GLX_COLOR_INDEX_BIT                0x00000002
+#define GLX_WINDOW_BIT                     0x00000001
+#define GLX_PIXMAP_BIT                     0x00000002
+#define GLX_PBUFFER_BIT                    0x00000004
+
+#define GLX_BIND_TO_TEXTURE_RGB_EXT        0x20D0
+#define GLX_BIND_TO_TEXTURE_RGBA_EXT       0x20D1
+#define GLX_BIND_TO_MIPMAP_TEXTURE_EXT     0x20D2
+#define GLX_BIND_TO_TEXTURE_TARGETS_EXT    0x20D3
+#define GLX_Y_INVERTED_EXT                 0x20D4
+
+#define GLX_TEXTURE_1D_BIT_EXT             0x00000001
+#define GLX_TEXTURE_2D_BIT_EXT             0x00000002
+#define GLX_TEXTURE_RECTANGLE_BIT_EXT      0x00000004
+
+#endif /* __gl_core_h_ */
diff --git a/depends/libxcb/depends/xorgproto/include/GL/internal/meson.build b/depends/libxcb/depends/xorgproto/include/GL/internal/meson.build
new file mode 100644
index 0000000..158e0cc
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/GL/internal/meson.build
@@ -0,0 +1 @@
+install_headers('glcore.h', subdir : 'GL/internal')
diff --git a/depends/libxcb/depends/xorgproto/include/GL/meson.build b/depends/libxcb/depends/xorgproto/include/GL/meson.build
new file mode 100644
index 0000000..10da898
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/GL/meson.build
@@ -0,0 +1,7 @@
+install_headers(
+    'glxint.h',
+    'glxmd.h',
+    'glxproto.h',
+    'glxtokens.h',
+    subdir : 'GL')
+subdir('internal')
diff --git a/depends/libxcb/depends/xorgproto/include/X11/DECkeysym.h b/depends/libxcb/depends/xorgproto/include/X11/DECkeysym.h
new file mode 100644
index 0000000..d9e23c4
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/DECkeysym.h
@@ -0,0 +1,65 @@
+/***********************************************************
+
+Copyright 1988, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1988 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+/*
+ * DEC private keysyms
+ * (29th bit set)
+ */
+
+/* two-key compose sequence initiators, chosen to map to Latin1 characters */
+
+#define DXK_ring_accent         0x1000FEB0
+#define DXK_circumflex_accent   0x1000FE5E
+#define DXK_cedilla_accent      0x1000FE2C
+#define DXK_acute_accent        0x1000FE27
+#define DXK_grave_accent        0x1000FE60
+#define DXK_tilde               0x1000FE7E
+#define DXK_diaeresis           0x1000FE22
+
+/* special keysym for LK2** "Remove" key on editing keypad */
+
+#define DXK_Remove	0x1000FF00   /* Remove */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/HPkeysym.h b/depends/libxcb/depends/xorgproto/include/X11/HPkeysym.h
new file mode 100644
index 0000000..d41ed38
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/HPkeysym.h
@@ -0,0 +1,164 @@
+/*
+
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Hewlett Packard
+or Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+HEWLETT-PACKARD MAKES NO WARRANTY OF ANY KIND WITH REGARD
+TO THIS SOFTWARE, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  Hewlett-Packard shall not be liable for errors
+contained herein or direct, indirect, special, incidental or
+consequential damages in connection with the furnishing,
+performance, or use of this material.
+
+*/
+
+#ifndef _HPKEYSYM_H
+
+#define _HPKEYSYM_H
+
+#define hpXK_ClearLine		0x1000FF6F
+#define hpXK_InsertLine		0x1000FF70
+#define hpXK_DeleteLine		0x1000FF71
+#define hpXK_InsertChar		0x1000FF72
+#define hpXK_DeleteChar		0x1000FF73
+#define hpXK_BackTab		0x1000FF74
+#define hpXK_KP_BackTab		0x1000FF75
+#define hpXK_Modelock1		0x1000FF48
+#define hpXK_Modelock2		0x1000FF49
+#define hpXK_Reset		0x1000FF6C
+#define hpXK_System		0x1000FF6D
+#define hpXK_User		0x1000FF6E
+#define hpXK_mute_acute		0x100000A8
+#define hpXK_mute_grave		0x100000A9
+#define hpXK_mute_asciicircum	0x100000AA
+#define hpXK_mute_diaeresis	0x100000AB
+#define hpXK_mute_asciitilde	0x100000AC
+#define hpXK_lira		0x100000AF
+#define hpXK_guilder		0x100000BE
+#define hpXK_Ydiaeresis		0x100000EE
+#define hpXK_IO			0x100000EE
+#define hpXK_longminus		0x100000F6
+#define hpXK_block		0x100000FC
+
+
+#ifndef _OSF_Keysyms
+#define _OSF_Keysyms
+
+#define osfXK_Copy		0x1004FF02
+#define osfXK_Cut		0x1004FF03
+#define osfXK_Paste		0x1004FF04
+#define osfXK_BackTab		0x1004FF07
+#define osfXK_BackSpace		0x1004FF08
+#define osfXK_Clear		0x1004FF0B
+#define osfXK_Escape		0x1004FF1B
+#define osfXK_AddMode		0x1004FF31
+#define osfXK_PrimaryPaste	0x1004FF32
+#define osfXK_QuickPaste	0x1004FF33
+#define osfXK_PageLeft		0x1004FF40
+#define osfXK_PageUp		0x1004FF41
+#define osfXK_PageDown		0x1004FF42
+#define osfXK_PageRight		0x1004FF43
+#define osfXK_Activate		0x1004FF44
+#define osfXK_MenuBar		0x1004FF45
+#define osfXK_Left		0x1004FF51
+#define osfXK_Up		0x1004FF52
+#define osfXK_Right		0x1004FF53
+#define osfXK_Down		0x1004FF54
+#define osfXK_EndLine		0x1004FF57
+#define osfXK_BeginLine		0x1004FF58
+#define osfXK_EndData		0x1004FF59
+#define osfXK_BeginData		0x1004FF5A
+#define osfXK_PrevMenu		0x1004FF5B
+#define osfXK_NextMenu		0x1004FF5C
+#define osfXK_PrevField		0x1004FF5D
+#define osfXK_NextField		0x1004FF5E
+#define osfXK_Select		0x1004FF60
+#define osfXK_Insert		0x1004FF63
+#define osfXK_Undo		0x1004FF65
+#define osfXK_Menu		0x1004FF67
+#define osfXK_Cancel		0x1004FF69
+#define osfXK_Help		0x1004FF6A
+#define osfXK_SelectAll		0x1004FF71
+#define osfXK_DeselectAll	0x1004FF72
+#define osfXK_Reselect		0x1004FF73
+#define osfXK_Extend		0x1004FF74
+#define osfXK_Restore		0x1004FF78
+#define osfXK_Delete		0x1004FFFF
+
+#endif /* _OSF_Keysyms */
+
+
+/**************************************************************
+ * The use of the following macros is deprecated.
+ * They are listed below only for backwards compatibility.
+ */
+#define XK_Reset                0x1000FF6C
+#define XK_System               0x1000FF6D
+#define XK_User                 0x1000FF6E
+#define XK_ClearLine            0x1000FF6F
+#define XK_InsertLine           0x1000FF70
+#define XK_DeleteLine           0x1000FF71
+#define XK_InsertChar           0x1000FF72
+#define XK_DeleteChar           0x1000FF73
+#define XK_BackTab              0x1000FF74
+#define XK_KP_BackTab           0x1000FF75
+#define XK_Ext16bit_L           0x1000FF76
+#define XK_Ext16bit_R           0x1000FF77
+#define XK_mute_acute           0x100000a8
+#define XK_mute_grave           0x100000a9
+#define XK_mute_asciicircum     0x100000aa
+#define XK_mute_diaeresis       0x100000ab
+#define XK_mute_asciitilde      0x100000ac
+#define XK_lira                 0x100000af
+#define XK_guilder              0x100000be
+#ifndef XK_Ydiaeresis
+#define XK_Ydiaeresis           0x100000ee
+#endif
+#define XK_IO                   0x100000ee
+#define XK_longminus            0x100000f6
+#define XK_block                0x100000fc
+
+#endif /* _HPKEYSYM_H */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/PM/PM.h b/depends/libxcb/depends/xorgproto/include/X11/PM/PM.h
new file mode 100644
index 0000000..c96644c
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/PM/PM.h
@@ -0,0 +1,54 @@
+/* $Xorg: PM.h,v 1.4 2001/02/09 02:05:34 xorgcvs Exp $ */
+
+/*
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+*/
+
+/*		Proxy Management Protocol		*/
+
+#ifndef _PM_H_
+#define _PM_H_
+
+#define PM_PROTOCOL_NAME "PROXY_MANAGEMENT"
+
+#define PM_MAJOR_VERSION 1
+#define PM_MINOR_VERSION 0
+
+/*
+ * PM minor opcodes
+ */
+#define PM_Error		ICE_Error /* == 0 */
+#define PM_GetProxyAddr		1
+#define PM_GetProxyAddrReply	2
+#define PM_StartProxy		3
+
+/*
+ * status return codes for GetProxyAddrReply
+ */
+#define		   PM_Unable	0
+#define		   PM_Success	1
+#define            PM_Failure	2
+
+#endif /* _PM_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/PM/PMproto.h b/depends/libxcb/depends/xorgproto/include/X11/PM/PMproto.h
new file mode 100644
index 0000000..1395905
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/PM/PMproto.h
@@ -0,0 +1,74 @@
+/* $Xorg: PMproto.h,v 1.4 2001/02/09 02:05:34 xorgcvs Exp $ */
+
+/*
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+*/
+
+/*		Proxy Management Protocol		*/
+
+#ifndef _PMPROTO_H_
+#define _PMPROTO_H_
+
+typedef struct {
+    CARD8	majorOpcode;
+    CARD8	minorOpcode;	/* == 1 */
+    CARD16	authLen;
+    CARD32	length;
+    /* STRING	   proxy-service */
+    /* STRING	   server-address */
+    /* STRING	   host-address */
+    /* STRING	   start-options */
+    /* STRING	   auth-name (if authLen > 0) */
+    /* LISTofCARD8 auth-data (if authLen > 0) */
+} pmGetProxyAddrMsg;
+
+#define sz_pmGetProxyAddrMsg 8
+
+
+typedef struct {
+    CARD8	majorOpcode;
+    CARD8	minorOpcode;	/* == 2 */
+    CARD8	status;
+    CARD8	unused;
+    CARD32	length;
+    /* STRING	proxy-address */
+    /* STRING	failure-reason */
+} pmGetProxyAddrReplyMsg;
+
+#define sz_pmGetProxyAddrReplyMsg 8
+
+
+typedef struct {
+    CARD8	majorOpcode;
+    CARD8	minorOpcode;	/* == 3 */
+    CARD16	unused;
+    CARD32	length;
+    /* STRING	  proxy-service */
+} pmStartProxyMsg;
+
+#define sz_pmStartProxyMsg 8
+
+
+#endif /* _PMPROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/PM/meson.build b/depends/libxcb/depends/xorgproto/include/X11/PM/meson.build
new file mode 100644
index 0000000..7d9fadf
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/PM/meson.build
@@ -0,0 +1,5 @@
+install_headers(
+    'PM.h',
+    'PMproto.h',
+    subdir : 'X11/PM'
+)
diff --git a/depends/libxcb/depends/xorgproto/include/X11/Sunkeysym.h b/depends/libxcb/depends/xorgproto/include/X11/Sunkeysym.h
new file mode 100644
index 0000000..149740b
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/Sunkeysym.h
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 1991, Oracle and/or its affiliates.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+/************************************************************
+
+Copyright 1991, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+***********************************************************/
+
+/*
+ * Floating Accent
+ */
+
+#define	SunXK_FA_Grave		0x1005FF00
+#define	SunXK_FA_Circum		0x1005FF01
+#define	SunXK_FA_Tilde		0x1005FF02
+#define	SunXK_FA_Acute		0x1005FF03
+#define	SunXK_FA_Diaeresis	0x1005FF04
+#define	SunXK_FA_Cedilla	0x1005FF05
+
+/*
+ * Miscellaneous Functions
+ */
+
+#define	SunXK_F36		0x1005FF10	/* Labeled F11 */
+#define	SunXK_F37		0x1005FF11	/* Labeled F12 */
+
+#define SunXK_Sys_Req   	0x1005FF60
+#define SunXK_Print_Screen	0x0000FF61	/* Same as XK_Print */
+
+/*
+ * International & Multi-Key Character Composition
+ */
+
+#define SunXK_Compose		0x0000FF20	/* Same as XK_Multi_key */
+#define SunXK_AltGraph		0x0000FF7E	/* Same as XK_Mode_switch */
+
+/*
+ * Cursor Control
+ */
+
+#define SunXK_PageUp		0x0000FF55 	/* Same as XK_Prior */
+#define SunXK_PageDown		0x0000FF56	/* Same as XK_Next */
+
+/*
+ * Open Look Functions
+ */
+
+#define SunXK_Undo		0x0000FF65	/* Same as XK_Undo */
+#define SunXK_Again		0x0000FF66	/* Same as XK_Redo */
+#define SunXK_Find		0x0000FF68	/* Same as XK_Find */
+#define SunXK_Stop		0x0000FF69	/* Same as XK_Cancel */
+#define SunXK_Props		0x1005FF70
+#define SunXK_Front		0x1005FF71
+#define SunXK_Copy		0x1005FF72
+#define SunXK_Open		0x1005FF73
+#define SunXK_Paste		0x1005FF74
+#define SunXK_Cut		0x1005FF75
+
+#define SunXK_PowerSwitch		0x1005FF76
+#define SunXK_AudioLowerVolume		0x1005FF77
+#define SunXK_AudioMute			0x1005FF78
+#define SunXK_AudioRaiseVolume		0x1005FF79
+#define SunXK_VideoDegauss		0x1005FF7A
+#define SunXK_VideoLowerBrightness	0x1005FF7B
+#define SunXK_VideoRaiseBrightness	0x1005FF7C
+#define SunXK_PowerSwitchShift		0x1005FF7D
diff --git a/depends/libxcb/depends/xorgproto/include/X11/X.h b/depends/libxcb/depends/xorgproto/include/X11/X.h
new file mode 100644
index 0000000..4df7d22
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/X.h
@@ -0,0 +1,717 @@
+/* Definitions for the X window system likely to be used by applications */
+
+#ifndef X_H
+#define X_H
+
+/***********************************************************
+
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+#define X_PROTOCOL	11		/* current protocol version */
+#define X_PROTOCOL_REVISION 0		/* current minor version */
+
+/* Resources */
+
+/*
+ * _XSERVER64 must ONLY be defined when compiling X server sources on
+ * systems where unsigned long is not 32 bits, must NOT be used in
+ * client or library code.
+ */
+#ifndef _XSERVER64
+#  ifndef _XTYPEDEF_XID
+#    define _XTYPEDEF_XID
+typedef unsigned long XID;
+#  endif
+#  ifndef _XTYPEDEF_MASK
+#    define _XTYPEDEF_MASK
+typedef unsigned long Mask;
+#  endif
+#  ifndef _XTYPEDEF_ATOM
+#    define _XTYPEDEF_ATOM
+typedef unsigned long Atom;		/* Also in Xdefs.h */
+#  endif
+typedef unsigned long VisualID;
+typedef unsigned long Time;
+#else
+#  include <X11/Xmd.h>
+#  ifndef _XTYPEDEF_XID
+#    define _XTYPEDEF_XID
+typedef CARD32 XID;
+#  endif
+#  ifndef _XTYPEDEF_MASK
+#    define _XTYPEDEF_MASK
+typedef CARD32 Mask;
+#  endif
+#  ifndef _XTYPEDEF_ATOM
+#    define _XTYPEDEF_ATOM
+typedef CARD32 Atom;
+#  endif
+typedef CARD32 VisualID;
+typedef CARD32 Time;
+#endif
+
+typedef XID Window;
+typedef XID Drawable;
+#ifndef _XTYPEDEF_FONT
+#  define _XTYPEDEF_FONT
+typedef XID Font;
+#endif
+typedef XID Pixmap;
+typedef XID Cursor;
+typedef XID Colormap;
+typedef XID GContext;
+typedef XID KeySym;
+
+typedef unsigned char KeyCode;
+
+/*****************************************************************
+ * RESERVED RESOURCE AND CONSTANT DEFINITIONS
+ *****************************************************************/
+
+#ifndef None
+#define None                 0L	/* universal null resource or null atom */
+#endif
+
+#define ParentRelative       1L	/* background pixmap in CreateWindow
+				    and ChangeWindowAttributes */
+
+#define CopyFromParent       0L	/* border pixmap in CreateWindow
+				       and ChangeWindowAttributes
+				   special VisualID and special window
+				       class passed to CreateWindow */
+
+#define PointerWindow        0L	/* destination window in SendEvent */
+#define InputFocus           1L	/* destination window in SendEvent */
+
+#define PointerRoot          1L	/* focus window in SetInputFocus */
+
+#define AnyPropertyType      0L	/* special Atom, passed to GetProperty */
+
+#define AnyKey		     0L	/* special Key Code, passed to GrabKey */
+
+#define AnyButton            0L	/* special Button Code, passed to GrabButton */
+
+#define AllTemporary         0L	/* special Resource ID passed to KillClient */
+
+#define CurrentTime          0L	/* special Time */
+
+#define NoSymbol	     0L	/* special KeySym */
+
+/*****************************************************************
+ * EVENT DEFINITIONS
+ *****************************************************************/
+
+/* Input Event Masks. Used as event-mask window attribute and as arguments
+   to Grab requests.  Not to be confused with event names.  */
+
+#define NoEventMask			0L
+#define KeyPressMask			(1L<<0)
+#define KeyReleaseMask			(1L<<1)
+#define ButtonPressMask			(1L<<2)
+#define ButtonReleaseMask		(1L<<3)
+#define EnterWindowMask			(1L<<4)
+#define LeaveWindowMask			(1L<<5)
+#define PointerMotionMask		(1L<<6)
+#define PointerMotionHintMask		(1L<<7)
+#define Button1MotionMask		(1L<<8)
+#define Button2MotionMask		(1L<<9)
+#define Button3MotionMask		(1L<<10)
+#define Button4MotionMask		(1L<<11)
+#define Button5MotionMask		(1L<<12)
+#define ButtonMotionMask		(1L<<13)
+#define KeymapStateMask			(1L<<14)
+#define ExposureMask			(1L<<15)
+#define VisibilityChangeMask		(1L<<16)
+#define StructureNotifyMask		(1L<<17)
+#define ResizeRedirectMask		(1L<<18)
+#define SubstructureNotifyMask		(1L<<19)
+#define SubstructureRedirectMask	(1L<<20)
+#define FocusChangeMask			(1L<<21)
+#define PropertyChangeMask		(1L<<22)
+#define ColormapChangeMask		(1L<<23)
+#define OwnerGrabButtonMask		(1L<<24)
+
+/* Event names.  Used in "type" field in XEvent structures.  Not to be
+confused with event masks above.  They start from 2 because 0 and 1
+are reserved in the protocol for errors and replies. */
+
+#define KeyPress		2
+#define KeyRelease		3
+#define ButtonPress		4
+#define ButtonRelease		5
+#define MotionNotify		6
+#define EnterNotify		7
+#define LeaveNotify		8
+#define FocusIn			9
+#define FocusOut		10
+#define KeymapNotify		11
+#define Expose			12
+#define GraphicsExpose		13
+#define NoExpose		14
+#define VisibilityNotify	15
+#define CreateNotify		16
+#define DestroyNotify		17
+#define UnmapNotify		18
+#define MapNotify		19
+#define MapRequest		20
+#define ReparentNotify		21
+#define ConfigureNotify		22
+#define ConfigureRequest	23
+#define GravityNotify		24
+#define ResizeRequest		25
+#define CirculateNotify		26
+#define CirculateRequest	27
+#define PropertyNotify		28
+#define SelectionClear		29
+#define SelectionRequest	30
+#define SelectionNotify		31
+#define ColormapNotify		32
+#define ClientMessage		33
+#define MappingNotify		34
+#define GenericEvent		35
+#define LASTEvent		36	/* must be bigger than any event # */
+
+
+/* Key masks. Used as modifiers to GrabButton and GrabKey, results of QueryPointer,
+   state in various key-, mouse-, and button-related events. */
+
+#define ShiftMask		(1<<0)
+#define LockMask		(1<<1)
+#define ControlMask		(1<<2)
+#define Mod1Mask		(1<<3)
+#define Mod2Mask		(1<<4)
+#define Mod3Mask		(1<<5)
+#define Mod4Mask		(1<<6)
+#define Mod5Mask		(1<<7)
+
+/* modifier names.  Used to build a SetModifierMapping request or
+   to read a GetModifierMapping request.  These correspond to the
+   masks defined above. */
+#define ShiftMapIndex		0
+#define LockMapIndex		1
+#define ControlMapIndex		2
+#define Mod1MapIndex		3
+#define Mod2MapIndex		4
+#define Mod3MapIndex		5
+#define Mod4MapIndex		6
+#define Mod5MapIndex		7
+
+
+/* button masks.  Used in same manner as Key masks above. Not to be confused
+   with button names below. */
+
+#define Button1Mask		(1<<8)
+#define Button2Mask		(1<<9)
+#define Button3Mask		(1<<10)
+#define Button4Mask		(1<<11)
+#define Button5Mask		(1<<12)
+
+#define AnyModifier		(1<<15)  /* used in GrabButton, GrabKey */
+
+
+/* button names. Used as arguments to GrabButton and as detail in ButtonPress
+   and ButtonRelease events.  Not to be confused with button masks above.
+   Note that 0 is already defined above as "AnyButton".  */
+
+#define Button1			1
+#define Button2			2
+#define Button3			3
+#define Button4			4
+#define Button5			5
+
+/* Notify modes */
+
+#define NotifyNormal		0
+#define NotifyGrab		1
+#define NotifyUngrab		2
+#define NotifyWhileGrabbed	3
+
+#define NotifyHint		1	/* for MotionNotify events */
+
+/* Notify detail */
+
+#define NotifyAncestor		0
+#define NotifyVirtual		1
+#define NotifyInferior		2
+#define NotifyNonlinear		3
+#define NotifyNonlinearVirtual	4
+#define NotifyPointer		5
+#define NotifyPointerRoot	6
+#define NotifyDetailNone	7
+
+/* Visibility notify */
+
+#define VisibilityUnobscured		0
+#define VisibilityPartiallyObscured	1
+#define VisibilityFullyObscured		2
+
+/* Circulation request */
+
+#define PlaceOnTop		0
+#define PlaceOnBottom		1
+
+/* protocol families */
+
+#define FamilyInternet		0	/* IPv4 */
+#define FamilyDECnet		1
+#define FamilyChaos		2
+#define FamilyInternet6		6	/* IPv6 */
+
+/* authentication families not tied to a specific protocol */
+#define FamilyServerInterpreted 5
+
+/* Property notification */
+
+#define PropertyNewValue	0
+#define PropertyDelete		1
+
+/* Color Map notification */
+
+#define ColormapUninstalled	0
+#define ColormapInstalled	1
+
+/* GrabPointer, GrabButton, GrabKeyboard, GrabKey Modes */
+
+#define GrabModeSync		0
+#define GrabModeAsync		1
+
+/* GrabPointer, GrabKeyboard reply status */
+
+#define GrabSuccess		0
+#define AlreadyGrabbed		1
+#define GrabInvalidTime		2
+#define GrabNotViewable		3
+#define GrabFrozen		4
+
+/* AllowEvents modes */
+
+#define AsyncPointer		0
+#define SyncPointer		1
+#define ReplayPointer		2
+#define AsyncKeyboard		3
+#define SyncKeyboard		4
+#define ReplayKeyboard		5
+#define AsyncBoth		6
+#define SyncBoth		7
+
+/* Used in SetInputFocus, GetInputFocus */
+
+#define RevertToNone		(int)None
+#define RevertToPointerRoot	(int)PointerRoot
+#define RevertToParent		2
+
+/*****************************************************************
+ * ERROR CODES
+ *****************************************************************/
+
+#define Success		   0	/* everything's okay */
+#define BadRequest	   1	/* bad request code */
+#define BadValue	   2	/* int parameter out of range */
+#define BadWindow	   3	/* parameter not a Window */
+#define BadPixmap	   4	/* parameter not a Pixmap */
+#define BadAtom		   5	/* parameter not an Atom */
+#define BadCursor	   6	/* parameter not a Cursor */
+#define BadFont		   7	/* parameter not a Font */
+#define BadMatch	   8	/* parameter mismatch */
+#define BadDrawable	   9	/* parameter not a Pixmap or Window */
+#define BadAccess	  10	/* depending on context:
+				 - key/button already grabbed
+				 - attempt to free an illegal
+				   cmap entry
+				- attempt to store into a read-only
+				   color map entry.
+ 				- attempt to modify the access control
+				   list from other than the local host.
+				*/
+#define BadAlloc	  11	/* insufficient resources */
+#define BadColor	  12	/* no such colormap */
+#define BadGC		  13	/* parameter not a GC */
+#define BadIDChoice	  14	/* choice not in range or already used */
+#define BadName		  15	/* font or color name doesn't exist */
+#define BadLength	  16	/* Request length incorrect */
+#define BadImplementation 17	/* server is defective */
+
+#define FirstExtensionError	128
+#define LastExtensionError	255
+
+/*****************************************************************
+ * WINDOW DEFINITIONS
+ *****************************************************************/
+
+/* Window classes used by CreateWindow */
+/* Note that CopyFromParent is already defined as 0 above */
+
+#define InputOutput		1
+#define InputOnly		2
+
+/* Window attributes for CreateWindow and ChangeWindowAttributes */
+
+#define CWBackPixmap		(1L<<0)
+#define CWBackPixel		(1L<<1)
+#define CWBorderPixmap		(1L<<2)
+#define CWBorderPixel           (1L<<3)
+#define CWBitGravity		(1L<<4)
+#define CWWinGravity		(1L<<5)
+#define CWBackingStore          (1L<<6)
+#define CWBackingPlanes	        (1L<<7)
+#define CWBackingPixel	        (1L<<8)
+#define CWOverrideRedirect	(1L<<9)
+#define CWSaveUnder		(1L<<10)
+#define CWEventMask		(1L<<11)
+#define CWDontPropagate	        (1L<<12)
+#define CWColormap		(1L<<13)
+#define CWCursor	        (1L<<14)
+
+/* ConfigureWindow structure */
+
+#define CWX			(1<<0)
+#define CWY			(1<<1)
+#define CWWidth			(1<<2)
+#define CWHeight		(1<<3)
+#define CWBorderWidth		(1<<4)
+#define CWSibling		(1<<5)
+#define CWStackMode		(1<<6)
+
+
+/* Bit Gravity */
+
+#define ForgetGravity		0
+#define NorthWestGravity	1
+#define NorthGravity		2
+#define NorthEastGravity	3
+#define WestGravity		4
+#define CenterGravity		5
+#define EastGravity		6
+#define SouthWestGravity	7
+#define SouthGravity		8
+#define SouthEastGravity	9
+#define StaticGravity		10
+
+/* Window gravity + bit gravity above */
+
+#define UnmapGravity		0
+
+/* Used in CreateWindow for backing-store hint */
+
+#define NotUseful               0
+#define WhenMapped              1
+#define Always                  2
+
+/* Used in GetWindowAttributes reply */
+
+#define IsUnmapped		0
+#define IsUnviewable		1
+#define IsViewable		2
+
+/* Used in ChangeSaveSet */
+
+#define SetModeInsert           0
+#define SetModeDelete           1
+
+/* Used in ChangeCloseDownMode */
+
+#define DestroyAll              0
+#define RetainPermanent         1
+#define RetainTemporary         2
+
+/* Window stacking method (in configureWindow) */
+
+#define Above                   0
+#define Below                   1
+#define TopIf                   2
+#define BottomIf                3
+#define Opposite                4
+
+/* Circulation direction */
+
+#define RaiseLowest             0
+#define LowerHighest            1
+
+/* Property modes */
+
+#define PropModeReplace         0
+#define PropModePrepend         1
+#define PropModeAppend          2
+
+/*****************************************************************
+ * GRAPHICS DEFINITIONS
+ *****************************************************************/
+
+/* graphics functions, as in GC.alu */
+
+#define	GXclear			0x0		/* 0 */
+#define GXand			0x1		/* src AND dst */
+#define GXandReverse		0x2		/* src AND NOT dst */
+#define GXcopy			0x3		/* src */
+#define GXandInverted		0x4		/* NOT src AND dst */
+#define	GXnoop			0x5		/* dst */
+#define GXxor			0x6		/* src XOR dst */
+#define GXor			0x7		/* src OR dst */
+#define GXnor			0x8		/* NOT src AND NOT dst */
+#define GXequiv			0x9		/* NOT src XOR dst */
+#define GXinvert		0xa		/* NOT dst */
+#define GXorReverse		0xb		/* src OR NOT dst */
+#define GXcopyInverted		0xc		/* NOT src */
+#define GXorInverted		0xd		/* NOT src OR dst */
+#define GXnand			0xe		/* NOT src OR NOT dst */
+#define GXset			0xf		/* 1 */
+
+/* LineStyle */
+
+#define LineSolid		0
+#define LineOnOffDash		1
+#define LineDoubleDash		2
+
+/* capStyle */
+
+#define CapNotLast		0
+#define CapButt			1
+#define CapRound		2
+#define CapProjecting		3
+
+/* joinStyle */
+
+#define JoinMiter		0
+#define JoinRound		1
+#define JoinBevel		2
+
+/* fillStyle */
+
+#define FillSolid		0
+#define FillTiled		1
+#define FillStippled		2
+#define FillOpaqueStippled	3
+
+/* fillRule */
+
+#define EvenOddRule		0
+#define WindingRule		1
+
+/* subwindow mode */
+
+#define ClipByChildren		0
+#define IncludeInferiors	1
+
+/* SetClipRectangles ordering */
+
+#define Unsorted		0
+#define YSorted			1
+#define YXSorted		2
+#define YXBanded		3
+
+/* CoordinateMode for drawing routines */
+
+#define CoordModeOrigin		0	/* relative to the origin */
+#define CoordModePrevious       1	/* relative to previous point */
+
+/* Polygon shapes */
+
+#define Complex			0	/* paths may intersect */
+#define Nonconvex		1	/* no paths intersect, but not convex */
+#define Convex			2	/* wholly convex */
+
+/* Arc modes for PolyFillArc */
+
+#define ArcChord		0	/* join endpoints of arc */
+#define ArcPieSlice		1	/* join endpoints to center of arc */
+
+/* GC components: masks used in CreateGC, CopyGC, ChangeGC, OR'ed into
+   GC.stateChanges */
+
+#define GCFunction              (1L<<0)
+#define GCPlaneMask             (1L<<1)
+#define GCForeground            (1L<<2)
+#define GCBackground            (1L<<3)
+#define GCLineWidth             (1L<<4)
+#define GCLineStyle             (1L<<5)
+#define GCCapStyle              (1L<<6)
+#define GCJoinStyle		(1L<<7)
+#define GCFillStyle		(1L<<8)
+#define GCFillRule		(1L<<9)
+#define GCTile			(1L<<10)
+#define GCStipple		(1L<<11)
+#define GCTileStipXOrigin	(1L<<12)
+#define GCTileStipYOrigin	(1L<<13)
+#define GCFont 			(1L<<14)
+#define GCSubwindowMode		(1L<<15)
+#define GCGraphicsExposures     (1L<<16)
+#define GCClipXOrigin		(1L<<17)
+#define GCClipYOrigin		(1L<<18)
+#define GCClipMask		(1L<<19)
+#define GCDashOffset		(1L<<20)
+#define GCDashList		(1L<<21)
+#define GCArcMode		(1L<<22)
+
+#define GCLastBit		22
+/*****************************************************************
+ * FONTS
+ *****************************************************************/
+
+/* used in QueryFont -- draw direction */
+
+#define FontLeftToRight		0
+#define FontRightToLeft		1
+
+#define FontChange		255
+
+/*****************************************************************
+ *  IMAGING
+ *****************************************************************/
+
+/* ImageFormat -- PutImage, GetImage */
+
+#define XYBitmap		0	/* depth 1, XYFormat */
+#define XYPixmap		1	/* depth == drawable depth */
+#define ZPixmap			2	/* depth == drawable depth */
+
+/*****************************************************************
+ *  COLOR MAP STUFF
+ *****************************************************************/
+
+/* For CreateColormap */
+
+#define AllocNone		0	/* create map with no entries */
+#define AllocAll		1	/* allocate entire map writeable */
+
+
+/* Flags used in StoreNamedColor, StoreColors */
+
+#define DoRed			(1<<0)
+#define DoGreen			(1<<1)
+#define DoBlue			(1<<2)
+
+/*****************************************************************
+ * CURSOR STUFF
+ *****************************************************************/
+
+/* QueryBestSize Class */
+
+#define CursorShape		0	/* largest size that can be displayed */
+#define TileShape		1	/* size tiled fastest */
+#define StippleShape		2	/* size stippled fastest */
+
+/*****************************************************************
+ * KEYBOARD/POINTER STUFF
+ *****************************************************************/
+
+#define AutoRepeatModeOff	0
+#define AutoRepeatModeOn	1
+#define AutoRepeatModeDefault	2
+
+#define LedModeOff		0
+#define LedModeOn		1
+
+/* masks for ChangeKeyboardControl */
+
+#define KBKeyClickPercent	(1L<<0)
+#define KBBellPercent		(1L<<1)
+#define KBBellPitch		(1L<<2)
+#define KBBellDuration		(1L<<3)
+#define KBLed			(1L<<4)
+#define KBLedMode		(1L<<5)
+#define KBKey			(1L<<6)
+#define KBAutoRepeatMode	(1L<<7)
+
+#define MappingSuccess     	0
+#define MappingBusy        	1
+#define MappingFailed		2
+
+#define MappingModifier		0
+#define MappingKeyboard		1
+#define MappingPointer		2
+
+/*****************************************************************
+ * SCREEN SAVER STUFF
+ *****************************************************************/
+
+#define DontPreferBlanking	0
+#define PreferBlanking		1
+#define DefaultBlanking		2
+
+#define DisableScreenSaver	0
+#define DisableScreenInterval	0
+
+#define DontAllowExposures	0
+#define AllowExposures		1
+#define DefaultExposures	2
+
+/* for ForceScreenSaver */
+
+#define ScreenSaverReset 0
+#define ScreenSaverActive 1
+
+/*****************************************************************
+ * HOSTS AND CONNECTIONS
+ *****************************************************************/
+
+/* for ChangeHosts */
+
+#define HostInsert		0
+#define HostDelete		1
+
+/* for ChangeAccessControl */
+
+#define EnableAccess		1
+#define DisableAccess		0
+
+/* Display classes  used in opening the connection
+ * Note that the statically allocated ones are even numbered and the
+ * dynamically changeable ones are odd numbered */
+
+#define StaticGray		0
+#define GrayScale		1
+#define StaticColor		2
+#define PseudoColor		3
+#define TrueColor		4
+#define DirectColor		5
+
+
+/* Byte order  used in imageByteOrder and bitmapBitOrder */
+
+#define LSBFirst		0
+#define MSBFirst		1
+
+#endif /* X_H */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/XF86keysym.h b/depends/libxcb/depends/xorgproto/include/X11/XF86keysym.h
new file mode 100644
index 0000000..e8a9fb8
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/XF86keysym.h
@@ -0,0 +1,469 @@
+/*
+ * XFree86 vendor specific keysyms.
+ *
+ * The XFree86 keysym range is 0x10080001 - 0x1008FFFF.
+ *
+ * The XF86 set of keysyms is a catch-all set of defines for keysyms found
+ * on various multimedia keyboards. Originally specific to XFree86 they have
+ * been been adopted over time and are considered a "standard" part of X
+ * keysym definitions.
+ * XFree86 never properly commented these keysyms, so we have done our
+ * best to explain the semantic meaning of these keys.
+ *
+ * XFree86 has removed their mail archives of the period, that might have
+ * shed more light on some of these definitions. Until/unless we resurrect
+ * these archives, these are from memory and usage.
+ */
+
+/*
+ * ModeLock
+ *
+ * This one is old, and not really used any more since XKB offers this
+ * functionality.
+ */
+
+#define XF86XK_ModeLock		0x1008FF01	/* Mode Switch Lock */
+
+/* Backlight controls. */
+#define XF86XK_MonBrightnessUp    0x1008FF02  /* Monitor/panel brightness */
+#define XF86XK_MonBrightnessDown  0x1008FF03  /* Monitor/panel brightness */
+#define XF86XK_KbdLightOnOff      0x1008FF04  /* Keyboards may be lit     */
+#define XF86XK_KbdBrightnessUp    0x1008FF05  /* Keyboards may be lit     */
+#define XF86XK_KbdBrightnessDown  0x1008FF06  /* Keyboards may be lit     */
+#define XF86XK_MonBrightnessCycle 0x1008FF07  /* Monitor/panel brightness */
+
+/*
+ * Keys found on some "Internet" keyboards.
+ */
+#define XF86XK_Standby		0x1008FF10   /* System into standby mode   */
+#define XF86XK_AudioLowerVolume	0x1008FF11   /* Volume control down        */
+#define XF86XK_AudioMute	0x1008FF12   /* Mute sound from the system */
+#define XF86XK_AudioRaiseVolume	0x1008FF13   /* Volume control up          */
+#define XF86XK_AudioPlay	0x1008FF14   /* Start playing of audio >   */
+#define XF86XK_AudioStop	0x1008FF15   /* Stop playing audio         */
+#define XF86XK_AudioPrev	0x1008FF16   /* Previous track             */
+#define XF86XK_AudioNext	0x1008FF17   /* Next track                 */
+#define XF86XK_HomePage		0x1008FF18   /* Display user's home page   */
+#define XF86XK_Mail		0x1008FF19   /* Invoke user's mail program */
+#define XF86XK_Start		0x1008FF1A   /* Start application          */
+#define XF86XK_Search		0x1008FF1B   /* Search                     */
+#define XF86XK_AudioRecord	0x1008FF1C   /* Record audio application   */
+
+/* These are sometimes found on PDA's (e.g. Palm, PocketPC or elsewhere)   */
+#define XF86XK_Calculator	0x1008FF1D   /* Invoke calculator program  */
+#define XF86XK_Memo		0x1008FF1E   /* Invoke Memo taking program */
+#define XF86XK_ToDoList		0x1008FF1F   /* Invoke To Do List program  */
+#define XF86XK_Calendar		0x1008FF20   /* Invoke Calendar program    */
+#define XF86XK_PowerDown	0x1008FF21   /* Deep sleep the system      */
+#define XF86XK_ContrastAdjust	0x1008FF22   /* Adjust screen contrast     */
+#define XF86XK_RockerUp		0x1008FF23   /* Rocker switches exist up   */
+#define XF86XK_RockerDown	0x1008FF24   /* and down                   */
+#define XF86XK_RockerEnter	0x1008FF25   /* and let you press them     */
+
+/* Some more "Internet" keyboard symbols */
+#define XF86XK_Back		0x1008FF26   /* Like back on a browser     */
+#define XF86XK_Forward		0x1008FF27   /* Like forward on a browser  */
+#define XF86XK_Stop		0x1008FF28   /* Stop current operation     */
+#define XF86XK_Refresh		0x1008FF29   /* Refresh the page           */
+#define XF86XK_PowerOff		0x1008FF2A   /* Power off system entirely  */
+#define XF86XK_WakeUp		0x1008FF2B   /* Wake up system from sleep  */
+#define XF86XK_Eject            0x1008FF2C   /* Eject device (e.g. DVD)    */
+#define XF86XK_ScreenSaver      0x1008FF2D   /* Invoke screensaver         */
+#define XF86XK_WWW              0x1008FF2E   /* Invoke web browser         */
+#define XF86XK_Sleep            0x1008FF2F   /* Put system to sleep        */
+#define XF86XK_Favorites	0x1008FF30   /* Show favorite locations    */
+#define XF86XK_AudioPause	0x1008FF31   /* Pause audio playing        */
+#define XF86XK_AudioMedia	0x1008FF32   /* Launch media collection app */
+#define XF86XK_MyComputer	0x1008FF33   /* Display "My Computer" window */
+#define XF86XK_VendorHome	0x1008FF34   /* Display vendor home web site */
+#define XF86XK_LightBulb	0x1008FF35   /* Light bulb keys exist       */
+#define XF86XK_Shop		0x1008FF36   /* Display shopping web site   */
+#define XF86XK_History		0x1008FF37   /* Show history of web surfing */
+#define XF86XK_OpenURL		0x1008FF38   /* Open selected URL           */
+#define XF86XK_AddFavorite	0x1008FF39   /* Add URL to favorites list   */
+#define XF86XK_HotLinks		0x1008FF3A   /* Show "hot" links            */
+#define XF86XK_BrightnessAdjust	0x1008FF3B   /* Invoke brightness adj. UI   */
+#define XF86XK_Finance		0x1008FF3C   /* Display financial site      */
+#define XF86XK_Community	0x1008FF3D   /* Display user's community    */
+#define XF86XK_AudioRewind	0x1008FF3E   /* "rewind" audio track        */
+#define XF86XK_BackForward	0x1008FF3F   /* ??? */
+#define XF86XK_Launch0		0x1008FF40   /* Launch Application          */
+#define XF86XK_Launch1		0x1008FF41   /* Launch Application          */
+#define XF86XK_Launch2		0x1008FF42   /* Launch Application          */
+#define XF86XK_Launch3		0x1008FF43   /* Launch Application          */
+#define XF86XK_Launch4		0x1008FF44   /* Launch Application          */
+#define XF86XK_Launch5		0x1008FF45   /* Launch Application          */
+#define XF86XK_Launch6		0x1008FF46   /* Launch Application          */
+#define XF86XK_Launch7		0x1008FF47   /* Launch Application          */
+#define XF86XK_Launch8		0x1008FF48   /* Launch Application          */
+#define XF86XK_Launch9		0x1008FF49   /* Launch Application          */
+#define XF86XK_LaunchA		0x1008FF4A   /* Launch Application          */
+#define XF86XK_LaunchB		0x1008FF4B   /* Launch Application          */
+#define XF86XK_LaunchC		0x1008FF4C   /* Launch Application          */
+#define XF86XK_LaunchD		0x1008FF4D   /* Launch Application          */
+#define XF86XK_LaunchE		0x1008FF4E   /* Launch Application          */
+#define XF86XK_LaunchF		0x1008FF4F   /* Launch Application          */
+
+#define XF86XK_ApplicationLeft	0x1008FF50   /* switch to application, left */
+#define XF86XK_ApplicationRight	0x1008FF51   /* switch to application, right*/
+#define XF86XK_Book		0x1008FF52   /* Launch bookreader           */
+#define XF86XK_CD		0x1008FF53   /* Launch CD/DVD player        */
+#define XF86XK_Calculater	0x1008FF54   /* Launch Calculater           */
+#define XF86XK_Clear		0x1008FF55   /* Clear window, screen        */
+#define XF86XK_Close		0x1008FF56   /* Close window                */
+#define XF86XK_Copy		0x1008FF57   /* Copy selection              */
+#define XF86XK_Cut		0x1008FF58   /* Cut selection               */
+#define XF86XK_Display		0x1008FF59   /* Output switch key           */
+#define XF86XK_DOS		0x1008FF5A   /* Launch DOS (emulation)      */
+#define XF86XK_Documents	0x1008FF5B   /* Open documents window       */
+#define XF86XK_Excel		0x1008FF5C   /* Launch spread sheet         */
+#define XF86XK_Explorer		0x1008FF5D   /* Launch file explorer        */
+#define XF86XK_Game		0x1008FF5E   /* Launch game                 */
+#define XF86XK_Go		0x1008FF5F   /* Go to URL                   */
+#define XF86XK_iTouch		0x1008FF60   /* Logitech iTouch- don't use  */
+#define XF86XK_LogOff		0x1008FF61   /* Log off system              */
+#define XF86XK_Market		0x1008FF62   /* ??                          */
+#define XF86XK_Meeting		0x1008FF63   /* enter meeting in calendar   */
+#define XF86XK_MenuKB		0x1008FF65   /* distinguish keyboard from PB */
+#define XF86XK_MenuPB		0x1008FF66   /* distinguish PB from keyboard */
+#define XF86XK_MySites		0x1008FF67   /* Favourites                  */
+#define XF86XK_New		0x1008FF68   /* New (folder, document...    */
+#define XF86XK_News		0x1008FF69   /* News                        */
+#define XF86XK_OfficeHome	0x1008FF6A   /* Office home (old Staroffice)*/
+#define XF86XK_Open		0x1008FF6B   /* Open                        */
+#define XF86XK_Option		0x1008FF6C   /* ?? */
+#define XF86XK_Paste		0x1008FF6D   /* Paste                       */
+#define XF86XK_Phone		0x1008FF6E   /* Launch phone; dial number   */
+#define XF86XK_Q		0x1008FF70   /* Compaq's Q - don't use      */
+#define XF86XK_Reply		0x1008FF72   /* Reply e.g., mail            */
+#define XF86XK_Reload		0x1008FF73   /* Reload web page, file, etc. */
+#define XF86XK_RotateWindows	0x1008FF74   /* Rotate windows e.g. xrandr  */
+#define XF86XK_RotationPB	0x1008FF75   /* don't use                   */
+#define XF86XK_RotationKB	0x1008FF76   /* don't use                   */
+#define XF86XK_Save		0x1008FF77   /* Save (file, document, state */
+#define XF86XK_ScrollUp		0x1008FF78   /* Scroll window/contents up   */
+#define XF86XK_ScrollDown	0x1008FF79   /* Scrool window/contentd down */
+#define XF86XK_ScrollClick	0x1008FF7A   /* Use XKB mousekeys instead   */
+#define XF86XK_Send		0x1008FF7B   /* Send mail, file, object     */
+#define XF86XK_Spell		0x1008FF7C   /* Spell checker               */
+#define XF86XK_SplitScreen	0x1008FF7D   /* Split window or screen      */
+#define XF86XK_Support		0x1008FF7E   /* Get support (??)            */
+#define XF86XK_TaskPane		0x1008FF7F   /* Show tasks */
+#define XF86XK_Terminal		0x1008FF80   /* Launch terminal emulator    */
+#define XF86XK_Tools		0x1008FF81   /* toolbox of desktop/app.     */
+#define XF86XK_Travel		0x1008FF82   /* ?? */
+#define XF86XK_UserPB		0x1008FF84   /* ?? */
+#define XF86XK_User1KB		0x1008FF85   /* ?? */
+#define XF86XK_User2KB		0x1008FF86   /* ?? */
+#define XF86XK_Video		0x1008FF87   /* Launch video player       */
+#define XF86XK_WheelButton	0x1008FF88   /* button from a mouse wheel */
+#define XF86XK_Word		0x1008FF89   /* Launch word processor     */
+#define XF86XK_Xfer		0x1008FF8A
+#define XF86XK_ZoomIn		0x1008FF8B   /* zoom in view, map, etc.   */
+#define XF86XK_ZoomOut		0x1008FF8C   /* zoom out view, map, etc.  */
+
+#define XF86XK_Away		0x1008FF8D   /* mark yourself as away     */
+#define XF86XK_Messenger	0x1008FF8E   /* as in instant messaging   */
+#define XF86XK_WebCam		0x1008FF8F   /* Launch web camera app.    */
+#define XF86XK_MailForward	0x1008FF90   /* Forward in mail           */
+#define XF86XK_Pictures		0x1008FF91   /* Show pictures             */
+#define XF86XK_Music		0x1008FF92   /* Launch music application  */
+
+#define XF86XK_Battery		0x1008FF93   /* Display battery information */
+#define XF86XK_Bluetooth	0x1008FF94   /* Enable/disable Bluetooth    */
+#define XF86XK_WLAN		0x1008FF95   /* Enable/disable WLAN         */
+#define XF86XK_UWB		0x1008FF96   /* Enable/disable UWB	    */
+
+#define XF86XK_AudioForward	0x1008FF97   /* fast-forward audio track    */
+#define XF86XK_AudioRepeat	0x1008FF98   /* toggle repeat mode          */
+#define XF86XK_AudioRandomPlay	0x1008FF99   /* toggle shuffle mode         */
+#define XF86XK_Subtitle		0x1008FF9A   /* cycle through subtitle      */
+#define XF86XK_AudioCycleTrack	0x1008FF9B   /* cycle through audio tracks  */
+#define XF86XK_CycleAngle	0x1008FF9C   /* cycle through angles        */
+#define XF86XK_FrameBack	0x1008FF9D   /* video: go one frame back    */
+#define XF86XK_FrameForward	0x1008FF9E   /* video: go one frame forward */
+#define XF86XK_Time		0x1008FF9F   /* display, or shows an entry for time seeking */
+#define XF86XK_Select		0x1008FFA0   /* Select button on joypads and remotes */
+#define XF86XK_View		0x1008FFA1   /* Show a view options/properties */
+#define XF86XK_TopMenu		0x1008FFA2   /* Go to a top-level menu in a video */
+
+#define XF86XK_Red		0x1008FFA3   /* Red button                  */
+#define XF86XK_Green		0x1008FFA4   /* Green button                */
+#define XF86XK_Yellow		0x1008FFA5   /* Yellow button               */
+#define XF86XK_Blue             0x1008FFA6   /* Blue button                 */
+
+#define XF86XK_Suspend		0x1008FFA7   /* Sleep to RAM                */
+#define XF86XK_Hibernate	0x1008FFA8   /* Sleep to disk               */
+#define XF86XK_TouchpadToggle	0x1008FFA9   /* Toggle between touchpad/trackstick */
+#define XF86XK_TouchpadOn	0x1008FFB0   /* The touchpad got switched on */
+#define XF86XK_TouchpadOff	0x1008FFB1   /* The touchpad got switched off */
+
+#define XF86XK_AudioMicMute	0x1008FFB2   /* Mute the Mic from the system */
+
+#define XF86XK_Keyboard		0x1008FFB3   /* User defined keyboard related action */
+
+#define XF86XK_WWAN		0x1008FFB4   /* Toggle WWAN (LTE, UMTS, etc.) radio */
+#define XF86XK_RFKill		0x1008FFB5   /* Toggle radios on/off */
+
+#define XF86XK_AudioPreset	0x1008FFB6   /* Select equalizer preset, e.g. theatre-mode */
+
+#define XF86XK_RotationLockToggle 0x1008FFB7 /* Toggle screen rotation lock on/off */
+
+#define XF86XK_FullScreen	0x1008FFB8   /* Toggle fullscreen */
+
+/* Keys for special action keys (hot keys) */
+/* Virtual terminals on some operating systems */
+#define XF86XK_Switch_VT_1	0x1008FE01
+#define XF86XK_Switch_VT_2	0x1008FE02
+#define XF86XK_Switch_VT_3	0x1008FE03
+#define XF86XK_Switch_VT_4	0x1008FE04
+#define XF86XK_Switch_VT_5	0x1008FE05
+#define XF86XK_Switch_VT_6	0x1008FE06
+#define XF86XK_Switch_VT_7	0x1008FE07
+#define XF86XK_Switch_VT_8	0x1008FE08
+#define XF86XK_Switch_VT_9	0x1008FE09
+#define XF86XK_Switch_VT_10	0x1008FE0A
+#define XF86XK_Switch_VT_11	0x1008FE0B
+#define XF86XK_Switch_VT_12	0x1008FE0C
+
+#define XF86XK_Ungrab		0x1008FE20   /* force ungrab               */
+#define XF86XK_ClearGrab	0x1008FE21   /* kill application with grab */
+#define XF86XK_Next_VMode	0x1008FE22   /* next video mode available  */
+#define XF86XK_Prev_VMode	0x1008FE23   /* prev. video mode available */
+#define XF86XK_LogWindowTree	0x1008FE24   /* print window tree to log   */
+#define XF86XK_LogGrabInfo	0x1008FE25   /* print all active grabs to log */
+
+
+/*
+ * Reserved range for evdev symbols: 0x10081000-0x10081FFF
+ *
+ * Key syms within this range must match the Linux kernel
+ * input-event-codes.h file in the format:
+ *     XF86XK_CamelCaseKernelName	_EVDEVK(kernel value)
+ * For example, the kernel
+ *   #define KEY_MACRO_RECORD_START	0x2b0
+ * effectively ends up as:
+ *   #define XF86XK_MacroRecordStart	0x100812b0
+ *
+ * For historical reasons, some keysyms within the reserved range will be
+ * missing, most notably all "normal" keys that are mapped through default
+ * XKB layouts (e.g. KEY_Q).
+ *
+ * CamelCasing is done with a human control as last authority, e.g. see VOD
+ * instead of Vod for the Video on Demand key.
+ *
+ * The format for #defines is strict:
+ *
+ * #define XF86XK_FOO<tab...>_EVDEVK(0xABC)<tab><tab> |* kver KEY_FOO *|
+ *
+ * Where
+ * - alignment by tabs
+ * - the _EVDEVK macro must be used
+ * - the hex code must be in uppercase hex
+ * - the kernel version (kver) is in the form v5.10
+ * - kver and key name are within a slash-star comment (a pipe is used in
+ *   this example for technical reasons)
+ * These #defines are parsed by scripts. Do not stray from the given format.
+ *
+ * Where the evdev keycode is mapped to a different symbol, please add a
+ * comment line starting with Use: but otherwise the same format, e.g.
+ *  Use: XF86XK_RotationLockToggle	_EVDEVK(0x231)		   v4.16 KEY_ROTATE_LOCK_TOGGLE
+ *
+ */
+#define _EVDEVK(_v) (0x10081000 + _v)
+/* Use: XF86XK_Eject			_EVDEVK(0x0A2)		         KEY_EJECTCLOSECD */
+/* Use: XF86XK_New			_EVDEVK(0x0B5)		   v2.6.14 KEY_NEW */
+/* Use: XK_Redo				_EVDEVK(0x0B6)		   v2.6.14 KEY_REDO */
+/* KEY_DASHBOARD has been mapped to LaunchB in xkeyboard-config since 2011 */
+/* Use: XF86XK_LaunchB			_EVDEVK(0x0CC)		   v2.6.28 KEY_DASHBOARD */
+/* Use: XF86XK_Display			_EVDEVK(0x0E3)		   v2.6.12 KEY_SWITCHVIDEOMODE */
+/* Use: XF86XK_KbdLightOnOff		_EVDEVK(0x0E4)		   v2.6.12 KEY_KBDILLUMTOGGLE */
+/* Use: XF86XK_KbdBrightnessDown	_EVDEVK(0x0E5)		   v2.6.12 KEY_KBDILLUMDOWN */
+/* Use: XF86XK_KbdBrightnessUp		_EVDEVK(0x0E6)		   v2.6.12 KEY_KBDILLUMUP */
+/* Use: XF86XK_Send			_EVDEVK(0x0E7)		   v2.6.14 KEY_SEND */
+/* Use: XF86XK_Reply			_EVDEVK(0x0E8)		   v2.6.14 KEY_REPLY */
+/* Use: XF86XK_MailForward		_EVDEVK(0x0E9)		   v2.6.14 KEY_FORWARDMAIL */
+/* Use: XF86XK_Save			_EVDEVK(0x0EA)		   v2.6.14 KEY_SAVE */
+/* Use: XF86XK_Documents		_EVDEVK(0x0EB)		   v2.6.14 KEY_DOCUMENTS */
+/* Use: XF86XK_Battery			_EVDEVK(0x0EC)		   v2.6.17 KEY_BATTERY */
+/* Use: XF86XK_Bluetooth		_EVDEVK(0x0ED)		   v2.6.19 KEY_BLUETOOTH */
+/* Use: XF86XK_WLAN			_EVDEVK(0x0EE)		   v2.6.19 KEY_WLAN */
+/* Use: XF86XK_UWB			_EVDEVK(0x0EF)		   v2.6.24 KEY_UWB */
+/* Use: XF86XK_Next_VMode		_EVDEVK(0x0F1)		   v2.6.23 KEY_VIDEO_NEXT */
+/* Use: XF86XK_Prev_VMode		_EVDEVK(0x0F2)		   v2.6.23 KEY_VIDEO_PREV */
+/* Use: XF86XK_MonBrightnessCycle	_EVDEVK(0x0F3)		   v2.6.23 KEY_BRIGHTNESS_CYCLE */
+#define XF86XK_BrightnessAuto		_EVDEVK(0x0F4)		/* v3.16 KEY_BRIGHTNESS_AUTO */
+#define XF86XK_DisplayOff		_EVDEVK(0x0F5)		/* v2.6.23 KEY_DISPLAY_OFF */
+/* Use: XF86XK_WWAN			_EVDEVK(0x0F6)		   v3.13 KEY_WWAN */
+/* Use: XF86XK_RFKill			_EVDEVK(0x0F7)		   v2.6.33 KEY_RFKILL */
+/* Use: XF86XK_AudioMicMute		_EVDEVK(0x0F8)		   v3.1  KEY_MICMUTE */
+#define XF86XK_Info			_EVDEVK(0x166)		/*       KEY_INFO */
+/* Use: XF86XK_CycleAngle		_EVDEVK(0x173)		         KEY_ANGLE */
+/* Use: XF86XK_FullScreen		_EVDEVK(0x174)		   v5.1  KEY_FULL_SCREEN */
+#define XF86XK_AspectRatio		_EVDEVK(0x177)		/* v5.1  KEY_ASPECT_RATIO */
+#define XF86XK_DVD			_EVDEVK(0x185)		/*       KEY_DVD */
+#define XF86XK_Audio			_EVDEVK(0x188)		/*       KEY_AUDIO */
+/* Use: XF86XK_Video			_EVDEVK(0x189)		         KEY_VIDEO */
+/* Use: XF86XK_Calendar			_EVDEVK(0x18D)		         KEY_CALENDAR */
+#define XF86XK_ChannelUp		_EVDEVK(0x192)		/*       KEY_CHANNELUP */
+#define XF86XK_ChannelDown		_EVDEVK(0x193)		/*       KEY_CHANNELDOWN */
+/* Use: XF86XK_AudioRandomPlay		_EVDEVK(0x19A)		         KEY_SHUFFLE */
+#define XF86XK_Break			_EVDEVK(0x19B)		/*       KEY_BREAK */
+#define XF86XK_VideoPhone		_EVDEVK(0x1A0)		/* v2.6.20 KEY_VIDEOPHONE */
+/* Use: XF86XK_Game			_EVDEVK(0x1A1)		   v2.6.20 KEY_GAMES */
+/* Use: XF86XK_ZoomIn			_EVDEVK(0x1A2)		   v2.6.20 KEY_ZOOMIN */
+/* Use: XF86XK_ZoomOut			_EVDEVK(0x1A3)		   v2.6.20 KEY_ZOOMOUT */
+#define XF86XK_ZoomReset		_EVDEVK(0x1A4)		/* v2.6.20 KEY_ZOOMRESET */
+/* Use: XF86XK_Word			_EVDEVK(0x1A5)		   v2.6.20 KEY_WORDPROCESSOR */
+#define XF86XK_Editor			_EVDEVK(0x1A6)		/* v2.6.20 KEY_EDITOR */
+/* Use: XF86XK_Excel			_EVDEVK(0x1A7)		   v2.6.20 KEY_SPREADSHEET */
+#define XF86XK_GraphicsEditor		_EVDEVK(0x1A8)		/* v2.6.20 KEY_GRAPHICSEDITOR */
+#define XF86XK_Presentation		_EVDEVK(0x1A9)		/* v2.6.20 KEY_PRESENTATION */
+#define XF86XK_Database			_EVDEVK(0x1AA)		/* v2.6.20 KEY_DATABASE */
+/* Use: XF86XK_News			_EVDEVK(0x1AB)		   v2.6.20 KEY_NEWS */
+#define XF86XK_Voicemail		_EVDEVK(0x1AC)		/* v2.6.20 KEY_VOICEMAIL */
+#define XF86XK_Addressbook		_EVDEVK(0x1AD)		/* v2.6.20 KEY_ADDRESSBOOK */
+/* Use: XF86XK_Messenger		_EVDEVK(0x1AE)		   v2.6.20 KEY_MESSENGER */
+#define XF86XK_DisplayToggle		_EVDEVK(0x1AF)		/* v2.6.20 KEY_DISPLAYTOGGLE */
+#define XF86XK_SpellCheck		_EVDEVK(0x1B0)		/* v2.6.24 KEY_SPELLCHECK */
+/* Use: XF86XK_LogOff			_EVDEVK(0x1B1)		   v2.6.24 KEY_LOGOFF */
+/* Use: XK_dollar			_EVDEVK(0x1B2)		   v2.6.24 KEY_DOLLAR */
+/* Use: XK_EuroSign			_EVDEVK(0x1B3)		   v2.6.24 KEY_EURO */
+/* Use: XF86XK_FrameBack		_EVDEVK(0x1B4)		   v2.6.24 KEY_FRAMEBACK */
+/* Use: XF86XK_FrameForward		_EVDEVK(0x1B5)		   v2.6.24 KEY_FRAMEFORWARD */
+#define XF86XK_ContextMenu		_EVDEVK(0x1B6)		/* v2.6.24 KEY_CONTEXT_MENU */
+#define XF86XK_MediaRepeat		_EVDEVK(0x1B7)		/* v2.6.26 KEY_MEDIA_REPEAT */
+#define XF86XK_10ChannelsUp		_EVDEVK(0x1B8)		/* v2.6.38 KEY_10CHANNELSUP */
+#define XF86XK_10ChannelsDown		_EVDEVK(0x1B9)		/* v2.6.38 KEY_10CHANNELSDOWN */
+#define XF86XK_Images			_EVDEVK(0x1BA)		/* v2.6.39 KEY_IMAGES */
+#define XF86XK_NotificationCenter	_EVDEVK(0x1BC)		/* v5.10 KEY_NOTIFICATION_CENTER */
+#define XF86XK_PickupPhone		_EVDEVK(0x1BD)		/* v5.10 KEY_PICKUP_PHONE */
+#define XF86XK_HangupPhone		_EVDEVK(0x1BE)		/* v5.10 KEY_HANGUP_PHONE */
+#define XF86XK_Fn			_EVDEVK(0x1D0)		/*       KEY_FN */
+#define XF86XK_Fn_Esc			_EVDEVK(0x1D1)		/*       KEY_FN_ESC */
+#define XF86XK_FnRightShift		_EVDEVK(0x1E5)		/* v5.10 KEY_FN_RIGHT_SHIFT */
+/* Use: XK_braille_dot_1		_EVDEVK(0x1F1)		   v2.6.17 KEY_BRL_DOT1 */
+/* Use: XK_braille_dot_2		_EVDEVK(0x1F2)		   v2.6.17 KEY_BRL_DOT2 */
+/* Use: XK_braille_dot_3		_EVDEVK(0x1F3)		   v2.6.17 KEY_BRL_DOT3 */
+/* Use: XK_braille_dot_4		_EVDEVK(0x1F4)		   v2.6.17 KEY_BRL_DOT4 */
+/* Use: XK_braille_dot_5		_EVDEVK(0x1F5)		   v2.6.17 KEY_BRL_DOT5 */
+/* Use: XK_braille_dot_6		_EVDEVK(0x1F6)		   v2.6.17 KEY_BRL_DOT6 */
+/* Use: XK_braille_dot_7		_EVDEVK(0x1F7)		   v2.6.17 KEY_BRL_DOT7 */
+/* Use: XK_braille_dot_8		_EVDEVK(0x1F8)		   v2.6.17 KEY_BRL_DOT8 */
+/* Use: XK_braille_dot_9		_EVDEVK(0x1F9)		   v2.6.23 KEY_BRL_DOT9 */
+/* Use: XK_braille_dot_1		_EVDEVK(0x1FA)		   v2.6.23 KEY_BRL_DOT10 */
+#define XF86XK_Numeric0			_EVDEVK(0x200)		/* v2.6.28 KEY_NUMERIC_0 */
+#define XF86XK_Numeric1			_EVDEVK(0x201)		/* v2.6.28 KEY_NUMERIC_1 */
+#define XF86XK_Numeric2			_EVDEVK(0x202)		/* v2.6.28 KEY_NUMERIC_2 */
+#define XF86XK_Numeric3			_EVDEVK(0x203)		/* v2.6.28 KEY_NUMERIC_3 */
+#define XF86XK_Numeric4			_EVDEVK(0x204)		/* v2.6.28 KEY_NUMERIC_4 */
+#define XF86XK_Numeric5			_EVDEVK(0x205)		/* v2.6.28 KEY_NUMERIC_5 */
+#define XF86XK_Numeric6			_EVDEVK(0x206)		/* v2.6.28 KEY_NUMERIC_6 */
+#define XF86XK_Numeric7			_EVDEVK(0x207)		/* v2.6.28 KEY_NUMERIC_7 */
+#define XF86XK_Numeric8			_EVDEVK(0x208)		/* v2.6.28 KEY_NUMERIC_8 */
+#define XF86XK_Numeric9			_EVDEVK(0x209)		/* v2.6.28 KEY_NUMERIC_9 */
+#define XF86XK_NumericStar		_EVDEVK(0x20A)		/* v2.6.28 KEY_NUMERIC_STAR */
+#define XF86XK_NumericPound		_EVDEVK(0x20B)		/* v2.6.28 KEY_NUMERIC_POUND */
+#define XF86XK_NumericA			_EVDEVK(0x20C)		/* v4.1  KEY_NUMERIC_A */
+#define XF86XK_NumericB			_EVDEVK(0x20D)		/* v4.1  KEY_NUMERIC_B */
+#define XF86XK_NumericC			_EVDEVK(0x20E)		/* v4.1  KEY_NUMERIC_C */
+#define XF86XK_NumericD			_EVDEVK(0x20F)		/* v4.1  KEY_NUMERIC_D */
+#define XF86XK_CameraFocus		_EVDEVK(0x210)		/* v2.6.33 KEY_CAMERA_FOCUS */
+#define XF86XK_WPSButton		_EVDEVK(0x211)		/* v2.6.34 KEY_WPS_BUTTON */
+/* Use: XF86XK_TouchpadToggle		_EVDEVK(0x212)		   v2.6.37 KEY_TOUCHPAD_TOGGLE */
+/* Use: XF86XK_TouchpadOn		_EVDEVK(0x213)		   v2.6.37 KEY_TOUCHPAD_ON */
+/* Use: XF86XK_TouchpadOff		_EVDEVK(0x214)		   v2.6.37 KEY_TOUCHPAD_OFF */
+#define XF86XK_CameraZoomIn		_EVDEVK(0x215)		/* v2.6.39 KEY_CAMERA_ZOOMIN */
+#define XF86XK_CameraZoomOut		_EVDEVK(0x216)		/* v2.6.39 KEY_CAMERA_ZOOMOUT */
+#define XF86XK_CameraUp			_EVDEVK(0x217)		/* v2.6.39 KEY_CAMERA_UP */
+#define XF86XK_CameraDown		_EVDEVK(0x218)		/* v2.6.39 KEY_CAMERA_DOWN */
+#define XF86XK_CameraLeft		_EVDEVK(0x219)		/* v2.6.39 KEY_CAMERA_LEFT */
+#define XF86XK_CameraRight		_EVDEVK(0x21A)		/* v2.6.39 KEY_CAMERA_RIGHT */
+#define XF86XK_AttendantOn		_EVDEVK(0x21B)		/* v3.10 KEY_ATTENDANT_ON */
+#define XF86XK_AttendantOff		_EVDEVK(0x21C)		/* v3.10 KEY_ATTENDANT_OFF */
+#define XF86XK_AttendantToggle		_EVDEVK(0x21D)		/* v3.10 KEY_ATTENDANT_TOGGLE */
+#define XF86XK_LightsToggle		_EVDEVK(0x21E)		/* v3.10 KEY_LIGHTS_TOGGLE */
+#define XF86XK_ALSToggle		_EVDEVK(0x230)		/* v3.13 KEY_ALS_TOGGLE */
+/* Use: XF86XK_RotationLockToggle	_EVDEVK(0x231)		   v4.16 KEY_ROTATE_LOCK_TOGGLE */
+#define XF86XK_Buttonconfig		_EVDEVK(0x240)		/* v3.16 KEY_BUTTONCONFIG */
+#define XF86XK_Taskmanager		_EVDEVK(0x241)		/* v3.16 KEY_TASKMANAGER */
+#define XF86XK_Journal			_EVDEVK(0x242)		/* v3.16 KEY_JOURNAL */
+#define XF86XK_ControlPanel		_EVDEVK(0x243)		/* v3.16 KEY_CONTROLPANEL */
+#define XF86XK_AppSelect		_EVDEVK(0x244)		/* v3.16 KEY_APPSELECT */
+#define XF86XK_Screensaver		_EVDEVK(0x245)		/* v3.16 KEY_SCREENSAVER */
+#define XF86XK_VoiceCommand		_EVDEVK(0x246)		/* v3.16 KEY_VOICECOMMAND */
+#define XF86XK_Assistant		_EVDEVK(0x247)		/* v4.13 KEY_ASSISTANT */
+/* Use: XK_ISO_Next_Group		_EVDEVK(0x248)		   v5.2  KEY_KBD_LAYOUT_NEXT */
+#define XF86XK_EmojiPicker		_EVDEVK(0x249)		/* v5.13 KEY_EMOJI_PICKER */
+#define XF86XK_Dictate			_EVDEVK(0x24A)		/* v5.17 KEY_DICTATE */
+#define XF86XK_BrightnessMin		_EVDEVK(0x250)		/* v3.16 KEY_BRIGHTNESS_MIN */
+#define XF86XK_BrightnessMax		_EVDEVK(0x251)		/* v3.16 KEY_BRIGHTNESS_MAX */
+#define XF86XK_KbdInputAssistPrev	_EVDEVK(0x260)		/* v3.18 KEY_KBDINPUTASSIST_PREV */
+#define XF86XK_KbdInputAssistNext	_EVDEVK(0x261)		/* v3.18 KEY_KBDINPUTASSIST_NEXT */
+#define XF86XK_KbdInputAssistPrevgroup	_EVDEVK(0x262)		/* v3.18 KEY_KBDINPUTASSIST_PREVGROUP */
+#define XF86XK_KbdInputAssistNextgroup	_EVDEVK(0x263)		/* v3.18 KEY_KBDINPUTASSIST_NEXTGROUP */
+#define XF86XK_KbdInputAssistAccept	_EVDEVK(0x264)		/* v3.18 KEY_KBDINPUTASSIST_ACCEPT */
+#define XF86XK_KbdInputAssistCancel	_EVDEVK(0x265)		/* v3.18 KEY_KBDINPUTASSIST_CANCEL */
+#define XF86XK_RightUp			_EVDEVK(0x266)		/* v4.7  KEY_RIGHT_UP */
+#define XF86XK_RightDown		_EVDEVK(0x267)		/* v4.7  KEY_RIGHT_DOWN */
+#define XF86XK_LeftUp			_EVDEVK(0x268)		/* v4.7  KEY_LEFT_UP */
+#define XF86XK_LeftDown			_EVDEVK(0x269)		/* v4.7  KEY_LEFT_DOWN */
+#define XF86XK_RootMenu			_EVDEVK(0x26A)		/* v4.7  KEY_ROOT_MENU */
+#define XF86XK_MediaTopMenu		_EVDEVK(0x26B)		/* v4.7  KEY_MEDIA_TOP_MENU */
+#define XF86XK_Numeric11		_EVDEVK(0x26C)		/* v4.7  KEY_NUMERIC_11 */
+#define XF86XK_Numeric12		_EVDEVK(0x26D)		/* v4.7  KEY_NUMERIC_12 */
+#define XF86XK_AudioDesc		_EVDEVK(0x26E)		/* v4.7  KEY_AUDIO_DESC */
+#define XF86XK_3DMode			_EVDEVK(0x26F)		/* v4.7  KEY_3D_MODE */
+#define XF86XK_NextFavorite		_EVDEVK(0x270)		/* v4.7  KEY_NEXT_FAVORITE */
+#define XF86XK_StopRecord		_EVDEVK(0x271)		/* v4.7  KEY_STOP_RECORD */
+#define XF86XK_PauseRecord		_EVDEVK(0x272)		/* v4.7  KEY_PAUSE_RECORD */
+#define XF86XK_VOD			_EVDEVK(0x273)		/* v4.7  KEY_VOD */
+#define XF86XK_Unmute			_EVDEVK(0x274)		/* v4.7  KEY_UNMUTE */
+#define XF86XK_FastReverse		_EVDEVK(0x275)		/* v4.7  KEY_FASTREVERSE */
+#define XF86XK_SlowReverse		_EVDEVK(0x276)		/* v4.7  KEY_SLOWREVERSE */
+#define XF86XK_Data			_EVDEVK(0x277)		/* v4.7  KEY_DATA */
+#define XF86XK_OnScreenKeyboard		_EVDEVK(0x278)		/* v4.12 KEY_ONSCREEN_KEYBOARD */
+#define XF86XK_PrivacyScreenToggle	_EVDEVK(0x279)		/* v5.5  KEY_PRIVACY_SCREEN_TOGGLE */
+#define XF86XK_SelectiveScreenshot	_EVDEVK(0x27A)		/* v5.6  KEY_SELECTIVE_SCREENSHOT */
+#define XF86XK_Macro1			_EVDEVK(0x290)		/* v5.5  KEY_MACRO1 */
+#define XF86XK_Macro2			_EVDEVK(0x291)		/* v5.5  KEY_MACRO2 */
+#define XF86XK_Macro3			_EVDEVK(0x292)		/* v5.5  KEY_MACRO3 */
+#define XF86XK_Macro4			_EVDEVK(0x293)		/* v5.5  KEY_MACRO4 */
+#define XF86XK_Macro5			_EVDEVK(0x294)		/* v5.5  KEY_MACRO5 */
+#define XF86XK_Macro6			_EVDEVK(0x295)		/* v5.5  KEY_MACRO6 */
+#define XF86XK_Macro7			_EVDEVK(0x296)		/* v5.5  KEY_MACRO7 */
+#define XF86XK_Macro8			_EVDEVK(0x297)		/* v5.5  KEY_MACRO8 */
+#define XF86XK_Macro9			_EVDEVK(0x298)		/* v5.5  KEY_MACRO9 */
+#define XF86XK_Macro10			_EVDEVK(0x299)		/* v5.5  KEY_MACRO10 */
+#define XF86XK_Macro11			_EVDEVK(0x29A)		/* v5.5  KEY_MACRO11 */
+#define XF86XK_Macro12			_EVDEVK(0x29B)		/* v5.5  KEY_MACRO12 */
+#define XF86XK_Macro13			_EVDEVK(0x29C)		/* v5.5  KEY_MACRO13 */
+#define XF86XK_Macro14			_EVDEVK(0x29D)		/* v5.5  KEY_MACRO14 */
+#define XF86XK_Macro15			_EVDEVK(0x29E)		/* v5.5  KEY_MACRO15 */
+#define XF86XK_Macro16			_EVDEVK(0x29F)		/* v5.5  KEY_MACRO16 */
+#define XF86XK_Macro17			_EVDEVK(0x2A0)		/* v5.5  KEY_MACRO17 */
+#define XF86XK_Macro18			_EVDEVK(0x2A1)		/* v5.5  KEY_MACRO18 */
+#define XF86XK_Macro19			_EVDEVK(0x2A2)		/* v5.5  KEY_MACRO19 */
+#define XF86XK_Macro20			_EVDEVK(0x2A3)		/* v5.5  KEY_MACRO20 */
+#define XF86XK_Macro21			_EVDEVK(0x2A4)		/* v5.5  KEY_MACRO21 */
+#define XF86XK_Macro22			_EVDEVK(0x2A5)		/* v5.5  KEY_MACRO22 */
+#define XF86XK_Macro23			_EVDEVK(0x2A6)		/* v5.5  KEY_MACRO23 */
+#define XF86XK_Macro24			_EVDEVK(0x2A7)		/* v5.5  KEY_MACRO24 */
+#define XF86XK_Macro25			_EVDEVK(0x2A8)		/* v5.5  KEY_MACRO25 */
+#define XF86XK_Macro26			_EVDEVK(0x2A9)		/* v5.5  KEY_MACRO26 */
+#define XF86XK_Macro27			_EVDEVK(0x2AA)		/* v5.5  KEY_MACRO27 */
+#define XF86XK_Macro28			_EVDEVK(0x2AB)		/* v5.5  KEY_MACRO28 */
+#define XF86XK_Macro29			_EVDEVK(0x2AC)		/* v5.5  KEY_MACRO29 */
+#define XF86XK_Macro30			_EVDEVK(0x2AD)		/* v5.5  KEY_MACRO30 */
+#define XF86XK_MacroRecordStart		_EVDEVK(0x2B0)		/* v5.5  KEY_MACRO_RECORD_START */
+#define XF86XK_MacroRecordStop		_EVDEVK(0x2B1)		/* v5.5  KEY_MACRO_RECORD_STOP */
+#define XF86XK_MacroPresetCycle		_EVDEVK(0x2B2)		/* v5.5  KEY_MACRO_PRESET_CYCLE */
+#define XF86XK_MacroPreset1		_EVDEVK(0x2B3)		/* v5.5  KEY_MACRO_PRESET1 */
+#define XF86XK_MacroPreset2		_EVDEVK(0x2B4)		/* v5.5  KEY_MACRO_PRESET2 */
+#define XF86XK_MacroPreset3		_EVDEVK(0x2B5)		/* v5.5  KEY_MACRO_PRESET3 */
+#define XF86XK_KbdLcdMenu1		_EVDEVK(0x2B8)		/* v5.5  KEY_KBD_LCD_MENU1 */
+#define XF86XK_KbdLcdMenu2		_EVDEVK(0x2B9)		/* v5.5  KEY_KBD_LCD_MENU2 */
+#define XF86XK_KbdLcdMenu3		_EVDEVK(0x2BA)		/* v5.5  KEY_KBD_LCD_MENU3 */
+#define XF86XK_KbdLcdMenu4		_EVDEVK(0x2BB)		/* v5.5  KEY_KBD_LCD_MENU4 */
+#define XF86XK_KbdLcdMenu5		_EVDEVK(0x2BC)		/* v5.5  KEY_KBD_LCD_MENU5 */
+#undef _EVDEVK
diff --git a/depends/libxcb/depends/xorgproto/include/X11/XWDFile.h b/depends/libxcb/depends/xorgproto/include/X11/XWDFile.h
new file mode 100644
index 0000000..3d0ab89
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/XWDFile.h
@@ -0,0 +1,113 @@
+/*
+
+Copyright 1985, 1986, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+/*
+ * XWDFile.h	MIT Project Athena, X Window system window raster
+ *		image dumper, dump file format header file.
+ *
+ *  Author:	Tony Della Fera, DEC
+ *		27-Jun-85
+ *
+ * Modifier:    William F. Wyatt, SAO
+ *              18-Nov-86  - version 6 for saving/restoring color maps
+ */
+
+#ifndef XWDFILE_H
+#define XWDFILE_H
+
+#include <X11/Xmd.h>
+
+#define XWD_FILE_VERSION 7
+#define sz_XWDheader 100
+#define sz_XWDColor 12
+
+typedef CARD32 xwdval;		/* for old broken programs */
+
+/* Values in the file are most significant byte first. */
+
+typedef struct _xwd_file_header {
+	/* header_size = SIZEOF(XWDheader) + length of null-terminated
+	 * window name. */
+	CARD32 header_size;
+
+	CARD32 file_version;		/* = XWD_FILE_VERSION above */
+	CARD32 pixmap_format;		/* ZPixmap or XYPixmap */
+	CARD32 pixmap_depth;		/* Pixmap depth */
+	CARD32 pixmap_width;		/* Pixmap width */
+	CARD32 pixmap_height;		/* Pixmap height */
+	CARD32 xoffset;			/* Bitmap x offset, normally 0 */
+	CARD32 byte_order;		/* of image data: MSBFirst, LSBFirst */
+
+	/* bitmap_unit applies to bitmaps (depth 1 format XY) only.
+	 * It is the number of bits that each scanline is padded to. */
+	CARD32 bitmap_unit;
+
+	CARD32 bitmap_bit_order;	/* bitmaps only: MSBFirst, LSBFirst */
+
+	/* bitmap_pad applies to pixmaps (non-bitmaps) only.
+	 * It is the number of bits that each scanline is padded to. */
+	CARD32 bitmap_pad;
+
+	CARD32 bits_per_pixel;		/* Bits per pixel */
+
+	/* bytes_per_line is pixmap_width padded to bitmap_unit (bitmaps)
+	 * or bitmap_pad (pixmaps).  It is the delta (in bytes) to get
+	 * to the same x position on an adjacent row. */
+	CARD32 bytes_per_line;
+	CARD32 visual_class;		/* Class of colormap */
+	CARD32 red_mask;		/* Z red mask */
+	CARD32 green_mask;		/* Z green mask */
+	CARD32 blue_mask;		/* Z blue mask */
+	CARD32 bits_per_rgb;		/* Log2 of distinct color values */
+	CARD32 colormap_entries;	/* Number of entries in colormap; not used? */
+	CARD32 ncolors;			/* Number of XWDColor structures */
+	CARD32 window_width;		/* Window width */
+	CARD32 window_height;		/* Window height */
+	CARD32 window_x;		/* Window upper left X coordinate */
+	CARD32 window_y;		/* Window upper left Y coordinate */
+	CARD32 window_bdrwidth;		/* Window border width */
+} XWDFileHeader;
+
+/* Null-terminated window name follows the above structure. */
+
+/* Next comes XWDColor structures, at offset XWDFileHeader.header_size in
+ * the file.  XWDFileHeader.ncolors tells how many XWDColor structures
+ * there are.
+ */
+
+typedef struct {
+        CARD32	pixel;
+        CARD16	red;
+        CARD16	green;
+        CARD16	blue;
+        CARD8	flags;
+        CARD8	pad;
+} XWDColor;
+
+/* Last comes the image data in the format described by XWDFileHeader. */
+
+#endif /* XWDFILE_H */
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/Xalloca.h b/depends/libxcb/depends/xorgproto/include/X11/Xalloca.h
new file mode 100644
index 0000000..687f5a4
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/Xalloca.h
@@ -0,0 +1,121 @@
+/*
+
+Copyright 1995, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+/*
+ * The purpose of this header is to define the macros ALLOCATE_LOCAL and
+ * DEALLOCATE_LOCAL appropriately for the platform being compiled on.
+ * These macros are used to make fast, function-local memory allocations.
+ * Their characteristics are as follows:
+ *
+ * void *ALLOCATE_LOCAL(size_t size)
+ *    Returns a pointer to size bytes of memory, or NULL if the allocation
+ *    failed.  The memory must be freed with DEALLOCATE_LOCAL before the
+ *    function that made the allocation returns.  You should not ask for
+ *    large blocks of memory with this function, since on many platforms
+ *    the memory comes from the stack, which may have limited size.
+ *
+ * void DEALLOCATE_LOCAL(void *)
+ *    Frees the memory allocated by ALLOCATE_LOCAL.  Omission of this
+ *    step may be harmless on some platforms, but will result in
+ *    memory leaks or worse on others.
+ *
+ * Before including this file, you should define two macros,
+ * ALLOCATE_LOCAL_FALLBACK and DEALLOCATE_LOCAL_FALLBACK, that have the
+ * same characteristics as ALLOCATE_LOCAL and DEALLOCATE_LOCAL.  The
+ * header uses the fallbacks if it doesn't know a "better" way to define
+ * ALLOCATE_LOCAL and DEALLOCATE_LOCAL.  Typical usage would be:
+ *
+ *    #define ALLOCATE_LOCAL_FALLBACK(_size) malloc(_size)
+ *    #define DEALLOCATE_LOCAL_FALLBACK(_ptr) free(_ptr)
+ *    #include "Xalloca.h"
+ */
+
+#ifndef XALLOCA_H
+#define XALLOCA_H 1
+
+#ifndef INCLUDE_ALLOCA_H
+/* Need to add more here to match Imake *.cf's */
+# if defined(HAVE_ALLOCA_H) || defined(__SUNPRO_C) || defined(__SUNPRO_CC)
+#  define INCLUDE_ALLOCA_H
+# endif
+#endif
+
+#ifdef INCLUDE_ALLOCA_H
+#  include <alloca.h>
+#endif
+
+#ifndef NO_ALLOCA
+/*
+ * os-dependent definition of local allocation and deallocation
+ * If you want something other than (DE)ALLOCATE_LOCAL_FALLBACK
+ * for ALLOCATE/DEALLOCATE_LOCAL then you add that in here.
+ */
+
+
+#  ifdef __GNUC__
+#    ifndef alloca
+#      define alloca __builtin_alloca
+#    endif /* !alloca */
+#    define ALLOCATE_LOCAL(size) alloca((size_t)(size))
+#  else /* ! __GNUC__ */
+
+/*
+ * warning: old mips alloca (pre 2.10) is unusable, new one is built in
+ * Test is easy, the new one is named __builtin_alloca and comes
+ * from alloca.h which #defines alloca.
+ */
+#      if defined(__sun) || defined(alloca)
+/*
+ * Some System V boxes extract alloca.o from /lib/libPW.a; if you
+ * decide that you don't want to use alloca, you might want to fix it here.
+ */
+/* alloca might be a macro taking one arg (hi, Sun!), so give it one. */
+#        if !defined(__cplusplus)
+#          define __Xnullarg		/* as nothing */
+           extern void *alloca(__Xnullarg);
+#        endif
+#        define ALLOCATE_LOCAL(size) alloca((size_t)(size))
+#      endif /* who does alloca */
+#  endif /* __GNUC__ */
+
+#endif /* NO_ALLOCA */
+
+#if !defined(ALLOCATE_LOCAL)
+#  if defined(ALLOCATE_LOCAL_FALLBACK) && defined(DEALLOCATE_LOCAL_FALLBACK)
+#    define ALLOCATE_LOCAL(_size)  ALLOCATE_LOCAL_FALLBACK(_size)
+#    define DEALLOCATE_LOCAL(_ptr) DEALLOCATE_LOCAL_FALLBACK(_ptr)
+#  else /* no fallbacks supplied; error */
+#    define ALLOCATE_LOCAL(_size)  ALLOCATE_LOCAL_FALLBACK undefined!
+#    define DEALLOCATE_LOCAL(_ptr) DEALLOCATE_LOCAL_FALLBACK undefined!
+#  endif /* defined(ALLOCATE_LOCAL_FALLBACK && DEALLOCATE_LOCAL_FALLBACK) */
+#else
+#  if !defined(DEALLOCATE_LOCAL)
+#    define DEALLOCATE_LOCAL(_ptr) do {} while(0)
+#  endif
+#endif /* defined(ALLOCATE_LOCAL) */
+
+#endif /* XALLOCA_H */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/Xarch.h b/depends/libxcb/depends/xorgproto/include/X11/Xarch.h
new file mode 100644
index 0000000..f80c580
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/Xarch.h
@@ -0,0 +1,94 @@
+#ifndef _XARCH_H_
+# define _XARCH_H_
+
+/*
+ * Copyright 1997 Metro Link Incorporated
+ *
+ *                           All Rights Reserved
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the names of the above listed copyright holder(s)
+ * not be used in advertising or publicity pertaining to distribution of
+ * the software without specific, written prior permission.  The above listed
+ * copyright holder(s) make(s) no representations about the suitability of
+ * this software for any purpose.  It is provided "as is" without express or
+ * implied warranty.
+ *
+ * THE ABOVE LISTED COPYRIGHT HOLDER(S) DISCLAIM(S) ALL WARRANTIES WITH REGARD
+ * TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS, IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT HOLDER(S) BE
+ * LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
+ * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+
+/*
+ * Determine the machine's byte order.
+ */
+
+/* See if it is set in the imake config first */
+# ifdef X_BYTE_ORDER
+
+#  define X_BIG_ENDIAN 4321
+#  define X_LITTLE_ENDIAN 1234
+
+# else
+
+#  if defined(SVR4) || defined(__SVR4)
+#   include <sys/types.h>
+#   include <sys/byteorder.h>
+#  elif defined(CSRG_BASED)
+#   if defined(__NetBSD__) || defined(__OpenBSD__)
+#    include <sys/types.h>
+#   endif
+#   include <machine/endian.h>
+#  elif defined(linux)
+#   if defined __STRICT_ANSI__
+#    undef __STRICT_ANSI__
+#    include <endian.h>
+#    define __STRICT_ANSI__
+#   else
+#    include <endian.h>
+#   endif
+/* 'endian.h' might have been included before 'Xarch.h' */
+#   if !defined(LITTLE_ENDIAN) && defined(__LITTLE_ENDIAN)
+#    define LITTLE_ENDIAN __LITTLE_ENDIAN
+#   endif
+#   if !defined(BIG_ENDIAN) && defined(__BIG_ENDIAN)
+#    define BIG_ENDIAN __BIG_ENDIAN
+#   endif
+#   if !defined(PDP_ENDIAN) && defined(__PDP_ENDIAN)
+#    define PDP_ENDIAN __PDP_ENDIAN
+#   endif
+#   if !defined(BYTE_ORDER) && defined(__BYTE_ORDER)
+#    define BYTE_ORDER __BYTE_ORDER
+#   endif
+#  endif
+
+#  ifndef BYTE_ORDER
+#   define LITTLE_ENDIAN 1234
+#   define BIG_ENDIAN    4321
+
+#   if defined(__sun) && defined(__SVR4)
+#    include <sys/isa_defs.h>
+#    ifdef _LITTLE_ENDIAN
+#     define BYTE_ORDER LITTLE_ENDIAN
+#    endif
+#    ifdef _BIG_ENDIAN
+#     define BYTE_ORDER BIG_ENDIAN
+#    endif
+#   endif /* sun */
+#  endif /* BYTE_ORDER */
+
+#  define X_BYTE_ORDER BYTE_ORDER
+#  define X_BIG_ENDIAN BIG_ENDIAN
+#  define X_LITTLE_ENDIAN LITTLE_ENDIAN
+
+# endif /* not in imake config */
+
+#endif /* _XARCH_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/Xatom.h b/depends/libxcb/depends/xorgproto/include/X11/Xatom.h
new file mode 100644
index 0000000..485a423
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/Xatom.h
@@ -0,0 +1,79 @@
+#ifndef XATOM_H
+#define XATOM_H 1
+
+/* THIS IS A GENERATED FILE
+ *
+ * Do not change!  Changing this file implies a protocol change!
+ */
+
+#define XA_PRIMARY ((Atom) 1)
+#define XA_SECONDARY ((Atom) 2)
+#define XA_ARC ((Atom) 3)
+#define XA_ATOM ((Atom) 4)
+#define XA_BITMAP ((Atom) 5)
+#define XA_CARDINAL ((Atom) 6)
+#define XA_COLORMAP ((Atom) 7)
+#define XA_CURSOR ((Atom) 8)
+#define XA_CUT_BUFFER0 ((Atom) 9)
+#define XA_CUT_BUFFER1 ((Atom) 10)
+#define XA_CUT_BUFFER2 ((Atom) 11)
+#define XA_CUT_BUFFER3 ((Atom) 12)
+#define XA_CUT_BUFFER4 ((Atom) 13)
+#define XA_CUT_BUFFER5 ((Atom) 14)
+#define XA_CUT_BUFFER6 ((Atom) 15)
+#define XA_CUT_BUFFER7 ((Atom) 16)
+#define XA_DRAWABLE ((Atom) 17)
+#define XA_FONT ((Atom) 18)
+#define XA_INTEGER ((Atom) 19)
+#define XA_PIXMAP ((Atom) 20)
+#define XA_POINT ((Atom) 21)
+#define XA_RECTANGLE ((Atom) 22)
+#define XA_RESOURCE_MANAGER ((Atom) 23)
+#define XA_RGB_COLOR_MAP ((Atom) 24)
+#define XA_RGB_BEST_MAP ((Atom) 25)
+#define XA_RGB_BLUE_MAP ((Atom) 26)
+#define XA_RGB_DEFAULT_MAP ((Atom) 27)
+#define XA_RGB_GRAY_MAP ((Atom) 28)
+#define XA_RGB_GREEN_MAP ((Atom) 29)
+#define XA_RGB_RED_MAP ((Atom) 30)
+#define XA_STRING ((Atom) 31)
+#define XA_VISUALID ((Atom) 32)
+#define XA_WINDOW ((Atom) 33)
+#define XA_WM_COMMAND ((Atom) 34)
+#define XA_WM_HINTS ((Atom) 35)
+#define XA_WM_CLIENT_MACHINE ((Atom) 36)
+#define XA_WM_ICON_NAME ((Atom) 37)
+#define XA_WM_ICON_SIZE ((Atom) 38)
+#define XA_WM_NAME ((Atom) 39)
+#define XA_WM_NORMAL_HINTS ((Atom) 40)
+#define XA_WM_SIZE_HINTS ((Atom) 41)
+#define XA_WM_ZOOM_HINTS ((Atom) 42)
+#define XA_MIN_SPACE ((Atom) 43)
+#define XA_NORM_SPACE ((Atom) 44)
+#define XA_MAX_SPACE ((Atom) 45)
+#define XA_END_SPACE ((Atom) 46)
+#define XA_SUPERSCRIPT_X ((Atom) 47)
+#define XA_SUPERSCRIPT_Y ((Atom) 48)
+#define XA_SUBSCRIPT_X ((Atom) 49)
+#define XA_SUBSCRIPT_Y ((Atom) 50)
+#define XA_UNDERLINE_POSITION ((Atom) 51)
+#define XA_UNDERLINE_THICKNESS ((Atom) 52)
+#define XA_STRIKEOUT_ASCENT ((Atom) 53)
+#define XA_STRIKEOUT_DESCENT ((Atom) 54)
+#define XA_ITALIC_ANGLE ((Atom) 55)
+#define XA_X_HEIGHT ((Atom) 56)
+#define XA_QUAD_WIDTH ((Atom) 57)
+#define XA_WEIGHT ((Atom) 58)
+#define XA_POINT_SIZE ((Atom) 59)
+#define XA_RESOLUTION ((Atom) 60)
+#define XA_COPYRIGHT ((Atom) 61)
+#define XA_NOTICE ((Atom) 62)
+#define XA_FONT_NAME ((Atom) 63)
+#define XA_FAMILY_NAME ((Atom) 64)
+#define XA_FULL_NAME ((Atom) 65)
+#define XA_CAP_HEIGHT ((Atom) 66)
+#define XA_WM_CLASS ((Atom) 67)
+#define XA_WM_TRANSIENT_FOR ((Atom) 68)
+
+#define XA_LAST_PREDEFINED ((Atom) 68)
+#endif /* XATOM_H */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/Xdefs.h b/depends/libxcb/depends/xorgproto/include/X11/Xdefs.h
new file mode 100644
index 0000000..f58946d
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/Xdefs.h
@@ -0,0 +1,108 @@
+/***********************************************************
+
+Copyright (c) 1999  The XFree86 Project Inc.
+
+All Rights Reserved.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The XFree86 Project
+Inc. shall not be used in advertising or otherwise to promote the
+sale, use or other dealings in this Software without prior written
+authorization from The XFree86 Project Inc..
+
+*/
+
+/**
+ ** Types definitions shared between server and clients
+ **/
+
+#ifndef _XDEFS_H
+#define _XDEFS_H
+
+#ifdef _XSERVER64
+#include <X11/Xmd.h>
+#endif
+
+#ifndef _XTYPEDEF_ATOM
+#  define _XTYPEDEF_ATOM
+#  ifndef _XSERVER64
+typedef unsigned long Atom;
+#  else
+typedef CARD32 Atom;
+#  endif
+#endif
+
+#ifndef Bool
+#  ifndef _XTYPEDEF_BOOL
+#   define _XTYPEDEF_BOOL
+typedef int Bool;
+#  endif
+#endif
+
+#ifndef _XTYPEDEF_POINTER
+#  define _XTYPEDEF_POINTER
+typedef void *pointer;
+#endif
+
+#ifndef _XTYPEDEF_CLIENTPTR
+typedef struct _Client *ClientPtr;
+#  define _XTYPEDEF_CLIENTPTR
+#endif
+
+#ifndef _XTYPEDEF_XID
+#  define _XTYPEDEF_XID
+#  ifndef _XSERVER64
+typedef unsigned long XID;
+#  else
+typedef CARD32 XID;
+#  endif
+#endif
+
+#ifndef _XTYPEDEF_MASK
+#  define _XTYPEDEF_MASK
+#  ifndef _XSERVER64
+typedef unsigned long Mask;
+#  else
+typedef CARD32 Mask;
+#  endif
+#endif
+
+#ifndef _XTYPEDEF_FONTPTR
+#  define _XTYPEDEF_FONTPTR
+typedef struct _Font *FontPtr; /* also in fonts/include/font.h */
+#endif
+
+#ifndef _XTYPEDEF_FONT
+#  define _XTYPEDEF_FONT
+typedef XID	Font;
+#endif
+
+#ifndef _XTYPEDEF_FSID
+#  ifndef _XSERVER64
+typedef unsigned long FSID;
+#  else
+typedef CARD32 FSID;
+#  endif
+#endif
+
+typedef FSID AccContext;
+
+/* OS independent time value
+   XXX Should probably go in Xos.h */
+typedef struct timeval **OSTimePtr;
+
+
+typedef void (* BlockHandlerProcPtr)(void * /* blockData */,
+				     OSTimePtr /* pTimeout */,
+				     void * /* pReadmask */);
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/Xfuncproto.h b/depends/libxcb/depends/xorgproto/include/X11/Xfuncproto.h
new file mode 100644
index 0000000..f78415e
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/Xfuncproto.h
@@ -0,0 +1,216 @@
+/*
+ *
+Copyright 1989, 1991, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ *
+ */
+
+/* Definitions to make function prototypes manageable */
+
+#ifndef _XFUNCPROTO_H_
+#define _XFUNCPROTO_H_
+
+#ifndef NeedFunctionPrototypes
+#define NeedFunctionPrototypes 1
+#endif /* NeedFunctionPrototypes */
+
+#ifndef NeedVarargsPrototypes
+#define NeedVarargsPrototypes 1
+#endif /* NeedVarargsPrototypes */
+
+#if NeedFunctionPrototypes
+
+#ifndef NeedNestedPrototypes
+#define NeedNestedPrototypes 1
+#endif /* NeedNestedPrototypes */
+
+#ifndef _Xconst
+#define _Xconst const
+#endif /* _Xconst */
+
+/* Function prototype configuration (see configure for more info) */
+#if !defined(NARROWPROTO) && \
+    (defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__))
+#define NARROWPROTO
+#endif
+#ifndef FUNCPROTO
+#define FUNCPROTO 15
+#endif
+
+#ifndef NeedWidePrototypes
+#ifdef NARROWPROTO
+#define NeedWidePrototypes 0
+#else
+#define NeedWidePrototypes 1		/* default to make interropt. easier */
+#endif
+#endif /* NeedWidePrototypes */
+
+#endif /* NeedFunctionPrototypes */
+
+#ifndef _XFUNCPROTOBEGIN
+#if defined(__cplusplus) || defined(c_plusplus) /* for C++ V2.0 */
+#define _XFUNCPROTOBEGIN extern "C" {	/* do not leave open across includes */
+#define _XFUNCPROTOEND }
+#else
+#define _XFUNCPROTOBEGIN
+#define _XFUNCPROTOEND
+#endif
+#endif /* _XFUNCPROTOBEGIN */
+
+/* http://clang.llvm.org/docs/LanguageExtensions.html#has-attribute */
+#ifndef __has_attribute
+# define __has_attribute(x) 0  /* Compatibility with non-clang compilers. */
+#endif
+#ifndef __has_feature
+# define __has_feature(x) 0    /* Compatibility with non-clang compilers. */
+#endif
+#ifndef __has_extension
+# define __has_extension(x) 0  /* Compatibility with non-clang compilers. */
+#endif
+
+/* Added in X11R6.9, so available in any version of modular xproto */
+#if __has_attribute(__sentinel__) || (defined(__GNUC__) && (__GNUC__ >= 4))
+# define _X_SENTINEL(x) __attribute__ ((__sentinel__(x)))
+#else
+# define _X_SENTINEL(x)
+#endif /* GNUC >= 4 */
+
+/* Added in X11R6.9, so available in any version of modular xproto */
+#if (__has_attribute(visibility) || (defined(__GNUC__) && (__GNUC__ >= 4))) \
+    && !defined(__CYGWIN__) && !defined(__MINGW32__)
+# define _X_EXPORT      __attribute__((visibility("default")))
+# define _X_HIDDEN      __attribute__((visibility("hidden")))
+# define _X_INTERNAL    __attribute__((visibility("internal")))
+#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550)
+# define _X_EXPORT      __global
+# define _X_HIDDEN      __hidden
+# define _X_INTERNAL    __hidden
+#else /* not gcc >= 4 and not Sun Studio >= 8 */
+# define _X_EXPORT
+# define _X_HIDDEN
+# define _X_INTERNAL
+#endif /* GNUC >= 4 */
+
+/* Branch prediction hints for individual conditionals */
+/* requires xproto >= 7.0.9 */
+#if defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 303)
+# define _X_LIKELY(x)   __builtin_expect(!!(x), 1)
+# define _X_UNLIKELY(x) __builtin_expect(!!(x), 0)
+#else /* not gcc >= 3.3 */
+# define _X_LIKELY(x)   (x)
+# define _X_UNLIKELY(x) (x)
+#endif
+
+/* Bulk branch prediction hints via marking error path functions as "cold" */
+/* requires xproto >= 7.0.25 */
+#if __has_attribute(__cold__) || \
+    (defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 403)) /* 4.3+ */
+# define _X_COLD __attribute__((__cold__))
+#else
+# define _X_COLD /* nothing */
+#endif
+
+/* Added in X11R6.9, so available in any version of modular xproto */
+#if __has_attribute(deprecated) \
+    || (defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 301)) \
+    || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x5130))
+# define _X_DEPRECATED  __attribute__((deprecated))
+#else /* not gcc >= 3.1 */
+# define _X_DEPRECATED
+#endif
+
+/* requires xproto >= 7.0.30 */
+#if __has_extension(attribute_deprecated_with_message) || \
+                (defined(__GNUC__) && ((__GNUC__ >= 5) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5))))
+# define _X_DEPRECATED_MSG(_msg) __attribute__((deprecated(_msg)))
+#else
+# define _X_DEPRECATED_MSG(_msg) _X_DEPRECATED
+#endif
+
+/* requires xproto >= 7.0.17 */
+#if __has_attribute(noreturn) \
+    || (defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 205)) \
+    || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590))
+# define _X_NORETURN __attribute((noreturn))
+#else
+# define _X_NORETURN
+#endif /* GNUC  */
+
+/* Added in X11R6.9, so available in any version of modular xproto */
+#if __has_attribute(__format__) \
+    || defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 203)
+# define _X_ATTRIBUTE_PRINTF(x,y) __attribute__((__format__(__printf__,x,y)))
+#else /* not gcc >= 2.3 */
+# define _X_ATTRIBUTE_PRINTF(x,y)
+#endif
+
+/* requires xproto >= 7.0.22 */
+#if __has_attribute(__unused__) \
+    || defined(__GNUC__) &&  ((__GNUC__ * 100 + __GNUC_MINOR__) >= 205)
+#define _X_UNUSED  __attribute__((__unused__))
+#else
+#define _X_UNUSED  /* */
+#endif
+
+/* C99 keyword "inline" or equivalent extensions in pre-C99 compilers */
+/* requires xproto >= 7.0.9
+   (introduced in 7.0.8 but didn't support all compilers until 7.0.9) */
+#if defined(inline) /* assume autoconf set it correctly */ || \
+   (defined(__STDC_VERSION__) && (__STDC_VERSION__ - 0 >= 199901L)) /* C99 */ || \
+   (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550))
+# define _X_INLINE inline
+#elif defined(__GNUC__) && !defined(__STRICT_ANSI__) /* gcc w/C89+extensions */
+# define _X_INLINE __inline__
+#else
+# define _X_INLINE
+#endif
+
+/* C99 keyword "restrict" or equivalent extensions in pre-C99 compilers */
+/* requires xproto >= 7.0.21 */
+#ifndef _X_RESTRICT_KYWD
+# if defined(restrict) /* assume autoconf set it correctly */ || \
+    (defined(__STDC_VERSION__) && (__STDC_VERSION__ - 0 >= 199901L) /* C99 */ \
+     && !defined(__cplusplus)) /* Workaround g++ issue on Solaris */
+#  define _X_RESTRICT_KYWD  restrict
+# elif defined(__GNUC__) && !defined(__STRICT_ANSI__) /* gcc w/C89+extensions */
+#  define _X_RESTRICT_KYWD __restrict__
+# else
+#  define _X_RESTRICT_KYWD
+# endif
+#endif
+
+/* requires xproto >= 7.0.30 */
+#if __has_attribute(no_sanitize_thread)
+# define _X_NOTSAN __attribute__((no_sanitize_thread))
+#else
+# define _X_NOTSAN
+#endif
+
+/* Mark a char array/pointer as not containing a NUL-terminated string */
+/* requires xproto >= 7.0.33 */
+#if __has_attribute(nonstring)
+# define _X_NONSTRING __attribute__((nonstring))
+#else
+# define _X_NONSTRING
+#endif
+
+#endif /* _XFUNCPROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/Xfuncs.h b/depends/libxcb/depends/xorgproto/include/X11/Xfuncs.h
new file mode 100644
index 0000000..b23c283
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/Xfuncs.h
@@ -0,0 +1,69 @@
+/*
+ *
+Copyright 1990, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ *
+ */
+
+#ifndef _XFUNCS_H_
+# define _XFUNCS_H_
+
+# include <X11/Xosdefs.h>
+
+/* the old Xfuncs.h, for pre-R6 */
+# if !(defined(XFree86LOADER) && defined(IN_MODULE))
+
+#  ifdef X_USEBFUNCS
+void bcopy();
+void bzero();
+int bcmp();
+#  else
+#   if defined(SYSV) && !defined(__SCO__) && !defined(__sun) && !defined(__UNIXWARE__) && !defined(_AIX)
+#    include <memory.h>
+void bcopy();
+#    define bzero(b,len) memset(b, 0, len)
+#    define bcmp(b1,b2,len) memcmp(b1, b2, len)
+#   else
+#    include <string.h>
+#    if defined(__SCO__) || defined(__sun) || defined(__UNIXWARE__) || defined(__CYGWIN__) || defined(_AIX) || defined(__APPLE__)
+#     include <strings.h>
+#    endif
+#    define _XFUNCS_H_INCLUDED_STRING_H
+#   endif
+#  endif /* X_USEBFUNCS */
+
+/* the new Xfuncs.h */
+
+/* the ANSI C way */
+#  ifndef _XFUNCS_H_INCLUDED_STRING_H
+#   include <string.h>
+#  endif
+#  undef bzero
+#  define bzero(b,len) memset(b,0,len)
+
+#  if defined WIN32 && defined __MINGW32__
+#   define bcopy(b1,b2,len) memmove(b2, b1, (size_t)(len))
+#  endif
+
+# endif /* !(defined(XFree86LOADER) && defined(IN_MODULE)) */
+
+#endif /* _XFUNCS_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/Xmd.h b/depends/libxcb/depends/xorgproto/include/X11/Xmd.h
new file mode 100644
index 0000000..68c45db
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/Xmd.h
@@ -0,0 +1,146 @@
+/***********************************************************
+
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+#ifndef XMD_H
+# define XMD_H 1
+/*
+ *  Xmd.h: MACHINE DEPENDENT DECLARATIONS.
+ */
+
+/*
+ * Special per-machine configuration flags.
+ */
+# if defined(__sun) && defined(__SVR4)
+#  include <sys/isa_defs.h> /* Solaris: defines _LP64 if necessary */
+# endif
+
+#if defined(__SIZEOF_LONG__)
+# if __SIZEOF_LONG__ == 8
+#  define LONG64				/* 32/64-bit architecture */
+# endif
+# elif defined (_LP64) || defined(__LP64__) || \
+     defined(__alpha) || defined(__alpha__) || \
+     defined(__ia64__) || defined(ia64) || \
+     defined(__sparc64__) || \
+     defined(__s390x__) || \
+     defined(__amd64__) || defined(amd64) || \
+     defined(__powerpc64__)
+#  if !defined(__ILP32__) /* amd64-x32 is 32bit */
+#   define LONG64				/* 32/64-bit architecture */
+#  endif /* !__ILP32__ */
+# endif
+
+/*
+ * Definition of macro used to set constants for size of network structures;
+ * machines with preprocessors that can't handle all of the sz_ symbols
+ * can define this macro to be sizeof(x) if and only if their compiler doesn't
+ * pad out structures (esp. the xTextElt structure which contains only two
+ * one-byte fields).  Network structures should always define sz_symbols.
+ *
+ * The sz_ prefix is used instead of something more descriptive so that the
+ * symbols are no more than 32 characters long (which causes problems for some
+ * compilers and preprocessors).
+ *
+ * The extra indirection is to get macro arguments to expand correctly before
+ * the concatenation, rather than afterward.
+ */
+# define _SIZEOF(x) sz_##x
+# define SIZEOF(x) _SIZEOF(x)
+
+/*
+ * Bitfield suffixes for the protocol structure elements, if you
+ * need them.  Note that bitfields are not guaranteed to be signed
+ * (or even unsigned) according to ANSI C.
+ */
+# define B32 /* bitfield not needed on architectures with native 32-bit type */
+# define B16 /* bitfield not needed on architectures with native 16-bit type */
+# ifdef LONG64
+typedef long INT64;
+typedef int INT32;
+# else
+typedef long INT32;
+# endif
+typedef short INT16;
+
+typedef signed char    INT8;
+
+# ifdef LONG64
+typedef unsigned long CARD64;
+typedef unsigned int CARD32;
+# else
+typedef unsigned long long CARD64;
+typedef unsigned long CARD32;
+# endif
+typedef unsigned short CARD16;
+typedef unsigned char  CARD8;
+
+typedef CARD32		BITS32;
+typedef CARD16		BITS16;
+
+typedef CARD8		BYTE;
+typedef CARD8		BOOL;
+
+/*
+ * was definitions for sign-extending bitfields on architectures without
+ * native types smaller than 64-bit, now just backwards compatibility
+ */
+# define cvtINT8toInt(val) (val)
+# define cvtINT16toInt(val) (val)
+# define cvtINT32toInt(val) (val)
+# define cvtINT8toShort(val) (val)
+# define cvtINT16toShort(val) (val)
+# define cvtINT32toShort(val) (val)
+# define cvtINT8toLong(val) (val)
+# define cvtINT16toLong(val) (val)
+# define cvtINT32toLong(val) (val)
+
+/*
+ * this version should leave result of type (t *), but that should only be
+ * used when not in MUSTCOPY
+ */
+# define NEXTPTR(p,t) (((t *)(p)) + 1)
+
+#endif /* XMD_H */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/Xos.h b/depends/libxcb/depends/xorgproto/include/X11/Xos.h
new file mode 100644
index 0000000..75cc5b7
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/Xos.h
@@ -0,0 +1,148 @@
+/*
+ *
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ *
+ * The X Window System is a Trademark of The Open Group.
+ *
+ */
+
+/* This is a collection of things to try and minimize system dependencies
+ * in a "significant" number of source files.
+ */
+
+#ifndef _XOS_H_
+# define _XOS_H_
+
+# include <X11/Xosdefs.h>
+
+/*
+ * Get major data types (esp. caddr_t)
+ */
+
+# include <sys/types.h>
+
+# if defined(__SCO__) || defined(__UNIXWARE__)
+#  include <stdint.h>
+# endif
+
+
+/*
+ * Just about everyone needs the strings routines.  We provide both forms here,
+ * index/rindex and strchr/strrchr, so any systems that don't provide them all
+ * need to have #defines here.
+ *
+ * These macros are defined this way, rather than, e.g.:
+ *    #defined index(s,c) strchr(s,c)
+ * because someone might be using them as function pointers, and such
+ * a change would break compatibility for anyone who's relying on them
+ * being the way they currently are. So we're stuck with them this way,
+ * which can be really inconvenient. :-(
+ */
+
+# include <string.h>
+# if defined(__SCO__) || defined(__UNIXWARE__) || defined(__sun) || defined(__CYGWIN__) || defined(_AIX) || defined(__APPLE__) || defined(__FreeBSD__)
+#  include <strings.h>
+# else
+#  ifndef index
+#   define index(s,c) (strchr((s),(c)))
+#  endif
+#  ifndef rindex
+#   define rindex(s,c) (strrchr((s),(c)))
+#  endif
+# endif
+
+/*
+ * Get open(2) constants
+ */
+# if defined(X_NOT_POSIX)
+#  include <fcntl.h>
+#  if defined(USL) || defined(__i386__) && (defined(SYSV) || defined(SVR4))
+#   include <unistd.h>
+#  endif
+#  ifdef WIN32
+#   include <X11/Xw32defs.h>
+#  else
+#   include <sys/file.h>
+#  endif
+# else /* X_NOT_POSIX */
+#  include <fcntl.h>
+#  include <unistd.h>
+# endif /* X_NOT_POSIX else */
+
+/*
+ * Get struct timeval and struct tm
+ */
+
+# if defined(_POSIX_SOURCE) && defined(SVR4)
+/* need to omit _POSIX_SOURCE in order to get what we want in SVR4 */
+#  undef _POSIX_SOURCE
+#  include <sys/time.h>
+#  define _POSIX_SOURCE
+# elif defined(WIN32)
+#  include <time.h>
+#  if !defined(_WINSOCKAPI_) && !defined(_WILLWINSOCK_) && !defined(_TIMEVAL_DEFINED) && !defined(_STRUCT_TIMEVAL)
+struct timeval {
+    long    tv_sec;         /* seconds */
+    long    tv_usec;        /* and microseconds */
+};
+#   define _TIMEVAL_DEFINED
+#  endif
+#  include <sys/timeb.h>
+#  define gettimeofday(t) \
+{ \
+    struct _timeb _gtodtmp; \
+    _ftime (&_gtodtmp); \
+    (t)->tv_sec = _gtodtmp.time; \
+    (t)->tv_usec = _gtodtmp.millitm * 1000; \
+}
+# else
+#  include <sys/time.h>
+#  include <time.h>
+# endif /* defined(_POSIX_SOURCE) && defined(SVR4) */
+
+/* define X_GETTIMEOFDAY macro, a portable gettimeofday() */
+# if defined(_XOPEN_XPG4) || defined(_XOPEN_UNIX) /* _XOPEN_UNIX is XPG4.2 */
+#  define X_GETTIMEOFDAY(t) gettimeofday(t, (struct timezone*)0)
+# else
+#  if defined(SVR4) || defined(__SVR4) || defined(WIN32)
+#   define X_GETTIMEOFDAY(t) gettimeofday(t)
+#  else
+#   define X_GETTIMEOFDAY(t) gettimeofday(t, (struct timezone*)0)
+#  endif
+# endif /* XPG4 else */
+
+
+# ifdef __GNU__
+#  define PATH_MAX 4096
+#  define MAXPATHLEN 4096
+#  define OPEN_MAX 256 /* We define a reasonable limit.  */
+# endif
+
+/* use POSIX name for signal */
+# if defined(X_NOT_POSIX) && defined(SYSV) && !defined(SIGCHLD)
+#  define SIGCHLD SIGCLD
+# endif
+
+# include <X11/Xarch.h>
+
+#endif /* _XOS_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/Xos_r.h b/depends/libxcb/depends/xorgproto/include/X11/Xos_r.h
new file mode 100644
index 0000000..f963b64
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/Xos_r.h
@@ -0,0 +1,1095 @@
+/*
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+*/
+
+/*
+ * Various and sundry Thread-Safe functions used by X11, Motif, and CDE.
+ *
+ * Use this file in MT-safe code where you would have included
+ *	<dirent.h>	for readdir()
+ *	<grp.h>		for getgrgid() or getgrnam()
+ *	<netdb.h>	for gethostbyname(), gethostbyaddr(), or getservbyname()
+ *	<pwd.h>		for getpwnam() or getpwuid()
+ *	<string.h>	for strtok()
+ *	<time.h>	for asctime(), ctime(), localtime(), or gmtime()
+ *	<unistd.h>	for getlogin() or ttyname()
+ * or their thread-safe analogs.
+ *
+ * If you are on a platform that defines XTHREADS but does not have
+ * MT-safe system API (e.g. UnixWare) you must define _Xos_processLock
+ * and _Xos_processUnlock macros before including this header.
+ *
+ * For convenience XOS_USE_XLIB_LOCKING or XOS_USE_XT_LOCKING may be defined
+ * to obtain either Xlib-only or Xt-based versions of these macros.  These
+ * macros won't result in truly thread-safe calls, but they are better than
+ * nothing.  If you do not want locking in this situation define
+ * XOS_USE_NO_LOCKING.
+ *
+ * NOTE: On systems lacking appropriate _r functions Gethostbyname(),
+ *	Gethostbyaddr(), and Getservbyname() do NOT copy the host or
+ *	protocol lists!
+ *
+ * NOTE: On systems lacking appropriate _r functions Getgrgid() and
+ *	Getgrnam() do NOT copy the list of group members!
+ *
+ * This header is nominally intended to simplify porting X11, Motif, and
+ * CDE; it may be useful to other people too.  The structure below is
+ * complicated, mostly because P1003.1c (the IEEE POSIX Threads spec)
+ * went through lots of drafts, and some vendors shipped systems based
+ * on draft API that were changed later.  Unfortunately POSIX did not
+ * provide a feature-test macro for distinguishing each of the drafts.
+ */
+
+/*
+ * This header has several parts.  Search for "Effective prototypes"
+ * to locate the beginning of a section.
+ */
+
+/* This header can be included multiple times with different defines! */
+#ifndef _XOS_R_H_
+# define _XOS_R_H_
+
+# include <X11/Xos.h>
+# include <X11/Xfuncs.h>
+
+# ifndef X_NOT_POSIX
+#  ifdef _POSIX_SOURCE
+#   include <limits.h>
+#  else
+#   define _POSIX_SOURCE
+#   include <limits.h>
+#   undef _POSIX_SOURCE
+#  endif
+#  ifndef LINE_MAX
+#   define X_LINE_MAX 2048
+#  else
+#   define X_LINE_MAX LINE_MAX
+#  endif
+# endif
+#endif /* _XOS_R_H */
+
+#ifndef WIN32
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+# if defined(XOS_USE_XLIB_LOCKING)
+#  ifndef XAllocIDs /* Xlibint.h does not have multiple include protection */
+typedef struct _LockInfoRec *LockInfoPtr;
+extern LockInfoPtr _Xglobal_lock;
+#  endif
+#  ifndef _Xos_isThreadInitialized
+#   define _Xos_isThreadInitialized	(_Xglobal_lock)
+#  endif
+#  if defined(XTHREADS_WARN) || defined(XTHREADS_FILE_LINE)
+#   ifndef XAllocIDs /* Xlibint.h does not have multiple include protection */
+#    include <X11/Xfuncproto.h>	/* for NeedFunctionPrototypes */
+extern void (*_XLockMutex_fn)(
+#    if NeedFunctionPrototypes
+    LockInfoPtr	/* lock */, char * /* file */, int /* line */
+#    endif
+);
+extern void (*_XUnlockMutex_fn)(
+#    if NeedFunctionPrototypes
+    LockInfoPtr	/* lock */, char * /* file */, int /* line */
+#    endif
+);
+#   endif
+#   ifndef _Xos_processLock
+#    define _Xos_processLock	\
+  (_XLockMutex_fn ? (*_XLockMutex_fn)(_Xglobal_lock,__FILE__,__LINE__) : 0)
+#   endif
+#   ifndef _Xos_processUnlock
+#    define _Xos_processUnlock	\
+  (_XUnlockMutex_fn ? (*_XUnlockMutex_fn)(_Xglobal_lock,__FILE__,__LINE__) : 0)
+#   endif
+#  else
+#   ifndef XAllocIDs /* Xlibint.h does not have multiple include protection */
+#    include <X11/Xfuncproto.h>	/* for NeedFunctionPrototypes */
+extern void (*_XLockMutex_fn)(
+#    if NeedFunctionPrototypes
+    LockInfoPtr	/* lock */
+#    endif
+);
+extern void (*_XUnlockMutex_fn)(
+#    if NeedFunctionPrototypes
+    LockInfoPtr	/* lock */
+#    endif
+);
+#   endif
+#   ifndef _Xos_processLock
+#    define _Xos_processLock	\
+  (_XLockMutex_fn ? ((*_XLockMutex_fn)(_Xglobal_lock), 0) : 0)
+#   endif
+#   ifndef _Xos_processUnlock
+#    define _Xos_processUnlock	\
+  (_XUnlockMutex_fn ? ((*_XUnlockMutex_fn)(_Xglobal_lock), 0) : 0)
+#   endif
+#  endif
+# elif defined(XOS_USE_XT_LOCKING)
+#  ifndef _XtThreadsI_h
+extern void (*_XtProcessLock)(void);
+#  endif
+#  ifndef _XtintrinsicP_h
+#   include <X11/Xfuncproto.h>	/* for NeedFunctionPrototypes */
+extern void XtProcessLock(
+#   if NeedFunctionPrototypes
+    void
+#   endif
+);
+extern void XtProcessUnlock(
+#   if NeedFunctionPrototypes
+    void
+#   endif
+);
+#  endif
+#  ifndef _Xos_isThreadInitialized
+#   define _Xos_isThreadInitialized	_XtProcessLock
+#  endif
+#  ifndef _Xos_processLock
+#   define _Xos_processLock		XtProcessLock()
+#  endif
+#  ifndef _Xos_processUnlock
+#   define _Xos_processUnlock		XtProcessUnlock()
+#  endif
+# elif defined(XOS_USE_NO_LOCKING)
+#  ifndef _Xos_isThreadInitialized
+#   define _Xos_isThreadInitialized	0
+#  endif
+#  ifndef _Xos_processLock
+#   define _Xos_processLock		0
+#  endif
+#  ifndef _Xos_processUnlock
+#   define _Xos_processUnlock		0
+#  endif
+# endif
+
+#endif /* !defined WIN32 */
+
+/*
+ * Solaris defines the POSIX thread-safe feature test macro, but
+ * uses the older SVR4 thread-safe functions unless the POSIX ones
+ * are specifically requested.  Fix the feature test macro.
+ */
+#if defined(__sun) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && \
+	(_POSIX_C_SOURCE - 0 < 199506L) && !defined(_POSIX_PTHREAD_SEMANTICS)
+# undef _POSIX_THREAD_SAFE_FUNCTIONS
+#endif
+
+/***** <pwd.h> wrappers *****/
+
+/*
+ * Effective prototypes for <pwd.h> wrappers:
+ *
+ * #define X_INCLUDE_PWD_H
+ * #define XOS_USE_..._LOCKING
+ * #include <X11/Xos_r.h>
+ *
+ * typedef ... _Xgetpwparams;
+ *
+ * struct passwd* _XGetpwnam(const char *name, _Xgetpwparams);
+ * struct passwd* _XGetpwuid(uid_t uid, _Xgetpwparams);
+ */
+
+#if defined(X_INCLUDE_PWD_H) && !defined(_XOS_INCLUDED_PWD_H)
+# include <pwd.h>
+# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_PWDAPI)
+#  define XOS_USE_MTSAFE_PWDAPI 1
+# endif
+#endif
+
+#undef X_NEEDS_PWPARAMS
+#if !defined(X_INCLUDE_PWD_H) || defined(_XOS_INCLUDED_PWD_H)
+/* Do nothing */
+
+#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API)
+/* Use regular, unsafe API. */
+# if defined(X_NOT_POSIX) && !defined(__i386__) && !defined(SYSV)
+extern struct passwd *getpwuid(), *getpwnam();
+# endif
+typedef int _Xgetpwparams;	/* dummy */
+# define _XGetpwuid(u,p)	getpwuid((u))
+# define _XGetpwnam(u,p)	getpwnam((u))
+
+#elif !defined(XOS_USE_MTSAFE_PWDAPI) || defined(XNO_MTSAFE_PWDAPI)
+/* UnixWare 2.0, or other systems with thread support but no _r API. */
+# define X_NEEDS_PWPARAMS
+typedef struct {
+  struct passwd pws;
+  char   pwbuf[1024];
+  struct passwd* pwp;
+  size_t len;
+} _Xgetpwparams;
+
+/*
+ * NetBSD and FreeBSD, at least, are missing several of the unixware passwd
+ * fields.
+ */
+
+#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) || \
+    defined(__APPLE__) || defined(__DragonFly__)
+static __inline__ void _Xpw_copyPasswd(_Xgetpwparams p)
+{
+   memcpy(&(p).pws, (p).pwp, sizeof(struct passwd));
+
+   (p).pws.pw_name = (p).pwbuf;
+   (p).len = strlen((p).pwp->pw_name);
+   strcpy((p).pws.pw_name, (p).pwp->pw_name);
+
+   (p).pws.pw_passwd = (p).pws.pw_name + (p).len + 1;
+   (p).len = strlen((p).pwp->pw_passwd);
+   strcpy((p).pws.pw_passwd,(p).pwp->pw_passwd);
+
+   (p).pws.pw_class = (p).pws.pw_passwd + (p).len + 1;
+   (p).len = strlen((p).pwp->pw_class);
+   strcpy((p).pws.pw_class, (p).pwp->pw_class);
+
+   (p).pws.pw_gecos = (p).pws.pw_class + (p).len + 1;
+   (p).len = strlen((p).pwp->pw_gecos);
+   strcpy((p).pws.pw_gecos, (p).pwp->pw_gecos);
+
+   (p).pws.pw_dir = (p).pws.pw_gecos + (p).len + 1;
+   (p).len = strlen((p).pwp->pw_dir);
+   strcpy((p).pws.pw_dir, (p).pwp->pw_dir);
+
+   (p).pws.pw_shell = (p).pws.pw_dir + (p).len + 1;
+   (p).len = strlen((p).pwp->pw_shell);
+   strcpy((p).pws.pw_shell, (p).pwp->pw_shell);
+
+   (p).pwp = &(p).pws;
+}
+
+#else
+# define _Xpw_copyPasswd(p) \
+   (memcpy(&(p).pws, (p).pwp, sizeof(struct passwd)), \
+    ((p).pws.pw_name = (p).pwbuf), \
+    ((p).len = strlen((p).pwp->pw_name)), \
+    strcpy((p).pws.pw_name, (p).pwp->pw_name), \
+    ((p).pws.pw_passwd = (p).pws.pw_name + (p).len + 1), \
+    ((p).len = strlen((p).pwp->pw_passwd)), \
+    strcpy((p).pws.pw_passwd,(p).pwp->pw_passwd), \
+    ((p).pws.pw_age = (p).pws.pw_passwd + (p).len + 1), \
+    ((p).len = strlen((p).pwp->pw_age)), \
+    strcpy((p).pws.pw_age, (p).pwp->pw_age), \
+    ((p).pws.pw_comment = (p).pws.pw_age + (p).len + 1), \
+    ((p).len = strlen((p).pwp->pw_comment)), \
+    strcpy((p).pws.pw_comment, (p).pwp->pw_comment), \
+    ((p).pws.pw_gecos = (p).pws.pw_comment + (p).len + 1), \
+    ((p).len = strlen((p).pwp->pw_gecos)), \
+    strcpy((p).pws.pw_gecos, (p).pwp->pw_gecos), \
+    ((p).pws.pw_dir = (p).pws.pw_comment + (p).len + 1), \
+    ((p).len = strlen((p).pwp->pw_dir)), \
+    strcpy((p).pws.pw_dir, (p).pwp->pw_dir), \
+    ((p).pws.pw_shell = (p).pws.pw_dir + (p).len + 1), \
+    ((p).len = strlen((p).pwp->pw_shell)), \
+    strcpy((p).pws.pw_shell, (p).pwp->pw_shell), \
+    ((p).pwp = &(p).pws), \
+    0 )
+#endif
+# define _XGetpwuid(u,p) \
+( (_Xos_processLock), \
+  (((p).pwp = getpwuid((u))) ? _Xpw_copyPasswd(p), 0 : 0), \
+  (_Xos_processUnlock), \
+  (p).pwp )
+# define _XGetpwnam(u,p) \
+( (_Xos_processLock), \
+  (((p).pwp = getpwnam((u))) ? _Xpw_copyPasswd(p), 0 : 0), \
+  (_Xos_processUnlock), \
+  (p).pwp )
+
+#elif !defined(_POSIX_THREAD_SAFE_FUNCTIONS) && !defined(__APPLE__)
+# define X_NEEDS_PWPARAMS
+typedef struct {
+  struct passwd pws;
+  char pwbuf[X_LINE_MAX];
+} _Xgetpwparams;
+# if defined(_POSIX_REENTRANT_FUNCTIONS) || !defined(SVR4)
+#   define _XGetpwuid(u,p) \
+((getpwuid_r((u),&(p).pws,(p).pwbuf,sizeof((p).pwbuf)) == -1) ? NULL : &(p).pws)
+#   define _XGetpwnam(u,p) \
+((getpwnam_r((u),&(p).pws,(p).pwbuf,sizeof((p).pwbuf)) == -1) ? NULL : &(p).pws)
+# else /* SVR4 */
+#  define _XGetpwuid(u,p) \
+((getpwuid_r((u),&(p).pws,(p).pwbuf,sizeof((p).pwbuf)) == NULL) ? NULL : &(p).pws)
+#  define _XGetpwnam(u,p) \
+((getpwnam_r((u),&(p).pws,(p).pwbuf,sizeof((p).pwbuf)) == NULL) ? NULL : &(p).pws)
+# endif /* SVR4 */
+
+#else /* _POSIX_THREAD_SAFE_FUNCTIONS */
+# define X_NEEDS_PWPARAMS
+typedef struct {
+  struct passwd pws;
+  char pwbuf[X_LINE_MAX];
+  struct passwd* pwp;
+} _Xgetpwparams;
+typedef int _Xgetpwret;
+# define _XGetpwuid(u,p) \
+((getpwuid_r((u),&(p).pws,(p).pwbuf,sizeof((p).pwbuf),&(p).pwp) == 0) ? \
+ (p).pwp : NULL)
+# define _XGetpwnam(u,p) \
+((getpwnam_r((u),&(p).pws,(p).pwbuf,sizeof((p).pwbuf),&(p).pwp) == 0) ? \
+ (p).pwp : NULL)
+#endif /* X_INCLUDE_PWD_H */
+
+#if defined(X_INCLUDE_PWD_H) && !defined(_XOS_INCLUDED_PWD_H)
+# define _XOS_INCLUDED_PWD_H
+#endif
+
+
+/***** <netdb.h> wrappers *****/
+
+/*
+ * Effective prototypes for <netdb.h> wrappers:
+ *
+ * NOTE: On systems lacking the appropriate _r functions Gethostbyname(),
+ *	Gethostbyaddr(), and Getservbyname() do NOT copy the host or
+ *	protocol lists!
+ *
+ * #define X_INCLUDE_NETDB_H
+ * #define XOS_USE_..._LOCKING
+ * #include <X11/Xos_r.h>
+ *
+ * typedef ... _Xgethostbynameparams;
+ * typedef ... _Xgetservbynameparams;
+ *
+ * struct hostent* _XGethostbyname(const char* name,_Xgethostbynameparams);
+ * struct hostent* _XGethostbyaddr(const char* addr, int len, int type,
+ *				   _Xgethostbynameparams);
+ * struct servent* _XGetservbyname(const char* name, const char* proto,
+ *				 _Xgetservbynameparams);
+ */
+
+#undef XTHREADS_NEEDS_BYNAMEPARAMS
+#if defined(X_INCLUDE_NETDB_H) && !defined(_XOS_INCLUDED_NETDB_H) \
+    && !defined(WIN32)
+# include <netdb.h>
+# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_NETDBAPI)
+#  define XOS_USE_MTSAFE_NETDBAPI 1
+# endif
+#endif
+
+#if !defined(X_INCLUDE_NETDB_H) || defined(_XOS_INCLUDED_NETDB_H)
+/* Do nothing. */
+
+#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API)
+/* Use regular, unsafe API. */
+typedef int _Xgethostbynameparams; /* dummy */
+typedef int _Xgetservbynameparams; /* dummy */
+# define _XGethostbyname(h,hp)		gethostbyname((h))
+# define _XGethostbyaddr(a,al,t,hp)	gethostbyaddr((a),(al),(t))
+# define _XGetservbyname(s,p,sp)	getservbyname((s),(p))
+
+#elif !defined(XOS_USE_MTSAFE_NETDBAPI) || defined(XNO_MTSAFE_NETDBAPI)
+/* WARNING:  The h_addr_list and s_aliases values are *not* copied! */
+
+#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
+#include <sys/param.h>
+#endif
+
+typedef struct {
+  struct hostent hent;
+  char           h_name[MAXHOSTNAMELEN];
+  struct hostent *hptr;
+} _Xgethostbynameparams;
+typedef struct {
+  struct servent sent;
+  char           s_name[255];
+  char		 s_proto[255];
+  struct servent *sptr;
+} _Xgetservbynameparams;
+
+# define XTHREADS_NEEDS_BYNAMEPARAMS
+
+# define _Xg_copyHostent(hp) \
+   (memcpy(&(hp).hent, (hp).hptr, sizeof(struct hostent)), \
+    strcpy((hp).h_name, (hp).hptr->h_name), \
+    ((hp).hent.h_name = (hp).h_name), \
+    ((hp).hptr = &(hp).hent), \
+     0 )
+# define _Xg_copyServent(sp) \
+   (memcpy(&(sp).sent, (sp).sptr, sizeof(struct servent)), \
+    strcpy((sp).s_name, (sp).sptr->s_name), \
+    ((sp).sent.s_name = (sp).s_name), \
+    strcpy((sp).s_proto, (sp).sptr->s_proto), \
+    ((sp).sent.s_proto = (sp).s_proto), \
+    ((sp).sptr = &(sp).sent), \
+    0 )
+# define _XGethostbyname(h,hp) \
+   ((_Xos_processLock), \
+    (((hp).hptr = gethostbyname((h))) ? _Xg_copyHostent(hp) : 0), \
+    (_Xos_processUnlock), \
+    (hp).hptr )
+# define _XGethostbyaddr(a,al,t,hp) \
+   ((_Xos_processLock), \
+    (((hp).hptr = gethostbyaddr((a),(al),(t))) ? _Xg_copyHostent(hp) : 0), \
+    (_Xos_processUnlock), \
+    (hp).hptr )
+# define _XGetservbyname(s,p,sp) \
+   ((_Xos_processLock), \
+    (((sp).sptr = getservbyname((s),(p))) ? _Xg_copyServent(sp) : 0), \
+    (_Xos_processUnlock), \
+    (sp).sptr )
+
+#elif defined(XUSE_NETDB_R_API)
+/*
+ * POSIX does not specify _r equivalents for <netdb.h> API, but some
+ * vendors provide them anyway.  Use them only when explicitly asked.
+ */
+# ifdef _POSIX_REENTRANT_FUNCTIONS
+#  ifndef _POSIX_THREAD_SAFE_FUNCTIONS
+#  endif
+# endif
+# ifdef _POSIX_THREAD_SAFE_FUNCTIONS
+#  define X_POSIX_THREAD_SAFE_FUNCTIONS 1
+# endif
+
+# define XTHREADS_NEEDS_BYNAMEPARAMS
+
+# ifndef X_POSIX_THREAD_SAFE_FUNCTIONS
+typedef struct {
+    struct hostent      hent;
+    char                hbuf[X_LINE_MAX];
+    int                 herr;
+} _Xgethostbynameparams;
+typedef struct {
+    struct servent      sent;
+    char                sbuf[X_LINE_MAX];
+} _Xgetservbynameparams;
+#  define _XGethostbyname(h,hp) \
+  gethostbyname_r((h),&(hp).hent,(hp).hbuf,sizeof((hp).hbuf),&(hp).herr)
+#  define _XGethostbyaddr(a,al,t,hp) \
+  gethostbyaddr_r((a),(al),(t),&(hp).hent,(hp).hbuf,sizeof((hp).hbuf),&(hp).herr)
+#  define _XGetservbyname(s,p,sp) \
+  getservbyname_r((s),(p),&(sp).sent,(sp).sbuf,sizeof((sp).sbuf))
+# else
+typedef struct {
+  struct hostent      hent;
+  struct hostent_data hdata;
+} _Xgethostbynameparams;
+typedef struct {
+  struct servent      sent;
+  struct servent_data sdata;
+} _Xgetservbynameparams;
+#  define _XGethostbyname(h,hp) \
+  (bzero((char*)&(hp).hdata,sizeof((hp).hdata)),	\
+   ((gethostbyname_r((h),&(hp).hent,&(hp).hdata) == -1) ? NULL : &(hp).hent))
+#  define _XGethostbyaddr(a,al,t,hp) \
+  (bzero((char*)&(hp).hdata,sizeof((hp).hdata)),	\
+   ((gethostbyaddr_r((a),(al),(t),&(hp).hent,&(hp).hdata) == -1) ? NULL : &(hp).hent))
+#  define _XGetservbyname(s,p,sp) \
+  (bzero((char*)&(sp).sdata,sizeof((sp).sdata)),	\
+   ((getservbyname_r((s),(p),&(sp).sent,&(sp).sdata) == -1) ? NULL : &(sp).sent) )
+# endif
+# ifdef X_POSIX_THREAD_SAFE_FUNCTIONS
+#  undef X_POSIX_THREAD_SAFE_FUNCTIONS
+# endif
+
+#else
+/* The regular API is assumed to be MT-safe under POSIX. */
+typedef int _Xgethostbynameparams; /* dummy */
+typedef int _Xgetservbynameparams; /* dummy */
+# define _XGethostbyname(h,hp)		gethostbyname((h))
+# define _XGethostbyaddr(a,al,t,hp)	gethostbyaddr((a),(al),(t))
+# define _XGetservbyname(s,p,sp)	getservbyname((s),(p))
+#endif /* X_INCLUDE_NETDB_H */
+
+#if defined(X_INCLUDE_NETDB_H) && !defined(_XOS_INCLUDED_NETDB_H)
+# define _XOS_INCLUDED_NETDB_H
+#endif
+
+
+/***** <dirent.h> wrappers *****/
+
+/*
+ * Effective prototypes for <dirent.h> wrappers:
+ *
+ * #define X_INCLUDE_DIRENT_H
+ * #define XOS_USE_..._LOCKING
+ * #include <X11/Xos_r.h>
+ *
+ * typedef ... _Xreaddirparams;
+ *
+ * struct dirent *_XReaddir(DIR *dir_pointer, _Xreaddirparams);
+ */
+
+#if defined(X_INCLUDE_DIRENT_H) && !defined(_XOS_INCLUDED_DIRENT_H)
+# include <sys/types.h>
+# if !defined(X_NOT_POSIX) || defined(SYSV)
+#  include <dirent.h>
+# else
+#  include <sys/dir.h>
+#  ifndef dirent
+#   define dirent direct
+#  endif
+# endif
+# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_DIRENTAPI)
+#  define XOS_USE_MTSAFE_DIRENTAPI 1
+# endif
+#endif
+
+#if !defined(X_INCLUDE_DIRENT_H) || defined(_XOS_INCLUDED_DIRENT_H)
+/* Do nothing. */
+
+#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API)
+/* Use regular, unsafe API. */
+typedef int _Xreaddirparams;	/* dummy */
+# define _XReaddir(d,p)	readdir(d)
+
+#elif !defined(XOS_USE_MTSAFE_DIRENTAPI) || defined(XNO_MTSAFE_DIRENTAPI)
+/* Systems with thread support but no _r API. */
+typedef struct {
+  struct dirent *result;
+  struct dirent dir_entry;
+# ifdef _POSIX_PATH_MAX
+  char buf[_POSIX_PATH_MAX];
+# elif defined(NAME_MAX)
+  char buf[NAME_MAX];
+# else
+  char buf[255];
+# endif
+} _Xreaddirparams;
+
+# define _XReaddir(d,p)	\
+ ( (_Xos_processLock),						 \
+   (((p).result = readdir((d))) ?				 \
+    (memcpy(&((p).dir_entry), (p).result, (p).result->d_reclen), \
+     ((p).result = &(p).dir_entry), 0) :			 \
+    0),								 \
+   (_Xos_processUnlock),					 \
+   (p).result )
+
+#else
+typedef struct {
+  struct dirent *result;
+  struct dirent dir_entry;
+# ifdef _POSIX_PATH_MAX
+  char buf[_POSIX_PATH_MAX];
+# elif defined(NAME_MAX)
+  char buf[NAME_MAX];
+# else
+  char buf[255];
+# endif
+} _Xreaddirparams;
+
+# if defined(_POSIX_THREAD_SAFE_FUNCTIONS) || defined(__APPLE__)
+/* POSIX final API, returns (int)0 on success. */
+#  define _XReaddir(d,p)						\
+    (readdir_r((d), &((p).dir_entry), &((p).result)) ? NULL : (p).result)
+# elif defined(_POSIX_REENTRANT_FUNCTIONS)
+/* POSIX draft API, returns (int)0 on success. */
+#  define _XReaddir(d,p)	\
+    (readdir_r((d),&((p).dir_entry)) ? NULL : &((p).dir_entry))
+# elif defined(SVR4)
+/* Pre-POSIX API, returns non-NULL on success. */
+#  define _XReaddir(d,p)	(readdir_r((d), &(p).dir_entry))
+# else
+/* We have no idea what is going on.  Fake it all using process locks. */
+#  define _XReaddir(d,p)	\
+    ( (_Xos_processLock),						\
+      (((p).result = readdir((d))) ?					\
+       (memcpy(&((p).dir_entry), (p).result, (p).result->d_reclen),	\
+	((p).result = &(p).dir_entry), 0) :				\
+       0),								\
+      (_Xos_processUnlock),						\
+      (p).result )
+# endif
+#endif /* X_INCLUDE_DIRENT_H */
+
+#if defined(X_INCLUDE_DIRENT_H) && !defined(_XOS_INCLUDED_DIRENT_H)
+# define _XOS_INCLUDED_DIRENT_H
+#endif
+
+
+/***** <unistd.h> wrappers *****/
+
+/*
+ * Effective prototypes for <unistd.h> wrappers:
+ *
+ * #define X_INCLUDE_UNISTD_H
+ * #define XOS_USE_..._LOCKING
+ * #include <X11/Xos_r.h>
+ *
+ * typedef ... _Xgetloginparams;
+ * typedef ... _Xttynameparams;
+ *
+ * char *_XGetlogin(_Xgetloginparams);
+ * char *_XTtyname(int, _Xttynameparams);
+ */
+
+#if defined(X_INCLUDE_UNISTD_H) && !defined(_XOS_INCLUDED_UNISTD_H)
+/* <unistd.h> already included by <X11/Xos.h> */
+# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_UNISTDAPI)
+#  define XOS_USE_MTSAFE_UNISTDAPI 1
+# endif
+#endif
+
+#if !defined(X_INCLUDE_UNISTD_H) || defined(_XOS_INCLUDED_UNISTD_H)
+/* Do nothing. */
+
+#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API)
+/* Use regular, unsafe API. */
+typedef int _Xgetloginparams;	/* dummy */
+typedef int _Xttynameparams;	/* dummy */
+# define _XGetlogin(p)	getlogin()
+# define _XTtyname(f)	ttyname((f))
+
+#elif !defined(XOS_USE_MTSAFE_UNISTDAPI) || defined(XNO_MTSAFE_UNISTDAPI)
+/* Systems with thread support but no _r API. */
+typedef struct {
+  char *result;
+# if defined(MAXLOGNAME)
+  char buf[MAXLOGNAME];
+# elif defined(LOGIN_NAME_MAX)
+  char buf[LOGIN_NAME_MAX];
+# else
+  char buf[64];
+# endif
+} _Xgetloginparams;
+typedef struct {
+  char *result;
+# ifdef TTY_NAME_MAX
+  char buf[TTY_NAME_MAX];
+# elif defined(_POSIX_TTY_NAME_MAX)
+  char buf[_POSIX_TTY_NAME_MAX];
+# elif defined(_POSIX_PATH_MAX)
+  char buf[_POSIX_PATH_MAX];
+# else
+  char buf[256];
+# endif
+} _Xttynameparams;
+
+# define _XGetlogin(p) \
+ ( (_Xos_processLock), \
+   (((p).result = getlogin()) ? \
+    (strncpy((p).buf, (p).result, sizeof((p).buf)), \
+     ((p).buf[sizeof((p).buf)-1] = '\0'), \
+     ((p).result = (p).buf), 0) : 0), \
+   (_Xos_processUnlock), \
+   (p).result )
+#define _XTtyname(f,p) \
+ ( (_Xos_processLock), \
+   (((p).result = ttyname(f)) ? \
+    (strncpy((p).buf, (p).result, sizeof((p).buf)), \
+     ((p).buf[sizeof((p).buf)-1] = '\0'), \
+     ((p).result = (p).buf), 0) : 0), \
+   (_Xos_processUnlock), \
+   (p).result )
+
+#elif defined(_POSIX_THREAD_SAFE_FUNCTIONS) || defined(_POSIX_REENTRANT_FUNCTIONS)
+/* POSIX API.
+ *
+ * extern int getlogin_r(char *, size_t);
+ * extern int ttyname_r(int, char *, size_t);
+ */
+typedef struct {
+# if defined(MAXLOGNAME)
+  char buf[MAXLOGNAME];
+# elif defined(LOGIN_NAME_MAX)
+  char buf[LOGIN_NAME_MAX];
+# else
+  char buf[64];
+# endif
+} _Xgetloginparams;
+typedef struct {
+# ifdef TTY_NAME_MAX
+  char buf[TTY_NAME_MAX];
+# elif defined(_POSIX_TTY_NAME_MAX)
+  char buf[_POSIX_TTY_NAME_MAX];
+# elif defined(_POSIX_PATH_MAX)
+  char buf[_POSIX_PATH_MAX];
+# else
+  char buf[256];
+# endif
+} _Xttynameparams;
+
+# define _XGetlogin(p)	(getlogin_r((p).buf, sizeof((p).buf)) ? NULL : (p).buf)
+# define _XTtyname(f,p)	\
+	(ttyname_r((f), (p).buf, sizeof((p).buf)) ? NULL : (p).buf)
+
+#else
+/* Pre-POSIX API.
+ *
+ * extern char *getlogin_r(char *, size_t);
+ * extern char *ttyname_r(int, char *, size_t);
+ */
+typedef struct {
+# if defined(MAXLOGNAME)
+  char buf[MAXLOGNAME];
+# elif defined(LOGIN_NAME_MAX)
+  char buf[LOGIN_NAME_MAX];
+# else
+  char buf[64];
+# endif
+} _Xgetloginparams;
+typedef struct {
+# ifdef TTY_NAME_MAX
+  char buf[TTY_NAME_MAX];
+# elif defined(_POSIX_TTY_NAME_MAX)
+  char buf[_POSIX_TTY_NAME_MAX];
+# elif defined(_POSIX_PATH_MAX)
+  char buf[_POSIX_PATH_MAX];
+# else
+  char buf[256];
+# endif
+} _Xttynameparams;
+
+# define _XGetlogin(p)	getlogin_r((p).buf, sizeof((p).buf))
+# define _XTtyname(f,p)	ttyname_r((f), (p).buf, sizeof((p).buf))
+#endif /* X_INCLUDE_UNISTD_H */
+
+#if defined(X_INCLUDE_UNISTD_H) && !defined(_XOS_INCLUDED_UNISTD_H)
+# define _XOS_INCLUDED_UNISTD_H
+#endif
+
+
+/***** <string.h> wrappers *****/
+
+/*
+ * Effective prototypes for <string.h> wrappers:
+ *
+ * #define X_INCLUDE_STRING_H
+ * #define XOS_USE_..._LOCKING
+ * #include <X11/Xos_r.h>
+ *
+ * typedef ... _Xstrtokparams;
+ *
+ * char *_XStrtok(char *, const char*, _Xstrtokparams);
+ */
+
+#if defined(X_INCLUDE_STRING_H) && !defined(_XOS_INCLUDED_STRING_H)
+/* <string.h> has already been included by <X11/Xos.h> */
+# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_STRINGAPI)
+#  define XOS_USE_MTSAFE_STRINGAPI 1
+# endif
+#endif
+
+#if !defined(X_INCLUDE_STRING_H) || defined(_XOS_INCLUDED_STRING_H)
+/* Do nothing. */
+
+#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API)
+/* Use regular, unsafe API. */
+typedef int _Xstrtokparams;	/* dummy */
+# define _XStrtok(s1,s2,p) \
+ ( p = 0, (void)p, strtok((s1),(s2)) )
+
+#elif !defined(XOS_USE_MTSAFE_STRINGAPI) || defined(XNO_MTSAFE_STRINGAPI)
+/* Systems with thread support but no _r API. */
+typedef char *_Xstrtokparams;
+# define _XStrtok(s1,s2,p) \
+ ( (_Xos_processLock), \
+   ((p) = strtok((s1),(s2))), \
+   (_Xos_processUnlock), \
+   (p) )
+
+#else
+/* POSIX or pre-POSIX API. */
+typedef char * _Xstrtokparams;
+# define _XStrtok(s1,s2,p)	strtok_r((s1),(s2),&(p))
+#endif /* X_INCLUDE_STRING_H */
+
+
+/***** <time.h> wrappers *****/
+
+/*
+ * Effective prototypes for <time.h> wrappers:
+ *
+ * #define X_INCLUDE_TIME_H
+ * #define XOS_USE_..._LOCKING
+ * #include <X11/Xos_r.h>
+ *
+ * typedef ... _Xatimeparams;
+ * typedef ... _Xctimeparams;
+ * typedef ... _Xgtimeparams;
+ * typedef ... _Xltimeparams;
+ *
+ * char *_XAsctime(const struct tm *, _Xatimeparams);
+ * char *_XCtime(const time_t *, _Xctimeparams);
+ * struct tm *_XGmtime(const time_t *, _Xgtimeparams);
+ * struct tm *_XLocaltime(const time_t *, _Xltimeparams);
+ */
+
+#if defined(X_INCLUDE_TIME_H) && !defined(_XOS_INCLUDED_TIME_H)
+# include <time.h>
+# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_TIMEAPI)
+#  define XOS_USE_MTSAFE_TIMEAPI 1
+# endif
+#endif
+
+#if !defined(X_INCLUDE_TIME_H) || defined(_XOS_INCLUDED_TIME_H)
+/* Do nothing. */
+
+#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API)
+/* Use regular, unsafe API. */
+typedef int _Xatimeparams;	/* dummy */
+# define _XAsctime(t,p)		asctime((t))
+typedef int _Xctimeparams;	/* dummy */
+# define _XCtime(t,p)		ctime((t))
+typedef int _Xgtimeparams;	/* dummy */
+# define _XGmtime(t,p)		gmtime((t))
+typedef int _Xltimeparams;	/* dummy */
+# define _XLocaltime(t,p)	localtime((t))
+
+#elif !defined(XOS_USE_MTSAFE_TIMEAPI) || defined(XNO_MTSAFE_TIMEAPI)
+/* Systems with thread support but no _r API. */
+typedef struct {
+# ifdef TIMELEN
+  char buf[TIMELEN];
+# else
+  char buf[26];
+# endif
+  char *result;
+} _Xctimeparams, _Xatimeparams;
+typedef struct {
+  struct tm buf;
+  struct tm *result;
+} _Xgtimeparams, _Xltimeparams;
+# define _XAsctime(t,p) \
+ ( (_Xos_processLock), \
+   (((p).result = asctime((t))) ? \
+    (strncpy((p).buf, (p).result, sizeof((p).buf)), (p).result = &(p).buf) : \
+    0), \
+   (_Xos_processUnlock), \
+   (p).result )
+# define _XCtime(t,p) \
+ ( (_Xos_processLock), \
+   (((p).result = ctime((t))) ? \
+    (strncpy((p).buf, (p).result, sizeof((p).buf)), (p).result = &(p).buf) : \
+    0), \
+   (_Xos_processUnlock), \
+   (p).result )
+# define _XGmtime(t,p) \
+ ( (_Xos_processLock), \
+   (((p).result = gmtime(t)) ? \
+    (memcpy(&(p).buf, (p).result, sizeof((p).buf)), (p).result = &(p).buf) : \
+    0), \
+   (_Xos_processUnlock), \
+   (p).result )
+# define _XLocaltime(t,p) \
+ ( (_Xos_processLock), \
+   (((p).result = localtime(t)) ? \
+    (memcpy(&(p).buf, (p).result, sizeof((p).buf)), (p).result = &(p).buf) : \
+    0), \
+   (_Xos_processUnlock), \
+   (p).result )
+
+#elif !defined(_POSIX_THREAD_SAFE_FUNCTIONS) &&  defined(hpV4)
+/* Returns (int)0 on success.
+ *
+ * extern int asctime_r(const struct tm *timeptr, char *buffer, int buflen);
+ * extern int ctime_r(const time_t *timer, char *buffer, int buflen);
+ * extern int gmtime_r(const time_t *timer, struct tm *result);
+ * extern int localtime_r(const time_t *timer, struct tm *result);
+ */
+# ifdef TIMELEN
+typedef char _Xatimeparams[TIMELEN];
+typedef char _Xctimeparams[TIMELEN];
+# else
+typedef char _Xatimeparams[26];
+typedef char _Xctimeparams[26];
+# endif
+typedef struct tm _Xgtimeparams;
+typedef struct tm _Xltimeparams;
+# define _XAsctime(t,p)		(asctime_r((t),(p),sizeof((p))) ? NULL : (p))
+# define _XCtime(t,p)		(ctime_r((t),(p),sizeof((p))) ? NULL : (p))
+# define _XGmtime(t,p)		(gmtime_r((t),&(p)) ? NULL : &(p))
+# define _XLocaltime(t,p)	(localtime_r((t),&(p)) ? NULL : &(p))
+
+#elif !defined(_POSIX_THREAD_SAFE_FUNCTIONS) && defined(__sun)
+/* Returns NULL on failure.  Solaris 2.5
+ *
+ * extern char *asctime_r(const struct tm *tm,char *buf, int buflen);
+ * extern char *ctime_r(const time_t *clock, char *buf, int buflen);
+ * extern struct tm *gmtime_r(const time_t *clock, struct tm *res);
+ * extern struct tm *localtime_r(const time_t *clock, struct tm *res);
+ */
+# ifdef TIMELEN
+typedef char _Xatimeparams[TIMELEN];
+typedef char _Xctimeparams[TIMELEN];
+# else
+typedef char _Xatimeparams[26];
+typedef char _Xctimeparams[26];
+# endif
+typedef struct tm _Xgtimeparams;
+typedef struct tm _Xltimeparams;
+# define _XAsctime(t,p)		asctime_r((t),(p),sizeof((p)))
+# define _XCtime(t,p)		ctime_r((t),(p),sizeof((p)))
+# define _XGmtime(t,p)		gmtime_r((t),&(p))
+# define _XLocaltime(t,p)	localtime_r((t),&(p))
+
+#else /* defined(_POSIX_THREAD_SAFE_FUNCTIONS) */
+/* POSIX final API.
+ * extern char *asctime_r(const struct tm *timeptr, char *buffer);
+ * extern char *ctime_r(const time_t *timer, char *buffer);
+ * extern struct tm *gmtime_r(const time_t *timer, struct tm *result);
+ * extern struct tm *localtime_r(const time_t *timer, struct tm *result);
+ */
+# ifdef TIMELEN
+typedef char _Xatimeparams[TIMELEN];
+typedef char _Xctimeparams[TIMELEN];
+# else
+typedef char _Xatimeparams[26];
+typedef char _Xctimeparams[26];
+# endif
+typedef struct tm _Xgtimeparams;
+typedef struct tm _Xltimeparams;
+# define _XAsctime(t,p)		asctime_r((t),(p))
+# define _XCtime(t,p)		ctime_r((t),(p))
+# define _XGmtime(t,p)		gmtime_r((t),&(p))
+# define _XLocaltime(t,p)	localtime_r((t),&(p))
+#endif /* X_INCLUDE_TIME_H */
+
+#if defined(X_INCLUDE_TIME_H) && !defined(_XOS_INCLUDED_TIME_H)
+# define _XOS_INCLUDED_TIME_H
+#endif
+
+
+/***** <grp.h> wrappers *****/
+
+/*
+ * Effective prototypes for <grp.h> wrappers:
+ *
+ * NOTE: On systems lacking appropriate _r functions Getgrgid() and
+ *	Getgrnam() do NOT copy the list of group members!
+ *
+ * Remember that fgetgrent(), setgrent(), getgrent(), and endgrent()
+ * are not included in POSIX.
+ *
+ * #define X_INCLUDE_GRP_H
+ * #define XOS_USE_..._LOCKING
+ * #include <X11/Xos_r.h>
+ *
+ * typedef ... _Xgetgrparams;
+ *
+ * struct group *_XGetgrgid(gid_t, _Xgetgrparams);
+ * struct group *_XGetgrnam(const char *, _Xgetgrparams);
+ */
+
+#if defined(X_INCLUDE_GRP_H) && !defined(_XOS_INCLUDED_GRP_H)
+# include <grp.h>
+# if defined(XUSE_MTSAFE_API) || defined(XUSE_MTSAFE_GRPAPI)
+#  define XOS_USE_MTSAFE_GRPAPI 1
+# endif
+#endif
+
+#if !defined(X_INCLUDE_GRP_H) || defined(_XOS_INCLUDED_GRP_H)
+/* Do nothing. */
+
+#elif !defined(XTHREADS) && !defined(X_FORCE_USE_MTSAFE_API)
+/* Use regular, unsafe API. */
+typedef int _Xgetgrparams;	/* dummy */
+#define _XGetgrgid(g,p)	getgrgid((g))
+#define _XGetgrnam(n,p)	getgrnam((n))
+
+#elif !defined(XOS_USE_MTSAFE_GRPAPI) || defined(XNO_MTSAFE_GRPAPI)
+/* Systems with thread support but no _r API.  UnixWare 2.0. */
+typedef struct {
+  struct group grp;
+  char buf[X_LINE_MAX];	/* Should be sysconf(_SC_GETGR_R_SIZE_MAX)? */
+  struct group *pgrp;
+  size_t len;
+} _Xgetgrparams;
+#ifdef SVR4
+/* Copy the gr_passwd field too. */
+# define _Xgrp_copyGroup(p) \
+ ( memcpy(&(p).grp, (p).pgrp, sizeof(struct group)), \
+   ((p).grp.gr_name = (p).buf), \
+   ((p).len = strlen((p).pgrp->gr_name)), \
+   strcpy((p).grp.gr_name, (p).pgrp->gr_name), \
+   ((p).grp.gr_passwd = (p).grp.gr_name + (p).len + 1), \
+   ((p).pgrp = &(p).grp), \
+   0 )
+#else
+# define _Xgrp_copyGroup(p) \
+ ( memcpy(&(p).grp, (p).pgrp, sizeof(struct group)), \
+   ((p).grp.gr_name = (p).buf), \
+   strcpy((p).grp.gr_name, (p).pgrp->gr_name), \
+   ((p).pgrp = &(p).grp), \
+   0 )
+#endif
+#define _XGetgrgid(g,p) \
+ ( (_Xos_processLock), \
+   (((p).pgrp = getgrgid((g))) ? _Xgrp_copyGroup(p) : 0), \
+   (_Xos_processUnlock), \
+   (p).pgrp )
+#define _XGetgrnam(n,p) \
+ ( (_Xos_processLock), \
+   (((p).pgrp = getgrnam((n))) ? _Xgrp_copyGroup(p) : 0), \
+   (_Xos_processUnlock), \
+   (p).pgrp )
+
+#elif !defined(_POSIX_THREAD_SAFE_FUNCTIONS) && defined(__sun)
+/* Non-POSIX API.  Solaris.
+ *
+ * extern struct group *getgrgid_r(gid_t, struct group *, char *, int);
+ * extern struct group *getgrnam_r(const char *, struct group *, char *, int);
+ */
+typedef struct {
+  struct group grp;
+  char buf[X_LINE_MAX];	/* Should be sysconf(_SC_GETGR_R_SIZE_MAX)? */
+} _Xgetgrparams;
+#define _XGetgrgid(g,p)	getgrgid_r((g), &(p).grp, (p).buf, sizeof((p).buf))
+#define _XGetgrnam(n,p)	getgrnam_r((n), &(p).grp, (p).buf, sizeof((p).buf))
+
+#elif !defined(_POSIX_THREAD_SAFE_FUNCTIONS)
+/* Non-POSIX API.
+ * extern int getgrgid_r(gid_t, struct group *, char *, int);
+ * extern int getgrnam_r(const char *, struct group *, char *, int);
+ */
+typedef struct {
+  struct group grp;
+  char buf[X_LINE_MAX];	/* Should be sysconf(_SC_GETGR_R_SIZE_MAX)? */
+} _Xgetgrparams;
+#define _XGetgrgid(g,p)	\
+ ((getgrgid_r((g), &(p).grp, (p).buf, sizeof((p).buf)) ? NULL : &(p).grp))
+#define _XGetgrnam(n,p)	\
+ ((getgrnam_r((n), &(p).grp, (p).buf, sizeof((p).buf)) ? NULL : &(p).grp))
+
+#else
+/* POSIX final API.
+ *
+ * int getgrgid_r(gid_t, struct group *, char *, size_t, struct group **);
+ * int getgrnam_r(const char *, struct group *, char *, size_t, struct group **);
+ */
+typedef struct {
+  struct group grp;
+  char buf[X_LINE_MAX];	/* Should be sysconf(_SC_GETGR_R_SIZE_MAX)? */
+  struct group *result;
+} _Xgetgrparams;
+
+#define _XGetgrgid(g,p)	\
+ ((getgrgid_r((g), &(p).grp, (p).buf, sizeof((p).buf), &(p).result) ? \
+   NULL : (p).result))
+#define _XGetgrnam(n,p)	\
+ ((getgrnam_r((n), &(p).grp, (p).buf, sizeof((p).buf), &(p).result) ? \
+   NULL : (p).result))
+#endif
+
+#if defined(X_INCLUDE_GRP_H) && !defined(_XOS_INCLUDED_GRP_H)
+# define _XOS_INCLUDED_GRP_H
+#endif
+
+
+#ifdef __cplusplus
+}  /* Close scope of 'extern "C"' declaration which encloses file. */
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/Xosdefs.h b/depends/libxcb/depends/xorgproto/include/X11/Xosdefs.h
new file mode 100644
index 0000000..33eaee4
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/Xosdefs.h
@@ -0,0 +1,116 @@
+/*
+ * O/S-dependent (mis)feature macro definitions
+ *
+Copyright 1991, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ */
+
+#ifndef _XOSDEFS_H_
+# define _XOSDEFS_H_
+
+/*
+ * X_NOT_POSIX means does not have POSIX header files.  Lack of this
+ * symbol does NOT mean that the POSIX environment is the default.
+ * You may still have to define _POSIX_SOURCE to get it.
+ */
+
+
+# ifdef _SCO_DS
+#  ifndef __SCO__
+#   define __SCO__
+#  endif
+# endif
+
+# ifdef __i386__
+#  ifdef SYSV
+#   if !defined(__SCO__) && \
+	!defined(__UNIXWARE__) && !defined(__sun)
+#    if !defined(_POSIX_SOURCE)
+#     define X_NOT_POSIX
+#    endif
+#   endif
+#  endif
+# endif
+
+# ifdef __sun
+/* Imake configs define SVR4 on Solaris, but cc & gcc only define __SVR4
+ * This check allows non-Imake configured programs to build correctly.
+ */
+#  if defined(__SVR4) && !defined(SVR4)
+#   define SVR4 1
+#  endif
+#  ifdef SVR4
+/* define this to whatever it needs to be */
+#   define X_POSIX_C_SOURCE 199300L
+#  endif
+# endif
+
+# ifdef WIN32
+#  ifndef _POSIX_
+#   define X_NOT_POSIX
+#  endif
+# endif
+
+
+# ifdef __APPLE__
+#  define NULL_NOT_ZERO
+
+/* Defining any of these will sanitize the namespace to JUST want is defined by
+ * that particular standard.  If that happens, we don't get some expected
+ * prototypes, typedefs, etc (like fd_mask).  We can define _DARWIN_C_SOURCE to
+ * loosen our belts a tad.
+ */
+#  if defined(_XOPEN_SOURCE) || defined(_POSIX_SOURCE) || defined(_POSIX_C_SOURCE)
+#   ifndef _DARWIN_C_SOURCE
+#    define _DARWIN_C_SOURCE
+#   endif
+#  endif
+
+# endif
+
+# ifdef __GNU__
+#  ifndef PATH_MAX
+#   define PATH_MAX 4096
+#  endif
+#  ifndef MAXPATHLEN
+#   define MAXPATHLEN 4096
+#  endif
+# endif
+
+# if defined(__SCO__) || defined(__UNIXWARE__)
+#  ifndef PATH_MAX
+#   define PATH_MAX	1024
+#  endif
+#  ifndef MAXPATHLEN
+#   define MAXPATHLEN	1024
+#  endif
+# endif
+
+# if defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD__) \
+	|| defined(__APPLE__) || defined(__DragonFly__)
+#  ifndef CSRG_BASED
+#   define CSRG_BASED
+#  endif
+# endif
+
+#endif /* _XOSDEFS_H_ */
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/Xpoll.h b/depends/libxcb/depends/xorgproto/include/X11/Xpoll.h
new file mode 100644
index 0000000..0940865
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/Xpoll.h
@@ -0,0 +1,230 @@
+/*
+
+Copyright 1994, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+
+/*
+ * Copyright © 2005 Daniel Stone
+ * 
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Daniel Stone not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission.  Daniel Stone makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * DANIEL STONE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+ * DANIEL STONE BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef _XPOLL_H_
+#define _XPOLL_H_
+
+#if !defined(WIN32) || defined(__CYGWIN__)
+
+#ifndef USE_POLL
+
+#include <X11/Xos.h>
+
+#include <sys/select.h>  /* Get the FD_* macros. */
+
+#include <X11/Xmd.h>
+
+#ifdef CSRG_BASED
+#include <sys/param.h>
+# if BSD < 199103
+typedef long fd_mask;
+# endif
+#endif
+
+#if defined(FD_SETSIZE) && FD_SETSIZE < 512
+# define XFD_SETSIZE	FD_SETSIZE
+#else
+# define XFD_SETSIZE	512
+# ifndef FD_SETSIZE
+#  define FD_SETSIZE	XFD_SETSIZE
+# endif
+#endif
+
+#ifndef NBBY
+#define NBBY	8		/* number of bits in a byte */
+#endif
+
+#ifndef NFDBITS
+#define NFDBITS (sizeof(fd_mask) * NBBY)	/* bits per mask */
+#endif
+
+#ifndef howmany
+#define howmany(x,y)	(((x)+((y)-1))/(y))
+#endif
+
+#if defined(BSD) && BSD < 198911 
+typedef struct fd_set {
+	fd_mask fds_bits[howmany(FD_SETSIZE, NFDBITS)];
+} fd_set;
+#endif
+
+# define Select(n,r,w,e,t) select(n,(fd_set*)r,(fd_set*)w,(fd_set*)e,(struct timeval*)t)
+
+#define __X_FDS_BITS __fds_bits
+
+#ifndef __FDS_BITS
+# define __FDS_BITS(p)  ((p)->__X_FDS_BITS)
+#endif
+
+#define __XFDS_BITS(p, n) (__FDS_BITS(p))[n]
+
+#ifndef FD_SET
+#define FD_SET(n, p)    (__XFDS_BITS(p, ((n)/NFDBITS)) |= ((fd_mask)1 << ((n) % NFDBITS)))
+#endif
+#ifndef FD_CLR
+#define FD_CLR(n, p)    (__XFDS_BITS((p), ((n)/NFDBITS)) &= ~((fd_mask)1 << ((n) % NFDBITS)))
+#endif
+#ifndef FD_ISSET
+#define FD_ISSET(n, p)  ((__XFDS_BITS((p), ((n)/NFDBITS))) & ((fd_mask)1 << ((n) % NFDBITS)))
+#endif
+#ifndef FD_ZERO
+#define FD_ZERO(p)      bzero((char *)(p), sizeof(*(p)))
+#endif
+
+/*
+ * The howmany(FD_SETSIZE, NFDBITS) computes the number of elements in the
+ * array. before accessing an element in the array we check it exists.
+ * If it does not exist then the compiler discards the code to access it. 
+ */
+#define XFD_ANYSET(p) \
+        ((howmany(FD_SETSIZE, NFDBITS) > 0 && (__XFDS_BITS(p, 0))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 1 && (__XFDS_BITS(p, 1))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 2 && (__XFDS_BITS(p, 2))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 3 && (__XFDS_BITS(p, 3))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 4 && (__XFDS_BITS(p, 4))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 5 && (__XFDS_BITS(p, 5))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 6 && (__XFDS_BITS(p, 6))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 7 && (__XFDS_BITS(p, 7))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 8 && (__XFDS_BITS(p, 8))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 9 && (__XFDS_BITS(p, 9))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 10 && (__XFDS_BITS(p, 10))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 11 && (__XFDS_BITS(p, 11))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 12 && (__XFDS_BITS(p, 12))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 13 && (__XFDS_BITS(p, 13))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 14 && (__XFDS_BITS(p, 14))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 15 && (__XFDS_BITS(p, 15))))
+
+
+#define XFD_COPYSET(src,dst) { \
+        int __i__; \
+		for (__i__ = 0; __i__ < howmany(FD_SETSIZE, NFDBITS); __i__++) \
+            __XFDS_BITS((dst), __i__) = __XFDS_BITS((src), __i__); \
+        }
+#define XFD_ANDSET(dst,b1,b2) { \
+        int __i__; \
+        for (__i__ = 0; __i__ < howmany(FD_SETSIZE, NFDBITS); __i__++) \
+            __XFDS_BITS((dst), __i__) = ((__XFDS_BITS((b1), __i__)) & (__XFDS_BITS((b2), __i__))); \
+        }
+#define XFD_ORSET(dst,b1,b2) { \
+        int __i__; \
+        for (__i__ = 0; __i__ < howmany(FD_SETSIZE, NFDBITS); __i__++) \
+		__XFDS_BITS((dst), __i__) = ((__XFDS_BITS((b1), __i__)) | (__XFDS_BITS((b2), __i__))); \
+        }        
+#define XFD_UNSET(dst,b1) { \
+        int __i__; \
+        for (__i__ = 0; __i__ < howmany(FD_SETSIZE, NFDBITS); __i__++) \
+    		__XFDS_BITS((dst), __i__) &= ~(__XFDS_BITS((b1), __i__)); \
+        }
+
+#else /* USE_POLL */
+#include <sys/poll.h>
+#endif /* USE_POLL */
+
+#else /* WIN32 */
+
+#define XFD_SETSIZE	512
+#ifndef FD_SETSIZE
+#define FD_SETSIZE	XFD_SETSIZE
+#endif
+#include <X11/Xwinsock.h>
+
+#define Select(n,r,w,e,t) select(0,(fd_set*)r,(fd_set*)w,(fd_set*)e,(struct timeval*)t)
+
+#define XFD_SETCOUNT(p)	(((fd_set FAR *)(p))->fd_count)
+#define XFD_FD(p,i) (((fd_set FAR *)(p))->fd_array[i])
+#define XFD_ANYSET(p)	XFD_SETCOUNT(p)
+
+#define XFD_COPYSET(src,dst) { \
+    u_int __i; \
+    FD_ZERO(dst); \
+    for (__i = 0; __i < XFD_SETCOUNT(src) ; __i++) { \
+        XFD_FD(dst,__i) = XFD_FD(src,__i); \
+    } \
+    XFD_SETCOUNT(dst) = XFD_SETCOUNT(src); \
+}
+
+#define XFD_ANDSET(dst,b1,b2) { \
+    u_int __i; \
+    FD_ZERO(dst); \
+    for (__i = 0; __i < XFD_SETCOUNT(b1) ; __i++) { \
+        if (FD_ISSET(XFD_FD(b1,__i), b2)) \
+	   FD_SET(XFD_FD(b1,__i), dst); \
+    } \
+}
+
+#define XFD_ORSET(dst,b1,b2) { \
+    u_int __i; \
+    if (dst != b1) XFD_COPYSET(b1,dst); \
+    for (__i = 0; __i < XFD_SETCOUNT(b2) ; __i++) { \
+        if (!FD_ISSET(XFD_FD(b2,__i), dst)) \
+	   FD_SET(XFD_FD(b2,__i), dst); \
+    } \
+}
+
+/* this one is really sub-optimal */
+#define XFD_UNSET(dst,b1) { \
+    u_int __i; \
+    for (__i = 0; __i < XFD_SETCOUNT(b1) ; __i++) { \
+	FD_CLR(XFD_FD(b1,__i), dst); \
+    } \
+}
+
+/* we have to pay the price of having an array here, unlike with bitmasks
+   calling twice FD_SET with the same fd is not transparent, so be careful */
+#undef FD_SET
+#define FD_SET(fd,set) do { \
+    if (XFD_SETCOUNT(set) < FD_SETSIZE && !FD_ISSET(fd,set)) \
+        XFD_FD(set,XFD_SETCOUNT(set)++)=(fd); \
+} while(0)
+
+#define getdtablesize() FD_SETSIZE 
+
+#endif /* WIN32 */
+
+#endif /* _XPOLL_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/Xpoll.h.in b/depends/libxcb/depends/xorgproto/include/X11/Xpoll.h.in
new file mode 100644
index 0000000..9f127e1
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/Xpoll.h.in
@@ -0,0 +1,230 @@
+/*
+
+Copyright 1994, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+
+/*
+ * Copyright © 2005 Daniel Stone
+ * 
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Daniel Stone not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission.  Daniel Stone makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * DANIEL STONE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+ * DANIEL STONE BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef _XPOLL_H_
+#define _XPOLL_H_
+
+#if !defined(WIN32) || defined(__CYGWIN__)
+
+#ifndef USE_POLL
+
+#include <X11/Xos.h>
+
+#include <sys/select.h>  /* Get the FD_* macros. */
+
+#include <X11/Xmd.h>
+
+#ifdef CSRG_BASED
+#include <sys/param.h>
+# if BSD < 199103
+typedef long fd_mask;
+# endif
+#endif
+
+#if defined(FD_SETSIZE) && FD_SETSIZE < 512
+# define XFD_SETSIZE	FD_SETSIZE
+#else
+# define XFD_SETSIZE	512
+# ifndef FD_SETSIZE
+#  define FD_SETSIZE	XFD_SETSIZE
+# endif
+#endif
+
+#ifndef NBBY
+#define NBBY	8		/* number of bits in a byte */
+#endif
+
+#ifndef NFDBITS
+#define NFDBITS (sizeof(fd_mask) * NBBY)	/* bits per mask */
+#endif
+
+#ifndef howmany
+#define howmany(x,y)	(((x)+((y)-1))/(y))
+#endif
+
+#if defined(BSD) && BSD < 198911 
+typedef struct fd_set {
+	fd_mask fds_bits[howmany(FD_SETSIZE, NFDBITS)];
+} fd_set;
+#endif
+
+# define Select(n,r,w,e,t) select(n,(fd_set*)r,(fd_set*)w,(fd_set*)e,(struct timeval*)t)
+
+#define __X_FDS_BITS @USE_FDS_BITS@
+
+#ifndef __FDS_BITS
+# define __FDS_BITS(p)  ((p)->__X_FDS_BITS)
+#endif
+
+#define __XFDS_BITS(p, n) (__FDS_BITS(p))[n]
+
+#ifndef FD_SET
+#define FD_SET(n, p)    (__XFDS_BITS(p, ((n)/NFDBITS)) |= ((fd_mask)1 << ((n) % NFDBITS)))
+#endif
+#ifndef FD_CLR
+#define FD_CLR(n, p)    (__XFDS_BITS((p), ((n)/NFDBITS)) &= ~((fd_mask)1 << ((n) % NFDBITS)))
+#endif
+#ifndef FD_ISSET
+#define FD_ISSET(n, p)  ((__XFDS_BITS((p), ((n)/NFDBITS))) & ((fd_mask)1 << ((n) % NFDBITS)))
+#endif
+#ifndef FD_ZERO
+#define FD_ZERO(p)      bzero((char *)(p), sizeof(*(p)))
+#endif
+
+/*
+ * The howmany(FD_SETSIZE, NFDBITS) computes the number of elements in the
+ * array. before accessing an element in the array we check it exists.
+ * If it does not exist then the compiler discards the code to access it. 
+ */
+#define XFD_ANYSET(p) \
+        ((howmany(FD_SETSIZE, NFDBITS) > 0 && (__XFDS_BITS(p, 0))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 1 && (__XFDS_BITS(p, 1))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 2 && (__XFDS_BITS(p, 2))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 3 && (__XFDS_BITS(p, 3))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 4 && (__XFDS_BITS(p, 4))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 5 && (__XFDS_BITS(p, 5))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 6 && (__XFDS_BITS(p, 6))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 7 && (__XFDS_BITS(p, 7))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 8 && (__XFDS_BITS(p, 8))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 9 && (__XFDS_BITS(p, 9))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 10 && (__XFDS_BITS(p, 10))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 11 && (__XFDS_BITS(p, 11))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 12 && (__XFDS_BITS(p, 12))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 13 && (__XFDS_BITS(p, 13))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 14 && (__XFDS_BITS(p, 14))) || \
+        (howmany(FD_SETSIZE, NFDBITS) > 15 && (__XFDS_BITS(p, 15))))
+
+
+#define XFD_COPYSET(src,dst) { \
+        int __i__; \
+		for (__i__ = 0; __i__ < howmany(FD_SETSIZE, NFDBITS); __i__++) \
+            __XFDS_BITS((dst), __i__) = __XFDS_BITS((src), __i__); \
+        }
+#define XFD_ANDSET(dst,b1,b2) { \
+        int __i__; \
+        for (__i__ = 0; __i__ < howmany(FD_SETSIZE, NFDBITS); __i__++) \
+            __XFDS_BITS((dst), __i__) = ((__XFDS_BITS((b1), __i__)) & (__XFDS_BITS((b2), __i__))); \
+        }
+#define XFD_ORSET(dst,b1,b2) { \
+        int __i__; \
+        for (__i__ = 0; __i__ < howmany(FD_SETSIZE, NFDBITS); __i__++) \
+		__XFDS_BITS((dst), __i__) = ((__XFDS_BITS((b1), __i__)) | (__XFDS_BITS((b2), __i__))); \
+        }        
+#define XFD_UNSET(dst,b1) { \
+        int __i__; \
+        for (__i__ = 0; __i__ < howmany(FD_SETSIZE, NFDBITS); __i__++) \
+    		__XFDS_BITS((dst), __i__) &= ~(__XFDS_BITS((b1), __i__)); \
+        }
+
+#else /* USE_POLL */
+#include <sys/poll.h>
+#endif /* USE_POLL */
+
+#else /* WIN32 */
+
+#define XFD_SETSIZE	512
+#ifndef FD_SETSIZE
+#define FD_SETSIZE	XFD_SETSIZE
+#endif
+#include <X11/Xwinsock.h>
+
+#define Select(n,r,w,e,t) select(0,(fd_set*)r,(fd_set*)w,(fd_set*)e,(struct timeval*)t)
+
+#define XFD_SETCOUNT(p)	(((fd_set FAR *)(p))->fd_count)
+#define XFD_FD(p,i) (((fd_set FAR *)(p))->fd_array[i])
+#define XFD_ANYSET(p)	XFD_SETCOUNT(p)
+
+#define XFD_COPYSET(src,dst) { \
+    u_int __i; \
+    FD_ZERO(dst); \
+    for (__i = 0; __i < XFD_SETCOUNT(src) ; __i++) { \
+        XFD_FD(dst,__i) = XFD_FD(src,__i); \
+    } \
+    XFD_SETCOUNT(dst) = XFD_SETCOUNT(src); \
+}
+
+#define XFD_ANDSET(dst,b1,b2) { \
+    u_int __i; \
+    FD_ZERO(dst); \
+    for (__i = 0; __i < XFD_SETCOUNT(b1) ; __i++) { \
+        if (FD_ISSET(XFD_FD(b1,__i), b2)) \
+	   FD_SET(XFD_FD(b1,__i), dst); \
+    } \
+}
+
+#define XFD_ORSET(dst,b1,b2) { \
+    u_int __i; \
+    if (dst != b1) XFD_COPYSET(b1,dst); \
+    for (__i = 0; __i < XFD_SETCOUNT(b2) ; __i++) { \
+        if (!FD_ISSET(XFD_FD(b2,__i), dst)) \
+	   FD_SET(XFD_FD(b2,__i), dst); \
+    } \
+}
+
+/* this one is really sub-optimal */
+#define XFD_UNSET(dst,b1) { \
+    u_int __i; \
+    for (__i = 0; __i < XFD_SETCOUNT(b1) ; __i++) { \
+	FD_CLR(XFD_FD(b1,__i), dst); \
+    } \
+}
+
+/* we have to pay the price of having an array here, unlike with bitmasks
+   calling twice FD_SET with the same fd is not transparent, so be careful */
+#undef FD_SET
+#define FD_SET(fd,set) do { \
+    if (XFD_SETCOUNT(set) < FD_SETSIZE && !FD_ISSET(fd,set)) \
+        XFD_FD(set,XFD_SETCOUNT(set)++)=(fd); \
+} while(0)
+
+#define getdtablesize() FD_SETSIZE 
+
+#endif /* WIN32 */
+
+#endif /* _XPOLL_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/Xproto.h b/depends/libxcb/depends/xorgproto/include/X11/Xproto.h
new file mode 100644
index 0000000..74193e2
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/Xproto.h
@@ -0,0 +1,2157 @@
+/* Definitions for the X window system used by server and c bindings */
+
+/*
+ * This packet-construction scheme makes the following assumptions:
+ *
+ * 1. The compiler is able
+ * to generate code which addresses one- and two-byte quantities.
+ * In the worst case, this would be done with bit-fields.  If bit-fields
+ * are used it may be necessary to reorder the request fields in this file,
+ * depending on the order in which the machine assigns bit fields to
+ * machine words.  There may also be a problem with sign extension,
+ * as K+R specify that bitfields are always unsigned.
+ *
+ * 2. 2- and 4-byte fields in packet structures must be ordered by hand
+ * such that they are naturally-aligned, so that no compiler will ever
+ * insert padding bytes.
+ *
+ * 3. All packets are hand-padded to a multiple of 4 bytes, for
+ * the same reason.
+ */
+
+#ifndef XPROTO_H
+#define XPROTO_H
+
+/***********************************************************
+
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+#include <X11/Xmd.h>
+#include <X11/Xprotostr.h>
+
+/*
+ * Define constants for the sizes of the network packets.  The sz_ prefix is
+ * used instead of something more descriptive so that the symbols are no more
+ * than 32 characters in length (which causes problems for some compilers).
+ */
+#define sz_xSegment 8
+#define sz_xPoint 4
+#define sz_xRectangle 8
+#define sz_xArc 12
+#define sz_xConnClientPrefix 12
+#define sz_xConnSetupPrefix 8
+#define sz_xConnSetup 32
+#define sz_xPixmapFormat 8
+#define sz_xDepth 8
+#define sz_xVisualType 24
+#define sz_xWindowRoot 40
+#define sz_xTimecoord 8
+#define sz_xHostEntry 4
+#define sz_xCharInfo 12
+#define sz_xFontProp 8
+#define sz_xTextElt 2
+#define sz_xColorItem 12
+#define sz_xrgb 8
+#define sz_xGenericReply 32
+#define sz_xGetWindowAttributesReply 44
+#define sz_xGetGeometryReply 32
+#define sz_xQueryTreeReply 32
+#define sz_xInternAtomReply 32
+#define sz_xGetAtomNameReply 32
+#define sz_xGetPropertyReply 32
+#define sz_xListPropertiesReply 32
+#define sz_xGetSelectionOwnerReply 32
+#define sz_xGrabPointerReply 32
+#define sz_xQueryPointerReply 32
+#define sz_xGetMotionEventsReply 32
+#define sz_xTranslateCoordsReply 32
+#define sz_xGetInputFocusReply 32
+#define sz_xQueryKeymapReply 40
+#define sz_xQueryFontReply 60
+#define sz_xQueryTextExtentsReply 32
+#define sz_xListFontsReply 32
+#define sz_xGetFontPathReply 32
+#define sz_xGetImageReply 32
+#define sz_xListInstalledColormapsReply 32
+#define sz_xAllocColorReply 32
+#define sz_xAllocNamedColorReply 32
+#define sz_xAllocColorCellsReply 32
+#define sz_xAllocColorPlanesReply 32
+#define sz_xQueryColorsReply 32
+#define sz_xLookupColorReply 32
+#define sz_xQueryBestSizeReply 32
+#define sz_xQueryExtensionReply 32
+#define sz_xListExtensionsReply 32
+#define sz_xSetMappingReply 32
+#define sz_xGetKeyboardControlReply 52
+#define sz_xGetPointerControlReply 32
+#define sz_xGetScreenSaverReply 32
+#define sz_xListHostsReply 32
+#define sz_xSetModifierMappingReply 32
+#define sz_xError 32
+#define sz_xEvent 32
+#define sz_xKeymapEvent 32
+#define sz_xReq 4
+#define sz_xResourceReq 8
+#define sz_xCreateWindowReq 32
+#define sz_xChangeWindowAttributesReq 12
+#define sz_xChangeSaveSetReq 8
+#define sz_xReparentWindowReq 16
+#define sz_xConfigureWindowReq 12
+#define sz_xCirculateWindowReq 8
+#define sz_xInternAtomReq 8
+#define sz_xChangePropertyReq 24
+#define sz_xDeletePropertyReq 12
+#define sz_xGetPropertyReq 24
+#define sz_xSetSelectionOwnerReq 16
+#define sz_xConvertSelectionReq 24
+#define sz_xSendEventReq 44
+#define sz_xGrabPointerReq 24
+#define sz_xGrabButtonReq 24
+#define sz_xUngrabButtonReq 12
+#define sz_xChangeActivePointerGrabReq 16
+#define sz_xGrabKeyboardReq 16
+#define sz_xGrabKeyReq 16
+#define sz_xUngrabKeyReq 12
+#define sz_xAllowEventsReq 8
+#define sz_xGetMotionEventsReq 16
+#define sz_xTranslateCoordsReq 16
+#define sz_xWarpPointerReq 24
+#define sz_xSetInputFocusReq 12
+#define sz_xOpenFontReq 12
+#define sz_xQueryTextExtentsReq 8
+#define sz_xListFontsReq 8
+#define sz_xSetFontPathReq 8
+#define sz_xCreatePixmapReq 16
+#define sz_xCreateGCReq 16
+#define sz_xChangeGCReq 12
+#define sz_xCopyGCReq 16
+#define sz_xSetDashesReq 12
+#define sz_xSetClipRectanglesReq 12
+#define sz_xCopyAreaReq 28
+#define sz_xCopyPlaneReq 32
+#define sz_xPolyPointReq 12
+#define sz_xPolySegmentReq 12
+#define sz_xFillPolyReq 16
+#define sz_xPutImageReq 24
+#define sz_xGetImageReq 20
+#define sz_xPolyTextReq 16
+#define sz_xImageTextReq 16
+#define sz_xCreateColormapReq 16
+#define sz_xCopyColormapAndFreeReq 12
+#define sz_xAllocColorReq 16
+#define sz_xAllocNamedColorReq 12
+#define sz_xAllocColorCellsReq 12
+#define sz_xAllocColorPlanesReq 16
+#define sz_xFreeColorsReq 12
+#define sz_xStoreColorsReq 8
+#define sz_xStoreNamedColorReq 16
+#define sz_xQueryColorsReq 8
+#define sz_xLookupColorReq 12
+#define sz_xCreateCursorReq 32
+#define sz_xCreateGlyphCursorReq 32
+#define sz_xRecolorCursorReq 20
+#define sz_xQueryBestSizeReq 12
+#define sz_xQueryExtensionReq 8
+#define sz_xChangeKeyboardControlReq 8
+#define sz_xBellReq 4
+#define sz_xChangePointerControlReq 12
+#define sz_xSetScreenSaverReq 12
+#define sz_xChangeHostsReq 8
+#define sz_xListHostsReq 4
+#define sz_xChangeModeReq 4
+#define sz_xRotatePropertiesReq 12
+#define sz_xReply 32
+#define sz_xGrabKeyboardReply 32
+#define sz_xListFontsWithInfoReply 60
+#define sz_xSetPointerMappingReply 32
+#define sz_xGetKeyboardMappingReply 32
+#define sz_xGetPointerMappingReply 32
+#define sz_xGetModifierMappingReply 32
+#define sz_xListFontsWithInfoReq 8
+#define sz_xPolyLineReq 12
+#define sz_xPolyArcReq 12
+#define sz_xPolyRectangleReq 12
+#define sz_xPolyFillRectangleReq 12
+#define sz_xPolyFillArcReq 12
+#define sz_xPolyText8Req 16
+#define sz_xPolyText16Req 16
+#define sz_xImageText8Req 16
+#define sz_xImageText16Req 16
+#define sz_xSetPointerMappingReq 4
+#define sz_xForceScreenSaverReq 4
+#define sz_xSetCloseDownModeReq 4
+#define sz_xClearAreaReq 16
+#define sz_xSetAccessControlReq 4
+#define sz_xGetKeyboardMappingReq 8
+#define sz_xSetModifierMappingReq 4
+#define sz_xPropIconSize 24
+#define sz_xChangeKeyboardMappingReq 8
+
+
+/* For the purpose of the structure definitions in this file,
+we must redefine the following types in terms of Xmd.h's types, which may
+include bit fields.  All of these are #undef'd at the end of this file,
+restoring the definitions in X.h.  */
+
+#define Window CARD32
+#define Drawable CARD32
+#define Font CARD32
+#define Pixmap CARD32
+#define Cursor CARD32
+#define Colormap CARD32
+#define GContext CARD32
+#define Atom CARD32
+#define VisualID CARD32
+#define Time CARD32
+#define KeyCode CARD8
+#define KeySym CARD32
+
+#define X_TCP_PORT 6000     /* add display number */
+
+#define xTrue        1
+#define xFalse       0
+
+
+typedef CARD16 KeyButMask;
+
+/*****************
+   Connection setup structures.  See Chapter 8: Connection Setup
+   of the X Window System Protocol specification for details.
+*****************/
+
+/* Client initiates handshake with this data, followed by the strings
+ * for the auth protocol & data.
+ */
+typedef struct {
+    CARD8	byteOrder;
+    BYTE	pad;
+    CARD16	majorVersion, minorVersion;
+    CARD16	nbytesAuthProto;	/* Authorization protocol */
+    CARD16	nbytesAuthString;	/* Authorization string */
+    CARD16	pad2;
+} xConnClientPrefix;
+
+/* Server response to xConnClientPrefix.
+ *
+ * If success == Success, this is followed by xConnSetup and
+ * numRoots xWindowRoot structs.
+ *
+ * If success == Failure, this is followed by a reason string.
+ *
+ * The protocol also defines a case of success == Authenticate, but
+ * that doesn't seem to have ever been implemented by the X Consortium.
+ */
+typedef struct {
+    CARD8          success;
+    BYTE           lengthReason; /*num bytes in string following if failure */
+    CARD16         majorVersion,
+                   minorVersion;
+    CARD16         length;       /* 1/4 additional bytes in setup info */
+} xConnSetupPrefix;
+
+
+typedef struct {
+    CARD32         release;
+    CARD32         ridBase,
+                   ridMask;
+    CARD32         motionBufferSize;
+    CARD16         nbytesVendor;      /* number of bytes in vendor string */
+    CARD16         maxRequestSize;
+    CARD8          numRoots;          /* number of roots structs to follow */
+    CARD8          numFormats;        /* number of pixmap formats */
+    CARD8          imageByteOrder;        /* LSBFirst, MSBFirst */
+    CARD8          bitmapBitOrder;        /* LeastSignificant, MostSign...*/
+    CARD8          bitmapScanlineUnit,     /* 8, 16, 32 */
+                   bitmapScanlinePad;     /* 8, 16, 32 */
+    KeyCode	   minKeyCode, maxKeyCode;
+    CARD32	   pad2;
+} xConnSetup;
+
+typedef struct {
+    CARD8          depth;
+    CARD8          bitsPerPixel;
+    CARD8          scanLinePad;
+    CARD8          pad1;
+    CARD32	   pad2;
+} xPixmapFormat;
+
+/* window root */
+
+typedef struct {
+    CARD8 	depth;
+    CARD8 	pad1;
+    CARD16	nVisuals;  /* number of xVisualType structures following */
+    CARD32	pad2;
+    } xDepth;
+
+typedef struct {
+    VisualID visualID;
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8 c_class;
+#else
+    CARD8 class;
+#endif
+    CARD8 bitsPerRGB;
+    CARD16 colormapEntries;
+    CARD32 redMask, greenMask, blueMask;
+    CARD32 pad;
+    } xVisualType;
+
+typedef struct {
+    Window         windowId;
+    Colormap       defaultColormap;
+    CARD32         whitePixel, blackPixel;
+    CARD32         currentInputMask;
+    CARD16         pixWidth, pixHeight;
+    CARD16         mmWidth, mmHeight;
+    CARD16         minInstalledMaps, maxInstalledMaps;
+    VisualID       rootVisualID;
+    CARD8          backingStore;
+    BOOL           saveUnders;
+    CARD8          rootDepth;
+    CARD8          nDepths;  /* number of xDepth structures following */
+} xWindowRoot;
+
+
+/*****************************************************************
+ * Structure Defns
+ *   Structures needed for replies
+ *****************************************************************/
+
+/* Used in GetMotionEvents */
+
+typedef struct {
+    CARD32 time;
+    INT16 x, y;
+} xTimecoord;
+
+typedef struct {
+    CARD8 family;
+    BYTE pad;
+    CARD16 length;
+} xHostEntry;
+
+typedef struct {
+    INT16 leftSideBearing,
+	  rightSideBearing,
+	  characterWidth,
+	  ascent,
+	  descent;
+    CARD16 attributes;
+} xCharInfo;
+
+typedef struct {
+    Atom name;
+    CARD32 value;
+} xFontProp;
+
+/*
+ * non-aligned big-endian font ID follows this struct
+ */
+typedef struct {           /* followed by string */
+    CARD8 len;	/* number of *characters* in string, or FontChange (255)
+		   for font change, or 0 if just delta given */
+    INT8 delta;
+} xTextElt;
+
+
+typedef struct {
+    CARD32 pixel;
+    CARD16 red, green, blue;
+    CARD8 flags;  /* DoRed, DoGreen, DoBlue booleans */
+    CARD8 pad;
+} xColorItem;
+
+
+typedef struct {
+    CARD16 red, green, blue, pad;
+} xrgb;
+
+typedef CARD8 KEYCODE;
+
+
+/*****************
+ * XRep:
+ *    meant to be 32 byte quantity
+ *****************/
+
+/* GenericReply is the common format of all replies.  The "data" items
+   are specific to each individual reply type. */
+
+typedef struct {
+    BYTE type;              /* X_Reply */
+    BYTE data1;             /* depends on reply type */
+    CARD16 sequenceNumber;  /* of last request received by server */
+    CARD32 length;          /* 4 byte quantities beyond size of GenericReply */
+    CARD32 data00;
+    CARD32 data01;
+    CARD32 data02;
+    CARD32 data03;
+    CARD32 data04;
+    CARD32 data05;
+    } xGenericReply;
+
+/* Individual reply formats. */
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    CARD8 backingStore;
+    CARD16 sequenceNumber;
+    CARD32 length;	/* NOT 0; this is an extra-large reply */
+    VisualID visualID;
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD16 c_class;
+#else
+    CARD16 class;
+#endif
+    CARD8 bitGravity;
+    CARD8 winGravity;
+    CARD32 backingBitPlanes;
+    CARD32 backingPixel;
+    BOOL saveUnder;
+    BOOL mapInstalled;
+    CARD8 mapState;
+    BOOL override;
+    Colormap colormap;
+    CARD32 allEventMasks;
+    CARD32 yourEventMask;
+    CARD16 doNotPropagateMask;
+    CARD16 pad;
+    } xGetWindowAttributesReply;
+
+typedef struct {
+    BYTE type;   /* X_Reply */
+    CARD8 depth;
+    CARD16 sequenceNumber;
+    CARD32 length;  /* 0 */
+    Window root;
+    INT16 x, y;
+    CARD16 width, height;
+    CARD16 borderWidth;
+    CARD16 pad1;
+    CARD32 pad2;
+    CARD32 pad3;
+    } xGetGeometryReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length;
+    Window root, parent;
+    CARD16 nChildren;
+    CARD16 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    } xQueryTreeReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length; /* 0 */
+    Atom atom;
+    CARD32 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    } xInternAtomReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length;  /* of additional bytes */
+    CARD16 nameLength;  /* # of characters in name */
+    CARD16 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    CARD32 pad7;
+    } xGetAtomNameReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    CARD8 format;
+    CARD16 sequenceNumber;
+    CARD32 length; /* of additional bytes */
+    Atom propertyType;
+    CARD32 bytesAfter;
+    CARD32 nItems; /* # of 8, 16, or 32-bit entities in reply */
+    CARD32 pad1;
+    CARD32 pad2;
+    CARD32 pad3;
+    } xGetPropertyReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length;
+    CARD16 nProperties;
+    CARD16 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    CARD32 pad7;
+    } xListPropertiesReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length;  /* 0 */
+    Window owner;
+    CARD32 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    } xGetSelectionOwnerReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BYTE status;
+    CARD16 sequenceNumber;
+    CARD32 length;  /* 0 */
+    CARD32 pad1;
+    CARD32 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    } xGrabPointerReply;
+
+typedef xGrabPointerReply xGrabKeyboardReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BOOL sameScreen;
+    CARD16 sequenceNumber;
+    CARD32 length;  /* 0 */
+    Window root, child;
+    INT16 rootX, rootY, winX, winY;
+    CARD16 mask;
+    CARD16 pad1;
+    CARD32 pad;
+    } xQueryPointerReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length;
+    CARD32 nEvents;
+    CARD32 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    } xGetMotionEventsReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BOOL sameScreen;
+    CARD16 sequenceNumber;
+    CARD32 length; /* 0 */
+    Window child;
+    INT16 dstX, dstY;
+    CARD32 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    } xTranslateCoordsReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    CARD8 revertTo;
+    CARD16 sequenceNumber;
+    CARD32 length;  /* 0 */
+    Window focus;
+    CARD32 pad1;
+    CARD32 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    } xGetInputFocusReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length;  /* 2, NOT 0; this is an extra-large reply */
+    BYTE map[32];
+    } xQueryKeymapReply;
+
+/* Warning: this MUST match (up to component renaming) xListFontsWithInfoReply */
+typedef struct _xQueryFontReply {
+    BYTE type;  /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length;  /* definitely > 0, even if "nCharInfos" is 0 */
+    xCharInfo minBounds;
+    CARD32 walign1;
+    xCharInfo maxBounds;
+    CARD32 walign2;
+    CARD16 minCharOrByte2, maxCharOrByte2;
+    CARD16 defaultChar;
+    CARD16 nFontProps;  /* followed by this many xFontProp structures */
+    CARD8 drawDirection;
+    CARD8 minByte1, maxByte1;
+    BOOL allCharsExist;
+    INT16 fontAscent, fontDescent;
+    CARD32 nCharInfos; /* followed by this many xCharInfo structures */
+} xQueryFontReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    CARD8 drawDirection;
+    CARD16 sequenceNumber;
+    CARD32 length;  /* 0 */
+    INT16 fontAscent, fontDescent;
+    INT16 overallAscent, overallDescent;
+    INT32 overallWidth, overallLeft, overallRight;
+    CARD32 pad;
+    } xQueryTextExtentsReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length;
+    CARD16 nFonts;
+    CARD16 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    CARD32 pad7;
+    } xListFontsReply;
+
+/* Warning: this MUST match (up to component renaming) xQueryFontReply */
+typedef struct {
+    BYTE type;  /* X_Reply */
+    CARD8 nameLength;  /* 0 indicates end-of-reply-sequence */
+    CARD16 sequenceNumber;
+    CARD32 length;  /* definitely > 0, even if "nameLength" is 0 */
+    xCharInfo minBounds;
+    CARD32 walign1;
+    xCharInfo maxBounds;
+    CARD32 walign2;
+    CARD16 minCharOrByte2, maxCharOrByte2;
+    CARD16 defaultChar;
+    CARD16 nFontProps;  /* followed by this many xFontProp structures */
+    CARD8 drawDirection;
+    CARD8 minByte1, maxByte1;
+    BOOL allCharsExist;
+    INT16 fontAscent, fontDescent;
+    CARD32 nReplies;   /* hint as to how many more replies might be coming */
+} xListFontsWithInfoReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length;
+    CARD16 nPaths;
+    CARD16 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    CARD32 pad7;
+    } xGetFontPathReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    CARD8 depth;
+    CARD16 sequenceNumber;
+    CARD32 length;
+    VisualID visual;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    CARD32 pad7;
+    } xGetImageReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length;
+    CARD16 nColormaps;
+    CARD16 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    CARD32 pad7;
+    } xListInstalledColormapsReply;
+
+typedef struct {
+    BYTE type; /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length;   /* 0 */
+    CARD16 red, green, blue;
+    CARD16 pad2;
+    CARD32 pixel;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    } xAllocColorReply;
+
+typedef struct {
+    BYTE type; /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length;  /* 0 */
+    CARD32 pixel;
+    CARD16 exactRed, exactGreen, exactBlue;
+    CARD16 screenRed, screenGreen, screenBlue;
+    CARD32 pad2;
+    CARD32 pad3;
+    } xAllocNamedColorReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length;
+    CARD16 nPixels, nMasks;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    CARD32 pad7;
+    } xAllocColorCellsReply;
+
+typedef struct {
+    BYTE type; /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length;
+    CARD16 nPixels;
+    CARD16 pad2;
+    CARD32 redMask, greenMask, blueMask;
+    CARD32 pad3;
+    CARD32 pad4;
+    } xAllocColorPlanesReply;
+
+typedef struct {
+    BYTE type; /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length;
+    CARD16 nColors;
+    CARD16 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    CARD32 pad7;
+    } xQueryColorsReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length;  /* 0 */
+    CARD16 exactRed, exactGreen, exactBlue;
+    CARD16 screenRed, screenGreen, screenBlue;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    } xLookupColorReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length;  /* 0 */
+    CARD16 width, height;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    CARD32 pad7;
+    } xQueryBestSizeReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length; /* 0 */
+    BOOL  present;
+    CARD8 major_opcode;
+    CARD8 first_event;
+    CARD8 first_error;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    CARD32 pad7;
+    } xQueryExtensionReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    CARD8 nExtensions;
+    CARD16 sequenceNumber;
+    CARD32 length;
+    CARD32 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    CARD32 pad7;
+    } xListExtensionsReply;
+
+
+typedef struct {
+    BYTE   type;  /* X_Reply */
+    CARD8  success;
+    CARD16 sequenceNumber;
+    CARD32 length;
+    CARD32 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    CARD32 pad7;
+    } xSetMappingReply;
+typedef xSetMappingReply xSetPointerMappingReply;
+typedef xSetMappingReply xSetModifierMappingReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    CARD8 nElts;  /* how many elements does the map have */
+    CARD16 sequenceNumber;
+    CARD32 length;
+    CARD32 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    CARD32 pad7;
+    } xGetPointerMappingReply;
+
+typedef struct {
+    BYTE type;
+    CARD8 keySymsPerKeyCode;
+    CARD16 sequenceNumber;
+    CARD32 length;
+    CARD32 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    CARD32 pad7;
+} xGetKeyboardMappingReply;
+
+typedef struct {
+    BYTE type;
+    CARD8 numKeyPerModifier;
+    CARD16 sequenceNumber;
+    CARD32 length;
+    CARD32 pad1;
+    CARD32 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+} xGetModifierMappingReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BOOL globalAutoRepeat;
+    CARD16 sequenceNumber;
+    CARD32 length;  /* 5 */
+    CARD32 ledMask;
+    CARD8 keyClickPercent, bellPercent;
+    CARD16 bellPitch, bellDuration;
+    CARD16 pad;
+    BYTE map[32];  /* bit masks start here */
+    } xGetKeyboardControlReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length;  /* 0 */
+    CARD16 accelNumerator, accelDenominator;
+    CARD16 threshold;
+    CARD16 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    } xGetPointerControlReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BYTE pad1;
+    CARD16 sequenceNumber;
+    CARD32 length;  /* 0 */
+    CARD16 timeout, interval;
+    BOOL preferBlanking;
+    BOOL allowExposures;
+    CARD16 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    } xGetScreenSaverReply;
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    BOOL enabled;
+    CARD16 sequenceNumber;
+    CARD32 length;
+    CARD16 nHosts;
+    CARD16 pad1;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    CARD32 pad7;
+    } xListHostsReply;
+
+
+
+
+/*****************************************************************
+ * Xerror
+ *    All errors  are 32 bytes
+ *****************************************************************/
+
+typedef struct {
+    BYTE type;                  /* X_Error */
+    BYTE errorCode;
+    CARD16 sequenceNumber;       /* the nth request from this client */
+    CARD32 resourceID;
+    CARD16 minorCode;
+    CARD8 majorCode;
+    BYTE pad1;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    CARD32 pad7;
+} xError;
+
+/*****************************************************************
+ * xEvent
+ *    All events are 32 bytes
+ *****************************************************************/
+
+typedef struct _xEvent {
+    union {
+	struct {
+	    BYTE type;
+	    BYTE detail;
+	    CARD16 sequenceNumber;
+	    } u;
+	struct {
+	    CARD32 pad00;
+	    Time time;
+	    Window root, event, child;
+	    INT16 rootX, rootY, eventX, eventY;
+	    KeyButMask state;
+	    BOOL sameScreen;
+	    BYTE pad1;
+	} keyButtonPointer;
+	struct {
+	    CARD32 pad00;
+	    Time time;
+	    Window root, event, child;
+	    INT16 rootX, rootY, eventX, eventY;
+	    KeyButMask state;
+	    BYTE mode; 			/* really XMode */
+	    BYTE flags;		/* sameScreen and focus booleans, packed together */
+#define ELFlagFocus        (1<<0)
+#define ELFlagSameScreen   (1<<1)
+	} enterLeave;
+	struct {
+	    CARD32 pad00;
+	    Window window;
+	    BYTE mode; 			/* really XMode */
+	    BYTE pad1, pad2, pad3;
+	} focus;
+	struct {
+	    CARD32 pad00;
+	    Window window;
+	    CARD16 x, y, width, height;
+	    CARD16 count;
+	    CARD16 pad2;
+	} expose;
+	struct {
+	    CARD32 pad00;
+	    Drawable drawable;
+	    CARD16 x, y, width, height;
+	    CARD16 minorEvent;
+	    CARD16 count;
+	    BYTE majorEvent;
+	    BYTE pad1, pad2, pad3;
+	} graphicsExposure;
+	struct {
+	    CARD32 pad00;
+	    Drawable drawable;
+	    CARD16 minorEvent;
+	    BYTE majorEvent;
+	    BYTE bpad;
+	} noExposure;
+	struct {
+	    CARD32 pad00;
+	    Window window;
+	    CARD8 state;
+	    BYTE pad1, pad2, pad3;
+	} visibility;
+	struct {
+	    CARD32 pad00;
+	    Window parent, window;
+	    INT16 x, y;
+	    CARD16 width, height, borderWidth;
+	    BOOL override;
+	    BYTE bpad;
+        } createNotify;
+/*
+ * The event fields in the structures for DestroyNotify, UnmapNotify,
+ * MapNotify, ReparentNotify, ConfigureNotify, CirculateNotify, GravityNotify,
+ * must be at the same offset because server internal code is depending upon
+ * this to patch up the events before they are delivered.
+ * Also note that MapRequest, ConfigureRequest and CirculateRequest have
+ * the same offset for the event window.
+ */
+	struct {
+	    CARD32 pad00;
+	    Window event, window;
+	} destroyNotify;
+	struct {
+	    CARD32 pad00;
+	    Window event, window;
+	    BOOL fromConfigure;
+	    BYTE pad1, pad2, pad3;
+        } unmapNotify;
+	struct {
+	    CARD32 pad00;
+	    Window event, window;
+	    BOOL override;
+	    BYTE pad1, pad2, pad3;
+        } mapNotify;
+	struct {
+	    CARD32 pad00;
+	    Window parent, window;
+        } mapRequest;
+	struct {
+	    CARD32 pad00;
+	    Window event, window, parent;
+	    INT16 x, y;
+	    BOOL override;
+	    BYTE pad1, pad2, pad3;
+	} reparent;
+	struct {
+	    CARD32 pad00;
+	    Window event, window, aboveSibling;
+	    INT16 x, y;
+	    CARD16 width, height, borderWidth;
+	    BOOL override;
+	    BYTE bpad;
+	} configureNotify;
+	struct {
+	    CARD32 pad00;
+	    Window parent, window, sibling;
+	    INT16 x, y;
+	    CARD16 width, height, borderWidth;
+	    CARD16 valueMask;
+	    CARD32 pad1;
+	} configureRequest;
+	struct {
+	    CARD32 pad00;
+	    Window event, window;
+	    INT16 x, y;
+	    CARD32 pad1, pad2, pad3, pad4;
+	} gravity;
+	struct {
+	    CARD32 pad00;
+	    Window window;
+	    CARD16 width, height;
+	} resizeRequest;
+	struct {
+/* The event field in the circulate record is really the parent when this
+   is used as a CirculateRequest instead of a CirculateNotify */
+	    CARD32 pad00;
+	    Window event, window, parent;
+	    BYTE place;			/* Top or Bottom */
+	    BYTE pad1, pad2, pad3;
+	} circulate;
+	struct {
+	    CARD32 pad00;
+	    Window window;
+	    Atom atom;
+	    Time time;
+	    BYTE state;			/* NewValue or Deleted */
+	    BYTE pad1;
+	    CARD16 pad2;
+	} property;
+	struct {
+	    CARD32 pad00;
+	    Time time;
+	    Window window;
+	    Atom atom;
+	} selectionClear;
+	struct {
+	    CARD32 pad00;
+	    Time time;
+	    Window owner, requestor;
+	    Atom selection, target, property;
+	} selectionRequest;
+	struct {
+	    CARD32 pad00;
+	    Time time;
+	    Window requestor;
+	    Atom selection, target, property;
+	} selectionNotify;
+	struct {
+	    CARD32 pad00;
+	    Window window;
+	    Colormap colormap;
+#if defined(__cplusplus) || defined(c_plusplus)
+	    BOOL c_new;
+#else
+	    BOOL new;
+#endif
+	    BYTE state;			/* Installed or UnInstalled */
+	    BYTE pad1, pad2;
+	} colormap;
+	struct {
+	    CARD32 pad00;
+	    CARD8 request;
+	    KeyCode firstKeyCode;
+	    CARD8 count;
+	    BYTE pad1;
+	} mappingNotify;
+	struct {
+	    CARD32 pad00;
+	    Window window;
+	    union {
+		struct {
+		    Atom type;
+		    INT32 longs0;
+		    INT32 longs1;
+		    INT32 longs2;
+		    INT32 longs3;
+		    INT32 longs4;
+		} l;
+		struct {
+		    Atom type;
+		    INT16 shorts0;
+		    INT16 shorts1;
+		    INT16 shorts2;
+		    INT16 shorts3;
+		    INT16 shorts4;
+		    INT16 shorts5;
+		    INT16 shorts6;
+		    INT16 shorts7;
+		    INT16 shorts8;
+		    INT16 shorts9;
+		} s;
+		struct {
+		    Atom type;
+		    INT8 bytes[20];
+		} b;
+	    } u;
+	} clientMessage;
+    } u;
+} xEvent;
+
+/*********************************************************
+ *
+ * Generic event
+ *
+ * Those events are not part of the core protocol spec and can be used by
+ * various extensions.
+ * type is always GenericEvent
+ * extension is the minor opcode of the extension the event belongs to.
+ * evtype is the actual event type, unique __per extension__.
+ *
+ * GenericEvents can be longer than 32 bytes, with the length field
+ * specifying the number of 4 byte blocks after the first 32 bytes.
+ *
+ *
+ */
+typedef struct
+{
+    BYTE    type;
+    CARD8   extension;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD16  evtype;
+    CARD16  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+    CARD32  pad6;
+    CARD32  pad7;
+} xGenericEvent;
+
+
+
+/* KeymapNotify events are not included in the above union because they
+   are different from all other events: they do not have a "detail"
+   or "sequenceNumber", so there is room for a 248-bit key mask. */
+
+typedef struct {
+    BYTE type;
+    BYTE map[31];
+    } xKeymapEvent;
+
+#define XEventSize (sizeof(xEvent))
+
+/* XReply is the union of all the replies above whose "fixed part"
+fits in 32 bytes.  It does NOT include GetWindowAttributesReply,
+QueryFontReply, QueryKeymapReply, or GetKeyboardControlReply
+ListFontsWithInfoReply */
+
+typedef union {
+    xGenericReply generic;
+    xGetGeometryReply geom;
+    xQueryTreeReply tree;
+    xInternAtomReply atom;
+    xGetAtomNameReply atomName;
+    xGetPropertyReply property;
+    xListPropertiesReply listProperties;
+    xGetSelectionOwnerReply selection;
+    xGrabPointerReply grabPointer;
+    xGrabKeyboardReply grabKeyboard;
+    xQueryPointerReply pointer;
+    xGetMotionEventsReply motionEvents;
+    xTranslateCoordsReply coords;
+    xGetInputFocusReply inputFocus;
+    xQueryTextExtentsReply textExtents;
+    xListFontsReply fonts;
+    xGetFontPathReply fontPath;
+    xGetImageReply image;
+    xListInstalledColormapsReply colormaps;
+    xAllocColorReply allocColor;
+    xAllocNamedColorReply allocNamedColor;
+    xAllocColorCellsReply colorCells;
+    xAllocColorPlanesReply colorPlanes;
+    xQueryColorsReply colors;
+    xLookupColorReply lookupColor;
+    xQueryBestSizeReply bestSize;
+    xQueryExtensionReply extension;
+    xListExtensionsReply extensions;
+    xSetModifierMappingReply setModifierMapping;
+    xGetModifierMappingReply getModifierMapping;
+    xSetPointerMappingReply setPointerMapping;
+    xGetKeyboardMappingReply getKeyboardMapping;
+    xGetPointerMappingReply getPointerMapping;
+    xGetPointerControlReply pointerControl;
+    xGetScreenSaverReply screenSaver;
+    xListHostsReply hosts;
+    xError error;
+    xEvent event;
+} xReply;
+
+
+
+/*****************************************************************
+ * REQUESTS
+ *****************************************************************/
+
+
+/* Request structure */
+
+typedef struct _xReq {
+	CARD8 reqType;
+	CARD8 data;            /* meaning depends on request type */
+	CARD16 length;         /* length in 4 bytes quantities
+				  of whole request, including this header */
+} xReq;
+
+/*****************************************************************
+ *  structures that follow request.
+ *****************************************************************/
+
+/* ResourceReq is used for any request which has a resource ID
+   (or Atom or Time) as its one and only argument.  */
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    CARD32 id;  /* a Window, Drawable, Font, GContext, Pixmap, etc. */
+    } xResourceReq;
+
+typedef struct {
+    CARD8 reqType;
+    CARD8 depth;
+    CARD16 length;
+    Window wid, parent;
+    INT16 x, y;
+    CARD16 width, height, borderWidth;
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD16 c_class;
+#else
+    CARD16 class;
+#endif
+    VisualID visual;
+    CARD32 mask;
+} xCreateWindowReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Window window;
+    CARD32 valueMask;
+} xChangeWindowAttributesReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE mode;
+    CARD16 length;
+    Window window;
+} xChangeSaveSetReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Window window, parent;
+    INT16 x, y;
+} xReparentWindowReq;
+
+typedef struct {
+    CARD8 reqType;
+    CARD8 pad;
+    CARD16 length;
+    Window window;
+    CARD16 mask;
+    CARD16 pad2;
+} xConfigureWindowReq;
+
+typedef struct {
+    CARD8 reqType;
+    CARD8 direction;
+    CARD16 length;
+    Window window;
+} xCirculateWindowReq;
+
+typedef struct {    /* followed by padded string */
+    CARD8 reqType;
+    BOOL onlyIfExists;
+    CARD16 length;
+    CARD16 nbytes;    /* number of bytes in string */
+    CARD16 pad;
+} xInternAtomReq;
+
+typedef struct {
+    CARD8 reqType;
+    CARD8 mode;
+    CARD16 length;
+    Window window;
+    Atom property, type;
+    CARD8 format;
+    BYTE pad[3];
+    CARD32 nUnits;     /* length of stuff following, depends on format */
+} xChangePropertyReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Window window;
+    Atom property;
+} xDeletePropertyReq;
+
+typedef struct {
+    CARD8 reqType;
+#if defined(__cplusplus) || defined(c_plusplus)
+    BOOL c_delete;
+#else
+    BOOL delete;
+#endif
+    CARD16 length;
+    Window window;
+    Atom property, type;
+    CARD32 longOffset;
+    CARD32 longLength;
+} xGetPropertyReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Window window;
+    Atom selection;
+    Time time;
+} xSetSelectionOwnerReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Window requestor;
+    Atom selection, target, property;
+    Time time;
+    } xConvertSelectionReq;
+
+typedef struct {
+    CARD8 reqType;
+    BOOL propagate;
+    CARD16 length;
+    Window destination;
+    CARD32 eventMask;
+    xEvent event;
+} xSendEventReq;
+
+typedef struct {
+    CARD8 reqType;
+    BOOL ownerEvents;
+    CARD16 length;
+    Window grabWindow;
+    CARD16 eventMask;
+    BYTE pointerMode, keyboardMode;
+    Window confineTo;
+    Cursor cursor;
+    Time time;
+} xGrabPointerReq;
+
+typedef struct {
+    CARD8 reqType;
+    BOOL ownerEvents;
+    CARD16 length;
+    Window grabWindow;
+    CARD16 eventMask;
+    BYTE pointerMode, keyboardMode;
+    Window confineTo;
+    Cursor cursor;
+    CARD8 button;
+    BYTE pad;
+    CARD16 modifiers;
+} xGrabButtonReq;
+
+typedef struct {
+    CARD8 reqType;
+    CARD8 button;
+    CARD16 length;
+    Window grabWindow;
+    CARD16 modifiers;
+    CARD16 pad;
+} xUngrabButtonReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Cursor cursor;
+    Time time;
+    CARD16 eventMask;
+    CARD16 pad2;
+} xChangeActivePointerGrabReq;
+
+typedef struct {
+    CARD8 reqType;
+    BOOL ownerEvents;
+    CARD16 length;
+    Window grabWindow;
+    Time time;
+    BYTE pointerMode, keyboardMode;
+    CARD16 pad;
+} xGrabKeyboardReq;
+
+typedef struct {
+    CARD8 reqType;
+    BOOL ownerEvents;
+    CARD16 length;
+    Window grabWindow;
+    CARD16 modifiers;
+    CARD8 key;
+    BYTE pointerMode, keyboardMode;
+    BYTE pad1, pad2, pad3;
+} xGrabKeyReq;
+
+typedef struct {
+    CARD8 reqType;
+    CARD8 key;
+    CARD16 length;
+    Window grabWindow;
+    CARD16 modifiers;
+    CARD16 pad;
+} xUngrabKeyReq;
+
+typedef struct {
+    CARD8 reqType;
+    CARD8 mode;
+    CARD16 length;
+    Time time;
+} xAllowEventsReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Window window;
+    Time start, stop;
+} xGetMotionEventsReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Window srcWid, dstWid;
+    INT16 srcX, srcY;
+} xTranslateCoordsReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Window srcWid, dstWid;
+    INT16 srcX, srcY;
+    CARD16 srcWidth, srcHeight;
+    INT16 dstX, dstY;
+} xWarpPointerReq;
+
+typedef struct {
+    CARD8 reqType;
+    CARD8 revertTo;
+    CARD16 length;
+    Window focus;
+    Time time;
+} xSetInputFocusReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Font fid;
+    CARD16 nbytes;
+    BYTE pad1, pad2;	/* string follows on word boundary */
+} xOpenFontReq;
+
+typedef struct {
+    CARD8 reqType;
+    BOOL oddLength;
+    CARD16 length;
+    Font fid;
+    } xQueryTextExtentsReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    CARD16 maxNames;
+    CARD16 nbytes;	/* followed immediately by string bytes */
+} xListFontsReq;
+
+typedef xListFontsReq xListFontsWithInfoReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    CARD16 nFonts;
+    BYTE pad1, pad2;	/* LISTofSTRING8 follows on word boundary */
+} xSetFontPathReq;
+
+typedef struct {
+    CARD8 reqType;
+    CARD8 depth;
+    CARD16 length;
+    Pixmap pid;
+    Drawable drawable;
+    CARD16 width, height;
+} xCreatePixmapReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    GContext gc;
+    Drawable drawable;
+    CARD32 mask;
+} xCreateGCReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    GContext gc;
+    CARD32 mask;
+} xChangeGCReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    GContext srcGC, dstGC;
+    CARD32 mask;
+} xCopyGCReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    GContext gc;
+    CARD16 dashOffset;
+    CARD16 nDashes;	/* length LISTofCARD8 of values following */
+} xSetDashesReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE ordering;
+    CARD16 length;
+    GContext gc;
+    INT16 xOrigin, yOrigin;
+} xSetClipRectanglesReq;
+
+typedef struct {
+    CARD8 reqType;
+    BOOL exposures;
+    CARD16 length;
+    Window window;
+    INT16 x, y;
+    CARD16 width, height;
+} xClearAreaReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Drawable srcDrawable, dstDrawable;
+    GContext gc;
+    INT16 srcX, srcY, dstX, dstY;
+    CARD16 width, height;
+} xCopyAreaReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Drawable srcDrawable, dstDrawable;
+    GContext gc;
+    INT16 srcX, srcY, dstX, dstY;
+    CARD16 width, height;
+    CARD32 bitPlane;
+} xCopyPlaneReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE coordMode;
+    CARD16 length;
+    Drawable drawable;
+    GContext gc;
+} xPolyPointReq;
+
+typedef xPolyPointReq xPolyLineReq;  /* same request structure */
+
+/* The following used for PolySegment, PolyRectangle, PolyArc, PolyFillRectangle, PolyFillArc */
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Drawable drawable;
+    GContext gc;
+} xPolySegmentReq;
+
+typedef xPolySegmentReq xPolyArcReq;
+typedef xPolySegmentReq xPolyRectangleReq;
+typedef xPolySegmentReq xPolyFillRectangleReq;
+typedef xPolySegmentReq xPolyFillArcReq;
+
+typedef struct _FillPolyReq {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Drawable drawable;
+    GContext gc;
+    BYTE shape;
+    BYTE coordMode;
+    CARD16 pad1;
+} xFillPolyReq;
+
+
+typedef struct _PutImageReq {
+    CARD8 reqType;
+    CARD8 format;
+    CARD16 length;
+    Drawable drawable;
+    GContext gc;
+    CARD16 width, height;
+    INT16 dstX, dstY;
+    CARD8 leftPad;
+    CARD8 depth;
+    CARD16 pad;
+} xPutImageReq;
+
+typedef struct {
+    CARD8 reqType;
+    CARD8 format;
+    CARD16 length;
+    Drawable drawable;
+    INT16 x, y;
+    CARD16 width, height;
+    CARD32 planeMask;
+} xGetImageReq;
+
+/* the following used by PolyText8 and PolyText16 */
+
+typedef struct {
+    CARD8 reqType;
+    CARD8 pad;
+    CARD16 length;
+    Drawable drawable;
+    GContext gc;
+    INT16 x, y;		/* items (xTextElt) start after struct */
+} xPolyTextReq;
+
+typedef xPolyTextReq xPolyText8Req;
+typedef xPolyTextReq xPolyText16Req;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE nChars;
+    CARD16 length;
+    Drawable drawable;
+    GContext gc;
+    INT16 x, y;
+} xImageTextReq;
+
+typedef xImageTextReq xImageText8Req;
+typedef xImageTextReq xImageText16Req;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE alloc;
+    CARD16 length;
+    Colormap mid;
+    Window window;
+    VisualID visual;
+} xCreateColormapReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Colormap mid;
+    Colormap srcCmap;
+} xCopyColormapAndFreeReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Colormap cmap;
+    CARD16 red, green, blue;
+    CARD16 pad2;
+} xAllocColorReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Colormap cmap;
+    CARD16 nbytes;	/* followed by structure */
+    BYTE pad1, pad2;
+} xAllocNamedColorReq;
+
+typedef struct {
+    CARD8 reqType;
+    BOOL contiguous;
+    CARD16 length;
+    Colormap cmap;
+    CARD16 colors, planes;
+} xAllocColorCellsReq;
+
+typedef struct {
+    CARD8 reqType;
+    BOOL contiguous;
+    CARD16 length;
+    Colormap cmap;
+    CARD16 colors, red, green, blue;
+} xAllocColorPlanesReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Colormap cmap;
+    CARD32 planeMask;
+} xFreeColorsReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Colormap cmap;
+} xStoreColorsReq;
+
+typedef struct {
+    CARD8 reqType;
+    CARD8 flags;   /* DoRed, DoGreen, DoBlue, as in xColorItem */
+    CARD16 length;
+    Colormap cmap;
+    CARD32 pixel;
+    CARD16 nbytes;  /* number of name string bytes following structure */
+    BYTE pad1, pad2;
+    } xStoreNamedColorReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Colormap cmap;
+} xQueryColorsReq;
+
+typedef struct {    /* followed  by string of length len */
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Colormap cmap;
+    CARD16 nbytes;  /* number of string bytes following structure*/
+    BYTE pad1, pad2;
+} xLookupColorReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Cursor cid;
+    Pixmap source, mask;
+    CARD16 foreRed, foreGreen, foreBlue;
+    CARD16 backRed, backGreen, backBlue;
+    CARD16 x, y;
+} xCreateCursorReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Cursor cid;
+    Font source, mask;
+    CARD16 sourceChar, maskChar;
+    CARD16 foreRed, foreGreen, foreBlue;
+    CARD16 backRed, backGreen, backBlue;
+} xCreateGlyphCursorReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Cursor cursor;
+    CARD16 foreRed, foreGreen, foreBlue;
+    CARD16 backRed, backGreen, backBlue;
+} xRecolorCursorReq;
+
+typedef struct {
+    CARD8 reqType;
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8 c_class;
+#else
+    CARD8 class;
+#endif
+    CARD16 length;
+    Drawable drawable;
+    CARD16 width, height;
+} xQueryBestSizeReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    CARD16 nbytes;	/* number of string bytes following structure */
+    BYTE pad1, pad2;
+} xQueryExtensionReq;
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   numKeyPerModifier;
+    CARD16  length;
+} xSetModifierMappingReq;
+
+typedef struct {
+    CARD8 reqType;
+    CARD8 nElts;	/* how many elements in the map */
+    CARD16 length;
+} xSetPointerMappingReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    KeyCode firstKeyCode;
+    CARD8 count;
+    CARD16 pad1;
+} xGetKeyboardMappingReq;
+
+typedef struct {
+    CARD8 reqType;
+    CARD8 keyCodes;
+    CARD16 length;
+    KeyCode firstKeyCode;
+    CARD8 keySymsPerKeyCode;
+    CARD16 pad1;
+} xChangeKeyboardMappingReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    CARD32 mask;
+} xChangeKeyboardControlReq;
+
+typedef struct {
+    CARD8 reqType;
+    INT8 percent;  /* -100 to 100 */
+    CARD16 length;
+} xBellReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    INT16 accelNum, accelDenum;
+    INT16 threshold;
+    BOOL doAccel, doThresh;
+} xChangePointerControlReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    INT16 timeout, interval;
+    BYTE preferBlank, allowExpose;
+    CARD16 pad2;
+} xSetScreenSaverReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE mode;
+    CARD16 length;
+    CARD8 hostFamily;
+    BYTE pad;
+    CARD16 hostLength;
+} xChangeHostsReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    } xListHostsReq;
+
+typedef struct {
+    CARD8 reqType;
+    BYTE mode;
+    CARD16 length;
+    } xChangeModeReq;
+
+typedef xChangeModeReq xSetAccessControlReq;
+typedef xChangeModeReq xSetCloseDownModeReq;
+typedef xChangeModeReq xForceScreenSaverReq;
+
+typedef struct { /* followed by LIST of ATOM */
+    CARD8 reqType;
+    BYTE pad;
+    CARD16 length;
+    Window window;
+    CARD16 nAtoms;
+    INT16 nPositions;
+    } xRotatePropertiesReq;
+
+
+
+/* Reply codes */
+
+#define X_Reply		1		/* Normal reply */
+#define X_Error		0		/* Error */
+
+/* Request codes */
+
+#define X_CreateWindow                  1
+#define X_ChangeWindowAttributes        2
+#define X_GetWindowAttributes           3
+#define X_DestroyWindow                 4
+#define X_DestroySubwindows             5
+#define X_ChangeSaveSet                 6
+#define X_ReparentWindow                7
+#define X_MapWindow                     8
+#define X_MapSubwindows                 9
+#define X_UnmapWindow                  10
+#define X_UnmapSubwindows              11
+#define X_ConfigureWindow              12
+#define X_CirculateWindow              13
+#define X_GetGeometry                  14
+#define X_QueryTree                    15
+#define X_InternAtom                   16
+#define X_GetAtomName                  17
+#define X_ChangeProperty               18
+#define X_DeleteProperty               19
+#define X_GetProperty                  20
+#define X_ListProperties               21
+#define X_SetSelectionOwner            22
+#define X_GetSelectionOwner            23
+#define X_ConvertSelection             24
+#define X_SendEvent                    25
+#define X_GrabPointer                  26
+#define X_UngrabPointer                27
+#define X_GrabButton                   28
+#define X_UngrabButton                 29
+#define X_ChangeActivePointerGrab      30
+#define X_GrabKeyboard                 31
+#define X_UngrabKeyboard               32
+#define X_GrabKey                      33
+#define X_UngrabKey                    34
+#define X_AllowEvents                  35
+#define X_GrabServer                   36
+#define X_UngrabServer                 37
+#define X_QueryPointer                 38
+#define X_GetMotionEvents              39
+#define X_TranslateCoords              40
+#define X_WarpPointer                  41
+#define X_SetInputFocus                42
+#define X_GetInputFocus                43
+#define X_QueryKeymap                  44
+#define X_OpenFont                     45
+#define X_CloseFont                    46
+#define X_QueryFont                    47
+#define X_QueryTextExtents             48
+#define X_ListFonts                    49
+#define X_ListFontsWithInfo    	       50
+#define X_SetFontPath                  51
+#define X_GetFontPath                  52
+#define X_CreatePixmap                 53
+#define X_FreePixmap                   54
+#define X_CreateGC                     55
+#define X_ChangeGC                     56
+#define X_CopyGC                       57
+#define X_SetDashes                    58
+#define X_SetClipRectangles            59
+#define X_FreeGC                       60
+#define X_ClearArea                    61
+#define X_CopyArea                     62
+#define X_CopyPlane                    63
+#define X_PolyPoint                    64
+#define X_PolyLine                     65
+#define X_PolySegment                  66
+#define X_PolyRectangle                67
+#define X_PolyArc                      68
+#define X_FillPoly                     69
+#define X_PolyFillRectangle            70
+#define X_PolyFillArc                  71
+#define X_PutImage                     72
+#define X_GetImage                     73
+#define X_PolyText8                    74
+#define X_PolyText16                   75
+#define X_ImageText8                   76
+#define X_ImageText16                  77
+#define X_CreateColormap               78
+#define X_FreeColormap                 79
+#define X_CopyColormapAndFree          80
+#define X_InstallColormap              81
+#define X_UninstallColormap            82
+#define X_ListInstalledColormaps       83
+#define X_AllocColor                   84
+#define X_AllocNamedColor              85
+#define X_AllocColorCells              86
+#define X_AllocColorPlanes             87
+#define X_FreeColors                   88
+#define X_StoreColors                  89
+#define X_StoreNamedColor              90
+#define X_QueryColors                  91
+#define X_LookupColor                  92
+#define X_CreateCursor                 93
+#define X_CreateGlyphCursor            94
+#define X_FreeCursor                   95
+#define X_RecolorCursor                96
+#define X_QueryBestSize                97
+#define X_QueryExtension               98
+#define X_ListExtensions               99
+#define X_ChangeKeyboardMapping        100
+#define X_GetKeyboardMapping           101
+#define X_ChangeKeyboardControl        102
+#define X_GetKeyboardControl           103
+#define X_Bell                         104
+#define X_ChangePointerControl         105
+#define X_GetPointerControl            106
+#define X_SetScreenSaver               107
+#define X_GetScreenSaver               108
+#define X_ChangeHosts                  109
+#define X_ListHosts                    110
+#define X_SetAccessControl             111
+#define X_SetCloseDownMode             112
+#define X_KillClient                   113
+#define X_RotateProperties	       114
+#define X_ForceScreenSaver	       115
+#define X_SetPointerMapping            116
+#define X_GetPointerMapping            117
+#define X_SetModifierMapping	       118
+#define X_GetModifierMapping	       119
+#define X_NoOperation                  127
+
+/* restore these definitions back to the typedefs in X.h */
+#undef Window
+#undef Drawable
+#undef Font
+#undef Pixmap
+#undef Cursor
+#undef Colormap
+#undef GContext
+#undef Atom
+#undef VisualID
+#undef Time
+#undef KeyCode
+#undef KeySym
+
+#endif /* XPROTO_H */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/Xprotostr.h b/depends/libxcb/depends/xorgproto/include/X11/Xprotostr.h
new file mode 100644
index 0000000..07d017d
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/Xprotostr.h
@@ -0,0 +1,77 @@
+#ifndef XPROTOSTRUCTS_H
+#define XPROTOSTRUCTS_H
+
+/***********************************************************
+
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+#include <X11/Xmd.h>
+
+/* Used by PolySegment */
+
+typedef struct _xSegment {
+    INT16 x1, y1, x2, y2;
+} xSegment;
+
+/* POINT */
+
+typedef struct _xPoint {
+    INT16   x, y;
+} xPoint;
+
+typedef struct _xRectangle {
+    INT16   x, y;
+    CARD16  width, height;
+} xRectangle;
+
+/*  ARC  */
+
+typedef struct _xArc {
+    INT16   x, y;
+    CARD16  width, height;
+    INT16   angle1, angle2;
+} xArc;
+
+#endif /* XPROTOSTRUCTS_H */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/Xthreads.h b/depends/libxcb/depends/xorgproto/include/X11/Xthreads.h
new file mode 100644
index 0000000..2027127
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/Xthreads.h
@@ -0,0 +1,314 @@
+/*
+ *
+Copyright 1993, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ * *
+ */
+
+#ifndef _XTHREADS_H_
+# define _XTHREADS_H_
+
+/* Redefine these to XtMalloc/XtFree or whatever you want before including
+ * this header file.
+ */
+# ifndef xmalloc
+#  define xmalloc malloc
+# endif
+# ifndef xfree
+#  define xfree free
+# endif
+
+# ifdef CTHREADS
+#  include <cthreads.h>
+typedef cthread_t xthread_t;
+typedef struct condition xcondition_rec;
+typedef struct mutex xmutex_rec;
+#  define xthread_init() cthread_init()
+#  define xthread_self cthread_self
+#  define xthread_fork(func,closure) cthread_fork(func,closure)
+#  define xthread_yield() cthread_yield()
+#  define xthread_exit(v) cthread_exit(v)
+#  define xthread_set_name(t,str) cthread_set_name(t,str)
+#  define xmutex_init(m) mutex_init(m)
+#  define xmutex_clear(m) mutex_clear(m)
+#  define xmutex_lock(m) mutex_lock(m)
+#  define xmutex_unlock(m) mutex_unlock(m)
+#  define xmutex_set_name(m,str) mutex_set_name(m,str)
+#  define xcondition_init(cv) condition_init(cv)
+#  define xcondition_clear(cv) condition_clear(cv)
+#  define xcondition_wait(cv,m) condition_wait(cv,m)
+#  define xcondition_signal(cv) condition_signal(cv)
+#  define xcondition_broadcast(cv) condition_broadcast(cv)
+#  define xcondition_set_name(cv,str) condition_set_name(cv,str)
+# else /* !CTHREADS */
+#  if defined(SVR4)
+#   include <thread.h>
+#   include <synch.h>
+typedef thread_t xthread_t;
+typedef thread_key_t xthread_key_t;
+typedef cond_t xcondition_rec;
+typedef mutex_t xmutex_rec;
+#   if defined(__UNIXWARE__)
+extern xthread_t (*_x11_thr_self)();
+#    define xthread_self  (_x11_thr_self)
+#   else
+#    define xthread_self thr_self
+#   endif
+#   define xthread_fork(func,closure) thr_create(NULL,0,func,closure,THR_NEW_LWP|THR_DETACHED,NULL)
+#   define xthread_yield() thr_yield()
+#   define xthread_exit(v) thr_exit(v)
+#   define xthread_key_create(kp,d) thr_keycreate(kp,d)
+#   ifdef __sun
+#    define xthread_key_delete(k) 0
+#   else
+#    define xthread_key_delete(k) thr_keydelete(k)
+#   endif
+#   define xthread_set_specific(k,v) thr_setspecific(k,v)
+#   define xthread_get_specific(k,vp) thr_getspecific(k,vp)
+#   define xmutex_init(m) mutex_init(m,USYNC_THREAD,0)
+#   define xmutex_clear(m) mutex_destroy(m)
+#   define xmutex_lock(m) mutex_lock(m)
+#   define xmutex_unlock(m) mutex_unlock(m)
+#   define xcondition_init(cv) cond_init(cv,USYNC_THREAD,0)
+#   define xcondition_clear(cv) cond_destroy(cv)
+#   define xcondition_wait(cv,m) cond_wait(cv,m)
+#   define xcondition_signal(cv) cond_signal(cv)
+#   define xcondition_broadcast(cv) cond_broadcast(cv)
+#  else /* !SVR4 */
+#   ifdef WIN32
+#    include <X11/Xwindows.h>
+typedef DWORD xthread_t;
+typedef DWORD xthread_key_t;
+struct _xthread_waiter {
+    HANDLE sem;
+    struct _xthread_waiter *next;
+};
+typedef struct {
+    CRITICAL_SECTION cs;
+    struct _xthread_waiter *waiters;
+} xcondition_rec;
+typedef CRITICAL_SECTION xmutex_rec;
+extern void _Xthread_init(void);
+#    define xthread_init() _Xthread_init()
+#    define xthread_self GetCurrentThreadId
+#    define xthread_fork(func,closure) { \
+    DWORD _tmptid; \
+    CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)func, (LPVOID)closure, 0, \
+		 &_tmptid); \
+}
+#    define xthread_yield() Sleep(0)
+#    define xthread_exit(v) ExitThread((DWORD)(v))
+#    define xthread_key_create(kp,d) *(kp) = TlsAlloc()
+#    define xthread_key_delete(k) TlsFree(k)
+#    define xthread_set_specific(k,v) TlsSetValue(k,v)
+#    define xthread_get_specific(k,vp) TlsGetValue(k)
+#    define xmutex_init(m) InitializeCriticalSection(m)
+#    define xmutex_clear(m) DeleteCriticalSection(m)
+#    define _XMUTEX_NESTS
+#    define xmutex_lock(m) EnterCriticalSection(m)
+#    define xmutex_unlock(m) LeaveCriticalSection(m)
+#    define xcondition_init(cv) { \
+    InitializeCriticalSection(&(cv)->cs); \
+    (cv)->waiters = NULL; \
+}
+#    define xcondition_clear(cv) DeleteCriticalSection(&(cv)->cs)
+extern struct _xthread_waiter *_Xthread_waiter();
+#    define xcondition_wait(cv,m) { \
+    struct _xthread_waiter *_tmpthr = _Xthread_waiter(); \
+    EnterCriticalSection(&(cv)->cs); \
+    _tmpthr->next = (cv)->waiters; \
+    (cv)->waiters = _tmpthr; \
+    LeaveCriticalSection(&(cv)->cs); \
+    LeaveCriticalSection(m); \
+    WaitForSingleObject(_tmpthr->sem, INFINITE); \
+    EnterCriticalSection(m); \
+}
+#    define xcondition_signal(cv) { \
+    EnterCriticalSection(&(cv)->cs); \
+    if ((cv)->waiters) { \
+        ReleaseSemaphore((cv)->waiters->sem, 1, NULL); \
+	(cv)->waiters = (cv)->waiters->next; \
+    } \
+    LeaveCriticalSection(&(cv)->cs); \
+}
+#    define xcondition_broadcast(cv) { \
+    struct _xthread_waiter *_tmpthr; \
+    EnterCriticalSection(&(cv)->cs); \
+    for (_tmpthr = (cv)->waiters; _tmpthr; _tmpthr = _tmpthr->next) \
+	ReleaseSemaphore(_tmpthr->sem, 1, NULL); \
+    (cv)->waiters = NULL; \
+    LeaveCriticalSection(&(cv)->cs); \
+}
+#   else /* !WIN32 */
+#    ifdef USE_TIS_SUPPORT
+/*
+ * TIS support is intended for thread safe libraries.
+ * This should not be used for general client programming.
+ */
+#     include <tis.h>
+typedef pthread_t xthread_t;
+typedef pthread_key_t xthread_key_t;
+typedef pthread_cond_t xcondition_rec;
+typedef pthread_mutex_t xmutex_rec;
+#     define xthread_self tis_self
+#     define xthread_fork(func,closure) { pthread_t _tmpxthr; \
+        pthread_create(&_tmpxthr,NULL,func,closure); }
+#     define xthread_yield() pthread_yield_np()
+#     define xthread_exit(v) pthread_exit(v)
+#     define xthread_key_create(kp,d) tis_key_create(kp,d)
+#     define xthread_key_delete(k) tis_key_delete(k)
+#     define xthread_set_specific(k,v) tis_setspecific(k,v)
+#     define xthread_get_specific(k,vp) *(vp) = tis_getspecific(k)
+#     define XMUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
+#     define xmutex_init(m) tis_mutex_init(m)
+#     define xmutex_clear(m) tis_mutex_destroy(m)
+#     define xmutex_lock(m) tis_mutex_lock(m)
+#     define xmutex_unlock(m) tis_mutex_unlock(m)
+#     define xcondition_init(c) tis_cond_init(c)
+#     define xcondition_clear(c) tis_cond_destroy(c)
+#     define xcondition_wait(c,m) tis_cond_wait(c,m)
+#     define xcondition_signal(c) tis_cond_signal(c)
+#     define xcondition_broadcast(c) tis_cond_broadcast(c)
+#    else
+#     ifdef USE_NBSD_THREADLIB
+/*
+ * NetBSD threadlib support is intended for thread safe libraries.
+ * This should not be used for general client programming.
+ */
+#      include <threadlib.h>
+typedef thr_t xthread_t;
+typedef thread_key_t xthread_key_t;
+typedef cond_t xcondition_rec;
+typedef mutex_t xmutex_rec;
+#      define xthread_self thr_self
+#      define xthread_fork(func,closure) { thr_t _tmpxthr; \
+	/* XXX Create it detached?  --thorpej */ \
+	thr_create(&_tmpxthr,NULL,func,closure); }
+#      define xthread_yield() thr_yield()
+#      define xthread_exit(v) thr_exit(v)
+#      define xthread_key_create(kp,d) thr_keycreate(kp,d)
+#      define xthread_key_delete(k) thr_keydelete(k)
+#      define xthread_set_specific(k,v) thr_setspecific(k,v)
+#      define xthread_get_specific(k,vp) *(vp) = thr_getspecific(k)
+#      define XMUTEX_INITIALIZER MUTEX_INITIALIZER
+#      define xmutex_init(m) mutex_init(m, 0)
+#      define xmutex_clear(m) mutex_destroy(m)
+#      define xmutex_lock(m) mutex_lock(m)
+#      define xmutex_unlock(m) mutex_unlock(m)
+#      define xcondition_init(c) cond_init(c, 0, 0)
+#      define xcondition_clear(c) cond_destroy(c)
+#      define xcondition_wait(c,m) cond_wait(c,m)
+#      define xcondition_signal(c) cond_signal(c)
+#      define xcondition_broadcast(c) cond_broadcast(c)
+#     else
+#      include <pthread.h>
+typedef pthread_t xthread_t;
+typedef pthread_key_t xthread_key_t;
+typedef pthread_cond_t xcondition_rec;
+typedef pthread_mutex_t xmutex_rec;
+#      define xthread_self pthread_self
+#      define xthread_yield() pthread_yield()
+#      define xthread_exit(v) pthread_exit(v)
+#      define xthread_set_specific(k,v) pthread_setspecific(k,v)
+#      define xmutex_clear(m) pthread_mutex_destroy(m)
+#      define xmutex_lock(m) pthread_mutex_lock(m)
+#      define xmutex_unlock(m) pthread_mutex_unlock(m)
+#      ifndef XPRE_STANDARD_API
+#       define xthread_key_create(kp,d) pthread_key_create(kp,d)
+#       define xthread_key_delete(k) pthread_key_delete(k)
+#       define xthread_get_specific(k,vp) *(vp) = pthread_getspecific(k)
+#       define xthread_fork(func,closure) { pthread_t _tmpxthr; \
+	pthread_create(&_tmpxthr,NULL,func,closure); }
+#       define XMUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
+#       define xmutex_init(m) pthread_mutex_init(m, NULL)
+#       define xcondition_init(c) pthread_cond_init(c, NULL)
+#      else /* XPRE_STANDARD_API */
+#       define xthread_key_create(kp,d) pthread_keycreate(kp,d)
+#       define xthread_key_delete(k) 0
+#       define xthread_get_specific(k,vp) pthread_getspecific(k,vp)
+#       define xthread_fork(func,closure) { pthread_t _tmpxthr; \
+	pthread_create(&_tmpxthr,pthread_attr_default,func,closure); }
+#       define xmutex_init(m) pthread_mutex_init(m, pthread_mutexattr_default)
+#       define xcondition_init(c) pthread_cond_init(c, pthread_condattr_default)
+#      endif /* XPRE_STANDARD_API */
+#      define xcondition_clear(c) pthread_cond_destroy(c)
+#      define xcondition_wait(c,m) pthread_cond_wait(c,m)
+#      define xcondition_signal(c) pthread_cond_signal(c)
+#      define xcondition_broadcast(c) pthread_cond_broadcast(c)
+#      if defined(_DECTHREADS_)
+static xthread_t _X_no_thread_id;
+#       define xthread_have_id(id) !pthread_equal(id, _X_no_thread_id)
+#       define xthread_clear_id(id) id = _X_no_thread_id
+#       define xthread_equal(id1,id2) pthread_equal(id1, id2)
+#      endif /* _DECTHREADS_ */
+#      if defined(__linux__)
+#       define xthread_have_id(id) !pthread_equal(id, 0)
+#       define xthread_clear_id(id) id = 0
+#       define xthread_equal(id1,id2) pthread_equal(id1, id2)
+#      endif /* linux */
+#      if defined(_CMA_VENDOR_) && defined(_CMA__IBM) && (_CMA_VENDOR_ == _CMA__IBM)
+#       ifdef DEBUG		/* too much of a hack to enable normally */
+/* see also cma__obj_set_name() */
+#        define xmutex_set_name(m,str) ((char**)(m)->field1)[5] = (str)
+#        define xcondition_set_name(cv,str) ((char**)(cv)->field1)[5] = (str)
+#       endif /* DEBUG */
+#      endif /* _CMA_VENDOR_ == _CMA__IBM */
+#     endif /* USE_NBSD_THREADLIB */
+#    endif /* USE_TIS_SUPPORT */
+#   endif /* WIN32 */
+#  endif /* SVR4 */
+# endif /* CTHREADS */
+typedef xcondition_rec *xcondition_t;
+typedef xmutex_rec *xmutex_t;
+# ifndef xcondition_malloc
+#  define xcondition_malloc() (xcondition_t)xmalloc(sizeof(xcondition_rec))
+# endif
+# ifndef xcondition_free
+#  define xcondition_free(c) xfree((char *)c)
+# endif
+# ifndef xmutex_malloc
+#  define xmutex_malloc() (xmutex_t)xmalloc(sizeof(xmutex_rec))
+# endif
+# ifndef xmutex_free
+#  define xmutex_free(m) xfree((char *)m)
+# endif
+# ifndef xthread_have_id
+#  define xthread_have_id(id) id
+# endif
+# ifndef xthread_clear_id
+#  define xthread_clear_id(id) id = 0
+# endif
+# ifndef xthread_equal
+#  define xthread_equal(id1,id2) ((id1) == (id2))
+# endif
+/* aids understood by some debuggers */
+# ifndef xthread_set_name
+#  define xthread_set_name(t,str)
+# endif
+# ifndef xmutex_set_name
+#  define xmutex_set_name(m,str)
+# endif
+# ifndef xcondition_set_name
+#  define xcondition_set_name(cv,str)
+# endif
+
+#endif /* _XTHREADS_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/Xw32defs.h b/depends/libxcb/depends/xorgproto/include/X11/Xw32defs.h
new file mode 100644
index 0000000..683b588
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/Xw32defs.h
@@ -0,0 +1,79 @@
+#ifndef _XW32DEFS_H
+# define  _XW32DEFS_H
+
+# ifdef __GNUC__ /* mingw is more close to unix than msvc */
+#  if !defined(__daddr_t_defined)
+typedef char *caddr_t;
+#  endif
+#  define lstat stat
+
+# else
+typedef char *caddr_t;
+
+#  define access	   _access
+#  define alloca	   _alloca
+#  define chdir	_chdir
+#  define chmod	   _chmod
+#  define close	   _close
+#  define creat	   _creat
+#  define dup	   _dup
+#  define dup2	   _dup2
+#  define environ     _environ
+#  define execl	 _execl
+#  define execle	 _execle
+#  define execlp	 _execlp
+#  define execlpe  _execlpe
+#  define execv	 _execv
+#  define execve	 _execve
+#  define execvp	 _execvp
+#  define execvpe  _execvpe
+#  define fdopen	  _fdopen
+#  define fileno	  _fileno
+#  define fstat	 _fstat
+#  define getcwd	_getcwd
+#  define getpid	 _getpid
+#  define hypot		_hypot
+#  define isascii __isascii
+#  define isatty	   _isatty
+#  define lseek	   _lseek
+#  define mkdir	_mkdir
+#  define mktemp	   _mktemp
+#  define open	   _open
+#  define putenv	    _putenv
+#  define read	   _read
+#  define rmdir	_rmdir
+#  define sleep(x) Sleep((x) * 1000)
+#  define stat	 _stat
+#  define sys_errlist _sys_errlist
+#  define sys_nerr    _sys_nerr
+#  define umask	   _umask
+#  define unlink	   _unlink
+#  define write	   _write
+#  define random   rand
+#  define srandom  srand
+
+#  define O_RDONLY    _O_RDONLY
+#  define O_WRONLY    _O_WRONLY
+#  define O_RDWR	    _O_RDWR
+#  define O_APPEND    _O_APPEND
+#  define O_CREAT     _O_CREAT
+#  define O_TRUNC     _O_TRUNC
+#  define O_EXCL	    _O_EXCL
+#  define O_TEXT	    _O_TEXT
+#  define O_BINARY    _O_BINARY
+#  define O_RAW	    _O_BINARY
+
+#  define S_IFMT	 _S_IFMT
+#  define S_IFDIR  _S_IFDIR
+#  define S_IFCHR  _S_IFCHR
+#  define S_IFREG  _S_IFREG
+#  define S_IREAD  _S_IREAD
+#  define S_IWRITE _S_IWRITE
+#  define S_IEXEC  _S_IEXEC
+
+#  define	F_OK	0
+#  define	X_OK	1
+#  define	W_OK	2
+#  define	R_OK	4
+# endif /* __GNUC__ */
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/Xwindows.h b/depends/libxcb/depends/xorgproto/include/X11/Xwindows.h
new file mode 100644
index 0000000..33f98a6
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/Xwindows.h
@@ -0,0 +1,117 @@
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT
+SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABIL-
+ITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization from
+The Open Group.
+
+*/
+
+/*
+ * This header file has the sole purpose of allowing the inclusion of
+ * windows.h without getting any name conflicts with X headers code, by
+ * renaming or disabling the conflicting definitions from windows.h
+ */
+
+/*
+ * Mingw.org versions of the Windows API headers actually avoid
+ * making the conflicting definitions if XFree86Server is defined, so we
+ * need to remember if that was defined and undefine it during including
+ * windows.h (so the conflicting definitions get wrapped correctly), and
+ * then redefine it afterwards. (This was never the correct thing to
+ * do as it's no help at all to X11 clients which also need to use the
+ * Win32 API)
+ */
+#undef _XFree86Server
+#ifdef XFree86Server
+# define _XFree86Server
+# undef XFree86Server
+#endif
+
+/*
+ * There doesn't seem to be a good way to wrap the min/max macros from
+ * windows.h, so we simply avoid defining them completely, allowing any
+ * pre-existing definition to stand.
+ *
+ */
+#define NOMINMAX
+
+/*
+ * mingw-w64 headers define BOOL as a typedef, protecting against macros
+ * mingw.org headers define BOOL in terms of WINBOOL
+ * ... so try to come up with something which works with both :-)
+ */
+#define _NO_BOOL_TYPEDEF
+#define BOOL WINBOOL
+#define INT32 wINT32
+#ifdef __x86_64__
+#define INT64 wINT64
+#define LONG64 wLONG64
+#endif
+#undef Status
+#define Status wStatus
+#define ATOM wATOM
+#define BYTE wBYTE
+#define FreeResource wFreeResource
+#pragma push_macro ("ControlMask")
+#undef ControlMask
+#include <windows.h>
+#undef NOMINMAX
+#undef Status
+#define Status int
+#undef BYTE
+#undef BOOL
+#undef INT32
+#undef INT64
+#undef LONG64
+#undef ATOM
+#undef FreeResource
+#pragma pop_macro ("ControlMask")
+#undef CreateWindowA
+
+/*
+ * Older version of this header used to name the windows API bool type wBOOL,
+ * rather than more standard name WINBOOL
+ */
+#define wBOOL WINBOOL
+
+#ifdef RESOURCE_H
+# undef RT_FONT
+# undef RT_CURSOR
+# define RT_FONT         ((RESTYPE)4)
+# define RT_CURSOR       ((RESTYPE)5)
+#endif
+
+#ifndef __CYGWIN__
+#define sleep(x) Sleep((x) * 1000)
+#endif
+
+#if defined(WIN32) && (!defined(PATH_MAX) || PATH_MAX < 1024)
+# undef PATH_MAX
+# define PATH_MAX 1024
+#endif
+
+#ifdef _XFree86Server
+# define XFree86Server
+# undef _XFree86Server
+#endif
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/Xwinsock.h b/depends/libxcb/depends/xorgproto/include/X11/Xwinsock.h
new file mode 100644
index 0000000..722a3cd
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/Xwinsock.h
@@ -0,0 +1,80 @@
+/*
+
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT
+SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABIL-
+ITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization from
+The Open Group.
+
+*/
+
+/*
+ * This header file has for sole purpose to allow to include winsock.h
+ * without getting any name conflicts with our code.
+ * Conflicts come from the fact that including winsock.h actually pulls
+ * in the whole Windows API...
+ */
+
+#undef _XFree86Server
+#ifdef XFree86Server
+# define _XFree86Server
+# undef XFree86Server
+#endif
+
+/*
+ * mingw-w64 headers define BOOL as a typedef, protecting against macros
+ * mingw.org headers define BOOL in terms of WINBOOL
+ * ... so try to come up with something which works with both :-)
+ */
+#define _NO_BOOL_TYPEDEF
+#define BOOL WINBOOL
+#define INT32 wINT32
+#undef Status
+#define Status wStatus
+#define ATOM wATOM
+#define BYTE wBYTE
+#define FreeResource wFreeResource
+#pragma push_macro ("ControlMask")
+#undef ControlMask
+#include <winsock2.h>
+#undef Status
+#define Status int
+#undef BYTE
+#undef BOOL
+#undef INT32
+#undef ATOM
+#undef FreeResource
+#pragma pop_macro ("ControlMask")
+#undef CreateWindowA
+#undef RT_FONT
+#undef RT_CURSOR
+
+/*
+ * Older version of this header used to name the windows API bool type wBOOL,
+ * rather than more standard name WINBOOL
+ */
+#define wBOOL WINBOOL
+
+#ifdef _XFree86Server
+# define XFree86Server
+# undef _XFree86Server
+#endif
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/ap_keysym.h b/depends/libxcb/depends/xorgproto/include/X11/ap_keysym.h
new file mode 100644
index 0000000..601f1e5
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/ap_keysym.h
@@ -0,0 +1,51 @@
+/******************************************************************
+Copyright 1987 by Apollo Computer Inc., Chelmsford, Massachusetts.
+Copyright 1989 by Hewlett-Packard Company.
+
+                        All Rights Reserved
+
+Permission to use, duplicate, change, and distribute this software and
+its documentation for any purpose and without fee is granted, provided
+that the above copyright notice appear in such copy and that this
+copyright notice appear in all supporting documentation, and that the
+names of Apollo Computer Inc., the Hewlett-Packard Company, or the X
+Consortium not be used in advertising or publicity pertaining to
+distribution of the software without written prior permission.
+
+HEWLETT-PACKARD MAKES NO WARRANTY OF ANY KIND WITH REGARD
+TO THIS SOFTWARE, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  Hewlett-Packard shall not be liable for errors
+contained herein or direct, indirect, special, incidental or
+consequential damages in connection with the furnishing,
+performance, or use of this material.
+
+This software is not subject to any license of the American
+Telephone and Telegraph Company or of the Regents of the
+University of California.
+******************************************************************/
+
+#define apXK_LineDel            0x1000FF00
+#define apXK_CharDel            0x1000FF01
+#define apXK_Copy               0x1000FF02
+#define apXK_Cut                0x1000FF03
+#define apXK_Paste              0x1000FF04
+#define apXK_Move               0x1000FF05
+#define apXK_Grow               0x1000FF06
+#define apXK_Cmd                0x1000FF07
+#define apXK_Shell              0x1000FF08
+#define apXK_LeftBar            0x1000FF09
+#define apXK_RightBar           0x1000FF0A
+#define apXK_LeftBox            0x1000FF0B
+#define apXK_RightBox           0x1000FF0C
+#define apXK_UpBox              0x1000FF0D
+#define apXK_DownBox            0x1000FF0E
+#define apXK_Pop                0x1000FF0F
+#define apXK_Read               0x1000FF10
+#define apXK_Edit               0x1000FF11
+#define apXK_Save               0x1000FF12
+#define apXK_Exit               0x1000FF13
+#define apXK_Repeat             0x1000FF14
+
+#define apXK_KP_parenleft       0x1000FFA8
+#define apXK_KP_parenright      0x1000FFA9
diff --git a/depends/libxcb/depends/xorgproto/include/X11/dri/meson.build b/depends/libxcb/depends/xorgproto/include/X11/dri/meson.build
new file mode 100644
index 0000000..d0ac724
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/dri/meson.build
@@ -0,0 +1,6 @@
+install_headers(
+    'xf86dri.h',
+    'xf86driproto.h',
+    'xf86dristr.h',
+    subdir : 'X11/dri'
+)
diff --git a/depends/libxcb/depends/xorgproto/include/X11/dri/xf86dri.h b/depends/libxcb/depends/xorgproto/include/X11/dri/xf86dri.h
new file mode 100644
index 0000000..00fb8ba
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/dri/xf86dri.h
@@ -0,0 +1,65 @@
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+Copyright 2000 VA Linux Systems, Inc.
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sub license, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice (including the
+next paragraph) shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+**************************************************************************/
+
+/**
+ * \file xf86dri.h
+ * Protocol numbers and function prototypes for DRI X protocol.
+ *
+ * \author Kevin E. Martin <martin@valinux.com>
+ * \author Jens Owen <jens@tungstengraphics.com>
+ * \author Rickard E. (Rik) Faith <faith@valinux.com>
+ */
+
+#ifndef _XF86DRI_H_
+#define _XF86DRI_H_
+
+#include <xf86drm.h>
+
+#define X_XF86DRIQueryVersion			0
+#define X_XF86DRIQueryDirectRenderingCapable	1
+#define X_XF86DRIOpenConnection			2
+#define X_XF86DRICloseConnection		3
+#define X_XF86DRIGetClientDriverName		4
+#define X_XF86DRICreateContext			5
+#define X_XF86DRIDestroyContext			6
+#define X_XF86DRICreateDrawable			7
+#define X_XF86DRIDestroyDrawable		8
+#define X_XF86DRIGetDrawableInfo		9
+#define X_XF86DRIGetDeviceInfo			10
+#define X_XF86DRIAuthConnection                 11
+#define X_XF86DRIOpenFullScreen                 12   /* Deprecated */
+#define X_XF86DRICloseFullScreen                13   /* Deprecated */
+
+#define XF86DRINumberEvents		0
+
+#define XF86DRIClientNotLocal		0
+#define XF86DRIOperationNotSupported	1
+#define XF86DRINumberErrors		(XF86DRIOperationNotSupported + 1)
+
+#endif /* _XF86DRI_H_ */
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/dri/xf86driproto.h b/depends/libxcb/depends/xorgproto/include/X11/dri/xf86driproto.h
new file mode 100644
index 0000000..1202e9b
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/dri/xf86driproto.h
@@ -0,0 +1,342 @@
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+Copyright 2000 VA Linux Systems, Inc.
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sub license, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice (including the
+next paragraph) shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Kevin E. Martin <martin@valinux.com>
+ *   Jens Owen <jens@tungstengraphics.com>
+ *   Rickard E. (Rik) Faith <faith@valinux.com>
+ *
+ */
+
+#ifndef _XF86DRISTR_H_
+#define _XF86DRISTR_H_
+
+#include "xf86dri.h"
+
+#define XF86DRINAME "XFree86-DRI"
+
+/* The DRI version number.  This was originally set to be the same of the
+ * XFree86 version number.  However, this version is really independent of
+ * the XFree86 version.
+ *
+ * Version History:
+ *    4.0.0: Original
+ *    4.0.1: Patch to bump clipstamp when windows are destroyed, 28 May 02
+ *    4.1.0: Add transition from single to multi in DRMInfo rec, 24 Jun 02
+ */
+#define XF86DRI_MAJOR_VERSION	4
+#define XF86DRI_MINOR_VERSION	1
+#define XF86DRI_PATCH_VERSION	0
+
+typedef struct _XF86DRIQueryVersion {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIQueryVersion */
+    CARD16	length;
+} xXF86DRIQueryVersionReq;
+#define sz_xXF86DRIQueryVersionReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	majorVersion;		/* major version of DRI protocol */
+    CARD16	minorVersion;		/* minor version of DRI protocol */
+    CARD32	patchVersion;		/* patch version of DRI protocol */
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXF86DRIQueryVersionReply;
+#define sz_xXF86DRIQueryVersionReply	32
+
+typedef struct _XF86DRIQueryDirectRenderingCapable {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* X_DRIQueryDirectRenderingCapable */
+    CARD16	length;
+    CARD32	screen;
+} xXF86DRIQueryDirectRenderingCapableReq;
+#define sz_xXF86DRIQueryDirectRenderingCapableReq	8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    BOOL	isCapable;
+    BOOL	pad2;
+    BOOL	pad3;
+    BOOL	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+    CARD32	pad7;
+    CARD32	pad8;
+    CARD32	pad9;
+} xXF86DRIQueryDirectRenderingCapableReply;
+#define sz_xXF86DRIQueryDirectRenderingCapableReply	32
+
+typedef struct _XF86DRIOpenConnection {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIOpenConnection */
+    CARD16	length;
+    CARD32	screen;
+} xXF86DRIOpenConnectionReq;
+#define sz_xXF86DRIOpenConnectionReq	8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	hSAREALow;
+    CARD32	hSAREAHigh;
+    CARD32	busIdStringLength;
+    CARD32	pad6;
+    CARD32	pad7;
+    CARD32	pad8;
+} xXF86DRIOpenConnectionReply;
+#define sz_xXF86DRIOpenConnectionReply	32
+
+typedef struct _XF86DRIAuthConnection {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRICloseConnection */
+    CARD16	length;
+    CARD32	screen;
+    CARD32	magic;
+} xXF86DRIAuthConnectionReq;
+#define sz_xXF86DRIAuthConnectionReq	12
+
+typedef struct {
+    BYTE        type;
+    BOOL        pad1;
+    CARD16      sequenceNumber;
+    CARD32      length;
+    CARD32      authenticated;
+    CARD32      pad2;
+    CARD32      pad3;
+    CARD32      pad4;
+    CARD32      pad5;
+    CARD32      pad6;
+} xXF86DRIAuthConnectionReply;
+#define zx_xXF86DRIAuthConnectionReply  32
+
+typedef struct _XF86DRICloseConnection {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRICloseConnection */
+    CARD16	length;
+    CARD32	screen;
+} xXF86DRICloseConnectionReq;
+#define sz_xXF86DRICloseConnectionReq	8
+
+typedef struct _XF86DRIGetClientDriverName {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIGetClientDriverName */
+    CARD16	length;
+    CARD32	screen;
+} xXF86DRIGetClientDriverNameReq;
+#define sz_xXF86DRIGetClientDriverNameReq	8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	ddxDriverMajorVersion;
+    CARD32	ddxDriverMinorVersion;
+    CARD32	ddxDriverPatchVersion;
+    CARD32	clientDriverNameLength;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXF86DRIGetClientDriverNameReply;
+#define sz_xXF86DRIGetClientDriverNameReply	32
+
+typedef struct _XF86DRICreateContext {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRICreateContext */
+    CARD16	length;
+    CARD32	screen;
+    CARD32	visual;
+    CARD32	context;
+} xXF86DRICreateContextReq;
+#define sz_xXF86DRICreateContextReq	16
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	hHWContext;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXF86DRICreateContextReply;
+#define sz_xXF86DRICreateContextReply	32
+
+typedef struct _XF86DRIDestroyContext {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIDestroyContext */
+    CARD16	length;
+    CARD32	screen;
+    CARD32	context;
+} xXF86DRIDestroyContextReq;
+#define sz_xXF86DRIDestroyContextReq	12
+
+typedef struct _XF86DRICreateDrawable {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRICreateDrawable */
+    CARD16	length;
+    CARD32	screen;
+    CARD32	drawable;
+} xXF86DRICreateDrawableReq;
+#define sz_xXF86DRICreateDrawableReq	12
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	hHWDrawable;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXF86DRICreateDrawableReply;
+#define sz_xXF86DRICreateDrawableReply	32
+
+typedef struct _XF86DRIDestroyDrawable {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIDestroyDrawable */
+    CARD16	length;
+    CARD32	screen;
+    CARD32	drawable;
+} xXF86DRIDestroyDrawableReq;
+#define sz_xXF86DRIDestroyDrawableReq	12
+
+typedef struct _XF86DRIGetDrawableInfo {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIGetDrawableInfo */
+    CARD16	length;
+    CARD32	screen;
+    CARD32	drawable;
+} xXF86DRIGetDrawableInfoReq;
+#define sz_xXF86DRIGetDrawableInfoReq	12
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	drawableTableIndex;
+    CARD32	drawableTableStamp;
+    INT16	drawableX;
+    INT16	drawableY;
+    INT16	drawableWidth;
+    INT16	drawableHeight;
+    CARD32	numClipRects;
+    INT16	backX;
+    INT16	backY;
+    CARD32	numBackClipRects;
+} xXF86DRIGetDrawableInfoReply;
+
+#define sz_xXF86DRIGetDrawableInfoReply	36
+
+
+typedef struct _XF86DRIGetDeviceInfo {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIGetDeviceInfo */
+    CARD16	length;
+    CARD32	screen;
+} xXF86DRIGetDeviceInfoReq;
+#define sz_xXF86DRIGetDeviceInfoReq	8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	hFrameBufferLow;
+    CARD32	hFrameBufferHigh;
+    CARD32	framebufferOrigin;
+    CARD32	framebufferSize;
+    CARD32	framebufferStride;
+    CARD32	devPrivateSize;
+} xXF86DRIGetDeviceInfoReply;
+#define sz_xXF86DRIGetDeviceInfoReply	32
+
+typedef struct _XF86DRIOpenFullScreen {
+    CARD8       reqType;	/* always DRIReqCode */
+    CARD8       driReqType;	/* always X_DRIOpenFullScreen */
+    CARD16      length;
+    CARD32      screen;
+    CARD32      drawable;
+} xXF86DRIOpenFullScreenReq;
+#define sz_xXF86DRIOpenFullScreenReq    12
+
+typedef struct {
+    BYTE        type;
+    BOOL        pad1;
+    CARD16      sequenceNumber;
+    CARD32      length;
+    CARD32      isFullScreen;
+    CARD32      pad2;
+    CARD32      pad3;
+    CARD32      pad4;
+    CARD32      pad5;
+    CARD32      pad6;
+} xXF86DRIOpenFullScreenReply;
+#define sz_xXF86DRIOpenFullScreenReply  32
+
+typedef struct _XF86DRICloseFullScreen {
+    CARD8       reqType;	/* always DRIReqCode */
+    CARD8       driReqType;	/* always X_DRICloseFullScreen */
+    CARD16      length;
+    CARD32      screen;
+    CARD32      drawable;
+} xXF86DRICloseFullScreenReq;
+#define sz_xXF86DRICloseFullScreenReq   12
+
+typedef struct {
+    BYTE        type;
+    BOOL        pad1;
+    CARD16      sequenceNumber;
+    CARD32      length;
+    CARD32      pad2;
+    CARD32      pad3;
+    CARD32      pad4;
+    CARD32      pad5;
+    CARD32      pad6;
+    CARD32      pad7;
+} xXF86DRICloseFullScreenReply;
+#define sz_xXF86DRICloseFullScreenReply  32
+
+
+#endif /* _XF86DRISTR_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/dri/xf86dristr.h b/depends/libxcb/depends/xorgproto/include/X11/dri/xf86dristr.h
new file mode 100644
index 0000000..048491e
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/dri/xf86dristr.h
@@ -0,0 +1,3 @@
+#warning "xf86dristr.h is obsolete and may be removed in the future."
+#warning "include <X11/dri/xf86driproto.h> for the protocol defines."
+#include <X11/dri/xf86driproto.h>
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/EVI.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/EVI.h
new file mode 100644
index 0000000..7f3f733
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/EVI.h
@@ -0,0 +1,36 @@
+/************************************************************
+Copyright (c) 1997 by Silicon Graphics Computer Systems, Inc.
+Permission to use, copy, modify, and distribute this
+software and its documentation for any purpose and without
+fee is hereby granted, provided that the above copyright
+notice appear in all copies and that both that copyright
+notice and this permission notice appear in supporting
+documentation, and that the name of Silicon Graphics not be
+used in advertising or publicity pertaining to distribution
+of the software without specific prior written permission.
+Silicon Graphics makes no representation about the suitability
+of this software for any purpose. It is provided "as is"
+without any express or implied warranty.
+SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+THE USE OR PERFORMANCE OF THIS SOFTWARE.
+********************************************************/
+
+#ifndef _EVI_H_
+#define _EVI_H_
+
+#define XEVI_TRANSPARENCY_NONE		0
+#define XEVI_TRANSPARENCY_PIXEL		1
+#define XEVI_TRANSPARENCY_MASK		2
+
+#define EVINAME "Extended-Visual-Information"
+
+#define XEVI_MAJOR_VERSION	1	/* current version numbers */
+#define XEVI_MINOR_VERSION	0
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/EVIproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/EVIproto.h
new file mode 100644
index 0000000..2218ef2
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/EVIproto.h
@@ -0,0 +1,96 @@
+/************************************************************
+Copyright (c) 1997 by Silicon Graphics Computer Systems, Inc.
+Permission to use, copy, modify, and distribute this
+software and its documentation for any purpose and without
+fee is hereby granted, provided that the above copyright
+notice appear in all copies and that both that copyright
+notice and this permission notice appear in supporting
+documentation, and that the name of Silicon Graphics not be
+used in advertising or publicity pertaining to distribution
+of the software without specific prior written permission.
+Silicon Graphics makes no representation about the suitability
+of this software for any purpose. It is provided "as is"
+without any express or implied warranty.
+SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+THE USE OR PERFORMANCE OF THIS SOFTWARE.
+********************************************************/
+
+#ifndef _EVIPROTO_H_
+#define _EVIPROTO_H_
+
+#include <X11/extensions/EVI.h>
+
+#define X_EVIQueryVersion		0
+#define X_EVIGetVisualInfo		1
+
+#define VisualID CARD32
+
+typedef CARD32 VisualID32;
+#define sz_VisualID32 4
+
+typedef struct _xExtendedVisualInfo {
+    VisualID	core_visual_id;
+    INT8	screen;
+    INT8	level;
+    CARD8	transparency_type;
+    CARD8	pad0;
+    CARD32	transparency_value;
+    CARD8	min_hw_colormaps;
+    CARD8	max_hw_colormaps;
+    CARD16	num_colormap_conflicts;
+} xExtendedVisualInfo;
+#define sz_xExtendedVisualInfo 16
+
+typedef struct _XEVIQueryVersion {
+    CARD8	reqType;		/* always XEVIReqCode */
+    CARD8	xeviReqType;		/* always X_EVIQueryVersion */
+    CARD16	length;
+} xEVIQueryVersionReq;
+#define sz_xEVIQueryVersionReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8 	unused;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	majorVersion;		/* major version of EVI protocol */
+    CARD16	minorVersion;		/* minor version of EVI protocol */
+    CARD32	pad0;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+} xEVIQueryVersionReply;
+#define sz_xEVIQueryVersionReply	32
+
+typedef struct _XEVIGetVisualInfoReq {
+    CARD8	reqType;	/* always XEVIReqCode */
+    CARD8	xeviReqType;	/* always X_EVIGetVisualInfo */
+    CARD16	length;
+    CARD32	n_visual;
+} xEVIGetVisualInfoReq;
+#define sz_xEVIGetVisualInfoReq	8
+
+typedef struct _XEVIGetVisualInfoReply {
+    BYTE	type;  /* X_Reply */
+    CARD8	unused;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	n_info;
+    CARD32	n_conflicts;
+    CARD32	pad0;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+} xEVIGetVisualInfoReply;
+#define sz_xEVIGetVisualInfoReply	32
+
+#undef VisualID
+
+#endif /* _EVIPROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/Print.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/Print.h
new file mode 100644
index 0000000..5c6b568
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/Print.h
@@ -0,0 +1,552 @@
+/* $Xorg: Print.h,v 1.3 2000/08/18 04:05:44 coskrey Exp $ */
+/******************************************************************************
+ ******************************************************************************
+ **
+ ** File:         Print.h
+ **
+ ** Description:  Definitions needed by the server, library, and
+ **               clients.  Subportion restricted to library and
+ **               clients.
+ **
+ **               Server, Library, Client portion has:
+ **                  o All sz_* defines
+ **                  o Revision and Name defines
+ **                  o Common defines and constants (e.g. Keywords, Masks)
+ **                  o Extension version structure
+ **
+ **               Library and client subportion has:
+ **                  o Convenience Macros
+ **                  o Client side data structures
+ **                  o Client side event structures (non wire)
+ **                  o Library function prototypes
+ **                  o some private stuff denoted with _whatever
+ **
+ **               Printstr.h for server and library, but NOT clients.
+ **
+ ******************************************************************************
+ **
+ ** (c) Copyright 1996 Hewlett-Packard Company
+ ** (c) Copyright 1996 International Business Machines Corp.
+ ** (c) Copyright 1996, Oracle and/or its affiliates.
+ ** (c) Copyright 1996 Novell, Inc.
+ ** (c) Copyright 1996 Digital Equipment Corp.
+ ** (c) Copyright 1996 Fujitsu Limited
+ ** (c) Copyright 1996 Hitachi, Ltd.
+ **
+ ** Permission is hereby granted, free of charge, to any person obtaining a copy
+ ** of this software and associated documentation files (the "Software"), to deal
+ ** in the Software without restriction, including without limitation the rights
+ ** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ ** copies of the Software, and to permit persons to whom the Software is
+ ** furnished to do so, subject to the following conditions:
+ **
+ ** The above copyright notice and this permission notice shall be included in
+ ** all copies or substantial portions of the Software.
+ **
+ ** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ ** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ ** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ ** COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ ** IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ ** CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ **
+ ** Except as contained in this notice, the names of the copyright holders shall
+ ** not be used in advertising or otherwise to promote the sale, use or other
+ ** dealings in this Software without prior written authorization from said
+ ** copyright holders.
+ **
+ ******************************************************************************
+ *****************************************************************************/
+/* $XFree86: xc/include/extensions/Print.h,v 1.4 2000/01/25 18:37:31 dawes Exp $ */
+
+#ifndef _XpPrint_H_
+#define _XpPrint_H_
+
+#ifndef _XP_PRINT_SERVER_
+#include <X11/Xlib.h>
+#include <X11/Xresource.h>
+#include <X11/Xauth.h>
+#endif /* _XP_PRINT_SERVER_ */
+
+#include <X11/Xfuncproto.h>
+
+_XFUNCPROTOBEGIN
+
+/******************************************************************************
+ *
+ * Definitions used by the server, library and client.
+ */
+
+/********************************************************************
+ *
+ * Naming and versioning information.
+ */
+#define XP_PRINTNAME  "XpExtension"
+
+/*
+ * Add a define below for each major extension release.
+ */
+#define XP_DONT_CHECK		0
+#define XP_INITIAL_RELEASE	1
+
+/*
+ * For each single entry above, create one major/minor pair.
+ */
+#define XP_PROTO_MAJOR		1
+#define XP_PROTO_MINOR		0
+
+/*
+ * Identify current version.
+ */
+#define XP_MAJOR_VERSION	XP_PROTO_MAJOR
+#define XP_MINOR_VERSION	XP_PROTO_MINOR
+
+/*
+ * Misc version defines.
+ */
+#define XP_ABSENT		0	/* Prior to XP Print support */
+#define XP_PRESENT		1	/* With XP Print support */
+
+/********************************************************************
+ *
+ * Xp Print Error codes.
+ */
+#define XP_ERRORS		3	/* number of error types */
+
+#define XPBadContext		0	/* Print Context invalid or missing */
+#define XPBadSequence		1	/* Illegal sequence of XP operations */
+#define XPBadResourceID		2	/* X-resource not valid */
+
+/********************************************************************
+ *
+ * Xp Print Event masks and codes.
+ *
+ */
+#define XP_EVENTS		2	/* number of event types */
+
+#define XPNoEventMask		0	/* not an event - just a null mask */
+#define XPPrintMask		(1L<<0)
+#define XPAttributeMask		(1L<<1)
+
+#define XPPrintNotify		0	/* contains "detail" - see below */
+#define XPAttributeNotify	1	/* contains "detail" - see below */
+
+#define XPStartJobNotify	0	/* value for "detail" in XPPrintNotify*/
+#define XPEndJobNotify		1
+#define XPStartDocNotify	2
+#define XPEndDocNotify		3
+#define XPStartPageNotify	4
+#define XPEndPageNotify		5
+
+/********************************************************************
+ *
+ * Xp Print Attribute Object codes (subset of ISO DPA 10175).  The
+ * Xp Server can get and set any of the values, while the Xp Library
+ * may only be able to set a subset of the attribute objects.
+ *
+ * note: the codes are also used as "detail" for XPAttributeNotify
+ *
+ * note: XPPageAttr is not defined in ISO DPA 10175.  It is unique
+ * to Xp, and its attributes are a proper subset of XPDocAttr.
+ */
+typedef unsigned char XPAttributes;	/* type of Xp*Attr codes */
+
+#define XP_ATTRIBUTES		5	/* those attrs currently supported */
+
+#define XPJobAttr		1	/* get/set */
+#define XPDocAttr		2	/* get/set */
+#define XPPageAttr		3	/* get/set - subset of XPDocAttr */
+#define XPPrinterAttr		4	/* get only (library) */
+#define XPServerAttr		5	/* get only (library), no
+					   context needed */
+
+/*
+ * note: ISO DPA 10175 defines a number of "attribute objects", of
+ *       which POSIX 1387.4 and the SI Xp will only support a
+ *       subset.
+ */
+#define XPMediumAttr		6	/* DPA-Object Medium */
+#define XPFontAttr		7	/* DPA-Object Font */
+#define XPResAttr		8	/* DPA-Object Resource */
+#define XPTransAttr		9	/* DPA-Object Transfer method */
+#define XPDelAttr		10	/* DPA-Object Delivery method */
+#define XPAuxSPkg		11	/* DPA-Object Auxiliary sheet package */
+#define XPAuxS			12	/* DPA-Object Auxiliary sheet */
+#define XPFinishAttr		13	/* DPA-Object Finishing */
+#define XPOutputAttr		14	/* DPA-Object Output method */
+#define XPImpAttr		15	/* DPA-Object Imposition */
+#define XPSchedAttr		16	/* DPA-Object Scheduler */
+#define XPIntJobAttr		17	/* DPA-Object Initial value job */
+#define XPIntDocAttr		18	/* DPA-Object Initial value document */
+#define XPResConAttr		19	/* DPA-Object Resource context */
+
+
+/*
+ * Replacement rules for XpSetAttributes
+ */
+typedef unsigned char XPAttrReplacement;
+#define	XPAttrReplace		1
+#define XPAttrMerge		2
+
+
+/*
+ * Return codes for XpGetDocumentData
+ */
+typedef unsigned char XPGetDocStatus;
+#define XPGetDocFinished	0	/* normal termination */
+#define XPGetDocSecondConsumer	1	/* setup error */
+#define XPGetDocError		2	/* runtime error, see generated error */
+
+
+/*
+ * Save data types for XpStartJob.
+ */
+typedef unsigned char XPSaveData;
+#define XPSpool			1	/* Job data sent to spooler */
+#define XPGetData		2	/* Job data via XpGetDocumentData */
+
+
+/*
+ * Document types for XpStartDoc.
+ */
+typedef unsigned char XPDocumentType;
+#define	XPDocNormal		1	/* Doc data handled by Xserver */
+#define	XPDocRaw		2	/* Doc data passed through Xserver */
+
+
+/********************************************************************
+ *
+ * Xp Print Property Names
+ */
+
+
+#ifndef _XP_PRINT_SERVER_
+
+/******************************************************************************
+ *
+ * Definitions used by the library and clients only.
+ */
+
+/*******************************************************************
+ *
+ * General API defines and such.
+ */
+
+/*
+ * Print Context for XpInitContext and related calls.
+ */
+typedef XID XPContext;
+
+/*
+ * Struct for XpGetPrinterList.
+ */
+typedef struct {
+    char	*name;		/* name */
+    char	*desc;		/* localized description */
+} XPPrinterRec, *XPPrinterList;
+
+/*
+ * Typedefs for XpGetDocumentData
+ */
+typedef void (*XPSaveProc)( Display *display,
+                            XPContext context,
+                            unsigned char *data,
+                            unsigned int data_len,
+                            XPointer client_data);
+
+typedef void (*XPFinishProc)( Display *display,
+                              XPContext context,
+                              XPGetDocStatus status,
+                              XPointer client_data);
+
+/*
+ * Typedefs for XpSetLocaleHinter and XpGetLocaleHinter
+ */
+typedef char * (*XPHinterProc)(void);
+
+#if 0
+/*******************************************************************
+ *
+ * Extension version structures.
+ *
+ **** this structure is now defined locally in the one file that uses it
+ **** in order to avoid clashes with its definition in XI.h
+ */
+typedef struct {
+        int     present;
+        short   major_version;
+        short   minor_version;
+} XExtensionVersion;
+#endif
+
+/********************************************************************
+ *
+ * Event structs for clients.
+ *
+ * note: these events are relative to a print context, and
+ * not to a window as in core X.
+ */
+typedef struct {
+    int            type;       /* base + XPPrintNotify */
+    unsigned long  serial;     /* # of last request processed by server */
+    Bool           send_event; /* true if from a SendEvent request */
+    Display        *display;   /* Display the event was read from */
+    XPContext      context;    /* print context where operation was requested */
+    Bool           cancel;     /* was detailed event canceled */
+    int            detail;     /* XPStartJobNotify, XPEndJobNotify,
+                                  XPStartDocNotify, XPEndDocNotify,
+                                  XPStartPageNotify, XPEndPageNotify */
+} XPPrintEvent;
+
+typedef struct {
+    int            type;       /* base + XPAttributeNotify */
+    unsigned long  serial;     /* # of last request processed by server */
+    Bool           send_event; /* true if from a SendEvent request */
+    Display        *display;   /* Display the event was read from */
+    XPContext      context;    /* print context where operation was requested */
+    int            detail;     /* XPJobAttr, XPDocAttr, XPPageAttr,
+                                  XPPrinterAttr, XPSpoolerAttr,
+                                  XPMediumAttr, XPServerAttr */
+} XPAttributeEvent;
+
+typedef struct {
+    int            type;       /* base + XPDataReadyNotify */
+    unsigned long  serial;     /* # of last request processed by server */
+    Bool           send_event; /* true if from a SendEvent request */
+    Display        *display;   /* Display the event was read from */
+    XPContext      context;    /* print context where operation was requested */
+    unsigned long  available;  /* bytes available for retrieval */
+} XPDataReadyEvent;
+
+
+/**********************************************************
+ *
+ * Function prototypes for library side.
+ */
+
+extern XPContext XpCreateContext (
+    Display		*display,
+    char		*printer_name
+);
+
+extern void XpSetContext (
+    Display		*display,
+    XPContext     	print_context
+);
+
+extern XPContext XpGetContext (
+    Display		*display
+);
+
+extern void XpDestroyContext (
+    Display		*display,
+    XPContext     	print_context
+);
+
+extern Screen *XpGetScreenOfContext (
+    Display		*display,
+    XPContext     	print_context
+);
+
+extern Status XpGetPageDimensions (
+    Display		*display,
+    XPContext     	print_context,
+    unsigned short	*width,			/* return value */
+    unsigned short	*height,		/* return value */
+    XRectangle		*reproducible_area	/* return value */
+);
+
+extern void XpStartJob (
+    Display		*display,
+    XPSaveData		save_data
+);
+
+extern void XpEndJob (
+    Display		*display
+);
+
+extern void XpCancelJob (
+    Display		*display,
+    Bool		discard
+);
+
+extern void XpStartDoc (
+    Display		*display,
+    XPDocumentType	type
+);
+
+extern void XpEndDoc (
+    Display		*display
+);
+
+extern void XpCancelDoc (
+    Display		*display,
+    Bool		discard
+);
+
+extern void XpPutDocumentData (
+    Display		*display,
+    Drawable		drawable,
+    unsigned char	*data,
+    int			data_len,
+    char		*doc_fmt,
+    char		*options
+);
+
+extern Status XpGetDocumentData (
+    Display		*display,
+    XPContext		context,
+    XPSaveProc		save_proc,
+    XPFinishProc	finish_proc,
+    XPointer		client_data
+);
+
+extern void XpStartPage (
+    Display		*display,
+    Window		window
+);
+
+extern void XpEndPage (
+    Display		*display
+);
+
+extern void XpCancelPage (
+    Display		*display,
+    Bool		discard
+);
+
+extern void XpSelectInput (
+    Display		*display,
+    XPContext     	print_context,
+    unsigned long	event_mask
+);
+
+extern unsigned long XpInputSelected (
+    Display		*display,
+    XPContext     	print_context,
+    unsigned long	*all_events_mask
+);
+
+extern Bool XpSetImageResolution (
+    Display		*display,
+    XPContext     	print_context,
+    int			image_res,
+    int			*prev_res
+);
+
+extern int XpGetImageResolution (
+    Display		*display,
+    XPContext     	print_context
+);
+
+extern char *XpGetAttributes (
+    Display		*display,
+    XPContext     	print_context,
+    XPAttributes	type
+);
+
+extern void XpSetAttributes (
+    Display		*display,
+    XPContext     	print_context,
+    XPAttributes	type,
+    char		*pool,
+    XPAttrReplacement	replacement_rule
+);
+
+extern char *XpGetOneAttribute (
+    Display		*display,
+    XPContext     	print_context,
+    XPAttributes	type,
+    char		*attribute_name
+);
+
+extern XPPrinterList XpGetPrinterList (
+    Display		*display,
+    char		*printer_name,
+    int			*list_count		/* return value */
+);
+
+extern void XpFreePrinterList (
+    XPPrinterList	printer_list
+);
+
+extern void XpRehashPrinterList (
+    Display		*display
+);
+
+extern Status XpQueryVersion (
+    Display		*display,
+    short		*major_version,		/* return value */
+    short		*minor_version		/* return value */
+);
+
+extern Bool XpQueryExtension (
+    Display		*display,
+    int			*event_base_return,	/* return value */
+    int			*error_base_return	/* return value */
+);
+
+extern Screen **XpQueryScreens (
+    Display		*display,
+    int			*list_count		/* return value */
+);
+
+extern Status XpGetPdmStartParams (
+    Display		*print_display,
+    Window		print_window,
+    XPContext		print_context,
+    Display		*video_display,
+    Window		video_window,
+    Display		**selection_display,	/* return value */
+    Atom		*selection,		/* return value */
+    Atom		*type,			/* return value */
+    int			*format,		/* return value */
+    unsigned char	**data,			/* return value */
+    int			*nelements		/* return value */
+);
+
+extern Status XpGetAuthParams (
+    Display		*print_display,
+    Display		*video_display,
+    Display		**selection_display,	/* return value */
+    Atom		*selection,		/* return value */
+    Atom		*target			/* return value */
+);
+
+extern Status XpSendAuth (
+    Display		*display,
+    Window		window
+);
+
+extern Status XpSendOneTicket (
+    Display		*display,
+    Window		window,
+    Xauth		*ticket,
+    Bool		more
+);
+
+extern void XpSetLocaleHinter (
+    XPHinterProc hinter_proc,
+    char         *hinter_desc
+);
+
+extern char *XpGetLocaleHinter (
+    XPHinterProc *hinter_proc
+);
+
+extern char *XpGetLocaleNetString(void);
+
+extern char *XpNotifyPdm (
+    Display		*print_display,
+    Window		print_window,
+    XPContext     	print_context,
+    Display		*video_display,
+    Window		video_window,
+    Bool		auth_flag
+);
+
+#endif /* _XP_PRINT_SERVER_ */
+
+_XFUNCPROTOEND
+
+#endif /* _XpPrint_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/Printstr.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/Printstr.h
new file mode 100644
index 0000000..0910231
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/Printstr.h
@@ -0,0 +1,781 @@
+/* $Xorg: Printstr.h,v 1.3 2000/08/18 04:05:44 coskrey Exp $ */
+/******************************************************************************
+ ******************************************************************************
+ **
+ ** File:         Printstr.h
+ **
+ ** Description: Definitions needed by the server and library, but
+ **              not clients.
+ **
+ **              Print.h for server, library and clients.
+ **
+ ******************************************************************************
+ **
+ ** (c) Copyright 1996 Hewlett-Packard Company
+ ** (c) Copyright 1996 International Business Machines Corp.
+ ** (c) Copyright 1996, Oracle and/or its affiliates.
+ ** (c) Copyright 1996 Novell, Inc.
+ ** (c) Copyright 1996 Digital Equipment Corp.
+ ** (c) Copyright 1996 Fujitsu Limited
+ ** (c) Copyright 1996 Hitachi, Ltd.
+ **
+ ** Permission is hereby granted, free of charge, to any person obtaining a copy
+ ** of this software and associated documentation files (the "Software"), to deal
+ ** in the Software without restriction, including without limitation the rights
+ ** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ ** copies of the Software, and to permit persons to whom the Software is
+ ** furnished to do so, subject to the following conditions:
+ **
+ ** The above copyright notice and this permission notice shall be included in
+ ** all copies or substantial portions of the Software.
+ **
+ ** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ ** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ ** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ ** COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ ** IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ ** CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ **
+ ** Except as contained in this notice, the names of the copyright holders shall
+ ** not be used in advertising or otherwise to promote the sale, use or other
+ ** dealings in this Software without prior written authorization from said
+ ** copyright holders.
+ **
+ ******************************************************************************
+ *****************************************************************************/
+/* $XFree86: xc/include/extensions/Printstr.h,v 1.5 2001/08/01 00:44:35 tsi Exp $ */
+
+
+#ifndef _XpPrintstr_H_
+#define _XpPrintstr_H_
+
+/*
+ * NEED_EVENTS and NEED_REPLIES are hacks to limit the linker symbol-table
+ * size.   When function prototypes are needed from Print.h, this sets up
+ * a cascading dependency on Printstr.h and eventually Xproto.h to provide
+ * the event and reply struct definitions.
+ */
+#ifndef NEED_EVENTS
+#define NEED_EVENTS
+#endif /* NEED_EVENTS */
+
+#define NEED_REPLIES
+
+#include <X11/Xproto.h>
+#ifndef _XP_PRINT_SERVER_
+#include <X11/Xlib.h>
+#endif /* _XP_PRINT_SERVER_ */
+
+/*
+ * Pull in other definitions.  Print.h will hide some things if we're
+ * doing server side work.
+ */
+#include <X11/extensions/Print.h>
+
+#include <X11/Xfuncproto.h>
+
+_XFUNCPROTOBEGIN
+
+/******************************************************************************
+ *
+ * Protocol requests constants and alignment values
+ *
+ * Note: Xlib macro's expect X_ABC where ABC is the name of the
+ * protocol request.
+ */
+#define X_PrintQueryVersion		0
+#define X_PrintGetPrinterList		1
+#define X_PrintCreateContext		2
+#define X_PrintSetContext		3
+#define X_PrintGetContext		4
+#define X_PrintDestroyContext		5
+#define X_PrintGetContextScreen		6
+#define X_PrintStartJob			7
+#define X_PrintEndJob			8
+#define X_PrintStartDoc			9
+#define X_PrintEndDoc			10
+#define X_PrintPutDocumentData		11
+#define X_PrintGetDocumentData		12
+#define X_PrintStartPage		13
+#define X_PrintEndPage			14
+#define X_PrintSelectInput		15
+#define X_PrintInputSelected		16
+#define X_PrintGetAttributes		17
+#define X_PrintSetAttributes		18
+#define X_PrintGetOneAttribute		19
+#define X_PrintRehashPrinterList	20
+#define X_PrintGetPageDimensions	21
+#define X_PrintQueryScreens		22
+#define X_PrintSetImageResolution	23
+#define X_PrintGetImageResolution	24
+
+/********************************************************************
+ *
+ * Protocol data types
+ */
+#define PCONTEXT CARD32
+#define WINDOW   CARD32
+#define DRAWABLE CARD32
+#define BITMASK  CARD32
+
+/******************************************************************************
+ *
+ * Event wire struct definitions
+ *
+ * Note: Xlib macro's expect xABC struct names and sz_xABC size
+ * constants where ABC is the name of the protocol request.
+ */
+
+
+/*********************************************************************
+ *
+ * Events.
+ *
+ * See Print.h for the protocol "type" values.
+ */
+typedef struct _xPrintPrintEvent {
+	BYTE type;		/* XPPrintNotify + extEntry->eventBase */
+	BYTE detail;		/* XPStartJobNotify, XPEndJobNotify,
+				   XPStartDocNotify, XPEndDocNotify,
+				   XPStartPageNotify, XPEndPageNotify */
+	CARD16 sequenceNumber;
+	PCONTEXT printContext;	/* print context */
+	BOOL   cancel;		/* canceled flag */
+	CARD8  pad1;		/* rest is unused */
+	CARD16 pad2;
+	CARD32 pad3;
+	CARD32 pad4;
+	CARD32 pad5;
+	CARD32 pad6;
+	CARD32 pad7;
+} xPrintPrintEvent;
+#define sz_xPrintPrintEvent 32;
+
+typedef struct _xPrintAttributeEvent {
+	BYTE   type;		/* XPAttributeNotify + extEntry->eventBase */
+	BYTE   detail;		/* XPJobAttr, XPDocAttr, XPPageAttr,
+				   XPPrinterAttr, XPSpoolerAttr,
+				   XPMediumAttr, XPServerAttr */
+	CARD16 sequenceNumber;
+	PCONTEXT printContext;	/* print context */
+	CARD32 pad1;
+	CARD32 pad2;
+	CARD32 pad3;
+	CARD32 pad4;
+	CARD32 pad5;
+	CARD32 pad6;
+} xPrintAttributeEvent;
+#define sz_xPrintAttributeEvent 32;
+
+
+/*********************************************************************
+ *
+ * Requests
+ */
+typedef struct _PrintQueryVersion {
+	CARD8	reqType;		/* always PrintReqCode */
+	CARD8	printReqType;		/* always X_PrintQueryVersion */
+	CARD16	length;
+} xPrintQueryVersionReq;
+#define sz_xPrintQueryVersionReq	4
+
+typedef struct {
+	BYTE	type;			/* X_Reply */
+	CARD8	unused;			/* not used */
+	CARD16	sequenceNumber;
+	CARD32	length;
+	CARD16	majorVersion;		/* major version of Xp protocol */
+	CARD16	minorVersion;		/* minor version of Xp protocol */
+	CARD32	pad1;
+	CARD32	pad2;
+	CARD32	pad3;
+	CARD32	pad4;
+	CARD32	pad5;
+} xPrintQueryVersionReply;
+#define sz_xPrintQueryVersionReply	32
+
+
+typedef struct _PrintGetPrinterList {
+	CARD8	reqType;		/* always PrintReqCode */
+	CARD8	printReqType;		/* always X_PrintGetPrinterList */
+	CARD16	length;
+	CARD32	printerNameLen;		/* length of printer name */
+	CARD32	localeLen;		/* length of locale string */
+
+	/* variable portion *****************************************
+	STRING8	printerName;		 * printer name *
+	BYTE	pad(printerNameLen)	 * unused *
+	STRING8	locale;			 * locale *
+	BYTE	pad(localeLen)		 * unused *
+	************************************************************/
+} xPrintGetPrinterListReq;
+#define sz_xPrintGetPrinterListReq	12
+
+typedef struct {
+	BYTE	type;			/* X_Reply */
+	CARD8	unused;			/* not used */
+	CARD16	sequenceNumber;
+	CARD32	length;
+	CARD32	listCount;		/* of PRINTER recs below */
+	CARD32	pad1;
+	CARD32	pad2;
+	CARD32	pad3;
+	CARD32	pad4;
+	CARD32	pad5;
+
+	/* variable portion *****************************************
+	CARD32	nameLen;		* length of name in bytes *
+	STRING8	name;			* name *
+	BYTE	pad(nameLen)		* unused *
+
+	CARD32	descLen;		* length of desc in bytes *
+	STRING8	desc;			* localized description *
+	BYTE	pad(descLen)		* unused *
+	************************************************************/
+} xPrintGetPrinterListReply;
+#define sz_xPrintGetPrinterListReply	32
+
+
+typedef struct _PrintRehashPrinterList {
+	CARD8	reqType;		/* always PrintReqCode */
+	CARD8	printReqType;		/* always X_PrintRehashPrinterList */
+	CARD16	length;
+} xPrintRehashPrinterListReq;
+#define sz_xPrintRehashPrinterListReq	4
+
+
+typedef struct _PrintCreateContext {
+	CARD8	reqType;		/* always PrintReqCode */
+	CARD8	printReqType;		/* always X_PrintInitSetContext */
+	CARD16	length;
+	CARD32	contextID;		/* ID for context */
+	CARD32	printerNameLen;		/* length of printerName in bytes */
+	CARD32	localeLen;		/* length of locale in bytes */
+
+	/* variable portion *****************************************
+	STRING8	printerName		 * printer name *
+	BYTE	pad(printerNameLen)	 * unused *
+	STRING8	locale			 * locale *
+	BYTE	pad(locale)		 * unused *
+	************************************************************/
+} xPrintCreateContextReq;
+#define sz_xPrintCreateContextReq	16
+
+
+typedef struct _PrintSetContext {
+	CARD8	reqType;		/* always PrintReqCode */
+	CARD8	printReqType;		/* always X_PrintSetContext */
+	CARD16	length;
+	PCONTEXT printContext;		/* print context */
+} xPrintSetContextReq;
+#define sz_xPrintSetContextReq		8
+
+
+typedef struct _PrintGetContext {
+	CARD8	reqType;		/* always PrintReqCode */
+	CARD8	printReqType;		/* always X_PrintGetContext */
+	CARD16	length;
+} xPrintGetContextReq;
+#define sz_xPrintGetContextReq		4
+
+typedef struct {
+	BYTE	type;			/* X_Reply */
+	CARD8	unused;			/* not used */
+	CARD16	sequenceNumber;
+	CARD32	length;
+	PCONTEXT printContext;		/* print context */
+	CARD32	pad1;
+	CARD32	pad2;
+	CARD32	pad3;
+	CARD32	pad4;
+	CARD32	pad5;
+} xPrintGetContextReply;
+#define sz_xPrintGetContextReply	32
+
+
+typedef struct _PrintDestroyContext {
+	CARD8	reqType;		/* always PrintReqCode */
+	CARD8	printReqType;		/* always X_PrintDestroyContext */
+	CARD16	length;
+	PCONTEXT printContext;		/* print context */
+} xPrintDestroyContextReq;
+#define sz_xPrintDestroyContextReq	8
+
+
+typedef struct _PrintGetContextScreen {
+	CARD8	reqType;		/* always PrintReqCode */
+	CARD8	printReqType;		/* always X_PrintGetContextScreen */
+	CARD16	length;
+	PCONTEXT printContext;		/* print context */
+} xPrintGetContextScreenReq;
+#define sz_xPrintGetContextScreenReq	8
+
+typedef struct {
+	BYTE	type;			/* X_Reply */
+	CARD8	unused;			/* not used */
+	CARD16	sequenceNumber;
+	CARD32	length;
+	WINDOW  rootWindow;		/* screenPtr represented as rootWin */
+	CARD32	pad1;
+	CARD32	pad2;
+	CARD32	pad3;
+	CARD32	pad4;
+	CARD32	pad5;
+} xPrintGetContextScreenReply;
+#define sz_xPrintGetContextScreenReply	32
+
+
+typedef struct _PrintStartJob {
+	CARD8	reqType;		/* always PrintReqCode */
+	CARD8	printReqType;		/* always X_PrintStartJob */
+	CARD16	length;
+	CARD8	saveData;		/* save data boolean */
+	CARD8	pad1;
+	CARD16	pad2;
+} xPrintStartJobReq;
+#define sz_xPrintStartJobReq		8
+
+typedef struct _PrintEndJob {
+	CARD8	reqType;		/* always PrintReqCode */
+	CARD8	printReqType;		/* always X_PrintEndJob */
+	CARD16	length;
+	BOOL	cancel;			/* cancel boolean */
+	CARD8	pad1;
+	CARD16	pad2;
+} xPrintEndJobReq;
+#define sz_xPrintEndJobReq		8
+
+
+typedef struct _PrintStartDoc {
+	CARD8	reqType;		/* always PrintReqCode */
+	CARD8	printReqType;		/* always X_PrintStartDoc */
+	CARD16	length;
+	CARD8	type;			/* type for document */
+	CARD8	pad1;
+	CARD16	pad2;
+} xPrintStartDocReq;
+#define sz_xPrintStartDocReq		8
+
+typedef struct _PrintEndDoc {
+	CARD8	reqType;		/* always PrintReqCode */
+	CARD8	printReqType;		/* always X_PrintEndDoc */
+	CARD16	length;
+	BOOL	cancel;			/* cancel boolean */
+	CARD8	pad1;
+	CARD16	pad2;
+} xPrintEndDocReq;
+#define sz_xPrintEndDocReq		8
+
+
+typedef struct _PrintPutDocumentData {
+	CARD8	reqType;		/* always PrintReqCode */
+	CARD8	printReqType;		/* always X_PrintPutDocumentData */
+	CARD16	length;
+	DRAWABLE drawable;		/* target drawable */
+	CARD32	len_data;		/* big len in bytes */
+	CARD16	len_fmt;		/* len in bytes */
+	CARD16	len_options;		/* len in bytes */
+
+	/* variable portion *****************************************
+	LISTofBYTE	data;		 * data *
+	BYTE		pad(len_data)	 * unused *
+	STRING8		doc_fmt;	 * ISO compliant desc of data type *
+	BYTE		pad(len_fmt)	 * unused *
+	STRING8		options;	 * additional device-dependent desc *
+	BYTE		pad(len_options) * unused *
+	************************************************************/
+} xPrintPutDocumentDataReq;
+#define sz_xPrintPutDocumentDataReq	16
+
+
+typedef struct _PrintGetDocumentData {
+	CARD8	reqType;		/* always PrintReqCode */
+	CARD8	printReqType;		/* always X_PrintGetDocumentData */
+	CARD16	length;
+	PCONTEXT printContext;		/* print context */
+	CARD32	maxBufferSize;		/* maximum buffer size requested */
+} xPrintGetDocumentDataReq;
+#define sz_xPrintGetDocumentDataReq	12
+
+typedef struct {
+	BYTE	type;			/* X_Reply */
+	CARD8	unused;			/* not used */
+	CARD16	sequenceNumber;
+	CARD32	length;
+	CARD32	statusCode;		/* status code for reply */
+	CARD32	finishedFlag;		/* is this the last reply */
+	CARD32	dataLen;		/* data length */
+	CARD32	pad1;
+	CARD32	pad2;
+	CARD32	pad3;
+
+	/* variable portion *****************************************
+	LISTofBYTE	data;		 * data *
+	BYTE		pad(count)	 * unused *
+	************************************************************/
+} xPrintGetDocumentDataReply;
+#define sz_xPrintGetDocumentDataReply	32
+
+
+typedef struct _PrintStartPage {
+	CARD8	reqType;		/* always PrintReqCode */
+	CARD8	printReqType;		/* always X_PrintStartPage */
+	CARD16	length;
+	WINDOW	window;			/* window */
+} xPrintStartPageReq;
+#define sz_xPrintStartPageReq		8
+
+typedef struct _PrintEndPage {
+	CARD8	reqType;		/* always PrintReqCode */
+	CARD8	printReqType;		/* always X_PrintEndPage */
+	CARD16	length;
+	BOOL	cancel;			/* cancel boolean */
+	CARD8	pad1;
+	CARD16	pad2;
+} xPrintEndPageReq;
+#define sz_xPrintEndPageReq		8
+
+
+typedef struct _PrintSelectInput {
+        CARD8   reqType;        	/* always PrintReqCode */
+	CARD8   printReqType;		/* always X_PrintSelectInput */
+	CARD16	length;
+	PCONTEXT printContext;		/* print context */
+	BITMASK	eventMask;
+} xPrintSelectInputReq;
+#define sz_xPrintSelectInputReq		12
+
+
+typedef struct _PrintInputSelected {
+        CARD8   reqType;        	/* always PrintReqCode */
+	CARD8   printReqType;		/* always X_PrintInputSelected */
+	CARD16	length;
+	PCONTEXT printContext;		/* print context */
+} xPrintInputSelectedReq;
+#define sz_xPrintInputSelectedReq	8
+
+typedef struct {
+	BYTE	type;			/* X_Reply */
+	CARD8	unused;			/* not used */
+	CARD16	sequenceNumber;
+	CARD32	length;
+	BITMASK	eventMask;		/* your event mask */
+	BITMASK	allEventsMask;		/* all event mask */
+	CARD32	pad1;
+	CARD32	pad2;
+	CARD32	pad3;
+	CARD32	pad4;
+} xPrintInputSelectedReply;
+#define sz_xPrintInputSelectedReply	32
+
+typedef struct _PrintGetAttributes {
+        CARD8   reqType;        	/* always PrintReqCode */
+	CARD8   printReqType;		/* always X_PrintGetAttributes */
+	CARD16	length;
+	PCONTEXT printContext;		/* print context */
+        CARD8   type;			/* type */
+        CARD8   pad1;			/* unused */
+        CARD16  pad2;			/* unused */
+} xPrintGetAttributesReq;
+#define sz_xPrintGetAttributesReq	12
+
+typedef struct {
+	BYTE	type;			/* X_Reply */
+	CARD8	unused;			/* not used */
+	CARD16	sequenceNumber;
+	CARD32	length;
+	CARD32	stringLen;		/* length of xrm db string */
+	CARD32	pad1;
+	CARD32	pad2;
+	CARD32	pad3;
+	CARD32	pad4;
+	CARD32	pad5;
+
+        /* variable portion *****************************************
+	STRING8	string;                  * xrm db as a string *
+	BYTE	pad(stringLen)           * unused *
+        ************************************************************/
+} xPrintGetAttributesReply;
+#define sz_xPrintGetAttributesReply	32
+
+
+typedef struct _PrintSetAttributes {
+        CARD8   reqType;        	/* always PrintReqCode */
+	CARD8   printReqType;		/* always X_PrintSetAttributes */
+	CARD16	length;
+	PCONTEXT printContext;		/* print context */
+	CARD32	stringLen;		/* length of xrm db string */
+        CARD8   type;                   /* type */
+	CARD8   rule;			/* replacement rule */
+	CARD16  pad1;			/* unused */
+
+        /* variable portion *****************************************
+	STRING8	string;                  * xrm db as a string *
+	BYTE	pad(stringLen)           * unused *
+        ************************************************************/
+} xPrintSetAttributesReq;
+#define sz_xPrintSetAttributesReq	16
+
+
+typedef struct _PrintGetOneAttribute {
+        CARD8   reqType;        	/* always PrintReqCode */
+	CARD8   printReqType;		/* always X_PrintGetOneAttribute */
+	CARD16	length;
+	PCONTEXT printContext;		/* print context */
+	CARD32	nameLen;		/* length of name string */
+        CARD8   type;			/* type */
+        CARD8   pad1;			/* unused */
+        CARD16  pad2;			/* unused */
+
+        /* variable portion *****************************************
+	STRING8	name;			 * name as a string *
+	BYTE	pad(name)		 * unused *
+        ************************************************************/
+} xPrintGetOneAttributeReq;
+#define sz_xPrintGetOneAttributeReq	16
+
+typedef struct {
+	BYTE	type;			/* X_Reply */
+	CARD8	unused;			/* not used */
+	CARD16	sequenceNumber;
+	CARD32	length;
+	CARD32	valueLen;		/* length of value string */
+	CARD32	pad1;
+	CARD32	pad2;
+	CARD32	pad3;
+	CARD32	pad4;
+	CARD32	pad5;
+
+        /* variable portion *****************************************
+	STRING8	value;			 * value as a string *
+	BYTE	pad(value)		 * unused *
+        ************************************************************/
+} xPrintGetOneAttributeReply;
+#define sz_xPrintGetOneAttributeReply	32
+
+
+typedef struct _PrintGetPageDimensions {
+	CARD8	reqType;		/* always PrintReqCode */
+	CARD8	printReqType;		/* always X_PrintGetPageDimensions */
+	CARD16	length;
+	PCONTEXT printContext;		/* print context */
+} xPrintGetPageDimensionsReq;
+#define sz_xPrintGetPageDimensionsReq	8
+
+typedef struct {
+	BYTE	type;			/* X_Reply */
+	CARD8	unused;			/* not used */
+	CARD16	sequenceNumber;
+	CARD32	length;
+	CARD16	width;			/* total pixel width */
+	CARD16	height;			/* total pixel height */
+	CARD16	rx;			/* reproducible x pixel offset */
+	CARD16	ry;			/* reproducible y pixel offset */
+	CARD16	rwidth;			/* reproducible x pixel width */
+	CARD16	rheight;		/* reproducible y pixel width */
+	CARD32	pad1;
+	CARD32	pad2;
+	CARD32	pad3;
+} xPrintGetPageDimensionsReply;
+#define sz_xPrintGetPageDimensionsReply	32
+
+
+typedef struct _PrintQueryScreens {
+	CARD8	reqType;		/* always PrintReqCode */
+	CARD8	printReqType;		/* always X_PrintQueryScreens */
+	CARD16	length;
+} xPrintQueryScreensReq;
+#define sz_xPrintQueryScreensReq	4
+
+typedef struct {
+	BYTE	type;			/* X_Reply */
+	CARD8	unused;			/* not used */
+	CARD16	sequenceNumber;
+	CARD32	length;
+	CARD32	listCount;		/* number of screens following */
+	CARD32	pad1;
+	CARD32	pad2;
+	CARD32	pad3;
+	CARD32	pad4;
+	CARD32	pad5;
+
+        /* variable portion *****************************************
+	WINDOW	rootWindow;		 * root window of screen *
+        ************************************************************/
+} xPrintQueryScreensReply;
+#define sz_xPrintQueryScreensReply	32
+
+typedef struct _PrintSetImageResolution {
+	CARD8	reqType;		/* always PrintReqCode */
+	CARD8	printReqType;		/* always X_PrintSetImageResolution */
+	CARD16	length;
+	PCONTEXT printContext;		/* print context */
+	CARD16 imageRes;		/* image resolution */
+	CARD16 pad1;
+} xPrintSetImageResolutionReq;
+#define sz_xPrintSetImageResolutionReq	12
+
+typedef struct {
+	BYTE	type;			/* X_Reply */
+	BOOL	status;			/* accepted or not */
+	CARD16	sequenceNumber;
+	CARD32	length;
+	CARD16	prevRes;		/* previous resolution */
+	CARD16	pad1;
+	CARD32	pad2;
+	CARD32	pad3;
+	CARD32	pad4;
+	CARD32	pad5;
+	CARD32	pad6;
+} xPrintSetImageResolutionReply;
+#define sz_xPrintSetImageResolutionReply 32
+
+typedef struct _PrintGetImageResolution {
+	CARD8	reqType;		/* always PrintReqCode */
+	CARD8	printReqType;		/* always X_PrintGetImageResolution */
+	CARD16	length;
+	PCONTEXT printContext;		/* print context */
+} xPrintGetImageResolutionReq;
+#define sz_xPrintGetImageResolutionReq	8
+
+typedef struct {
+	BYTE	type;			/* X_Reply */
+	CARD8	unused;
+	CARD16	sequenceNumber;
+	CARD32	length;
+	CARD16	imageRes;		/* image resolution */
+	CARD16	pad1;
+	CARD32	pad2;
+	CARD32	pad3;
+	CARD32	pad4;
+	CARD32	pad5;
+	CARD32	pad6;
+} xPrintGetImageResolutionReply;
+#define sz_xPrintGetImageResolutionReply 32
+
+#ifndef _XP_PRINT_SERVER_
+/***********************************************************************
+ *
+ * Library-only definitions.
+ */
+extern XPHinterProc  _xp_hinter_proc;
+extern char         *_xp_hinter_desc;
+extern int           _xp_hinter_init;
+
+#else /* _XP_PRINT_SERVER_ */
+
+/***********************************************************************
+ *
+ * Server-only definitions shared between the extension and DDX layers.
+ *
+ */
+
+/*
+ * Internal return code used to indicate that the requesting
+ * client has been suspended.
+ */
+#define Suspended 84
+
+struct _XpContext;
+
+extern void XpRegisterPrinterScreen(
+    ScreenPtr pScreen,
+    int (*CreateContext)(struct _XpContext *));
+
+typedef struct _xpprintFuncs {
+    int (*StartJob)(
+	struct _XpContext *	/* pContext */,
+	Bool			/* sendClientData */,
+	ClientPtr		/* client */);
+    int (*EndJob)(struct _XpContext *, int);
+    int (*StartDoc)(
+	struct _XpContext *	/* pContext */,
+	XPDocumentType		/* type */);
+    int (*EndDoc)(struct _XpContext *, int);
+    int (*StartPage)(
+	struct _XpContext *	/* pContext */,
+	WindowPtr		/* pWin */);
+    int (*EndPage)(
+	struct _XpContext *	/* pContext */,
+	WindowPtr		/* pWin */);
+    int (*PutDocumentData)(
+	struct _XpContext *	/* pContext */,
+    	DrawablePtr		/* pDraw */,
+	char *			/* pData */,
+	int			/* len_data */,
+	char *			/* pDoc_fmt */,
+	int			/* len_fmt */,
+	char *			/* pOptions */,
+	int			/* len_options */,
+	ClientPtr		/* client */);
+    int (*GetDocumentData)(
+	struct _XpContext *	/* pContext */,
+	ClientPtr		/* client */,
+	int			/* maxBufferSize */);
+    int (*DestroyContext)(
+	struct _XpContext *);	/* pContext */
+    char *(*GetAttributes)(
+	struct _XpContext *,
+	XPAttributes 		/* pool */);
+    char *(*GetOneAttribute)(
+	struct _XpContext *	/* pContext */,
+	XPAttributes 		/* pool */,
+	char *			/* attrs */);
+    int (*SetAttributes)(
+	struct _XpContext *	/* pContext */,
+	XPAttributes 		/* pool */,
+	char *			/* attrs */);
+    int (*AugmentAttributes)(
+	struct _XpContext *	/* pContext */,
+	XPAttributes 		/* pool */,
+	char *			/* attrs */);
+    int (*GetMediumDimensions)(
+	struct _XpContext *	/* pPrintContext */,
+	CARD16 *		/* pWidth */,
+	CARD16 *		/* pHeight */);
+    int (*GetReproducibleArea)(
+	struct _XpContext *	/* pPrintContext */,
+	xRectangle *		/* pRect */);
+    int (*SetImageResolution)(
+	struct _XpContext *	/* pPrintContext */,
+	int			/* imageRes */,
+	Bool *			/* pStatus */);
+} XpDriverFuncs, *XpDriverFuncsPtr;
+
+/*
+ * Each print context is represented by one of the following structs
+ * associated with a resource ID of type RTcontext .  A pointer to
+ * the context is placed in the Xp extension's devPrivates
+ * element in each client * which establishes a context via
+ * either initContext or setContext.
+ * The context pointer is also placed in the struct indicated by the
+ * RTpage resource associated with each StartPage'd window.
+ */
+typedef struct _XpContext {
+        XID contextID;
+        char *printerName;
+        int screenNum;          /* screen containing the printer */
+        struct _XpClient *clientHead; /* list of clients */
+        CARD32 state;
+        VisualID pageWin;
+        PrivateRec *devPrivates;
+        XpDriverFuncs funcs;
+	ClientPtr clientSlept;
+	int imageRes;
+} XpContextRec, *XpContextPtr;
+
+#include <X11/fonts/fontstruct.h>	/* FontResolutionPtr */
+
+extern FontResolutionPtr XpGetClientResolutions(ClientPtr, int *);
+extern XpContextPtr XpContextOfClient(ClientPtr);
+extern XpContextPtr XpGetPrintContext(ClientPtr);
+extern int XpRehashPrinterList(void);
+extern void XpSetFontResFunc(ClientPtr);
+extern void XpUnsetFontResFunc(ClientPtr);
+extern void XpRegisterInitFunc(ScreenPtr, char *, int (*)(struct _XpContext *));
+
+#endif /* _XP_PRINT_SERVER_ */
+
+_XFUNCPROTOEND
+
+#endif /* _XpPrintstr_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/XI.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/XI.h
new file mode 100644
index 0000000..7b44399
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/XI.h
@@ -0,0 +1,308 @@
+/************************************************************
+
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+Copyright 1989 by Hewlett-Packard Company, Palo Alto, California.
+
+			All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Hewlett-Packard not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+HEWLETT-PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+HEWLETT-PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+********************************************************/
+
+/* Definitions used by the server, library and client */
+
+#ifndef _XI_H_
+#define _XI_H_
+
+#define sz_xGetExtensionVersionReq             8
+#define sz_xGetExtensionVersionReply           32
+#define sz_xListInputDevicesReq			4
+#define sz_xListInputDevicesReply		32
+#define sz_xOpenDeviceReq			8
+#define sz_xOpenDeviceReply			32
+#define sz_xCloseDeviceReq			8
+#define sz_xSetDeviceModeReq			8
+#define sz_xSetDeviceModeReply			32
+#define sz_xSelectExtensionEventReq		12
+#define sz_xGetSelectedExtensionEventsReq	8
+#define sz_xGetSelectedExtensionEventsReply	32
+#define sz_xChangeDeviceDontPropagateListReq	12
+#define sz_xGetDeviceDontPropagateListReq	8
+#define sz_xGetDeviceDontPropagateListReply	32
+#define sz_xGetDeviceMotionEventsReq		16
+#define sz_xGetDeviceMotionEventsReply		32
+#define sz_xChangeKeyboardDeviceReq		8
+#define sz_xChangeKeyboardDeviceReply		32
+#define sz_xChangePointerDeviceReq		8
+#define sz_xChangePointerDeviceReply		32
+#define sz_xGrabDeviceReq			20
+#define sz_xGrabDeviceReply			32
+#define sz_xUngrabDeviceReq			12
+#define sz_xGrabDeviceKeyReq			20
+#define sz_xGrabDeviceKeyReply			32
+#define sz_xUngrabDeviceKeyReq			16
+#define sz_xGrabDeviceButtonReq			20
+#define sz_xGrabDeviceButtonReply		32
+#define sz_xUngrabDeviceButtonReq		16
+#define sz_xAllowDeviceEventsReq		12
+#define sz_xGetDeviceFocusReq			8
+#define sz_xGetDeviceFocusReply			32
+#define sz_xSetDeviceFocusReq			16
+#define sz_xGetFeedbackControlReq		8
+#define sz_xGetFeedbackControlReply		32
+#define sz_xChangeFeedbackControlReq		12
+#define sz_xGetDeviceKeyMappingReq		8
+#define sz_xGetDeviceKeyMappingReply		32
+#define sz_xChangeDeviceKeyMappingReq		8
+#define sz_xGetDeviceModifierMappingReq		8
+#define sz_xSetDeviceModifierMappingReq		8
+#define sz_xSetDeviceModifierMappingReply	32
+#define sz_xGetDeviceButtonMappingReq		8
+#define sz_xGetDeviceButtonMappingReply		32
+#define sz_xSetDeviceButtonMappingReq		8
+#define sz_xSetDeviceButtonMappingReply		32
+#define sz_xQueryDeviceStateReq			8
+#define sz_xQueryDeviceStateReply		32
+#define sz_xSendExtensionEventReq		16
+#define sz_xDeviceBellReq			8
+#define sz_xSetDeviceValuatorsReq		8
+#define sz_xSetDeviceValuatorsReply		32
+#define sz_xGetDeviceControlReq			8
+#define sz_xGetDeviceControlReply		32
+#define sz_xChangeDeviceControlReq		8
+#define sz_xChangeDeviceControlReply		32
+#define sz_xListDevicePropertiesReq             8
+#define sz_xListDevicePropertiesReply           32
+#define sz_xChangeDevicePropertyReq             20
+#define sz_xDeleteDevicePropertyReq             12
+#define sz_xGetDevicePropertyReq                24
+#define sz_xGetDevicePropertyReply              32
+
+#define INAME		"XInputExtension"
+
+#define XI_KEYBOARD	"KEYBOARD"
+#define XI_MOUSE	"MOUSE"
+#define XI_TABLET	"TABLET"
+#define XI_TOUCHSCREEN	"TOUCHSCREEN"
+#define XI_TOUCHPAD	"TOUCHPAD"
+#define XI_BARCODE	"BARCODE"
+#define XI_BUTTONBOX	"BUTTONBOX"
+#define XI_KNOB_BOX	"KNOB_BOX"
+#define XI_ONE_KNOB	"ONE_KNOB"
+#define XI_NINE_KNOB	"NINE_KNOB"
+#define XI_TRACKBALL	"TRACKBALL"
+#define XI_QUADRATURE	"QUADRATURE"
+#define XI_ID_MODULE	"ID_MODULE"
+#define XI_SPACEBALL	"SPACEBALL"
+#define XI_DATAGLOVE	"DATAGLOVE"
+#define XI_EYETRACKER	"EYETRACKER"
+#define XI_CURSORKEYS	"CURSORKEYS"
+#define XI_FOOTMOUSE	"FOOTMOUSE"
+#define XI_JOYSTICK	"JOYSTICK"
+
+/* Indices into the versions[] array (XExtInt.c). Used as a index to
+ * retrieve the minimum version of XI from _XiCheckExtInit */
+#define Dont_Check			0
+#define XInput_Initial_Release		1
+#define XInput_Add_XDeviceBell		2
+#define XInput_Add_XSetDeviceValuators	3
+#define XInput_Add_XChangeDeviceControl	4
+#define XInput_Add_DevicePresenceNotify	5
+#define XInput_Add_DeviceProperties	6
+/* DO NOT ADD TO HERE -> XI2 */
+
+#define XI_Absent		0
+#define XI_Present		1
+
+#define XI_Initial_Release_Major		1
+#define XI_Initial_Release_Minor		0
+
+#define XI_Add_XDeviceBell_Major		1
+#define XI_Add_XDeviceBell_Minor		1
+
+#define XI_Add_XSetDeviceValuators_Major	1
+#define XI_Add_XSetDeviceValuators_Minor	2
+
+#define XI_Add_XChangeDeviceControl_Major	1
+#define XI_Add_XChangeDeviceControl_Minor	3
+
+#define XI_Add_DevicePresenceNotify_Major	1
+#define XI_Add_DevicePresenceNotify_Minor	4
+
+#define XI_Add_DeviceProperties_Major		1
+#define XI_Add_DeviceProperties_Minor		5
+
+#define DEVICE_RESOLUTION	1
+#define DEVICE_ABS_CALIB        2
+#define DEVICE_CORE             3
+#define DEVICE_ENABLE           4
+#define DEVICE_ABS_AREA         5
+
+#define NoSuchExtension		1
+
+#define COUNT			0
+#define CREATE			1
+
+#define NewPointer		0
+#define NewKeyboard		1
+
+#define XPOINTER		0
+#define XKEYBOARD		1
+
+#define UseXKeyboard		0xFF
+
+#define IsXPointer		0
+#define IsXKeyboard		1
+#define IsXExtensionDevice	2
+#define IsXExtensionKeyboard    3
+#define IsXExtensionPointer     4
+
+#define AsyncThisDevice		0
+#define SyncThisDevice		1
+#define ReplayThisDevice	2
+#define AsyncOtherDevices	3
+#define AsyncAll		4
+#define SyncAll			5
+
+#define FollowKeyboard 		3
+#ifndef RevertToFollowKeyboard
+#define RevertToFollowKeyboard 	3
+#endif
+
+#define DvAccelNum              (1L << 0)
+#define DvAccelDenom            (1L << 1)
+#define DvThreshold             (1L << 2)
+
+#define DvKeyClickPercent	(1L<<0)
+#define DvPercent		(1L<<1)
+#define DvPitch			(1L<<2)
+#define DvDuration		(1L<<3)
+#define DvLed			(1L<<4)
+#define DvLedMode		(1L<<5)
+#define DvKey			(1L<<6)
+#define DvAutoRepeatMode	(1L<<7)
+
+#define DvString                (1L << 0)
+
+#define DvInteger               (1L << 0)
+
+#define DeviceMode              (1L << 0)
+#define Relative                0
+#define Absolute                1
+
+#define ProximityState          (1L << 1)
+#define InProximity             (0L << 1)
+#define OutOfProximity          (1L << 1)
+
+#define AddToList               0
+#define DeleteFromList          1
+
+#define KeyClass  		0
+#define ButtonClass  		1
+#define ValuatorClass  		2
+#define FeedbackClass  		3
+#define ProximityClass  	4
+#define FocusClass  		5
+#define OtherClass  		6
+#define AttachClass             7
+
+#define KbdFeedbackClass  	0
+#define PtrFeedbackClass  	1
+#define StringFeedbackClass  	2
+#define IntegerFeedbackClass  	3
+#define LedFeedbackClass  	4
+#define BellFeedbackClass  	5
+
+#define _devicePointerMotionHint 0
+#define _deviceButton1Motion	 1
+#define _deviceButton2Motion	 2
+#define _deviceButton3Motion	 3
+#define _deviceButton4Motion	 4
+#define _deviceButton5Motion	 5
+#define _deviceButtonMotion	 6
+#define _deviceButtonGrab	 7
+#define _deviceOwnerGrabButton	 8
+#define _noExtensionEvent	 9
+
+#define _devicePresence		 0
+
+#define _deviceEnter             0
+#define _deviceLeave             1
+
+/* Device presence notify states */
+#define DeviceAdded              0
+#define DeviceRemoved            1
+#define DeviceEnabled            2
+#define DeviceDisabled           3
+#define DeviceUnrecoverable      4
+#define DeviceControlChanged     5
+
+/* XI Errors */
+#define XI_BadDevice	0
+#define XI_BadEvent	1
+#define XI_BadMode	2
+#define XI_DeviceBusy	3
+#define XI_BadClass	4
+
+/*
+ * Make XEventClass be a CARD32 for 64 bit servers.  Don't affect client
+ * definition of XEventClass since that would be a library interface change.
+ * See the top of X.h for more _XSERVER64 magic.
+ *
+ * But, don't actually use the CARD32 type.  We can't get it defined here
+ * without polluting the namespace.
+ */
+#ifdef _XSERVER64
+typedef	unsigned int	XEventClass;
+#else
+typedef	unsigned long	XEventClass;
+#endif
+
+/*******************************************************************
+ *
+ * Extension version structure.
+ *
+ */
+
+typedef struct {
+        int   	present;
+        short	major_version;
+        short	minor_version;
+} XExtensionVersion;
+
+#endif /* _XI_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/XI2.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/XI2.h
new file mode 100644
index 0000000..cc47085
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/XI2.h
@@ -0,0 +1,259 @@
+/*
+ * Copyright © 2009 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef _XI2_H_
+#define _XI2_H_
+
+#define XInput_2_0                              7
+/* DO NOT ADD TO THIS LIST. These are libXi-specific defines.
+   See commit libXi-1.4.2-21-ge8531dd */
+
+#define XI_2_Major                              2
+#define XI_2_Minor                              4
+
+/* Property event flags */
+#define XIPropertyDeleted                       0
+#define XIPropertyCreated                       1
+#define XIPropertyModified                      2
+
+/* Property modes */
+#define XIPropModeReplace                       0
+#define XIPropModePrepend                       1
+#define XIPropModeAppend                        2
+
+/* Special property type used for XIGetProperty */
+#define XIAnyPropertyType                       0L
+
+/* Enter/Leave and Focus In/Out modes */
+#define XINotifyNormal                          0
+#define XINotifyGrab                            1
+#define XINotifyUngrab                          2
+#define XINotifyWhileGrabbed                    3
+#define XINotifyPassiveGrab                     4
+#define XINotifyPassiveUngrab                   5
+
+/* Enter/Leave and focus In/out detail */
+#define XINotifyAncestor                        0
+#define XINotifyVirtual                         1
+#define XINotifyInferior                        2
+#define XINotifyNonlinear                       3
+#define XINotifyNonlinearVirtual                4
+#define XINotifyPointer                         5
+#define XINotifyPointerRoot                     6
+#define XINotifyDetailNone                      7
+
+/* Grab modes */
+#define XIGrabModeSync                          0
+#define XIGrabModeAsync                         1
+#define XIGrabModeTouch                         2
+
+/* Grab reply status codes */
+#define XIGrabSuccess                           0
+#define XIAlreadyGrabbed                        1
+#define XIGrabInvalidTime                       2
+#define XIGrabNotViewable                       3
+#define XIGrabFrozen                            4
+
+/* Grab owner events values */
+#define XIOwnerEvents                           True
+#define XINoOwnerEvents                         False
+
+/* Passive grab types */
+#define XIGrabtypeButton                        0
+#define XIGrabtypeKeycode                       1
+#define XIGrabtypeEnter                         2
+#define XIGrabtypeFocusIn                       3
+#define XIGrabtypeTouchBegin                    4
+#define XIGrabtypeGesturePinchBegin             5
+#define XIGrabtypeGestureSwipeBegin             6
+
+/* Passive grab modifier */
+#define XIAnyModifier                           (1U << 31)
+#define XIAnyButton                             0
+#define XIAnyKeycode                            0
+
+/* XIAllowEvents event-modes */
+#define XIAsyncDevice                           0
+#define XISyncDevice                            1
+#define XIReplayDevice                          2
+#define XIAsyncPairedDevice                     3
+#define XIAsyncPair                             4
+#define XISyncPair                              5
+#define XIAcceptTouch                           6
+#define XIRejectTouch                           7
+
+/* DeviceChangedEvent change reasons */
+#define XISlaveSwitch                           1
+#define XIDeviceChange                          2
+
+/* Hierarchy flags */
+#define XIMasterAdded                           (1 << 0)
+#define XIMasterRemoved                         (1 << 1)
+#define XISlaveAdded                            (1 << 2)
+#define XISlaveRemoved                          (1 << 3)
+#define XISlaveAttached                         (1 << 4)
+#define XISlaveDetached                         (1 << 5)
+#define XIDeviceEnabled                         (1 << 6)
+#define XIDeviceDisabled                        (1 << 7)
+
+/* ChangeHierarchy constants */
+#define XIAddMaster                             1
+#define XIRemoveMaster                          2
+#define XIAttachSlave                           3
+#define XIDetachSlave                           4
+
+#define XIAttachToMaster                        1
+#define XIFloating                              2
+
+/* Valuator modes */
+#define XIModeRelative                          0
+#define XIModeAbsolute                          1
+
+/* Device types */
+#define XIMasterPointer                         1
+#define XIMasterKeyboard                        2
+#define XISlavePointer                          3
+#define XISlaveKeyboard                         4
+#define XIFloatingSlave                         5
+
+/* Device classes: classes that are not identical to Xi 1.x classes must be
+ * numbered starting from 8. */
+#define XIKeyClass                              0
+#define XIButtonClass                           1
+#define XIValuatorClass                         2
+#define XIScrollClass                           3
+#define XITouchClass                            8
+#define XIGestureClass                          9
+
+/* Scroll class types */
+#define XIScrollTypeVertical                    1
+#define XIScrollTypeHorizontal                  2
+
+/* Scroll class flags */
+#define XIScrollFlagNoEmulation                 (1 << 0)
+#define XIScrollFlagPreferred                   (1 << 1)
+
+/* Device event flags (common) */
+/* Device event flags (key events only) */
+#define XIKeyRepeat                             (1 << 16)
+/* Device event flags (pointer events only) */
+#define XIPointerEmulated                       (1 << 16)
+/* Device event flags (touch events only) */
+#define XITouchPendingEnd                       (1 << 16)
+#define XITouchEmulatingPointer                 (1 << 17)
+
+/* Barrier event flags */
+#define XIBarrierPointerReleased                (1 << 0)
+#define XIBarrierDeviceIsGrabbed                (1 << 1)
+
+/* Gesture pinch event flags */
+#define XIGesturePinchEventCancelled            (1 << 0)
+
+/* Gesture swipe event flags */
+#define XIGestureSwipeEventCancelled            (1 << 0)
+
+/* Touch modes */
+#define XIDirectTouch                           1
+#define XIDependentTouch                        2
+
+/* XI2 event mask macros */
+#define XISetMask(ptr, event)   (((unsigned char*)(ptr))[(event)>>3] |=  (1 << ((event) & 7)))
+#define XIClearMask(ptr, event) (((unsigned char*)(ptr))[(event)>>3] &= ~(1 << ((event) & 7)))
+#define XIMaskIsSet(ptr, event) (((unsigned char*)(ptr))[(event)>>3] &   (1 << ((event) & 7)))
+#define XIMaskLen(event)        (((event) >> 3) + 1)
+
+/* Fake device ID's for event selection */
+#define XIAllDevices                            0
+#define XIAllMasterDevices                      1
+
+/* Event types */
+#define XI_DeviceChanged                 1
+#define XI_KeyPress                      2
+#define XI_KeyRelease                    3
+#define XI_ButtonPress                   4
+#define XI_ButtonRelease                 5
+#define XI_Motion                        6
+#define XI_Enter                         7
+#define XI_Leave                         8
+#define XI_FocusIn                       9
+#define XI_FocusOut                      10
+#define XI_HierarchyChanged              11
+#define XI_PropertyEvent                 12
+#define XI_RawKeyPress                   13
+#define XI_RawKeyRelease                 14
+#define XI_RawButtonPress                15
+#define XI_RawButtonRelease              16
+#define XI_RawMotion                     17
+#define XI_TouchBegin                    18 /* XI 2.2 */
+#define XI_TouchUpdate                   19
+#define XI_TouchEnd                      20
+#define XI_TouchOwnership                21
+#define XI_RawTouchBegin                 22
+#define XI_RawTouchUpdate                23
+#define XI_RawTouchEnd                   24
+#define XI_BarrierHit                    25 /* XI 2.3 */
+#define XI_BarrierLeave                  26
+#define XI_GesturePinchBegin             27 /* XI 2.4 */
+#define XI_GesturePinchUpdate            28
+#define XI_GesturePinchEnd               29
+#define XI_GestureSwipeBegin             30
+#define XI_GestureSwipeUpdate            31
+#define XI_GestureSwipeEnd               32
+#define XI_LASTEVENT                     XI_GestureSwipeEnd
+/* NOTE: XI2LASTEVENT in xserver/include/inputstr.h must be the same value
+ * as XI_LASTEVENT if the server is supposed to handle masks etc. for this
+ * type of event. */
+
+/* Event masks.
+ * Note: the protocol spec defines a mask to be of (1 << type). Clients are
+ * free to create masks by bitshifting instead of using these defines.
+ */
+#define XI_DeviceChangedMask             (1 << XI_DeviceChanged)
+#define XI_KeyPressMask                  (1 << XI_KeyPress)
+#define XI_KeyReleaseMask                (1 << XI_KeyRelease)
+#define XI_ButtonPressMask               (1 << XI_ButtonPress)
+#define XI_ButtonReleaseMask             (1 << XI_ButtonRelease)
+#define XI_MotionMask                    (1 << XI_Motion)
+#define XI_EnterMask                     (1 << XI_Enter)
+#define XI_LeaveMask                     (1 << XI_Leave)
+#define XI_FocusInMask                   (1 << XI_FocusIn)
+#define XI_FocusOutMask                  (1 << XI_FocusOut)
+#define XI_HierarchyChangedMask          (1 << XI_HierarchyChanged)
+#define XI_PropertyEventMask             (1 << XI_PropertyEvent)
+#define XI_RawKeyPressMask               (1 << XI_RawKeyPress)
+#define XI_RawKeyReleaseMask             (1 << XI_RawKeyRelease)
+#define XI_RawButtonPressMask            (1 << XI_RawButtonPress)
+#define XI_RawButtonReleaseMask          (1 << XI_RawButtonRelease)
+#define XI_RawMotionMask                 (1 << XI_RawMotion)
+#define XI_TouchBeginMask                (1 << XI_TouchBegin)
+#define XI_TouchEndMask                  (1 << XI_TouchEnd)
+#define XI_TouchOwnershipChangedMask     (1 << XI_TouchOwnership)
+#define XI_TouchUpdateMask               (1 << XI_TouchUpdate)
+#define XI_RawTouchBeginMask             (1 << XI_RawTouchBegin)
+#define XI_RawTouchEndMask               (1 << XI_RawTouchEnd)
+#define XI_RawTouchUpdateMask            (1 << XI_RawTouchUpdate)
+#define XI_BarrierHitMask                (1 << XI_BarrierHit)
+#define XI_BarrierLeaveMask              (1 << XI_BarrierLeave)
+
+#endif /* _XI2_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/XI2proto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/XI2proto.h
new file mode 100644
index 0000000..aaeac7b
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/XI2proto.h
@@ -0,0 +1,1169 @@
+/*
+ * Copyright © 2009 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+/* Conventions for this file:
+ * Names:
+ * structs: always typedef'd, prefixed with xXI, CamelCase
+ * struct members: lower_case_with_underscores
+ *        Exceptions: reqType, ReqType, repType, RepType, sequenceNumber are
+ *        named as such for historical reasons.
+ * request opcodes: X_XIRequestName as CamelCase
+ * defines: defines used in client applications must go in XI2.h
+ *          defines used only in protocol handling: XISOMENAME
+ *
+ * Data types: unless there is a historical name for a datatype (e.g.
+ * Window), use stdint types specifying the size of the datatype.
+ * historical data type names must be defined and undefined at the top and
+ * end of the file.
+ *
+ * General:
+ * spaces, not tabs.
+ * structs specific to a request or reply added before the request
+ *      definition. structs used in more than one request, reply or event
+ *      appended to the common structs section before the definition of the
+ *      first request.
+ * members of structs vertically aligned on column 16 if datatypes permit.
+ *      otherwise aligned on next available 8n column.
+ */
+
+/**
+ * Protocol definitions for the XI2 protocol.
+ * This file should not be included by clients that merely use XI2, but do not
+ * need the wire protocol. Such clients should include XI2.h, or the matching
+ * header from the library.
+ *
+ */
+#ifndef _XI2PROTO_H_
+#define _XI2PROTO_H_
+
+#include <X11/Xproto.h>
+#include <X11/X.h>
+#include <X11/extensions/XI2.h>
+#include <stdint.h>
+
+/* make sure types have right sizes for protocol structures. */
+#define Window  uint32_t
+#define Time    uint32_t
+#define Atom    uint32_t
+#define Cursor  uint32_t
+#define Barrier uint32_t
+
+/**
+ * XI2 Request opcodes
+ */
+#define X_XIQueryPointer                40
+#define X_XIWarpPointer                 41
+#define X_XIChangeCursor                42
+#define X_XIChangeHierarchy             43
+#define X_XISetClientPointer            44
+#define X_XIGetClientPointer            45
+#define X_XISelectEvents                46
+#define X_XIQueryVersion                47
+#define X_XIQueryDevice                 48
+#define X_XISetFocus                    49
+#define X_XIGetFocus                    50
+#define X_XIGrabDevice                  51
+#define X_XIUngrabDevice                52
+#define X_XIAllowEvents                 53
+#define X_XIPassiveGrabDevice           54
+#define X_XIPassiveUngrabDevice         55
+#define X_XIListProperties              56
+#define X_XIChangeProperty              57
+#define X_XIDeleteProperty              58
+#define X_XIGetProperty                 59
+#define X_XIGetSelectedEvents           60
+#define X_XIBarrierReleasePointer       61
+
+/** Number of XI requests */
+#define XI2REQUESTS (X_XIBarrierReleasePointer - X_XIQueryPointer + 1)
+/** Number of XI2 events */
+#define XI2EVENTS   (XI_LASTEVENT + 1)
+
+/*************************************************************************************
+ *                                                                                   *
+ *                               COMMON STRUCTS                                      *
+ *                                                                                   *
+ *************************************************************************************/
+/** Fixed point 16.16 */
+typedef int32_t FP1616;
+
+/** Fixed point 32.32 */
+typedef struct {
+    int32_t     integral;
+    uint32_t    frac;
+} FP3232;
+
+/**
+ * Struct to describe a device.
+ *
+ * For a MasterPointer or a MasterKeyboard, 'attachment' specifies the
+ * paired master device.
+ * For a SlaveKeyboard or SlavePointer, 'attachment' specifies the master
+ * device this device is attached to.
+ * For a FloatingSlave, 'attachment' is undefined.
+ */
+typedef struct {
+    uint16_t    deviceid;
+    uint16_t    use;            /**< ::XIMasterPointer, ::XIMasterKeyboard,
+                                     ::XISlavePointer, ::XISlaveKeyboard,
+                                     ::XIFloatingSlave */
+    uint16_t    attachment;     /**< Current attachment or pairing.*/
+    uint16_t    num_classes;    /**< Number of classes following this struct. */
+    uint16_t    name_len;       /**< Length of name in bytes. */
+    uint8_t     enabled;        /**< TRUE if device is enabled. */
+    uint8_t     pad;
+} xXIDeviceInfo;
+
+/**
+ * Default template for a device class.
+ * A device class is equivalent to a device's capabilities. Multiple classes
+ * are supported per device.
+ */
+typedef struct {
+    uint16_t    type;           /**< One of *class */
+    uint16_t    length;         /**< Length in 4 byte units */
+    uint16_t    sourceid;       /**< source device for this class */
+    uint16_t    pad;
+} xXIAnyInfo;
+
+/**
+ * Denotes button capability on a device.
+ * Struct is followed by a button bit-mask (padded to four byte chunks) and
+ * then num_buttons * Atom that names the buttons in the device-native setup
+ * (i.e.  ignoring button mappings).
+ */
+typedef struct {
+    uint16_t    type;           /**< Always ButtonClass */
+    uint16_t    length;         /**< Length in 4 byte units */
+    uint16_t    sourceid;       /**< source device for this class */
+    uint16_t    num_buttons;    /**< Number of buttons provided */
+} xXIButtonInfo;
+
+/**
+ * Denotes key capability on a device.
+ * Struct is followed by num_keys * CARD32 that lists the keycodes available
+ * on the device.
+ */
+typedef struct {
+    uint16_t    type;           /**< Always KeyClass */
+    uint16_t    length;         /**< Length in 4 byte units */
+    uint16_t    sourceid;       /**< source device for this class */
+    uint16_t    num_keycodes;   /**< Number of keys provided */
+} xXIKeyInfo;
+
+/**
+ * Denotes an valuator capability on a device.
+ * One XIValuatorInfo describes exactly one valuator (axis) on the device.
+ */
+typedef struct {
+    uint16_t    type;           /**< Always ValuatorClass       */
+    uint16_t    length;         /**< Length in 4 byte units */
+    uint16_t    sourceid;       /**< source device for this class */
+    uint16_t    number;         /**< Valuator number            */
+    Atom        label;          /**< Axis label                 */
+    FP3232      min;            /**< Min value                  */
+    FP3232      max;            /**< Max value                  */
+    FP3232      value;          /**< Last published value       */
+    uint32_t    resolution;     /**< Resolutions in units/m     */
+    uint8_t     mode;           /**< ModeRelative or ModeAbsolute */
+    uint8_t     pad1;
+    uint16_t    pad2;
+} xXIValuatorInfo;
+
+/***
+ * Denotes a scroll valuator on a device.
+ * One XIScrollInfo describes exactly one scroll valuator that must have a
+ * XIValuatorInfo struct.
+ */
+typedef struct {
+    uint16_t    type;           /**< Always ValuatorClass         */
+    uint16_t    length;         /**< Length in 4 byte units       */
+    uint16_t    sourceid;       /**< source device for this class */
+    uint16_t    number;         /**< Valuator number              */
+    uint16_t    scroll_type;    /**< ::XIScrollTypeVertical, ::XIScrollTypeHorizontal */
+    uint16_t    pad0;
+    uint32_t    flags;          /**< ::XIScrollFlagEmulate, ::XIScrollFlagPreferred   */
+    FP3232      increment;      /**< Increment for one unit of scrolling              */
+} xXIScrollInfo;
+
+/**
+ * Denotes multitouch capability on a device.
+ */
+typedef struct {
+    uint16_t    type;           /**< Always TouchClass */
+    uint16_t    length;         /**< Length in 4 byte units */
+    uint16_t    sourceid;       /**< source device for this class */
+    uint8_t     mode;           /**< DirectTouch or DependentTouch */
+    uint8_t     num_touches;    /**< Maximum number of touches (0==unlimited) */
+} xXITouchInfo;
+
+/**
+ * Denotes touchpad gesture capability on a device.
+ */
+typedef struct {
+    uint16_t    type;           /**< Always GestureClass */
+    uint16_t    length;         /**< Length in 4 byte units */
+    uint16_t    sourceid;       /**< source device for this class */
+    uint8_t     num_touches;    /**< Maximum number of touches gesture supports (0==unlimited) */
+    uint8_t     pad0;
+} xXIGestureInfo;
+
+/**
+ * Used to select for events on a given window.
+ * Struct is followed by (mask_len * CARD8), with each bit set representing
+ * the event mask for the given type. A mask bit represents an event type if
+ * (mask == (1 << type)).
+ */
+typedef struct {
+    uint16_t    deviceid;       /**< Device id to select for        */
+    uint16_t    mask_len;       /**< Length of mask in 4 byte units */
+} xXIEventMask;
+
+/**
+ * XKB modifier information.
+ * The effective modifier is a binary mask of base, latched, and locked
+ * modifiers.
+ */
+typedef struct
+{
+    uint32_t    base_mods;              /**< Logically pressed modifiers */
+    uint32_t    latched_mods;           /**< Logically latched modifiers */
+    uint32_t    locked_mods;            /**< Logically locked modifiers */
+    uint32_t    effective_mods;         /**< Effective modifiers */
+} xXIModifierInfo;
+
+/**
+ * XKB group information.
+ * The effective group is the mathematical sum of base, latched, and locked
+ * group after group wrapping is taken into account.
+ */
+typedef struct
+{
+    uint8_t     base_group;             /**< Logically "pressed" group */
+    uint8_t     latched_group;          /**< Logically latched group */
+    uint8_t     locked_group;           /**< Logically locked group */
+    uint8_t     effective_group;        /**< Effective group */
+} xXIGroupInfo;
+
+
+/*************************************************************************************
+ *                                                                                   *
+ *                                   REQUESTS                                        *
+ *                                                                                   *
+ *************************************************************************************/
+
+/**
+ * Query the server for the supported X Input extension version.
+ */
+
+typedef struct {
+    uint8_t     reqType;                /**< Input extension major code */
+    uint8_t     ReqType;                /**< Always ::X_XIQueryVersion */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    uint16_t    major_version;
+    uint16_t    minor_version;
+} xXIQueryVersionReq;
+#define sz_xXIQueryVersionReq                     8
+
+typedef struct {
+    uint8_t     repType;                /**< ::X_Reply */
+    uint8_t     RepType;                /**< Always ::X_XIQueryVersion */
+    uint16_t    sequenceNumber;
+    uint32_t    length;
+    uint16_t    major_version;
+    uint16_t    minor_version;
+    uint32_t    pad1;
+    uint32_t    pad2;
+    uint32_t    pad3;
+    uint32_t    pad4;
+    uint32_t    pad5;
+} xXIQueryVersionReply;
+#define sz_xXIQueryVersionReply             32
+
+/**
+ * Query the server for information about a specific device or all input
+ * devices.
+ */
+typedef struct {
+    uint8_t     reqType;                /**< Input extension major code */
+    uint8_t     ReqType;                /**< Always ::X_XIQueryDevice */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    uint16_t    deviceid;
+    uint16_t    pad;
+} xXIQueryDeviceReq;
+#define sz_xXIQueryDeviceReq                    8
+
+typedef struct {
+    uint8_t     repType;                /**< ::X_Reply */
+    uint8_t     RepType;                /**< Always ::X_XIQueryDevice */
+    uint16_t    sequenceNumber;
+    uint32_t    length;
+    uint16_t    num_devices;
+    uint16_t    pad0;
+    uint32_t    pad1;
+    uint32_t    pad2;
+    uint32_t    pad3;
+    uint32_t    pad4;
+    uint32_t    pad5;
+} xXIQueryDeviceReply;
+#define sz_xXIQueryDeviceReply                  32
+
+/**
+ * Select for events on a given window.
+ */
+typedef struct {
+    uint8_t     reqType;                /**< Input extension major code */
+    uint8_t     ReqType;                /**< Always ::X_XISelectEvents */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    Window      win;
+    uint16_t    num_masks;
+    uint16_t    pad;
+} xXISelectEventsReq;
+#define sz_xXISelectEventsReq                  12
+
+/**
+ * Query for selected events on a given window.
+ */
+typedef struct {
+    uint8_t     reqType;                /**< Input extension major code */
+    uint8_t     ReqType;                /**< Always ::X_XIGetSelectedEvents */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    Window      win;
+} xXIGetSelectedEventsReq;
+#define sz_xXIGetSelectedEventsReq              8
+
+typedef struct {
+    uint8_t     repType;                /**< Input extension major opcode */
+    uint8_t     RepType;                /**< Always ::X_XIGetSelectedEvents */
+    uint16_t    sequenceNumber;
+    uint32_t    length;
+    uint16_t    num_masks;              /**< Number of xXIEventMask structs
+                                             trailing the reply */
+    uint16_t    pad0;
+    uint32_t    pad1;
+    uint32_t    pad2;
+    uint32_t    pad3;
+    uint32_t    pad4;
+    uint32_t    pad5;
+} xXIGetSelectedEventsReply;
+#define sz_xXIGetSelectedEventsReply            32
+
+/**
+ * Query the given device's screen/window coordinates.
+ */
+
+typedef struct {
+    uint8_t     reqType;                /**< Input extension major code */
+    uint8_t     ReqType;                /**< Always ::X_XIQueryPointer */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    Window      win;
+    uint16_t    deviceid;
+    uint16_t    pad1;
+} xXIQueryPointerReq;
+#define sz_xXIQueryPointerReq                   12
+
+
+typedef struct {
+    uint8_t     repType;                /**< Input extension major opcode */
+    uint8_t     RepType;                /**< Always ::X_XIQueryPointer */
+    uint16_t    sequenceNumber;
+    uint32_t    length;
+    Window      root;
+    Window      child;
+    FP1616      root_x;
+    FP1616      root_y;
+    FP1616      win_x;
+    FP1616      win_y;
+    uint8_t     same_screen;
+    uint8_t     pad0;
+    uint16_t    buttons_len;
+    xXIModifierInfo mods;
+    xXIGroupInfo group;
+} xXIQueryPointerReply;
+#define sz_xXIQueryPointerReply                 56
+
+/**
+ * Warp the given device's pointer to the specified position.
+ */
+
+typedef struct {
+    uint8_t     reqType;                /**< Input extension major code */
+    uint8_t     ReqType;                /**< Always ::X_XIWarpPointer   */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    Window      src_win;
+    Window      dst_win;
+    FP1616      src_x;
+    FP1616      src_y;
+    uint16_t    src_width;
+    uint16_t    src_height;
+    FP1616      dst_x;
+    FP1616      dst_y;
+    uint16_t    deviceid;
+    uint16_t    pad1;
+} xXIWarpPointerReq;
+#define sz_xXIWarpPointerReq                    36
+
+/**
+ * Change the given device's sprite to the given cursor.
+ */
+
+typedef struct {
+    uint8_t     reqType;                /**< Input extension major code */
+    uint8_t     ReqType;                /**< Always ::X_XIChangeCursor  */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    Window      win;
+    Cursor      cursor;
+    uint16_t    deviceid;
+    uint16_t    pad1;
+} xXIChangeCursorReq;
+#define sz_xXIChangeCursorReq                           16
+
+/**
+ * Modify the device hierarchy.
+ */
+
+typedef struct {
+    uint8_t     reqType;                /**< Input extension major code */
+    uint8_t     ReqType;                /**< Always ::X_XIChangeHierarchy */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    uint8_t     num_changes;
+    uint8_t     pad0;
+    uint16_t    pad1;
+} xXIChangeHierarchyReq;
+#define sz_xXIChangeHierarchyReq                        8
+
+/**
+ * Generic header for any hierarchy change.
+ */
+typedef struct {
+    uint16_t    type;
+    uint16_t    length;                 /**< Length in 4 byte units */
+} xXIAnyHierarchyChangeInfo;
+
+/**
+ * Create a new master device.
+ * Name of new master follows struct (4-byte padded)
+ */
+typedef struct {
+    uint16_t    type;                   /**< Always ::XIAddMaster */
+    uint16_t    length;                 /**< 2 + (namelen + padding)/4 */
+    uint16_t    name_len;
+    uint8_t     send_core;
+    uint8_t     enable;
+} xXIAddMasterInfo;
+
+/**
+ * Delete a master device. Will automatically delete the master device paired
+ * with the given master device.
+ */
+typedef struct {
+    uint16_t    type;            /**< Always ::XIRemoveMaster */
+    uint16_t    length;          /**< 3 */
+    uint16_t    deviceid;
+    uint8_t     return_mode;     /**< ::XIAttachToMaster, ::XIFloating */
+    uint8_t     pad;
+    uint16_t    return_pointer;  /**< Pointer to attach slave ptr devices to */
+    uint16_t    return_keyboard; /**< keyboard to attach slave keybd devices to*/
+} xXIRemoveMasterInfo;
+
+/**
+ * Attach an SD to a new device.
+ * NewMaster has to be of same type (pointer->pointer, keyboard->keyboard);
+ */
+typedef struct {
+    uint16_t    type;           /**< Always ::XIAttachSlave */
+    uint16_t    length;         /**< 2 */
+    uint16_t    deviceid;
+    uint16_t    new_master;     /**< id of new master device */
+} xXIAttachSlaveInfo;
+
+/**
+ * Detach an SD from its current master device.
+ */
+typedef struct {
+    uint16_t    type;           /**< Always ::XIDetachSlave */
+    uint16_t    length;         /**< 2 */
+    uint16_t    deviceid;
+    uint16_t    pad;
+} xXIDetachSlaveInfo;
+
+
+/**
+ * Set the window/client's ClientPointer.
+ */
+typedef struct {
+    uint8_t     reqType;
+    uint8_t     ReqType;                /**< Always ::X_XISetClientPointer */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    Window      win;
+    uint16_t    deviceid;
+    uint16_t    pad1;
+} xXISetClientPointerReq;
+#define sz_xXISetClientPointerReq                 12
+
+/**
+ * Query the given window/client's ClientPointer setting.
+ */
+typedef struct {
+    uint8_t     reqType;
+    uint8_t     ReqType;                /**< Always ::X_GetClientPointer */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    Window      win;
+} xXIGetClientPointerReq;
+#define sz_xXIGetClientPointerReq                 8
+
+typedef struct {
+    uint8_t     repType;                /**< Input extension major opcode */
+    uint8_t     RepType;                /**< Always ::X_GetClientPointer */
+    uint16_t    sequenceNumber;
+    uint32_t    length;
+    BOOL        set;                    /**< client pointer is set? */
+    uint8_t     pad0;
+    uint16_t    deviceid;
+    uint32_t    pad1;
+    uint32_t    pad2;
+    uint32_t    pad3;
+    uint32_t    pad4;
+    uint32_t    pad5;
+} xXIGetClientPointerReply;
+#define sz_xXIGetClientPointerReply               32
+
+/**
+ * Set the input focus to the specified window.
+ */
+typedef struct {
+    uint8_t     reqType;
+    uint8_t     ReqType;                /**< Always ::X_XISetFocus */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    Window      focus;
+    Time        time;
+    uint16_t    deviceid;
+    uint16_t    pad0;
+} xXISetFocusReq;
+#define sz_xXISetFocusReq                       16
+
+/**
+ * Query the current input focus.
+ */
+typedef struct {
+    uint8_t     reqType;
+    uint8_t     ReqType;                /**< Always ::X_XIGetDeviceFocus */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    uint16_t    deviceid;
+    uint16_t    pad0;
+} xXIGetFocusReq;
+#define sz_xXIGetFocusReq                       8
+
+typedef struct {
+    uint8_t     repType;                /**< Input extension major opcode */
+    uint8_t     RepType;                /**< Always ::X_XIGetFocus */
+    uint16_t    sequenceNumber;
+    uint32_t    length;
+    Window      focus;
+    uint32_t    pad1;
+    uint32_t    pad2;
+    uint32_t    pad3;
+    uint32_t    pad4;
+    uint32_t    pad5;
+} xXIGetFocusReply;
+#define sz_xXIGetFocusReply                     32
+
+
+/**
+ * Grab the given device.
+ */
+typedef struct {
+    uint8_t     reqType;
+    uint8_t     ReqType;                /**< Always ::X_XIGrabDevice */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    Window      grab_window;
+    Time        time;
+    Cursor      cursor;
+    uint16_t    deviceid;
+    uint8_t     grab_mode;
+    uint8_t     paired_device_mode;
+    uint8_t     owner_events;
+    uint8_t     pad;
+    uint16_t    mask_len;
+} xXIGrabDeviceReq;
+#define sz_xXIGrabDeviceReq                     24
+
+/**
+ * Return codes from a XIPassiveGrabDevice request.
+ */
+typedef struct {
+    uint32_t    modifiers;              /**< Modifier state */
+    uint8_t     status;                 /**< Grab status code */
+    uint8_t     pad0;
+    uint16_t    pad1;
+} xXIGrabModifierInfo;
+
+typedef struct {
+    uint8_t     repType;                /**< Input extension major opcode */
+    uint8_t     RepType;                /**< Always ::X_XIGrabDevice */
+    uint16_t    sequenceNumber;
+    uint32_t    length;
+    uint8_t     status;
+    uint8_t     pad0;
+    uint16_t    pad1;
+    uint32_t    pad2;
+    uint32_t    pad3;
+    uint32_t    pad4;
+    uint32_t    pad5;
+    uint32_t    pad6;
+} xXIGrabDeviceReply;
+#define sz_xXIGrabDeviceReply                  32
+
+/**
+ * Ungrab the specified device.
+ *
+ */
+typedef struct {
+    uint8_t     reqType;
+    uint8_t     ReqType;                /**< Always ::X_XIUngrabDevice */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    Time        time;
+    uint16_t    deviceid;
+    uint16_t    pad;
+} xXIUngrabDeviceReq;
+#define sz_xXIUngrabDeviceReq                   12
+
+
+/**
+ * Allow or replay events on the specified grabbed device.
+ */
+typedef struct {
+    uint8_t     reqType;
+    uint8_t     ReqType;                /**< Always ::X_XIAllowEvents */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    Time        time;
+    uint16_t    deviceid;
+    uint8_t     mode;
+    uint8_t     pad;
+} xXIAllowEventsReq;
+#define sz_xXIAllowEventsReq                   12
+
+/**
+ * Allow or replay events on the specified grabbed device.
+ * Since XI 2.2
+ */
+typedef struct {
+    uint8_t     reqType;
+    uint8_t     ReqType;                /**< Always ::X_XIAllowEvents */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    Time        time;
+    uint16_t    deviceid;
+    uint8_t     mode;
+    uint8_t     pad;
+    uint32_t    touchid;                /**< Since XI 2.2 */
+    Window      grab_window;            /**< Since XI 2.2 */
+} xXI2_2AllowEventsReq;
+#define sz_xXI2_2AllowEventsReq                20
+
+
+/**
+ * Passively grab the device.
+ */
+typedef struct {
+    uint8_t     reqType;
+    uint8_t     ReqType;                /**< Always ::X_XIPassiveGrabDevice */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    Time        time;
+    Window      grab_window;
+    Cursor      cursor;
+    uint32_t    detail;
+    uint16_t    deviceid;
+    uint16_t    num_modifiers;
+    uint16_t    mask_len;
+    uint8_t     grab_type;
+    uint8_t     grab_mode;
+    uint8_t     paired_device_mode;
+    uint8_t     owner_events;
+    uint16_t    pad1;
+} xXIPassiveGrabDeviceReq;
+#define sz_xXIPassiveGrabDeviceReq              32
+
+typedef struct {
+    uint8_t     repType;                /**< Input extension major opcode */
+    uint8_t     RepType;                /**< Always ::X_XIPassiveGrabDevice */
+    uint16_t    sequenceNumber;
+    uint32_t    length;
+    uint16_t    num_modifiers;
+    uint16_t    pad1;
+    uint32_t    pad2;
+    uint32_t    pad3;
+    uint32_t    pad4;
+    uint32_t    pad5;
+    uint32_t    pad6;
+} xXIPassiveGrabDeviceReply;
+#define sz_xXIPassiveGrabDeviceReply            32
+
+/**
+ * Delete a passive grab for the given device.
+ */
+typedef struct {
+    uint8_t     reqType;
+    uint8_t     ReqType;                /**< Always ::X_XIPassiveUngrabDevice */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    Window      grab_window;
+    uint32_t    detail;
+    uint16_t    deviceid;
+    uint16_t    num_modifiers;
+    uint8_t     grab_type;
+    uint8_t     pad0;
+    uint16_t    pad1;
+} xXIPassiveUngrabDeviceReq;
+#define sz_xXIPassiveUngrabDeviceReq            20
+
+/**
+ * List all device properties on the specified device.
+ */
+typedef struct {
+    uint8_t     reqType;
+    uint8_t     ReqType;                /**< Always ::X_XIListProperties */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    uint16_t    deviceid;
+    uint16_t    pad;
+} xXIListPropertiesReq;
+#define sz_xXIListPropertiesReq                 8
+
+typedef struct {
+    uint8_t     repType;                /**< Input extension major opcode */
+    uint8_t     RepType;                /**< Always ::X_XIListProperties */
+    uint16_t    sequenceNumber;
+    uint32_t    length;
+    uint16_t    num_properties;
+    uint16_t    pad0;
+    uint32_t    pad1;
+    uint32_t    pad2;
+    uint32_t    pad3;
+    uint32_t    pad4;
+    uint32_t    pad5;
+} xXIListPropertiesReply;
+#define sz_xXIListPropertiesReply               32
+
+/**
+ * Change a property on the specified device.
+ */
+typedef struct {
+    uint8_t     reqType;
+    uint8_t     ReqType;                /**< Always ::X_XIChangeProperty */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    uint16_t    deviceid;
+    uint8_t     mode;
+    uint8_t     format;
+    Atom        property;
+    Atom        type;
+    uint32_t    num_items;
+} xXIChangePropertyReq;
+#define sz_xXIChangePropertyReq                 20
+
+/**
+ * Delete the specified property.
+ */
+typedef struct {
+    uint8_t     reqType;
+    uint8_t     ReqType;                /**< Always X_XIDeleteProperty */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    uint16_t    deviceid;
+    uint16_t    pad0;
+    Atom        property;
+} xXIDeletePropertyReq;
+#define sz_xXIDeletePropertyReq                 12
+
+/**
+ * Query the specified property's values.
+ */
+typedef struct {
+    uint8_t     reqType;
+    uint8_t     ReqType;                /**< Always X_XIGetProperty */
+    uint16_t    length;                 /**< Length in 4 byte units */
+    uint16_t    deviceid;
+#if defined(__cplusplus) || defined(c_plusplus)
+    uint8_t     c_delete;
+#else
+    uint8_t     delete;
+#endif
+    uint8_t     pad0;
+    Atom        property;
+    Atom        type;
+    uint32_t    offset;
+    uint32_t    len;
+} xXIGetPropertyReq;
+#define sz_xXIGetPropertyReq                    24
+
+typedef struct {
+    uint8_t     repType;                /**< Input extension major opcode */
+    uint8_t     RepType;                /**< Always X_XIGetProperty */
+    uint16_t    sequenceNumber;
+    uint32_t    length;
+    Atom        type;
+    uint32_t    bytes_after;
+    uint32_t    num_items;
+    uint8_t     format;
+    uint8_t     pad0;
+    uint16_t    pad1;
+    uint32_t    pad2;
+    uint32_t    pad3;
+} xXIGetPropertyReply;
+#define sz_xXIGetPropertyReply               32
+
+typedef struct {
+    uint16_t    deviceid;
+    uint16_t    pad;
+    Barrier     barrier;
+    uint32_t    eventid;
+} xXIBarrierReleasePointerInfo;
+
+typedef struct {
+    uint8_t     reqType;                /**< Input extension major opcode */
+    uint8_t     ReqType;                /**< Always X_XIBarrierReleasePointer */
+    uint16_t    length;
+    uint32_t    num_barriers;
+    /* array of xXIBarrierReleasePointerInfo */
+} xXIBarrierReleasePointerReq;
+#define sz_xXIBarrierReleasePointerReq       8
+
+/*************************************************************************************
+ *                                                                                   *
+ *                                      EVENTS                                       *
+ *                                                                                   *
+ *************************************************************************************/
+
+/**
+ * Generic XI2 event header. All XI2 events use the same header.
+ */
+typedef struct
+{
+    uint8_t     type;
+    uint8_t     extension;              /**< XI extension offset */
+    uint16_t    sequenceNumber;
+    uint32_t    length;
+    uint16_t    evtype;
+    uint16_t    deviceid;
+    Time        time;
+} xXIGenericDeviceEvent;
+
+/**
+ * Device hierarchy information.
+ */
+typedef struct
+{
+    uint16_t    deviceid;
+    uint16_t    attachment;             /**< ID of master or paired device */
+    uint8_t     use;                    /**< ::XIMasterKeyboard,
+                                             ::XIMasterPointer,
+                                             ::XISlaveKeyboard,
+                                             ::XISlavePointer,
+                                             ::XIFloatingSlave */
+    BOOL        enabled;                /**< TRUE if the device is enabled */
+    uint16_t    pad;
+    uint32_t    flags;                  /**< ::XIMasterAdded, ::XIMasterRemoved,
+                                             ::XISlaveAttached, ::XISlaveDetached,
+                                             ::XISlaveAdded, ::XISlaveRemoved,
+                                             ::XIDeviceEnabled, ::XIDeviceDisabled */
+} xXIHierarchyInfo;
+
+/**
+ * The device hierarchy has been modified. This event includes the device
+ * hierarchy after the modification has been applied.
+ */
+typedef struct
+{
+    uint8_t     type;                   /**< Always GenericEvent */
+    uint8_t     extension;              /**< XI extension offset */
+    uint16_t    sequenceNumber;
+    uint32_t    length;                 /**< Length in 4 byte units */
+    uint16_t    evtype;                 /**< ::XI_Hierarchy */
+    uint16_t    deviceid;
+    Time        time;
+    uint32_t    flags;                  /**< ::XIMasterAdded, ::XIMasterDeleted,
+                                             ::XISlaveAttached, ::XISlaveDetached,
+                                             ::XISlaveAdded, ::XISlaveRemoved,
+                                             ::XIDeviceEnabled, ::XIDeviceDisabled */
+    uint16_t    num_info;
+    uint16_t    pad0;
+    uint32_t    pad1;
+    uint32_t    pad2;
+} xXIHierarchyEvent;
+
+/**
+ * A device has changed capabilities.
+ */
+typedef struct
+{
+    uint8_t     type;                   /**< Always GenericEvent */
+    uint8_t     extension;              /**< XI extension offset */
+    uint16_t    sequenceNumber;
+    uint32_t    length;                 /**< Length in 4 byte units */
+    uint16_t    evtype;                 /**< XI_DeviceChanged */
+    uint16_t    deviceid;               /**< Device that has changed */
+    Time        time;
+    uint16_t    num_classes;            /**< Number of classes that have changed */
+    uint16_t    sourceid;               /**< Source of the new classes */
+    uint8_t     reason;                 /**< ::XISlaveSwitch, ::XIDeviceChange */
+    uint8_t     pad0;
+    uint16_t    pad1;
+    uint32_t    pad2;
+    uint32_t    pad3;
+} xXIDeviceChangedEvent;
+
+/**
+ * The owner of a touch stream has passed on ownership to another client.
+ */
+typedef struct
+{
+    uint8_t     type;               /**< Always GenericEvent */
+    uint8_t     extension;          /**< XI extension offset */
+    uint16_t    sequenceNumber;
+    uint32_t    length;             /**< Length in 4 byte units */
+    uint16_t    evtype;             /**< XI_TouchOwnership */
+    uint16_t    deviceid;           /**< Device that has changed */
+    Time        time;
+    uint32_t    touchid;
+    Window      root;
+    Window      event;
+    Window      child;
+/* └──────── 32 byte boundary ────────┘ */
+    uint16_t    sourceid;
+    uint16_t    pad0;
+    uint32_t    flags;
+    uint32_t    pad1;
+    uint32_t    pad2;
+} xXITouchOwnershipEvent;
+
+/**
+ * Default input event for pointer, keyboard or touch input.
+ */
+typedef struct
+{
+    uint8_t     type;                   /**< Always GenericEvent */
+    uint8_t     extension;              /**< XI extension offset */
+    uint16_t    sequenceNumber;
+    uint32_t    length;                 /**< Length in 4 byte uints */
+    uint16_t    evtype;
+    uint16_t    deviceid;
+    Time        time;
+    uint32_t    detail;                 /**< Keycode or button */
+    Window      root;
+    Window      event;
+    Window      child;
+/* └──────── 32 byte boundary ────────┘ */
+    FP1616      root_x;                 /**< Always screen coords, 16.16 fixed point */
+    FP1616      root_y;
+    FP1616      event_x;                /**< Always screen coords, 16.16 fixed point */
+    FP1616      event_y;
+    uint16_t    buttons_len;            /**< Len of button flags in 4 b units */
+    uint16_t    valuators_len;          /**< Len of val. flags in 4 b units */
+    uint16_t    sourceid;               /**< The source device */
+    uint16_t    pad0;
+    uint32_t    flags;                  /**< ::XIKeyRepeat */
+    xXIModifierInfo     mods;
+    xXIGroupInfo        group;
+} xXIDeviceEvent;
+
+
+/**
+ * Sent when an input event is generated. RawEvents include valuator
+ * information in both device-specific data (i.e. unaccelerated) and
+ * processed data (i.e. accelerated, if applicable).
+ */
+typedef struct
+{
+    uint8_t     type;                   /**< Always GenericEvent */
+    uint8_t     extension;              /**< XI extension offset */
+    uint16_t    sequenceNumber;
+    uint32_t    length;                 /**< Length in 4 byte uints */
+    uint16_t    evtype;                 /**< ::XI_RawEvent */
+    uint16_t    deviceid;
+    Time        time;
+    uint32_t    detail;
+    uint16_t    sourceid;               /**< The source device (XI 2.1) */
+    uint16_t    valuators_len;          /**< Length of trailing valuator
+                                             mask in 4 byte units */
+    uint32_t    flags;                  /**< ::XIKeyRepeat */
+    uint32_t    pad2;
+} xXIRawEvent;
+
+/**
+ * Note that the layout of root, event, child, root_x, root_y, event_x,
+ * event_y must be identical to the xXIDeviceEvent.
+ */
+typedef struct
+{
+    uint8_t     type;                   /**< Always GenericEvent */
+    uint8_t     extension;              /**< XI extension offset */
+    uint16_t    sequenceNumber;
+    uint32_t    length;                 /**< Length in 4 byte uints */
+    uint16_t    evtype;                 /**< ::XI_Enter */
+    uint16_t    deviceid;
+    Time        time;
+    uint16_t    sourceid;
+    uint8_t     mode;
+    uint8_t     detail;
+    Window      root;
+    Window      event;
+    Window      child;
+/* └──────── 32 byte boundary ────────┘ */
+    FP1616      root_x;
+    FP1616      root_y;
+    FP1616      event_x;
+    FP1616      event_y;
+    BOOL        same_screen;
+    BOOL        focus;
+    uint16_t    buttons_len;            /**< Length of trailing button mask
+                                             in 4 byte units */
+    xXIModifierInfo     mods;
+    xXIGroupInfo        group;
+} xXIEnterEvent;
+
+typedef xXIEnterEvent xXILeaveEvent;
+typedef xXIEnterEvent xXIFocusInEvent;
+typedef xXIEnterEvent xXIFocusOutEvent;
+
+/**
+ * Sent when a device property is created, modified or deleted. Does not
+ * include property data, the client is required to query the data.
+ */
+typedef struct
+{
+    uint8_t     type;                   /**< Always GenericEvent */
+    uint8_t     extension;              /**< XI extension offset */
+    uint16_t    sequenceNumber;
+    uint32_t    length;                 /**< Length in 4 byte units */
+    uint16_t    evtype;                 /**< ::XI_PropertyEvent */
+    uint16_t    deviceid;
+    Time        time;
+    Atom        property;
+    uint8_t     what;                   /**< ::XIPropertyDeleted,
+                                             ::XIPropertyCreated,
+                                             ::XIPropertyMotified */
+    uint8_t     pad0;
+    uint16_t    pad1;
+    uint32_t    pad2;
+    uint32_t    pad3;
+} xXIPropertyEvent;
+
+typedef struct
+{
+    uint8_t     type;                   /**< Always GenericEvent */
+    uint8_t     extension;              /**< XI extension offset */
+    uint16_t    sequenceNumber;
+    uint32_t    length;                 /**< Length in 4 byte units */
+    uint16_t    evtype;                 /**< ::XI_BarrierHit or ::XI_BarrierLeave */
+    uint16_t    deviceid;
+    Time        time;
+    uint32_t    eventid;
+    Window      root;
+    Window      event;
+    Barrier     barrier;
+/* └──────── 32 byte boundary ────────┘ */
+    uint32_t    dtime;
+    uint32_t    flags;                  /**< ::XIBarrierPointerReleased
+                                             ::XIBarrierDeviceIsGrabbed */
+    uint16_t    sourceid;
+    int16_t     pad;
+    FP1616      root_x;
+    FP1616      root_y;
+    FP3232      dx;
+    FP3232      dy;
+} xXIBarrierEvent;
+
+typedef xXIBarrierEvent xXIBarrierHitEvent;
+typedef xXIBarrierEvent xXIBarrierPointerReleasedEvent;
+typedef xXIBarrierEvent xXIBarrierLeaveEvent;
+
+/**
+ * Event for touchpad gesture pinch input events
+ */
+typedef struct
+{
+    uint8_t     type;                   /**< Always GenericEvent */
+    uint8_t     extension;              /**< XI extension offset */
+    uint16_t    sequenceNumber;
+    uint32_t    length;                 /**< Length in 4 byte uints */
+    uint16_t    evtype;
+    uint16_t    deviceid;
+    Time        time;
+    uint32_t    detail;                 /**< The number of touches in the gesture */
+    Window      root;
+    Window      event;
+    Window      child;
+/* └──────── 32 byte boundary ────────┘ */
+    FP1616      root_x;                 /**< Always screen coords, 16.16 fixed point */
+    FP1616      root_y;
+    FP1616      event_x;                /**< Always screen coords, 16.16 fixed point */
+    FP1616      event_y;
+    FP1616      delta_x;
+    FP1616      delta_y;
+    FP1616      delta_unaccel_x;
+    FP1616      delta_unaccel_y;
+    FP1616      scale;
+    FP1616      delta_angle;
+    uint16_t    sourceid;               /**< The source device */
+    uint16_t    pad0;
+    xXIModifierInfo     mods;
+    xXIGroupInfo        group;
+    uint32_t    flags;                  /**< ::XIGesturePinchEventCancelled */
+} xXIGesturePinchEvent;
+
+/**
+ * Event for touchpad gesture swipe input events
+ */
+typedef struct
+{
+    uint8_t     type;                   /**< Always GenericEvent */
+    uint8_t     extension;              /**< XI extension offset */
+    uint16_t    sequenceNumber;
+    uint32_t    length;                 /**< Length in 4 byte uints */
+    uint16_t    evtype;
+    uint16_t    deviceid;
+    Time        time;
+    uint32_t    detail;                 /**< The number of touches in the gesture */
+    Window      root;
+    Window      event;
+    Window      child;
+/* └──────── 32 byte boundary ────────┘ */
+    FP1616      root_x;                 /**< Always screen coords, 16.16 fixed point */
+    FP1616      root_y;
+    FP1616      event_x;                /**< Always screen coords, 16.16 fixed point */
+    FP1616      event_y;
+    FP1616      delta_x;
+    FP1616      delta_y;
+    FP1616      delta_unaccel_x;
+    FP1616      delta_unaccel_y;
+    uint16_t    sourceid;               /**< The source device */
+    uint16_t    pad0;
+    xXIModifierInfo     mods;
+    xXIGroupInfo        group;
+    uint32_t    flags;                  /**< ::XIGestureSwipeEventCancelled */
+} xXIGestureSwipeEvent;
+
+#undef Window
+#undef Time
+#undef Atom
+#undef Cursor
+#undef Barrier
+
+#endif /* _XI2PROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/XIproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/XIproto.h
new file mode 100644
index 0000000..ac1f096
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/XIproto.h
@@ -0,0 +1,1758 @@
+/************************************************************
+
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+Copyright 1989 by Hewlett-Packard Company, Palo Alto, California.
+
+			All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Hewlett-Packard not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+HEWLETT-PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+HEWLETT-PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+********************************************************/
+
+#ifndef _XIPROTO_H
+#define _XIPROTO_H
+
+#include <X11/Xproto.h>
+#include <X11/X.h>
+
+/* make sure types have right sizes for protocol structures. */
+#define Window CARD32
+#define Time CARD32
+#define KeyCode CARD8
+#define Mask CARD32
+#define Atom CARD32
+#define Cursor CARD32
+
+/*********************************************************
+ *
+ * number of events, errors, and extension name.
+ *
+ */
+
+#define MORE_EVENTS	0x80
+#define DEVICE_BITS	0x7F
+
+#define InputClassBits	0x3F	/* bits in mode field for input classes */
+#define ModeBitsShift	6	/* amount to shift the remaining bits   */
+
+#define numInputClasses 7
+
+#define IEVENTS         17       /* does NOT include generic events */
+#define IERRORS         5
+#define IREQUESTS       39
+
+#define CLIENT_REQ      1
+
+typedef struct  _XExtEventInfo
+    {
+    Mask	mask;
+    BYTE	type;
+    BYTE	word;
+    } XExtEventInfo;
+
+#ifndef _XITYPEDEF_POINTER
+typedef void *Pointer;
+#endif
+
+struct tmask
+    {
+    Mask	mask;
+    void        *dev;
+    };
+
+/*********************************************************
+ *
+ * Event constants used by library.
+ *
+ */
+
+#define XI_DeviceValuator		0
+#define XI_DeviceKeyPress		1
+#define XI_DeviceKeyRelease		2
+#define XI_DeviceButtonPress		3
+#define XI_DeviceButtonRelease		4
+#define XI_DeviceMotionNotify		5
+#define XI_DeviceFocusIn		6
+#define XI_DeviceFocusOut		7
+#define XI_ProximityIn			8
+#define XI_ProximityOut			9
+#define XI_DeviceStateNotify		10
+#define XI_DeviceMappingNotify		11
+#define XI_ChangeDeviceNotify		12
+#define XI_DeviceKeystateNotify		13
+#define XI_DeviceButtonstateNotify	14
+#define XI_DevicePresenceNotify		15
+#define XI_DevicePropertyNotify         16
+
+/*********************************************************
+ *
+ * Protocol request constants
+ *
+ */
+
+#define X_GetExtensionVersion		1
+#define X_ListInputDevices		2
+#define X_OpenDevice			3
+#define X_CloseDevice			4
+#define X_SetDeviceMode			5
+#define X_SelectExtensionEvent		6
+#define X_GetSelectedExtensionEvents	7
+#define X_ChangeDeviceDontPropagateList 8
+#define X_GetDeviceDontPropagateList	9
+#define X_GetDeviceMotionEvents		10
+#define X_ChangeKeyboardDevice		11
+#define X_ChangePointerDevice		12
+#define X_GrabDevice			13
+#define X_UngrabDevice			14
+#define X_GrabDeviceKey			15
+#define X_UngrabDeviceKey		16
+#define X_GrabDeviceButton		17
+#define X_UngrabDeviceButton		18
+#define X_AllowDeviceEvents		19
+#define X_GetDeviceFocus		20
+#define X_SetDeviceFocus		21
+#define X_GetFeedbackControl		22
+#define X_ChangeFeedbackControl		23
+#define X_GetDeviceKeyMapping		24
+#define X_ChangeDeviceKeyMapping	25
+#define X_GetDeviceModifierMapping	26
+#define X_SetDeviceModifierMapping	27
+#define X_GetDeviceButtonMapping	28
+#define X_SetDeviceButtonMapping	29
+#define X_QueryDeviceState		30
+#define X_SendExtensionEvent		31
+#define X_DeviceBell			32
+#define X_SetDeviceValuators		33
+#define X_GetDeviceControl		34
+#define X_ChangeDeviceControl		35
+/* XI 1.5 */
+#define X_ListDeviceProperties          36
+#define X_ChangeDeviceProperty          37
+#define X_DeleteDeviceProperty          38
+#define X_GetDeviceProperty             39
+
+/*********************************************************
+ *
+ * Protocol request and reply structures.
+ *
+ * GetExtensionVersion.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;       /* input extension major code   */
+    CARD8	ReqType;       /* always X_GetExtensionVersion */
+    CARD16	length;
+    CARD16	nbytes;
+    CARD8	pad1, pad2;
+} xGetExtensionVersionReq;
+
+typedef struct {
+    CARD8	repType;	/* X_Reply			*/
+    CARD8	RepType;	/* always X_GetExtensionVersion */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	major_version;
+    CARD16	minor_version;
+    BOOL	present;
+    CARD8	pad1, pad2, pad3;
+    CARD32	pad01;
+    CARD32	pad02;
+    CARD32	pad03;
+    CARD32	pad04;
+} xGetExtensionVersionReply;
+
+/*********************************************************
+ *
+ * ListInputDevices.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;	/* always X_ListInputDevices	*/
+    CARD16	length;
+} xListInputDevicesReq;
+
+typedef struct {
+    CARD8	repType;	/* X_Reply			*/
+    CARD8	RepType;        /* always X_ListInputDevices	*/
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD8	ndevices;
+    CARD8	pad1, pad2, pad3;
+    CARD32	pad01;
+    CARD32	pad02;
+    CARD32	pad03;
+    CARD32	pad04;
+    CARD32	pad05;
+} xListInputDevicesReply;
+
+typedef struct _xDeviceInfo *xDeviceInfoPtr;
+
+typedef struct _xAnyClassinfo *xAnyClassPtr;
+
+typedef struct _xAnyClassinfo {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8	c_class;
+#else
+    CARD8	class;
+#endif
+    CARD8	length;
+    } xAnyClassInfo;
+
+typedef struct _xDeviceInfo {
+    CARD32	type;
+    CARD8	id;
+    CARD8	num_classes;
+    CARD8	use;      /* IsXPointer | IsXKeyboard | IsXExtension... */
+    CARD8	attached; /* id of master dev (if IsXExtension..) */
+    } xDeviceInfo;
+
+typedef struct _xKeyInfo *xKeyInfoPtr;
+
+typedef struct _xKeyInfo {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8	c_class;
+#else
+    CARD8	class;
+#endif
+    CARD8	length;
+    KeyCode	min_keycode;
+    KeyCode	max_keycode;
+    CARD16	num_keys;
+    CARD8	pad1,pad2;
+    } xKeyInfo;
+
+typedef struct _xButtonInfo *xButtonInfoPtr;
+
+typedef struct _xButtonInfo {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8	c_class;
+#else
+    CARD8	class;
+#endif
+    CARD8	length;
+    CARD16	num_buttons;
+    } xButtonInfo;
+
+typedef struct _xValuatorInfo *xValuatorInfoPtr;
+
+typedef struct _xValuatorInfo {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8	c_class;
+#else
+    CARD8	class;
+#endif
+    CARD8	length;
+    CARD8	num_axes;
+    CARD8	mode;
+    CARD32	motion_buffer_size;
+    } xValuatorInfo;
+
+typedef struct _xAxisInfo *xAxisInfoPtr;
+
+typedef struct _xAxisInfo {
+    CARD32	resolution;
+    CARD32	min_value;
+    CARD32	max_value;
+    } xAxisInfo;
+
+/*********************************************************
+ *
+ * OpenDevice.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;        /* always X_OpenDevice		*/
+    CARD16	length;
+    CARD8       deviceid;
+    BYTE	pad1, pad2, pad3;
+} xOpenDeviceReq;
+
+typedef struct {
+    CARD8	repType;	/* X_Reply			*/
+    CARD8	RepType;	/* always X_OpenDevice		*/
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD8	num_classes;
+    BYTE	pad1, pad2, pad3;
+    CARD32	pad00;
+    CARD32	pad01;
+    CARD32	pad02;
+    CARD32	pad03;
+    CARD32	pad04;
+    } xOpenDeviceReply;
+
+typedef struct {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8	c_class;
+#else
+    CARD8	class;
+#endif
+    CARD8	event_type_base;
+    } xInputClassInfo;
+
+/*********************************************************
+ *
+ * CloseDevice.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;        /* always X_CloseDevice	*/
+    CARD16	length;
+    CARD8       deviceid;
+    BYTE	pad1, pad2, pad3;
+} xCloseDeviceReq;
+
+/*********************************************************
+ *
+ * SetDeviceMode.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;	/* always X_SetDeviceMode	*/
+    CARD16	length;
+    CARD8       deviceid;
+    CARD8       mode;
+    BYTE	pad1, pad2;
+} xSetDeviceModeReq;
+
+typedef struct {
+    CARD8	repType;	/* X_Reply			*/
+    CARD8	RepType;	/* always X_SetDeviceMode	*/
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD8	status;
+    BYTE	pad1, pad2, pad3;
+    CARD32	pad01;
+    CARD32	pad02;
+    CARD32	pad03;
+    CARD32	pad04;
+    CARD32	pad05;
+} xSetDeviceModeReply;
+
+/*********************************************************
+ *
+ * SelectExtensionEvent.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;        /* always X_SelectExtensionEvent */
+    CARD16	length;
+    Window	window;
+    CARD16	count;
+    CARD16	pad00;
+} xSelectExtensionEventReq;
+
+/*********************************************************
+ *
+ * GetSelectedExtensionEvent.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;        /* X_GetSelectedExtensionEvents */
+    CARD16	length;
+    Window	window;
+} xGetSelectedExtensionEventsReq;
+
+typedef struct {
+    CARD8	repType;	/* X_Reply			*/
+    CARD8	RepType;	/* GetSelectedExtensionEvents	*/
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	this_client_count;
+    CARD16	all_clients_count;
+    CARD32	pad01;
+    CARD32	pad02;
+    CARD32	pad03;
+    CARD32	pad04;
+    CARD32	pad05;
+} xGetSelectedExtensionEventsReply;
+
+/*********************************************************
+ *
+ * ChangeDeviceDontPropagateList.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;        /* X_ChangeDeviceDontPropagateList */
+    CARD16	length;
+    Window	window;
+    CARD16	count;
+    CARD8	mode;
+    BYTE	pad;
+} xChangeDeviceDontPropagateListReq;
+
+/*********************************************************
+ *
+ * GetDeviceDontPropagateList.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;        /* X_GetDeviceDontPropagateList */
+    CARD16	length;
+    Window	window;
+} xGetDeviceDontPropagateListReq;
+
+typedef struct {
+    CARD8	repType;	/* X_Reply			*/
+    CARD8	RepType;        /* GetDeviceDontPropagateList   */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	count;
+    CARD16	pad00;
+    CARD32	pad01;
+    CARD32	pad02;
+    CARD32	pad03;
+    CARD32	pad04;
+    CARD32	pad05;
+    } xGetDeviceDontPropagateListReply;
+
+/*********************************************************
+ *
+ * GetDeviceMotionEvents.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;        /* always X_GetDeviceMotionEvents*/
+    CARD16	length;
+    Time	start;
+    Time	stop;
+    CARD8	deviceid;
+    BYTE	pad1, pad2, pad3;
+} xGetDeviceMotionEventsReq;
+
+typedef struct {
+    CARD8	repType;	/* X_Reply */
+    CARD8	RepType;        /* always X_GetDeviceMotionEvents  */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	nEvents;
+    CARD8	axes;
+    CARD8	mode;
+    BYTE	pad1, pad2;
+    CARD32	pad01;
+    CARD32	pad02;
+    CARD32	pad03;
+    CARD32	pad04;
+} xGetDeviceMotionEventsReply;
+
+/*********************************************************
+ *
+ * ChangeKeyboardDevice.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;        /* X_ChangeKeyboardDevice	*/
+    CARD16	length;
+    CARD8	deviceid;
+    BYTE	pad1, pad2, pad3;
+} xChangeKeyboardDeviceReq;
+
+typedef struct {
+    CARD8	repType;	/* X_Reply			*/
+    CARD8	RepType;        /* always X_ChangeKeyboardDevice*/
+    CARD16	sequenceNumber;
+    CARD32	length;		/* 0 */
+    CARD8	status;
+    BYTE	pad1, pad2, pad3;
+    CARD32	pad01;
+    CARD32	pad02;
+    CARD32	pad03;
+    CARD32	pad04;
+    CARD32	pad05;
+    } xChangeKeyboardDeviceReply;
+
+/*********************************************************
+ *
+ * ChangePointerDevice.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;        /* X_ChangePointerDevice	*/
+    CARD16	length;
+    CARD8	xaxis;
+    CARD8	yaxis;
+    CARD8	deviceid;
+    BYTE	pad1;
+} xChangePointerDeviceReq;
+
+typedef struct {
+    CARD8	repType;	/* X_Reply			*/
+    CARD8	RepType;        /* always X_ChangePointerDevice */
+    CARD16	sequenceNumber;
+    CARD32	length;		/* 0 */
+    CARD8	status;
+    BYTE	pad1, pad2, pad3;
+    CARD32	pad01;
+    CARD32	pad02;
+    CARD32	pad03;
+    CARD32	pad04;
+    CARD32	pad05;
+    } xChangePointerDeviceReply;
+
+/*********************************************************
+ *
+ * GrabDevice.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;        /* always X_GrabDevice */
+    CARD16	length;
+    Window	grabWindow;
+    Time	time;
+    CARD16	event_count;
+    CARD8	this_device_mode;
+    CARD8	other_devices_mode;
+    BOOL	ownerEvents;
+    CARD8	deviceid;
+    CARD16	pad01;
+} xGrabDeviceReq;
+
+typedef struct {
+    CARD8	repType;	/* X_Reply			*/
+    CARD8	RepType;        /* always X_GrabDevice	*/
+    CARD16	sequenceNumber;
+    CARD32	length;		/* 0 */
+    CARD8	status;
+    BYTE	pad1, pad2, pad3;
+    CARD32	pad01;
+    CARD32	pad02;
+    CARD32	pad03;
+    CARD32	pad04;
+    CARD32	pad05;
+    } xGrabDeviceReply;
+
+/*********************************************************
+ *
+ * UngrabDevice.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;        /* always X_UnGrabDevice	*/
+    CARD16	length;
+    Time	time;
+    CARD8	deviceid;
+    BYTE	pad1, pad2, pad3;
+} xUngrabDeviceReq;
+
+/*********************************************************
+ *
+ * GrabDeviceKey.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;        /* always X_GrabDeviceKey	*/
+    CARD16	length;
+    Window	grabWindow;
+    CARD16	event_count;
+    CARD16	modifiers;
+    CARD8	modifier_device;
+    CARD8	grabbed_device;
+    CARD8	key;
+    BYTE	this_device_mode;
+    BYTE	other_devices_mode;
+    BOOL	ownerEvents;
+    BYTE	pad1, pad2;
+} xGrabDeviceKeyReq;
+
+/*********************************************************
+ *
+ * UngrabDeviceKey.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;        /* always X_UngrabDeviceKey	*/
+    CARD16	length;
+    Window	grabWindow;
+    CARD16	modifiers;
+    CARD8	modifier_device;
+    CARD8	key;
+    CARD8	grabbed_device;
+    BYTE	pad1, pad2, pad3;
+} xUngrabDeviceKeyReq;
+
+/*********************************************************
+ *
+ * GrabDeviceButton.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;        /* always X_GrabDeviceButton	*/
+    CARD16	length;
+    Window	grabWindow;
+    CARD8	grabbed_device;
+    CARD8	modifier_device;
+    CARD16	event_count;
+    CARD16	modifiers;
+    BYTE	this_device_mode;
+    BYTE	other_devices_mode;
+    CARD8	button;
+    BOOL	ownerEvents;
+    BYTE	pad1, pad2;
+} xGrabDeviceButtonReq;
+
+/*********************************************************
+ *
+ * UngrabDeviceButton.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;        /* always X_UngrabDeviceButton	*/
+    CARD16	length;
+    Window	grabWindow;
+    CARD16	modifiers;
+    CARD8	modifier_device;
+    CARD8	button;
+    CARD8	grabbed_device;
+    BYTE	pad1, pad2, pad3;
+} xUngrabDeviceButtonReq;
+
+/*********************************************************
+ *
+ * AllowDeviceEvents.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;        /* always X_AllowDeviceEvents	*/
+    CARD16	length;
+    Time	time;
+    CARD8	mode;
+    CARD8	deviceid;
+    BYTE	pad1, pad2;
+} xAllowDeviceEventsReq;
+
+/*********************************************************
+ *
+ * GetDeviceFocus.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;        /* input extension major code   */
+    CARD8	ReqType;        /* always X_GetDeviceFocus	*/
+    CARD16	length;
+    CARD8	deviceid;
+    BYTE	pad1, pad2, pad3;
+} xGetDeviceFocusReq;
+
+typedef struct {
+    CARD8	repType;	/* X_Reply			*/
+    CARD8	RepType;        /* always X_GetDeviceFocus	*/
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	focus;
+    Time	time;
+    CARD8	revertTo;
+    BYTE	pad1, pad2, pad3;
+    CARD32	pad01;
+    CARD32	pad02;
+    CARD32	pad03;
+    } xGetDeviceFocusReply;
+
+/*********************************************************
+ *
+ * SetDeviceFocus.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;        /* input extension major code   */
+    CARD8	ReqType;        /* always X_SetDeviceFocus	*/
+    CARD16	length;
+    Window	focus;
+    Time	time;
+    CARD8	revertTo;
+    CARD8	device;
+    CARD16	pad01;
+} xSetDeviceFocusReq;
+
+/*********************************************************
+ *
+ * GetFeedbackControl.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;        /* X_GetFeedbackControl	*/
+    CARD16	length;
+    CARD8	deviceid;
+    BYTE	pad1, pad2, pad3;
+} xGetFeedbackControlReq;
+
+typedef struct {
+    CARD8	repType;	/* X_Reply			*/
+    CARD8	RepType;        /* always X_GetFeedbackControl	*/
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	num_feedbacks;
+    CARD16	pad01;
+    CARD32	pad02;
+    CARD32	pad03;
+    CARD32	pad04;
+    CARD32	pad05;
+    CARD32	pad06;
+} xGetFeedbackControlReply;
+
+typedef struct {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8	c_class;	/* feedback class		*/
+#else
+    CARD8	class;		/* feedback class		*/
+#endif
+    CARD8	id;		/* feedback id		*/
+    CARD16	length;		/* feedback length		*/
+} xFeedbackState;
+
+typedef struct {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8   c_class;
+#else
+    CARD8   class;
+#endif
+    CARD8   id;
+    CARD16  length;
+    CARD16  pitch;
+    CARD16  duration;
+    CARD32  led_mask;
+    CARD32  led_values;
+    BOOL    global_auto_repeat;
+    CARD8   click;
+    CARD8   percent;
+    BYTE    pad;
+    BYTE    auto_repeats[32];
+} xKbdFeedbackState;
+
+typedef struct {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8   c_class;
+#else
+    CARD8   class;
+#endif
+    CARD8   id;
+    CARD16  length;
+    CARD8   pad1,pad2;
+    CARD16  accelNum;
+    CARD16  accelDenom;
+    CARD16  threshold;
+} xPtrFeedbackState;
+
+typedef struct {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8	c_class;	/* feedback class id		*/
+#else
+    CARD8	class;		/* feedback class id		*/
+#endif
+    CARD8	id;
+    CARD16	length;		/* feedback length		*/
+    CARD32	resolution;
+    INT32	min_value;
+    INT32	max_value;
+} xIntegerFeedbackState;
+
+typedef struct {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8	c_class;	/* feedback class id		*/
+#else
+    CARD8	class;		/* feedback class id		*/
+#endif
+    CARD8	id;
+    CARD16	length;		/* feedback length		*/
+    CARD16	max_symbols;
+    CARD16	num_syms_supported;
+} xStringFeedbackState;
+
+typedef struct {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8	c_class;	/* feedback class id		*/
+#else
+    CARD8	class;		/* feedback class id		*/
+#endif
+    CARD8	id;
+    CARD16	length;		/* feedback length		*/
+    CARD8	percent;
+    BYTE	pad1, pad2, pad3;
+    CARD16	pitch;
+    CARD16	duration;
+} xBellFeedbackState;
+
+typedef struct {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8	c_class;	/* feedback class id		*/
+#else
+    CARD8	class;		/* feedback class id		*/
+#endif
+    CARD8	id;
+    CARD16	length;		/* feedback length		*/
+    CARD32	led_mask;
+    CARD32	led_values;
+} xLedFeedbackState;
+
+/*********************************************************
+ *
+ * ChangeFeedbackControl.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;        /* X_ChangeFeedbackControl	*/
+    CARD16	length;
+    CARD32	mask;
+    CARD8	deviceid;
+    CARD8	feedbackid;
+    BYTE	pad1, pad2;
+} xChangeFeedbackControlReq;
+
+typedef struct {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8	c_class;	/* feedback class id		*/
+#else
+    CARD8	class;		/* feedback class id		*/
+#endif
+    CARD8	id;		/* feedback id		*/
+    CARD16	length;		/* feedback length		*/
+} xFeedbackCtl;
+
+typedef struct {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8	c_class;	/* feedback class id		*/
+#else
+    CARD8	class;		/* feedback class id		*/
+#endif
+    CARD8	id;		/* feedback length		*/
+    CARD16	length;		/* feedback length		*/
+    KeyCode	key;
+    CARD8	auto_repeat_mode;
+    INT8	click;
+    INT8	percent;
+    INT16	pitch;
+    INT16	duration;
+    CARD32	led_mask;
+    CARD32	led_values;
+} xKbdFeedbackCtl;
+
+typedef struct {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8	c_class;	/* feedback class id		*/
+#else
+    CARD8	class;		/* feedback class id		*/
+#endif
+    CARD8	id;		/* feedback id		*/
+    CARD16	length;		/* feedback length		*/
+    CARD8	pad1,pad2;
+    INT16	num;
+    INT16	denom;
+    INT16	thresh;
+} xPtrFeedbackCtl;
+
+typedef struct {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8	c_class;	/* feedback class id		*/
+#else
+    CARD8	class;		/* feedback class id		*/
+#endif
+    CARD8	id;		/* feedback id		*/
+    CARD16	length;		/* feedback length		*/
+    INT32	int_to_display;
+} xIntegerFeedbackCtl;
+
+typedef struct {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8	c_class;	/* feedback class id		*/
+#else
+    CARD8	class;		/* feedback class id		*/
+#endif
+    CARD8	id;		/* feedback id		*/
+    CARD16	length;		/* feedback length		*/
+    CARD8	pad1,pad2;
+    CARD16	num_keysyms;
+} xStringFeedbackCtl;
+
+typedef struct {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8	c_class;	/* feedback class id		*/
+#else
+    CARD8	class;		/* feedback class id		*/
+#endif
+    CARD8	id;		/* feedback id		*/
+    CARD16	length;		/* feedback length		*/
+    INT8	percent;
+    BYTE	pad1, pad2, pad3;
+    INT16	pitch;
+    INT16	duration;
+} xBellFeedbackCtl;
+
+typedef struct {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8	c_class;	/* feedback class id		*/
+#else
+    CARD8	class;		/* feedback class id		*/
+#endif
+    CARD8	id;		/* feedback id		*/
+    CARD16	length;		/* feedback length		*/
+    CARD32	led_mask;
+    CARD32	led_values;
+} xLedFeedbackCtl;
+
+/*********************************************************
+ *
+ * GetDeviceKeyMapping.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;        /* input extension major code   */
+    CARD8	ReqType;	/* always X_GetDeviceKeyMapping */
+    CARD16	length;
+    CARD8	deviceid;
+    KeyCode	firstKeyCode;
+    CARD8	count;
+    BYTE	pad1;
+} xGetDeviceKeyMappingReq;
+
+typedef struct {
+    CARD8	repType;	/* X_Reply			*/
+    CARD8	RepType;	/* always X_GetDeviceKeyMapping */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD8	keySymsPerKeyCode;
+    CARD8	pad0;
+    CARD16	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGetDeviceKeyMappingReply;
+
+/*********************************************************
+ *
+ * ChangeDeviceKeyMapping.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;        /* input extension major code   */
+    CARD8	ReqType;        /* always X_ChangeDeviceKeyMapping */
+    CARD16	length;
+    CARD8	deviceid;
+    KeyCode	firstKeyCode;
+    CARD8	keySymsPerKeyCode;
+    CARD8	keyCodes;
+} xChangeDeviceKeyMappingReq;
+
+/*********************************************************
+ *
+ * GetDeviceModifierMapping.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;        /* input extension major code   */
+    CARD8	ReqType;        /* always X_GetDeviceModifierMapping */
+    CARD16	length;
+    CARD8	deviceid;
+    BYTE	pad1, pad2, pad3;
+} xGetDeviceModifierMappingReq;
+
+typedef struct {
+    CARD8	repType;	/* X_Reply */
+    CARD8	RepType;        /* always X_GetDeviceModifierMapping */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD8	numKeyPerModifier;
+    CARD8	pad0;
+    CARD16	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xGetDeviceModifierMappingReply;
+
+/*********************************************************
+ *
+ * SetDeviceModifierMapping.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;        /* input extension major code   */
+    CARD8	ReqType;        /* always X_SetDeviceModifierMapping */
+    CARD16	length;
+    CARD8	deviceid;
+    CARD8	numKeyPerModifier;
+    CARD16	pad1;
+} xSetDeviceModifierMappingReq;
+
+typedef struct {
+    CARD8	repType;	/* X_Reply */
+    CARD8	RepType;        /* always X_SetDeviceModifierMapping */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD8	success;
+    CARD8	pad0;
+    CARD16	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xSetDeviceModifierMappingReply;
+
+/*********************************************************
+ *
+ * GetDeviceButtonMapping.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;        /* X_GetDeviceButtonMapping     */
+    CARD16	length;
+    CARD8	deviceid;
+    BYTE	pad1, pad2, pad3;
+} xGetDeviceButtonMappingReq;
+
+typedef struct {
+    CARD8	repType;	/* X_Reply */
+    CARD8	RepType;        /* always X_GetDeviceButtonMapping */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD8	nElts;
+    BYTE	pad1, pad2, pad3;
+    CARD32	pad01;
+    CARD32	pad02;
+    CARD32	pad03;
+    CARD32	pad04;
+    CARD32	pad05;
+} xGetDeviceButtonMappingReply;
+
+/*********************************************************
+ *
+ * SetDeviceButtonMapping.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;        /* X_SetDeviceButtonMapping     */
+    CARD16	length;
+    CARD8	deviceid;
+    CARD8	map_length;
+    BYTE	pad1, pad2;
+} xSetDeviceButtonMappingReq;
+
+typedef struct {
+    CARD8	repType;		/* X_Reply */
+    CARD8	RepType;	/* always X_SetDeviceButtonMapping */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD8	status;
+    BYTE	pad0;
+    CARD16	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xSetDeviceButtonMappingReply;
+
+/*********************************************************
+ *
+ * QueryDeviceState.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	ReqType;        /* always X_QueryDeviceState */
+    CARD16	length;
+    CARD8	deviceid;
+    BYTE	pad1, pad2, pad3;
+} xQueryDeviceStateReq;
+
+typedef struct {
+    CARD8	repType;		/* X_Reply */
+    CARD8	RepType;	/* always X_QueryDeviceState	*/
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD8	num_classes;
+    BYTE	pad0;
+    CARD16	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xQueryDeviceStateReply;
+
+typedef struct {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8	c_class;
+#else
+    CARD8	class;
+#endif
+    CARD8	length;
+    CARD8	num_keys;
+    BYTE	pad1;
+    CARD8	keys[32];
+} xKeyState;
+
+typedef struct {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8	c_class;
+#else
+    CARD8	class;
+#endif
+    CARD8	length;
+    CARD8	num_buttons;
+    BYTE	pad1;
+    CARD8	buttons[32];
+} xButtonState;
+
+typedef struct {
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD8	c_class;
+#else
+    CARD8	class;
+#endif
+    CARD8	length;
+    CARD8	num_valuators;
+    CARD8	mode;
+} xValuatorState;
+
+/*********************************************************
+ *
+ * SendExtensionEvent.
+ * THIS REQUEST MUST BE KEPT A MULTIPLE OF 8 BYTES IN LENGTH!
+ * MORE EVENTS MAY FOLLOW AND THEY MUST BE QUAD-ALIGNED!
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	ReqType;        /* always X_SendExtensionEvent */
+    CARD16	length;
+    Window	destination;
+    CARD8	deviceid;
+    BOOL	propagate;
+    CARD16	count;
+    CARD8	num_events;
+    BYTE	pad1,pad2,pad3;
+} xSendExtensionEventReq;
+
+/*********************************************************
+ *
+ * DeviceBell.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	ReqType;        /* always X_DeviceBell */
+    CARD16	length;
+    CARD8	deviceid;
+    CARD8	feedbackid;
+    CARD8	feedbackclass;
+    INT8	percent;
+} xDeviceBellReq;
+
+/*********************************************************
+ *
+ * SetDeviceValuators.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;	/* always X_SetDeviceValuators	*/
+    CARD16	length;
+    CARD8       deviceid;
+    CARD8       first_valuator;
+    CARD8       num_valuators;
+    BYTE	pad1;
+} xSetDeviceValuatorsReq;
+
+typedef struct {
+    CARD8	repType;	/* X_Reply			*/
+    CARD8	RepType;	/* always X_SetDeviceValuators	*/
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD8	status;
+    BYTE	pad1, pad2, pad3;
+    CARD32	pad01;
+    CARD32	pad02;
+    CARD32	pad03;
+    CARD32	pad04;
+    CARD32	pad05;
+} xSetDeviceValuatorsReply;
+
+/*********************************************************
+ *
+ * GetDeviceControl.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;	/* always X_GetDeviceControl	*/
+    CARD16	length;
+    CARD16	control;
+    CARD8       deviceid;
+    BYTE	pad2;
+} xGetDeviceControlReq;
+
+typedef struct {
+    CARD8	repType;	/* X_Reply			*/
+    CARD8	RepType;	/* always X_GetDeviceControl	*/
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD8	status;
+    BYTE	pad1, pad2, pad3;
+    CARD32	pad01;
+    CARD32	pad02;
+    CARD32	pad03;
+    CARD32	pad04;
+    CARD32	pad05;
+} xGetDeviceControlReply;
+
+typedef struct {
+    CARD16	control;	/* control type			*/
+    CARD16	length;		/* control length		*/
+} xDeviceState;
+
+typedef struct {
+    CARD16	control;	/* control type			*/
+    CARD16	length;		/* control length		*/
+    CARD32	num_valuators;	/* number of valuators		*/
+} xDeviceResolutionState;
+
+typedef struct {
+     CARD16         control;
+     CARD16         length;
+     INT32          min_x;
+     INT32          max_x;
+     INT32          min_y;
+     INT32          max_y;
+     CARD32         flip_x;
+     CARD32         flip_y;
+     CARD32         rotation;
+     CARD32         button_threshold;
+} xDeviceAbsCalibState;
+
+typedef struct {
+     CARD16         control;
+     CARD16         length;
+     CARD32         offset_x;
+     CARD32         offset_y;
+     CARD32         width;
+     CARD32         height;
+     CARD32         screen;
+     CARD32         following;
+} xDeviceAbsAreaState;
+
+typedef struct {
+    CARD16      control;	/* control type                 */
+    CARD16      length; 	/* control length               */
+    CARD8       status;
+    CARD8       iscore;
+    CARD16      pad1;
+} xDeviceCoreState;
+
+typedef struct {
+    CARD16      control;	/* control type                 */
+    CARD16      length; 	/* control length               */
+    CARD8       enable;
+    CARD8       pad0;
+    CARD16      pad1;
+} xDeviceEnableState;
+
+/*********************************************************
+ *
+ * ChangeDeviceControl.
+ *
+ */
+
+typedef struct {
+    CARD8	reqType;	/* input extension major code	*/
+    CARD8	ReqType;	/* always X_ChangeDeviceControl */
+    CARD16	length;
+    CARD16      control;
+    CARD8       deviceid;
+    BYTE        pad0;
+} xChangeDeviceControlReq;
+
+typedef struct {
+    CARD8	repType;	/* X_Reply			*/
+    CARD8	RepType;	/* always X_ChangeDeviceControl	*/
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD8	status;
+    BYTE	pad1, pad2, pad3;
+    CARD32	pad01;
+    CARD32	pad02;
+    CARD32	pad03;
+    CARD32	pad04;
+    CARD32	pad05;
+} xChangeDeviceControlReply;
+
+typedef struct {
+    CARD16	control;		/* control type			*/
+    CARD16	length;			/* control length		*/
+} xDeviceCtl;
+
+typedef struct {
+    CARD16	control;		/* control type			*/
+    CARD16	length;			/* control length		*/
+    CARD8	first_valuator;		/* first valuator to change     */
+    CARD8	num_valuators;		/* number of valuators to change*/
+    CARD8	pad1,pad2;
+} xDeviceResolutionCtl;
+
+typedef struct {
+     CARD16         control;
+     CARD16         length;
+     INT32          min_x;
+     INT32          max_x;
+     INT32          min_y;
+     INT32          max_y;
+     CARD32         flip_x;
+     CARD32         flip_y;
+     CARD32         rotation;
+     CARD32         button_threshold;
+} xDeviceAbsCalibCtl;
+
+typedef struct {
+     CARD16         control;
+     CARD16         length;
+     CARD32         offset_x;
+     CARD32         offset_y;
+     INT32          width;
+     INT32          height;
+     INT32          screen;
+     CARD32         following;
+} xDeviceAbsAreaCtl;
+
+typedef struct {
+    CARD16          control;
+    CARD16          length;
+    CARD8           status;
+    CARD8           pad0;
+    CARD16          pad1;
+} xDeviceCoreCtl;
+
+typedef struct {
+    CARD16          control;
+    CARD16          length;
+    CARD8           enable;
+    CARD8           pad0;
+    CARD16          pad1;
+} xDeviceEnableCtl;
+
+/* XI 1.5 */
+
+/*********************************************************
+ *
+ * ListDeviceProperties.
+ *
+ */
+
+typedef struct {
+    CARD8       reqType;        /* input extension major opcode */
+    CARD8       ReqType;        /* always X_ListDeviceProperties */
+    CARD16      length;
+    CARD8       deviceid;
+    CARD8       pad0;
+    CARD16      pad1;
+} xListDevicePropertiesReq;
+
+typedef struct {
+    CARD8       repType;        /* X_Reply                       */
+    CARD8       RepType;        /* always X_ListDeviceProperties */
+    CARD16      sequenceNumber;
+    CARD32      length;
+    CARD16      nAtoms;
+    CARD16      pad1;
+    CARD32      pad2;
+    CARD32      pad3;
+    CARD32      pad4;
+    CARD32      pad5;
+    CARD32      pad6;
+} xListDevicePropertiesReply;
+
+/*********************************************************
+ *
+ * ChangeDeviceProperty.
+ *
+ */
+
+typedef struct {
+    CARD8       reqType;        /* input extension major opcode */
+    CARD8       ReqType;        /* always X_ChangeDeviceProperty */
+    CARD16      length;
+    Atom        property;
+    Atom        type;
+    CARD8       deviceid;
+    CARD8       format;
+    CARD8       mode;
+    CARD8       pad;
+    CARD32      nUnits;
+} xChangeDevicePropertyReq;
+
+/*********************************************************
+ *
+ * DeleteDeviceProperty.
+ *
+ */
+
+typedef struct {
+    CARD8       reqType;        /* input extension major opcode */
+    CARD8       ReqType;        /* always X_DeleteDeviceProperty */
+    CARD16      length;
+    Atom        property;
+    CARD8       deviceid;
+    CARD8       pad0;
+    CARD16      pad1;
+} xDeleteDevicePropertyReq;
+
+/*********************************************************
+ *
+ * GetDeviceProperty.
+ *
+ */
+
+typedef struct {
+    CARD8       reqType;        /* input extension major opcode */
+    CARD8       ReqType;        /* always X_GetDeviceProperty */
+    CARD16      length;
+    Atom        property;
+    Atom        type;
+    CARD32      longOffset;
+    CARD32      longLength;
+    CARD8       deviceid;
+#if defined(__cplusplus) || defined(c_plusplus)
+    BOOL        c_delete;
+#else
+    BOOL        delete;
+#endif
+    CARD16      pad;
+} xGetDevicePropertyReq;
+
+typedef struct {
+    CARD8       repType;        /* X_Reply                        */
+    CARD8       RepType;        /* always X_GetDeviceProperty   */
+    CARD16      sequenceNumber;
+    CARD32      length;
+    Atom        propertyType;
+    CARD32      bytesAfter;
+    CARD32      nItems;
+    CARD8       format;
+    CARD8       deviceid;
+    CARD16      pad1;
+    CARD32      pad2;
+    CARD32      pad3;
+} xGetDevicePropertyReply;
+
+
+/**********************************************************
+ *
+ * Input extension events.
+ *
+ * DeviceValuator
+ *
+ */
+
+typedef struct
+    {
+    BYTE	type;
+    CARD8       deviceid;
+    CARD16	sequenceNumber;
+    KeyButMask	device_state;
+    CARD8	num_valuators;
+    CARD8       first_valuator;
+    INT32	valuator0;
+    INT32	valuator1;
+    INT32	valuator2;
+    INT32	valuator3;
+    INT32	valuator4;
+    INT32	valuator5;
+    }  deviceValuator;
+
+/**********************************************************
+ *
+ * DeviceKeyButtonPointer.
+ *
+ * Used for: DeviceKeyPress, DeviceKeyRelease,
+ *	     DeviceButtonPress, DeviceButtonRelease,
+ *	     ProximityIn, ProximityOut
+ *	     DeviceMotionNotify,
+ *
+ */
+
+typedef struct
+    {
+    BYTE	type;
+    BYTE        detail;
+    CARD16      sequenceNumber;
+    Time        time;
+    Window      root;
+    Window      event;
+    Window      child;
+    INT16       root_x;
+    INT16       root_y;
+    INT16       event_x;
+    INT16       event_y;
+    KeyButMask  state;
+    BOOL        same_screen;
+    CARD8       deviceid;
+    }  deviceKeyButtonPointer;
+
+/**********************************************************
+ *
+ * DeviceFocus.
+ *
+ */
+
+typedef struct
+    {
+    BYTE	type;
+    BYTE        detail;
+    CARD16	sequenceNumber;
+    Time	time;
+    Window	window;
+    BYTE	mode;
+    CARD8       deviceid;
+    BYTE	pad1, pad2;
+    CARD32	pad00;
+    CARD32	pad01;
+    CARD32	pad02;
+    CARD32	pad03;
+    }  deviceFocus;
+
+/**********************************************************
+ *
+ * DeviceStateNotify.
+ *
+ * Note that the two high-order bits in the classes_reported
+ * field are the proximity state (InProximity or OutOfProximity),
+ * and the device mode (Absolute or Relative), respectively.
+ *
+ */
+
+typedef struct
+    {
+    BYTE	type;
+    BYTE        deviceid;
+    CARD16	sequenceNumber;
+    Time	time;
+    CARD8	num_keys;
+    CARD8	num_buttons;
+    CARD8	num_valuators;
+    CARD8       classes_reported;
+    CARD8       buttons[4];
+    CARD8       keys[4];
+    INT32	valuator0;
+    INT32	valuator1;
+    INT32	valuator2;
+    }  deviceStateNotify;
+
+/**********************************************************
+ *
+ * DeviceKeyStateNotify.
+ *
+ */
+
+typedef struct
+    {
+    BYTE	type;
+    BYTE        deviceid;
+    CARD16	sequenceNumber;
+    CARD8       keys[28];
+    }  deviceKeyStateNotify;
+
+/**********************************************************
+ *
+ * DeviceButtonStateNotify.
+ *
+ */
+
+typedef struct
+    {
+    BYTE	type;
+    BYTE        deviceid;
+    CARD16	sequenceNumber;
+    CARD8       buttons[28];
+    }  deviceButtonStateNotify;
+
+/**********************************************************
+ *
+ * DeviceMappingNotify.
+ * Fields must be kept in sync with core mappingnotify event.
+ *
+ */
+
+typedef struct
+    {
+    BYTE	type;
+    BYTE        deviceid;
+    CARD16      sequenceNumber;
+    CARD8       request;
+    KeyCode     firstKeyCode;
+    CARD8       count;
+    BYTE        pad1;
+    Time        time;
+    CARD32      pad00;
+    CARD32      pad01;
+    CARD32      pad02;
+    CARD32      pad03;
+    CARD32      pad04;
+    }  deviceMappingNotify;
+
+/**********************************************************
+ *
+ * ChangeDeviceNotify.
+ *
+ */
+
+typedef struct
+    {
+    BYTE	type;
+    BYTE        deviceid;
+    CARD16      sequenceNumber;
+    Time        time;
+    CARD8       request;
+    BYTE        pad1, pad2, pad3;
+    CARD32      pad00;
+    CARD32      pad01;
+    CARD32      pad02;
+    CARD32      pad03;
+    CARD32      pad04;
+    }  changeDeviceNotify;
+
+/**********************************************************
+ *
+ * devicePresenceNotify.
+ *
+ */
+
+typedef struct
+    {
+    BYTE	type;
+    BYTE        pad00;
+    CARD16      sequenceNumber;
+    Time        time;
+    BYTE        devchange; /* Device{Added|Removed|Enabled|Disabled|ControlChanged} */
+    BYTE        deviceid;
+    CARD16      control;
+    CARD32      pad02;
+    CARD32      pad03;
+    CARD32      pad04;
+    CARD32      pad05;
+    CARD32      pad06;
+    }  devicePresenceNotify;
+
+
+/*********************************************************
+ * DevicePropertyNotifyEvent
+ *
+ * Sent whenever a device's property changes.
+ *
+ */
+
+typedef struct
+    {
+    BYTE        type;
+    BYTE        state;               /* NewValue or Deleted */
+    CARD16      sequenceNumber;
+    CARD32      time;
+    Atom        atom;                /* affected property */
+    CARD32      pad0;
+    CARD32      pad1;
+    CARD32      pad2;
+    CARD32      pad3;
+    CARD16      pad5;
+    CARD8       pad4;
+    CARD8       deviceid;            /* id of device */
+    } devicePropertyNotify;
+
+#undef Window
+#undef Time
+#undef KeyCode
+#undef Mask
+#undef Atom
+#undef Cursor
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/XKB.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/XKB.h
new file mode 100644
index 0000000..5d3f870
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/XKB.h
@@ -0,0 +1,786 @@
+/************************************************************
+Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
+
+Permission to use, copy, modify, and distribute this
+software and its documentation for any purpose and without
+fee is hereby granted, provided that the above copyright
+notice appear in all copies and that both that copyright
+notice and this permission notice appear in supporting
+documentation, and that the name of Silicon Graphics not be
+used in advertising or publicity pertaining to distribution
+of the software without specific prior written permission.
+Silicon Graphics makes no representation about the suitability
+of this software for any purpose. It is provided "as is"
+without any express or implied warranty.
+
+SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+********************************************************/
+
+#ifndef _XKB_H_
+#define	_XKB_H_
+
+    /*
+     * XKB request codes, used in:
+     *  -  xkbReqType field of all requests
+     *  -  requestMinor field of some events
+     */
+#define	X_kbUseExtension		 0
+#define	X_kbSelectEvents	 	 1
+#define	X_kbBell			 3
+#define	X_kbGetState			 4
+#define	X_kbLatchLockState		 5
+#define	X_kbGetControls			 6
+#define	X_kbSetControls			 7
+#define	X_kbGetMap			 8
+#define	X_kbSetMap			 9
+#define	X_kbGetCompatMap		10
+#define	X_kbSetCompatMap		11
+#define	X_kbGetIndicatorState		12
+#define	X_kbGetIndicatorMap		13
+#define	X_kbSetIndicatorMap		14
+#define	X_kbGetNamedIndicator		15
+#define	X_kbSetNamedIndicator		16
+#define	X_kbGetNames			17
+#define	X_kbSetNames			18
+#define	X_kbGetGeometry			19
+#define	X_kbSetGeometry			20
+#define	X_kbPerClientFlags		21
+#define	X_kbListComponents		22
+#define	X_kbGetKbdByName		23
+#define	X_kbGetDeviceInfo		24
+#define	X_kbSetDeviceInfo		25
+#define	X_kbSetDebuggingFlags		101
+
+    /*
+     * In the X sense, XKB reports only one event.
+     * The type field of all XKB events is XkbEventCode
+     */
+#define	XkbEventCode			0
+#define	XkbNumberEvents			(XkbEventCode+1)
+
+    /*
+     * XKB has a minor event code so it can use one X event code for
+     * multiple purposes.
+     *  - reported in the xkbType field of all XKB events.
+     *  - XkbSelectEventDetails: Indicates the event for which event details
+     *    are being changed
+     */
+#define	XkbNewKeyboardNotify		0
+#define XkbMapNotify			1
+#define	XkbStateNotify			2
+#define XkbControlsNotify		3
+#define	XkbIndicatorStateNotify		4
+#define	XkbIndicatorMapNotify		5
+#define	XkbNamesNotify			6
+#define XkbCompatMapNotify		7
+#define	XkbBellNotify			8
+#define	XkbActionMessage		9
+#define	XkbAccessXNotify		10
+#define	XkbExtensionDeviceNotify	11
+
+    /*
+     * Event Mask:
+     *  - XkbSelectEvents:  Specifies event interest.
+     */
+#define	XkbNewKeyboardNotifyMask	(1L << 0)
+#define XkbMapNotifyMask		(1L << 1)
+#define	XkbStateNotifyMask		(1L << 2)
+#define XkbControlsNotifyMask		(1L << 3)
+#define	XkbIndicatorStateNotifyMask	(1L << 4)
+#define	XkbIndicatorMapNotifyMask	(1L << 5)
+#define	XkbNamesNotifyMask		(1L << 6)
+#define XkbCompatMapNotifyMask		(1L << 7)
+#define	XkbBellNotifyMask		(1L << 8)
+#define	XkbActionMessageMask		(1L << 9)
+#define	XkbAccessXNotifyMask		(1L << 10)
+#define	XkbExtensionDeviceNotifyMask	(1L << 11)
+#define	XkbAllEventsMask		(0xFFF)
+
+    /*
+     * NewKeyboardNotify event details:
+     */
+#define	XkbNKN_KeycodesMask		(1L << 0)
+#define	XkbNKN_GeometryMask		(1L << 1)
+#define	XkbNKN_DeviceIDMask		(1L << 2)
+#define	XkbAllNewKeyboardEventsMask	(0x7)
+
+    /*
+     * AccessXNotify event types:
+     *  - The 'what' field of AccessXNotify events reports the
+     *    reason that the event was generated.
+     */
+#define	XkbAXN_SKPress			0
+#define	XkbAXN_SKAccept			1
+#define	XkbAXN_SKReject			2
+#define	XkbAXN_SKRelease		3
+#define	XkbAXN_BKAccept			4
+#define	XkbAXN_BKReject			5
+#define	XkbAXN_AXKWarning		6
+
+    /*
+     * AccessXNotify details:
+     * - Used as an event detail mask to limit the conditions under which
+     *   AccessXNotify events are reported
+     */
+#define	XkbAXN_SKPressMask		(1L << 0)
+#define	XkbAXN_SKAcceptMask		(1L << 1)
+#define	XkbAXN_SKRejectMask		(1L << 2)
+#define	XkbAXN_SKReleaseMask		(1L << 3)
+#define	XkbAXN_BKAcceptMask		(1L << 4)
+#define	XkbAXN_BKRejectMask		(1L << 5)
+#define	XkbAXN_AXKWarningMask		(1L << 6)
+#define	XkbAllAccessXEventsMask		(0x7f)
+
+    /*
+     * Miscellaneous event details:
+     * - event detail masks for assorted events that don't really
+     *   have any details.
+     */
+#define	XkbAllStateEventsMask		XkbAllStateComponentsMask
+#define	XkbAllMapEventsMask		XkbAllMapComponentsMask
+#define	XkbAllControlEventsMask		XkbAllControlsMask
+#define	XkbAllIndicatorEventsMask	XkbAllIndicatorsMask
+#define	XkbAllNameEventsMask		XkbAllNamesMask
+#define	XkbAllCompatMapEventsMask	XkbAllCompatMask
+#define	XkbAllBellEventsMask		(1L << 0)
+#define	XkbAllActionMessagesMask	(1L << 0)
+
+    /*
+     * XKB reports one error:  BadKeyboard
+     * A further reason for the error is encoded into to most significant
+     * byte of the resourceID for the error:
+     *    XkbErr_BadDevice - the device in question was not found
+     *    XkbErr_BadClass  - the device was found but it doesn't belong to
+     *                       the appropriate class.
+     *    XkbErr_BadId     - the device was found and belongs to the right
+     *                       class, but not feedback with a matching id was
+     *                       found.
+     * The low byte of the resourceID for this error contains the device
+     * id, class specifier or feedback id that failed.
+     */
+#define	XkbKeyboard			0
+#define	XkbNumberErrors			1
+
+#define	XkbErr_BadDevice	0xff
+#define	XkbErr_BadClass		0xfe
+#define	XkbErr_BadId		0xfd
+
+    /*
+     * Keyboard Components Mask:
+     * - Specifies the components that follow a GetKeyboardByNameReply
+     */
+#define	XkbClientMapMask		(1L << 0)
+#define	XkbServerMapMask		(1L << 1)
+#define	XkbCompatMapMask		(1L << 2)
+#define	XkbIndicatorMapMask		(1L << 3)
+#define	XkbNamesMask			(1L << 4)
+#define	XkbGeometryMask			(1L << 5)
+#define	XkbControlsMask			(1L << 6)
+#define	XkbAllComponentsMask		(0x7f)
+
+    /*
+     * State detail mask:
+     *  - The 'changed' field of StateNotify events reports which of
+     *    the keyboard state components have changed.
+     *  - Used as an event detail mask to limit the conditions under
+     *    which StateNotify events are reported.
+     */
+#define	XkbModifierStateMask		(1L << 0)
+#define	XkbModifierBaseMask		(1L << 1)
+#define	XkbModifierLatchMask		(1L << 2)
+#define	XkbModifierLockMask		(1L << 3)
+#define	XkbGroupStateMask		(1L << 4)
+#define	XkbGroupBaseMask		(1L << 5)
+#define	XkbGroupLatchMask		(1L << 6)
+#define XkbGroupLockMask		(1L << 7)
+#define	XkbCompatStateMask		(1L << 8)
+#define	XkbGrabModsMask			(1L << 9)
+#define	XkbCompatGrabModsMask		(1L << 10)
+#define	XkbLookupModsMask		(1L << 11)
+#define	XkbCompatLookupModsMask		(1L << 12)
+#define	XkbPointerButtonMask		(1L << 13)
+#define	XkbAllStateComponentsMask	(0x3fff)
+
+    /*
+     * Controls detail masks:
+     *  The controls specified in XkbAllControlsMask:
+     *  - The 'changed' field of ControlsNotify events reports which of
+     *    the keyboard controls have changed.
+     *  - The 'changeControls' field of the SetControls request specifies
+     *    the controls for which values are to be changed.
+     *  - Used as an event detail mask to limit the conditions under
+     *    which ControlsNotify events are reported.
+     *
+     *  The controls specified in the XkbAllBooleanCtrlsMask:
+     *  - The 'enabledControls' field of ControlsNotify events reports the
+     *    current status of the boolean controls.
+     *  - The 'enabledControlsChanges' field of ControlsNotify events reports
+     *    any boolean controls that have been turned on or off.
+     *  - The 'affectEnabledControls' and 'enabledControls' fields of the
+     *    kbSetControls request change the set of enabled controls.
+     *  - The 'accessXTimeoutMask' and 'accessXTimeoutValues' fields of
+     *    an XkbControlsRec specify the controls to be changed if the keyboard
+     *    times out and the values to which they should be changed.
+     *  - The 'autoCtrls' and 'autoCtrlsValues' fields of the PerClientFlags
+     *    request specifies the specify the controls to be reset when the
+     *    client exits and the values to which they should be reset.
+     *  - The 'ctrls' field of an indicator map specifies the controls
+     *    that drive the indicator.
+     *  - Specifies the boolean controls affected by the SetControls and
+     *    LockControls key actions.
+     */
+#define	XkbRepeatKeysMask	 (1L << 0)
+#define	XkbSlowKeysMask		 (1L << 1)
+#define	XkbBounceKeysMask	 (1L << 2)
+#define	XkbStickyKeysMask	 (1L << 3)
+#define	XkbMouseKeysMask	 (1L << 4)
+#define	XkbMouseKeysAccelMask	 (1L << 5)
+#define	XkbAccessXKeysMask	 (1L << 6)
+#define	XkbAccessXTimeoutMask	 (1L << 7)
+#define	XkbAccessXFeedbackMask	 (1L << 8)
+#define	XkbAudibleBellMask	 (1L << 9)
+#define	XkbOverlay1Mask		 (1L << 10)
+#define	XkbOverlay2Mask		 (1L << 11)
+#define	XkbIgnoreGroupLockMask	 (1L << 12)
+#define	XkbGroupsWrapMask	 (1L << 27)
+#define	XkbInternalModsMask	 (1L << 28)
+#define	XkbIgnoreLockModsMask	 (1L << 29)
+#define	XkbPerKeyRepeatMask	 (1L << 30)
+#define	XkbControlsEnabledMask	 (1L << 31)
+
+#define	XkbAccessXOptionsMask    (XkbStickyKeysMask|XkbAccessXFeedbackMask)
+
+#define	XkbAllBooleanCtrlsMask	 (0x00001FFF)
+#define	XkbAllControlsMask	 (0xF8001FFF)
+#define	XkbAllControlEventsMask	 XkbAllControlsMask
+
+    /*
+     * AccessX Options Mask
+     *  - The 'accessXOptions' field of an XkbControlsRec specifies the
+     *    AccessX options that are currently in effect.
+     *  - The 'accessXTimeoutOptionsMask' and 'accessXTimeoutOptionsValues'
+     *    fields of an XkbControlsRec specify the Access X options to be
+     *    changed if the keyboard times out and the values to which they
+     *    should be changed.
+     */
+#define	XkbAX_SKPressFBMask	(1L << 0)
+#define	XkbAX_SKAcceptFBMask	(1L << 1)
+#define	XkbAX_FeatureFBMask	(1L << 2)
+#define	XkbAX_SlowWarnFBMask	(1L << 3)
+#define	XkbAX_IndicatorFBMask	(1L << 4)
+#define	XkbAX_StickyKeysFBMask	(1L << 5)
+#define	XkbAX_TwoKeysMask	(1L << 6)
+#define	XkbAX_LatchToLockMask	(1L << 7)
+#define	XkbAX_SKReleaseFBMask	(1L << 8)
+#define	XkbAX_SKRejectFBMask	(1L << 9)
+#define	XkbAX_BKRejectFBMask	(1L << 10)
+#define	XkbAX_DumbBellFBMask	(1L << 11)
+#define	XkbAX_FBOptionsMask	(0xF3F)
+#define	XkbAX_SKOptionsMask	(0x0C0)
+#define	XkbAX_AllOptionsMask	(0xFFF)
+
+    /*
+     * XkbUseCoreKbd is used to specify the core keyboard without having
+     * 			to look up its X input extension identifier.
+     * XkbUseCorePtr is used to specify the core pointer without having
+     *			to look up its X input extension identifier.
+     * XkbDfltXIClass is used to specify "don't care" any place that the
+     *			XKB protocol is looking for an X Input Extension
+     *			device class.
+     * XkbDfltXIId is used to specify "don't care" any place that the
+     *			XKB protocol is looking for an X Input Extension
+     *			feedback identifier.
+     * XkbAllXIClasses is used to get information about all device indicators,
+     *			whether they're part of the indicator feedback class
+     *			or the keyboard feedback class.
+     * XkbAllXIIds is used to get information about all device indicator
+     *			feedbacks without having to list them.
+     * XkbXINone is used to indicate that no class or id has been specified.
+     * XkbLegalXILedClass(c)  True if 'c' specifies a legal class with LEDs
+     * XkbLegalXIBellClass(c) True if 'c' specifies a legal class with bells
+     * XkbExplicitXIDevice(d) True if 'd' explicitly specifies a device
+     * XkbExplicitXIClass(c)  True if 'c' explicitly specifies a device class
+     * XkbExplicitXIId(c)     True if 'i' explicitly specifies a device id
+     * XkbSingleXIClass(c)    True if 'c' specifies exactly one device class,
+     *                        including the default.
+     * XkbSingleXIId(i)       True if 'i' specifies exactly one device
+     *	                      identifier, including the default.
+     */
+#define	XkbUseCoreKbd		0x0100
+#define	XkbUseCorePtr		0x0200
+#define	XkbDfltXIClass		0x0300
+#define	XkbDfltXIId		0x0400
+#define	XkbAllXIClasses		0x0500
+#define	XkbAllXIIds		0x0600
+#define	XkbXINone		0xff00
+
+#define	XkbLegalXILedClass(c)	(((c)==KbdFeedbackClass)||\
+					((c)==LedFeedbackClass)||\
+					((c)==XkbDfltXIClass)||\
+					((c)==XkbAllXIClasses))
+#define	XkbLegalXIBellClass(c)	(((c)==KbdFeedbackClass)||\
+					((c)==BellFeedbackClass)||\
+					((c)==XkbDfltXIClass)||\
+					((c)==XkbAllXIClasses))
+#define	XkbExplicitXIDevice(c)	(((c)&(~0xff))==0)
+#define	XkbExplicitXIClass(c)	(((c)&(~0xff))==0)
+#define	XkbExplicitXIId(c)	(((c)&(~0xff))==0)
+#define	XkbSingleXIClass(c)	((((c)&(~0xff))==0)||((c)==XkbDfltXIClass))
+#define	XkbSingleXIId(c)	((((c)&(~0xff))==0)||((c)==XkbDfltXIId))
+
+#define	XkbNoModifier		0xff
+#define	XkbNoShiftLevel		0xff
+#define	XkbNoShape		0xff
+#define	XkbNoIndicator		0xff
+
+#define	XkbNoModifierMask	0
+#define	XkbAllModifiersMask	0xff
+#define	XkbAllVirtualModsMask	0xffff
+
+#define	XkbNumKbdGroups		4
+#define	XkbMaxKbdGroup		(XkbNumKbdGroups-1)
+
+#define	XkbMaxMouseKeysBtn	4
+
+    /*
+     * Group Index and Mask:
+     *  - Indices into the kt_index array of a key type.
+     *  - Mask specifies types to be changed for XkbChangeTypesOfKey
+     */
+#define	XkbGroup1Index		0
+#define	XkbGroup2Index		1
+#define	XkbGroup3Index		2
+#define	XkbGroup4Index		3
+#define	XkbAnyGroup		254
+#define	XkbAllGroups		255
+
+#define	XkbGroup1Mask		(1<<0)
+#define	XkbGroup2Mask		(1<<1)
+#define	XkbGroup3Mask		(1<<2)
+#define	XkbGroup4Mask		(1<<3)
+#define	XkbAnyGroupMask		(1<<7)
+#define	XkbAllGroupsMask	(0xf)
+
+    /*
+     * BuildCoreState: Given a keyboard group and a modifier state,
+     *                 construct the value to be reported an event.
+     * GroupForCoreState:  Given the state reported in an event,
+     *                 determine the keyboard group.
+     * IsLegalGroup:   Returns TRUE if 'g' is a valid group index.
+     */
+#define	XkbBuildCoreState(m,g)	((((g)&0x3)<<13)|((m)&0xff))
+#define XkbGroupForCoreState(s)	(((s)>>13)&0x3)
+#define	XkbIsLegalGroup(g)	(((g)>=0)&&((g)<XkbNumKbdGroups))
+
+    /*
+     * GroupsWrap values:
+     *  - The 'groupsWrap' field of an XkbControlsRec specifies the
+     *    treatment of out of range groups.
+     *  - Bits 6 and 7 of the group info field of a key symbol map
+     *    specify the interpretation of out of range groups for the
+     *    corresponding key.
+     */
+#define	XkbWrapIntoRange	(0x00)
+#define	XkbClampIntoRange	(0x40)
+#define	XkbRedirectIntoRange	(0x80)
+
+    /*
+     * Action flags:  Reported in the 'flags' field of most key actions.
+     * Interpretation depends on the type of the action; not all actions
+     * accept all flags.
+     *
+     * Option			Used for Actions
+     * ------			----------------
+     * ClearLocks		SetMods, LatchMods, SetGroup, LatchGroup
+     * LatchToLock		SetMods, LatchMods, SetGroup, LatchGroup
+     * LockNoLock		LockMods, ISOLock, LockPtrBtn, LockDeviceBtn
+     * LockNoUnlock		LockMods, ISOLock, LockPtrBtn, LockDeviceBtn
+     * UseModMapMods		SetMods, LatchMods, LockMods, ISOLock
+     * GroupAbsolute		SetGroup, LatchGroup, LockGroup, ISOLock
+     * UseDfltButton		PtrBtn, LockPtrBtn
+     * NoAcceleration		MovePtr
+     * MoveAbsoluteX		MovePtr
+     * MoveAbsoluteY		MovePtr
+     * ISODfltIsGroup		ISOLock
+     * ISONoAffectMods		ISOLock
+     * ISONoAffectGroup		ISOLock
+     * ISONoAffectPtr		ISOLock
+     * ISONoAffectCtrls		ISOLock
+     * MessageOnPress		ActionMessage
+     * MessageOnRelease		ActionMessage
+     * MessageGenKeyEvent	ActionMessage
+     * AffectDfltBtn		SetPtrDflt
+     * DfltBtnAbsolute		SetPtrDflt
+     * SwitchApplication	SwitchScreen
+     * SwitchAbsolute		SwitchScreen
+     */
+
+#define	XkbSA_ClearLocks	(1L << 0)
+#define	XkbSA_LatchToLock	(1L << 1)
+
+#define	XkbSA_LockNoLock	(1L << 0)
+#define	XkbSA_LockNoUnlock	(1L << 1)
+
+#define	XkbSA_UseModMapMods	(1L << 2)
+
+#define	XkbSA_GroupAbsolute	(1L << 2)
+#define	XkbSA_UseDfltButton	0
+
+#define	XkbSA_NoAcceleration	(1L << 0)
+#define	XkbSA_MoveAbsoluteX	(1L << 1)
+#define	XkbSA_MoveAbsoluteY	(1L << 2)
+
+#define	XkbSA_ISODfltIsGroup 	 (1L << 7)
+#define	XkbSA_ISONoAffectMods	 (1L << 6)
+#define	XkbSA_ISONoAffectGroup	 (1L << 5)
+#define	XkbSA_ISONoAffectPtr	 (1L << 4)
+#define	XkbSA_ISONoAffectCtrls	 (1L << 3)
+#define	XkbSA_ISOAffectMask	 (0x78)
+
+#define	XkbSA_MessageOnPress	 (1L << 0)
+#define	XkbSA_MessageOnRelease	 (1L << 1)
+#define	XkbSA_MessageGenKeyEvent (1L << 2)
+
+#define	XkbSA_AffectDfltBtn	1
+#define	XkbSA_DfltBtnAbsolute	(1L << 2)
+
+#define	XkbSA_SwitchApplication	(1L << 0)
+#define	XkbSA_SwitchAbsolute	(1L << 2)
+
+    /*
+     * The following values apply to the SA_DeviceValuator
+     * action only.  Valuator operations specify the action
+     * to be taken.   Values specified in the action are
+     * multiplied by 2^scale before they are applied.
+     */
+#define	XkbSA_IgnoreVal		(0x00)
+#define	XkbSA_SetValMin		(0x10)
+#define	XkbSA_SetValCenter	(0x20)
+#define	XkbSA_SetValMax		(0x30)
+#define	XkbSA_SetValRelative	(0x40)
+#define	XkbSA_SetValAbsolute	(0x50)
+#define	XkbSA_ValOpMask		(0x70)
+#define	XkbSA_ValScaleMask	(0x07)
+#define	XkbSA_ValOp(a)		((a)&XkbSA_ValOpMask)
+#define	XkbSA_ValScale(a)	((a)&XkbSA_ValScaleMask)
+
+    /*
+     * Action types: specifies the type of a key action.  Reported in the
+     * type field of all key actions.
+     */
+#define	XkbSA_NoAction		0x00
+#define	XkbSA_SetMods		0x01
+#define	XkbSA_LatchMods		0x02
+#define	XkbSA_LockMods		0x03
+#define	XkbSA_SetGroup		0x04
+#define	XkbSA_LatchGroup	0x05
+#define	XkbSA_LockGroup		0x06
+#define	XkbSA_MovePtr		0x07
+#define	XkbSA_PtrBtn		0x08
+#define	XkbSA_LockPtrBtn	0x09
+#define	XkbSA_SetPtrDflt	0x0a
+#define	XkbSA_ISOLock		0x0b
+#define	XkbSA_Terminate		0x0c
+#define	XkbSA_SwitchScreen	0x0d
+#define	XkbSA_SetControls	0x0e
+#define	XkbSA_LockControls	0x0f
+#define	XkbSA_ActionMessage	0x10
+#define	XkbSA_RedirectKey	0x11
+#define	XkbSA_DeviceBtn		0x12
+#define	XkbSA_LockDeviceBtn	0x13
+#define	XkbSA_DeviceValuator	0x14
+#define	XkbSA_LastAction	XkbSA_DeviceValuator
+#define	XkbSA_NumActions	(XkbSA_LastAction+1)
+
+#define	XkbSA_XFree86Private	0x86
+
+    /*
+     * Specifies the key actions that clear latched groups or modifiers.
+     */
+#define	XkbSA_BreakLatch \
+	((1<<XkbSA_NoAction)|(1<<XkbSA_PtrBtn)|(1<<XkbSA_LockPtrBtn)|\
+	(1<<XkbSA_Terminate)|(1<<XkbSA_SwitchScreen)|(1<<XkbSA_SetControls)|\
+	(1<<XkbSA_LockControls)|(1<<XkbSA_ActionMessage)|\
+	(1<<XkbSA_RedirectKey)|(1<<XkbSA_DeviceBtn)|(1<<XkbSA_LockDeviceBtn))
+
+    /*
+     * Macros to classify key actions
+     */
+#define	XkbIsModAction(a)	(((a)->type>=Xkb_SASetMods)&&((a)->type<=XkbSA_LockMods))
+#define	XkbIsGroupAction(a)	(((a)->type>=XkbSA_SetGroup)&&((a)->type<=XkbSA_LockGroup))
+#define	XkbIsPtrAction(a)	(((a)->type>=XkbSA_MovePtr)&&((a)->type<=XkbSA_SetPtrDflt))
+
+
+    /*
+     * Key Behavior Qualifier:
+     *    KB_Permanent indicates that the behavior describes an unalterable
+     *    characteristic of the keyboard, not an XKB software-simulation of
+     *    the listed behavior.
+     * Key Behavior Types:
+     *    Specifies the behavior of the underlying key.
+     */
+#define	XkbKB_Permanent		0x80
+#define	XkbKB_OpMask		0x7f
+
+#define	XkbKB_Default		0x00
+#define	XkbKB_Lock		0x01
+#define	XkbKB_RadioGroup	0x02
+#define	XkbKB_Overlay1		0x03
+#define	XkbKB_Overlay2		0x04
+
+#define	XkbKB_RGAllowNone	0x80
+
+    /*
+     * Various macros which describe the range of legal keycodes.
+     */
+#define	XkbMinLegalKeyCode	8
+#define	XkbMaxLegalKeyCode	255
+#define	XkbMaxKeyCount		(XkbMaxLegalKeyCode-XkbMinLegalKeyCode+1)
+#define	XkbPerKeyBitArraySize	((XkbMaxLegalKeyCode+1)/8)
+/* Seems kinda silly to check that an unsigned char is <= 255... */
+#define	XkbIsLegalKeycode(k)	((k)>=XkbMinLegalKeyCode)
+
+    /*
+     * Assorted constants and limits.
+     */
+#define	XkbNumModifiers		8
+#define	XkbNumVirtualMods	16
+#define	XkbNumIndicators	32
+#define	XkbAllIndicatorsMask	(0xffffffff)
+#define	XkbMaxRadioGroups	32
+#define	XkbAllRadioGroupsMask	(0xffffffff)
+#define	XkbMaxShiftLevel	63
+#define	XkbMaxSymsPerKey	(XkbMaxShiftLevel*XkbNumKbdGroups)
+#define	XkbRGMaxMembers		12
+#define	XkbActionMessageLength	6
+#define	XkbKeyNameLength	4
+#define	XkbMaxRedirectCount	8
+
+#define	XkbGeomPtsPerMM		10
+#define	XkbGeomMaxColors	32
+#define	XkbGeomMaxLabelColors	3
+#define	XkbGeomMaxPriority	255
+
+    /*
+     * Key Type index and mask for the four standard key types.
+     */
+#define	XkbOneLevelIndex	0
+#define	XkbTwoLevelIndex	1
+#define	XkbAlphabeticIndex	2
+#define	XkbKeypadIndex		3
+#define	XkbLastRequiredType	XkbKeypadIndex
+#define	XkbNumRequiredTypes	(XkbLastRequiredType+1)
+#define	XkbMaxKeyTypes		255
+
+#define	XkbOneLevelMask		(1<<0)
+#define	XkbTwoLevelMask		(1<<1)
+#define	XkbAlphabeticMask	(1<<2)
+#define	XkbKeypadMask		(1<<3)
+#define	XkbAllRequiredTypes	(0xf)
+
+#define	XkbShiftLevel(n)	((n)-1)
+#define	XkbShiftLevelMask(n)	(1<<((n)-1))
+
+    /*
+     * Extension name and version information
+     */
+#define	XkbName "XKEYBOARD"
+#define	XkbMajorVersion	1
+#define	XkbMinorVersion	0
+
+    /*
+     * Explicit map components:
+     *  - Used in the 'explicit' field of an XkbServerMap.  Specifies
+     *    the keyboard components that should _not_ be updated automatically
+     *    in response to core protocol keyboard mapping requests.
+     */
+#define	XkbExplicitKeyTypesMask	  (0x0f)
+#define	XkbExplicitKeyType1Mask	  (1<<0)
+#define	XkbExplicitKeyType2Mask	  (1<<1)
+#define	XkbExplicitKeyType3Mask	  (1<<2)
+#define	XkbExplicitKeyType4Mask	  (1<<3)
+#define	XkbExplicitInterpretMask  (1<<4)
+#define	XkbExplicitAutoRepeatMask (1<<5)
+#define	XkbExplicitBehaviorMask	  (1<<6)
+#define	XkbExplicitVModMapMask	  (1<<7)
+#define	XkbAllExplicitMask	  (0xff)
+
+    /*
+     * Map components masks:
+     * Those in AllMapComponentsMask:
+     *  - Specifies the individual fields to be loaded or changed for the
+     *    GetMap and SetMap requests.
+     * Those in ClientInfoMask:
+     *  - Specifies the components to be allocated by XkbAllocClientMap.
+     * Those in ServerInfoMask:
+     *  - Specifies the components to be allocated by XkbAllocServerMap.
+     */
+#define	XkbKeyTypesMask		(1<<0)
+#define	XkbKeySymsMask		(1<<1)
+#define	XkbModifierMapMask	(1<<2)
+#define	XkbExplicitComponentsMask (1<<3)
+#define XkbKeyActionsMask	(1<<4)
+#define	XkbKeyBehaviorsMask	(1<<5)
+#define	XkbVirtualModsMask	(1<<6)
+#define	XkbVirtualModMapMask	(1<<7)
+
+#define	XkbAllClientInfoMask	(XkbKeyTypesMask|XkbKeySymsMask|XkbModifierMapMask)
+#define	XkbAllServerInfoMask	(XkbExplicitComponentsMask|XkbKeyActionsMask|XkbKeyBehaviorsMask|XkbVirtualModsMask|XkbVirtualModMapMask)
+#define	XkbAllMapComponentsMask	(XkbAllClientInfoMask|XkbAllServerInfoMask)
+
+    /*
+     * Symbol interpretations flags:
+     *  - Used in the flags field of a symbol interpretation
+     */
+#define	XkbSI_AutoRepeat	(1<<0)
+#define	XkbSI_LockingKey	(1<<1)
+
+    /*
+     * Symbol interpretations match specification:
+     *  - Used in the match field of a symbol interpretation to specify
+     *    the conditions under which an interpretation is used.
+     */
+#define	XkbSI_LevelOneOnly	(0x80)
+#define	XkbSI_OpMask		(0x7f)
+#define	XkbSI_NoneOf		(0)
+#define	XkbSI_AnyOfOrNone	(1)
+#define	XkbSI_AnyOf		(2)
+#define	XkbSI_AllOf		(3)
+#define	XkbSI_Exactly		(4)
+
+    /*
+     * Indicator map flags:
+     *  - Used in the flags field of an indicator map to indicate the
+     *    conditions under which and indicator can be changed and the
+     *    effects of changing the indicator.
+     */
+#define	XkbIM_NoExplicit	(1L << 7)
+#define	XkbIM_NoAutomatic	(1L << 6)
+#define	XkbIM_LEDDrivesKB	(1L << 5)
+
+    /*
+     * Indicator map component specifications:
+     *  - Used by the 'which_groups' and 'which_mods' fields of an indicator
+     *    map to specify which keyboard components should be used to drive
+     *    the indicator.
+     */
+#define	XkbIM_UseBase		(1L << 0)
+#define	XkbIM_UseLatched	(1L << 1)
+#define	XkbIM_UseLocked		(1L << 2)
+#define	XkbIM_UseEffective	(1L << 3)
+#define	XkbIM_UseCompat		(1L << 4)
+
+#define	XkbIM_UseNone	  0
+#define	XkbIM_UseAnyGroup (XkbIM_UseBase|XkbIM_UseLatched|XkbIM_UseLocked\
+                           |XkbIM_UseEffective)
+#define	XkbIM_UseAnyMods  (XkbIM_UseAnyGroup|XkbIM_UseCompat)
+
+    /*
+     * Compatibility Map Components:
+     *  - Specifies the components to be allocated in XkbAllocCompatMap.
+     */
+#define	XkbSymInterpMask	(1<<0)
+#define	XkbGroupCompatMask	(1<<1)
+#define	XkbAllCompatMask	(0x3)
+
+    /*
+     * Names component mask:
+     *  - Specifies the names to be loaded or changed for the GetNames and
+     *    SetNames requests.
+     *  - Specifies the names that have changed in a NamesNotify event.
+     *  - Specifies the names components to be allocated by XkbAllocNames.
+     */
+#define	XkbKeycodesNameMask	(1<<0)
+#define	XkbGeometryNameMask	(1<<1)
+#define	XkbSymbolsNameMask	(1<<2)
+#define	XkbPhysSymbolsNameMask	(1<<3)
+#define	XkbTypesNameMask	(1<<4)
+#define	XkbCompatNameMask 	(1<<5)
+#define	XkbKeyTypeNamesMask	(1<<6)
+#define	XkbKTLevelNamesMask	(1<<7)
+#define	XkbIndicatorNamesMask	(1<<8)
+#define	XkbKeyNamesMask		(1<<9)
+#define	XkbKeyAliasesMask	(1<<10)
+#define	XkbVirtualModNamesMask	(1<<11)
+#define	XkbGroupNamesMask	(1<<12)
+#define	XkbRGNamesMask		(1<<13)
+#define	XkbComponentNamesMask	(0x3f)
+#define	XkbAllNamesMask		(0x3fff)
+
+    /*
+     * GetByName components:
+     *  - Specifies desired or necessary components to GetKbdByName request.
+     *  - Reports the components that were found in a GetKbdByNameReply
+     */
+#define	XkbGBN_TypesMask		(1L << 0)
+#define	XkbGBN_CompatMapMask		(1L << 1)
+#define	XkbGBN_ClientSymbolsMask	(1L << 2)
+#define	XkbGBN_ServerSymbolsMask	(1L << 3)
+#define	XkbGBN_SymbolsMask (XkbGBN_ClientSymbolsMask|XkbGBN_ServerSymbolsMask)
+#define	XkbGBN_IndicatorMapMask		(1L << 4)
+#define	XkbGBN_KeyNamesMask		(1L << 5)
+#define	XkbGBN_GeometryMask		(1L << 6)
+#define	XkbGBN_OtherNamesMask		(1L << 7)
+#define	XkbGBN_AllComponentsMask	(0xff)
+
+     /*
+      * ListComponents flags
+      */
+#define	XkbLC_Hidden			(1L <<  0)
+#define	XkbLC_Default			(1L <<  1)
+#define	XkbLC_Partial			(1L <<  2)
+
+#define	XkbLC_AlphanumericKeys		(1L <<  8)
+#define	XkbLC_ModifierKeys		(1L <<  9)
+#define	XkbLC_KeypadKeys		(1L << 10)
+#define	XkbLC_FunctionKeys		(1L << 11)
+#define	XkbLC_AlternateGroup		(1L << 12)
+
+    /*
+     * X Input Extension Interactions
+     * - Specifies the possible interactions between XKB and the X input
+     *   extension
+     * - Used to request (XkbGetDeviceInfo) or change (XKbSetDeviceInfo)
+     *   XKB information about an extension device.
+     * - Reports the list of supported optional features in the reply to
+     *   XkbGetDeviceInfo or in an XkbExtensionDeviceNotify event.
+     * XkbXI_UnsupportedFeature is reported in XkbExtensionDeviceNotify
+     * events to indicate an attempt to use an unsupported feature.
+     */
+#define	XkbXI_KeyboardsMask		(1L << 0)
+#define	XkbXI_ButtonActionsMask		(1L << 1)
+#define	XkbXI_IndicatorNamesMask	(1L << 2)
+#define	XkbXI_IndicatorMapsMask		(1L << 3)
+#define	XkbXI_IndicatorStateMask	(1L << 4)
+#define	XkbXI_UnsupportedFeatureMask	(1L << 15)
+#define	XkbXI_AllFeaturesMask		(0x001f)
+#define	XkbXI_AllDeviceFeaturesMask	(0x001e)
+
+#define	XkbXI_IndicatorsMask		(0x001c)
+#define	XkbAllExtensionDeviceEventsMask (0x801f)
+
+    /*
+     * Per-Client Flags:
+     *  - Specifies flags to be changed by the PerClientFlags request.
+     */
+#define	XkbPCF_DetectableAutoRepeatMask	(1L << 0)
+#define	XkbPCF_GrabsUseXKBStateMask	(1L << 1)
+#define	XkbPCF_AutoResetControlsMask	(1L << 2)
+#define	XkbPCF_LookupStateWhenGrabbed	(1L << 3)
+#define	XkbPCF_SendEventUsesXKBState	(1L << 4)
+#define	XkbPCF_AllFlagsMask		(0x1F)
+
+    /*
+     * Debugging flags and controls
+     */
+#define	XkbDF_DisableLocks	(1<<0)
+
+#endif /* _XKB_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/XKBgeom.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/XKBgeom.h
new file mode 100644
index 0000000..380fa18
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/XKBgeom.h
@@ -0,0 +1,662 @@
+/************************************************************
+Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
+
+Permission to use, copy, modify, and distribute this
+software and its documentation for any purpose and without
+fee is hereby granted, provided that the above copyright
+notice appear in all copies and that both that copyright
+notice and this permission notice appear in supporting
+documentation, and that the name of Silicon Graphics not be
+used in advertising or publicity pertaining to distribution
+of the software without specific prior written permission.
+Silicon Graphics makes no representation about the suitability
+of this software for any purpose. It is provided "as is"
+without any express or implied warranty.
+
+SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+********************************************************/
+
+#ifndef _XKBGEOM_H_
+#define	_XKBGEOM_H_
+
+#include <X11/extensions/XKBstr.h>
+
+#ifdef XKB_IN_SERVER
+#define XkbAddGeomKeyAlias 		SrvXkbAddGeomKeyAlias
+#define XkbAddGeomColor 		SrvXkbAddGeomColor
+#define XkbAddGeomDoodad		SrvXkbAddGeomDoodad
+#define XkbAddGeomKey			SrvXkbAddGeomKey
+#define XkbAddGeomOutline		SrvXkbAddGeomOutline
+#define XkbAddGeomOverlay		SrvXkbAddGeomOverlay
+#define XkbAddGeomOverlayRow		SrvXkbAddGeomOverlayRow
+#define	XkbAddGeomOverlayKey		SrvXkbAddGeomOverlayKey
+#define XkbAddGeomProperty		SrvXkbAddGeomProperty
+#define XkbAddGeomRow			SrvXkbAddGeomRow
+#define XkbAddGeomSection		SrvXkbAddGeomSection
+#define XkbAddGeomShape			SrvXkbAddGeomShape
+#define XkbAllocGeomKeyAliases		SrvXkbAllocGeomKeyAliases
+#define XkbAllocGeomColors		SrvXkbAllocGeomColors
+#define XkbAllocGeomDoodads		SrvXkbAllocGeomDoodads
+#define XkbAllocGeomKeys		SrvXkbAllocGeomKeys
+#define XkbAllocGeomOutlines		SrvXkbAllocGeomOutlines
+#define XkbAllocGeomPoints		SrvXkbAllocGeomPoints
+#define XkbAllocGeomProps		SrvXkbAllocGeomProps
+#define XkbAllocGeomRows		SrvXkbAllocGeomRows
+#define XkbAllocGeomSectionDoodads	SrvXkbAllocGeomSectionDoodads
+#define XkbAllocGeomSections		SrvXkbAllocGeomSections
+#define	XkbAllocGeomOverlays		SrvXkbAllocGeomOverlays
+#define	XkbAllocGeomOverlayRows		SrvXkbAllocGeomOverlayRows
+#define	XkbAllocGeomOverlayKeys		SrvXkbAllocGeomOverlayKeys
+#define XkbAllocGeomShapes		SrvXkbAllocGeomShapes
+#define XkbAllocGeometry		SrvXkbAllocGeometry
+#define XkbFreeGeomKeyAliases		SrvXkbFreeGeomKeyAliases
+#define XkbFreeGeomColors		SrvXkbFreeGeomColors
+#define XkbFreeGeomDoodads		SrvXkbFreeGeomDoodads
+#define XkbFreeGeomProperties		SrvXkbFreeGeomProperties
+#define	XkbFreeGeomOverlayKeys		SrvXkbFreeGeomOverlayKeys
+#define	XkbFreeGeomOverlayRows		SrvXkbFreeGeomOverlayRows
+#define	XkbFreeGeomOverlays		SrvXkbFreeGeomOverlays
+#define	XkbFreeGeomKeys			SrvXkbFreeGeomKeys
+#define	XkbFreeGeomRows			SrvXkbFreeGeomRows
+#define XkbFreeGeomSections		SrvXkbFreeGeomSections
+#define	XkbFreeGeomPoints		SrvXkbFreeGeomPoints
+#define	XkbFreeGeomOutlines		SrvXkbFreeGeomOutlines
+#define XkbFreeGeomShapes		SrvXkbFreeGeomShapes
+#define XkbFreeGeometry			SrvXkbFreeGeometry
+#endif
+
+typedef	struct _XkbProperty {
+	char	*name;
+	char	*value;
+} XkbPropertyRec,*XkbPropertyPtr;
+
+typedef struct _XkbColor {
+	unsigned int 	pixel;
+	char *		spec;
+} XkbColorRec,*XkbColorPtr;
+
+typedef	struct _XkbPoint {
+	short	x;
+	short	y;
+} XkbPointRec, *XkbPointPtr;
+
+typedef struct	_XkbBounds {
+	short	x1,y1;
+	short	x2,y2;
+} XkbBoundsRec, *XkbBoundsPtr;
+#define	XkbBoundsWidth(b)	(((b)->x2)-((b)->x1))
+#define	XkbBoundsHeight(b)	(((b)->y2)-((b)->y1))
+
+/*
+ * In the following structs, this pattern is used for dynamically sized arrays:
+ * foo is an array for which sz_foo entries are allocated & num_foo are used
+ */
+
+typedef struct _XkbOutline {
+	unsigned short	num_points;
+	unsigned short	sz_points;
+	unsigned short	corner_radius;
+	XkbPointPtr	points;
+} XkbOutlineRec, *XkbOutlinePtr;
+
+typedef struct _XkbShape {
+	Atom	 	 name;
+	unsigned short	 num_outlines;
+	unsigned short	 sz_outlines;
+	XkbOutlinePtr	 outlines;
+	XkbOutlinePtr	 approx;
+	XkbOutlinePtr	 primary;
+	XkbBoundsRec	 bounds;
+} XkbShapeRec, *XkbShapePtr;
+#define	XkbOutlineIndex(s,o)	((int)((o)-&(s)->outlines[0]))
+
+typedef struct _XkbShapeDoodad {
+	Atom		 name;
+	unsigned char	 type;
+	unsigned char	 priority;
+	short		 top;
+	short		 left;
+	short	 	 angle;
+	unsigned short	 color_ndx;
+	unsigned short	 shape_ndx;
+} XkbShapeDoodadRec, *XkbShapeDoodadPtr;
+#define	XkbShapeDoodadColor(g,d)	(&(g)->colors[(d)->color_ndx])
+#define	XkbShapeDoodadShape(g,d)	(&(g)->shapes[(d)->shape_ndx])
+#define	XkbSetShapeDoodadColor(g,d,c)	((d)->color_ndx= (c)-&(g)->colors[0])
+#define	XkbSetShapeDoodadShape(g,d,s)	((d)->shape_ndx= (s)-&(g)->shapes[0])
+
+typedef struct _XkbTextDoodad {
+	Atom		 name;
+	unsigned char	 type;
+	unsigned char	 priority;
+	short	 	 top;
+	short	 	 left;
+	short	 	 angle;
+	short	 	 width;
+	short		 height;
+	unsigned short	 color_ndx;
+	char *		 text;
+	char *		 font;
+} XkbTextDoodadRec, *XkbTextDoodadPtr;
+#define	XkbTextDoodadColor(g,d)	(&(g)->colors[(d)->color_ndx])
+#define	XkbSetTextDoodadColor(g,d,c)	((d)->color_ndx= (c)-&(g)->colors[0])
+
+typedef struct _XkbIndicatorDoodad {
+	Atom		 name;
+	unsigned char	 type;
+	unsigned char	 priority;
+	short	 	 top;
+	short	 	 left;
+	short		 angle;
+	unsigned short	 shape_ndx;
+	unsigned short	 on_color_ndx;
+	unsigned short	 off_color_ndx;
+} XkbIndicatorDoodadRec, *XkbIndicatorDoodadPtr;
+#define	XkbIndicatorDoodadShape(g,d)	(&(g)->shapes[(d)->shape_ndx])
+#define	XkbIndicatorDoodadOnColor(g,d)	(&(g)->colors[(d)->on_color_ndx])
+#define	XkbIndicatorDoodadOffColor(g,d)	(&(g)->colors[(d)->off_color_ndx])
+#define	XkbSetIndicatorDoodadOnColor(g,d,c) \
+				((d)->on_color_ndx= (c)-&(g)->colors[0])
+#define	XkbSetIndicatorDoodadOffColor(g,d,c) \
+				((d)->off_color_ndx= (c)-&(g)->colors[0])
+#define	XkbSetIndicatorDoodadShape(g,d,s) \
+				((d)->shape_ndx= (s)-&(g)->shapes[0])
+
+typedef struct _XkbLogoDoodad {
+	Atom		 name;
+	unsigned char	 type;
+	unsigned char	 priority;
+	short		 top;
+	short		 left;
+	short	 	 angle;
+	unsigned short	 color_ndx;
+	unsigned short	 shape_ndx;
+	char *		 logo_name;
+} XkbLogoDoodadRec, *XkbLogoDoodadPtr;
+#define	XkbLogoDoodadColor(g,d)		(&(g)->colors[(d)->color_ndx])
+#define	XkbLogoDoodadShape(g,d)		(&(g)->shapes[(d)->shape_ndx])
+#define	XkbSetLogoDoodadColor(g,d,c)	((d)->color_ndx= (c)-&(g)->colors[0])
+#define	XkbSetLogoDoodadShape(g,d,s)	((d)->shape_ndx= (s)-&(g)->shapes[0])
+
+typedef struct _XkbAnyDoodad {
+	Atom		 name;
+	unsigned char	 type;
+	unsigned char	 priority;
+	short	 	 top;
+	short	 	 left;
+	short		 angle;
+} XkbAnyDoodadRec, *XkbAnyDoodadPtr;
+
+typedef union _XkbDoodad {
+	XkbAnyDoodadRec		any;
+	XkbShapeDoodadRec	shape;
+	XkbTextDoodadRec	text;
+	XkbIndicatorDoodadRec	indicator;
+	XkbLogoDoodadRec	logo;
+} XkbDoodadRec, *XkbDoodadPtr;
+
+#define	XkbUnknownDoodad	0
+#define	XkbOutlineDoodad	1
+#define	XkbSolidDoodad		2
+#define	XkbTextDoodad		3
+#define	XkbIndicatorDoodad	4
+#define	XkbLogoDoodad		5
+
+typedef struct _XkbKey {
+	XkbKeyNameRec	 name;
+	short		 gap;
+	unsigned char	 shape_ndx;
+	unsigned char	 color_ndx;
+} XkbKeyRec, *XkbKeyPtr;
+#define	XkbKeyShape(g,k)	(&(g)->shapes[(k)->shape_ndx])
+#define	XkbKeyColor(g,k)	(&(g)->colors[(k)->color_ndx])
+#define	XkbSetKeyShape(g,k,s)	((k)->shape_ndx= (s)-&(g)->shapes[0])
+#define	XkbSetKeyColor(g,k,c)	((k)->color_ndx= (c)-&(g)->colors[0])
+
+typedef struct _XkbRow {
+	short	 	top;
+	short	 	left;
+	unsigned short	num_keys;
+	unsigned short	sz_keys;
+	int		vertical;
+	XkbKeyPtr	keys;
+	XkbBoundsRec	bounds;
+} XkbRowRec, *XkbRowPtr;
+
+typedef struct _XkbSection {
+	Atom		 name;
+	unsigned char	 priority;
+	short	 	 top;
+	short	 	 left;
+	unsigned short	 width;
+	unsigned short	 height;
+	short	 	 angle;
+	unsigned short	 num_rows;
+	unsigned short	 num_doodads;
+	unsigned short	 num_overlays;
+	unsigned short	 sz_rows;
+	unsigned short	 sz_doodads;
+	unsigned short	 sz_overlays;
+	XkbRowPtr	 rows;
+	XkbDoodadPtr	 doodads;
+	XkbBoundsRec	 bounds;
+	struct _XkbOverlay *overlays;
+} XkbSectionRec, *XkbSectionPtr;
+
+typedef	struct _XkbOverlayKey {
+	XkbKeyNameRec	over;
+	XkbKeyNameRec	under;
+} XkbOverlayKeyRec,*XkbOverlayKeyPtr;
+
+typedef struct _XkbOverlayRow {
+	unsigned short		row_under;
+	unsigned short		num_keys;
+	unsigned short		sz_keys;
+	XkbOverlayKeyPtr	keys;
+} XkbOverlayRowRec,*XkbOverlayRowPtr;
+
+typedef struct _XkbOverlay {
+	Atom			name;
+	XkbSectionPtr		section_under;
+	unsigned short		num_rows;
+	unsigned short		sz_rows;
+	XkbOverlayRowPtr	rows;
+	XkbBoundsPtr		bounds;
+} XkbOverlayRec,*XkbOverlayPtr;
+
+typedef struct _XkbGeometry {
+	Atom		 name;
+	unsigned short	 width_mm;
+	unsigned short	 height_mm;
+	char *		 label_font;
+	XkbColorPtr	 label_color;
+	XkbColorPtr	 base_color;
+	unsigned short	 sz_properties;
+	unsigned short	 sz_colors;
+	unsigned short	 sz_shapes;
+	unsigned short   sz_sections;
+	unsigned short	 sz_doodads;
+	unsigned short	 sz_key_aliases;
+	unsigned short	 num_properties;
+	unsigned short	 num_colors;
+	unsigned short	 num_shapes;
+	unsigned short	 num_sections;
+	unsigned short	 num_doodads;
+	unsigned short	 num_key_aliases;
+	XkbPropertyPtr	 properties;
+	XkbColorPtr	 colors;
+	XkbShapePtr	 shapes;
+	XkbSectionPtr	 sections;
+	XkbDoodadPtr	 doodads;
+	XkbKeyAliasPtr	 key_aliases;
+} XkbGeometryRec;
+#define	XkbGeomColorIndex(g,c)	((int)((c)-&(g)->colors[0]))
+
+#define	XkbGeomPropertiesMask	(1<<0)
+#define	XkbGeomColorsMask	(1<<1)
+#define	XkbGeomShapesMask	(1<<2)
+#define	XkbGeomSectionsMask	(1<<3)
+#define	XkbGeomDoodadsMask	(1<<4)
+#define	XkbGeomKeyAliasesMask	(1<<5)
+#define	XkbGeomAllMask		(0x3f)
+
+typedef struct _XkbGeometrySizes {
+	unsigned int	which;
+	unsigned short	num_properties;
+	unsigned short	num_colors;
+	unsigned short	num_shapes;
+	unsigned short	num_sections;
+	unsigned short	num_doodads;
+	unsigned short	num_key_aliases;
+} XkbGeometrySizesRec,*XkbGeometrySizesPtr;
+
+_XFUNCPROTOBEGIN
+
+extern	XkbPropertyPtr
+XkbAddGeomProperty(
+    XkbGeometryPtr	/* geom */,
+    char *		/* name */,
+    char *		/* value */
+);
+
+extern	XkbKeyAliasPtr
+XkbAddGeomKeyAlias(
+    XkbGeometryPtr	/* geom */,
+    char *		/* alias */,
+    char *		/* real */
+);
+
+extern	XkbColorPtr
+XkbAddGeomColor(
+    XkbGeometryPtr	/* geom */,
+    char *		/* spec */,
+    unsigned int	/* pixel */
+);
+
+extern	XkbOutlinePtr
+XkbAddGeomOutline(
+    XkbShapePtr		/* shape */,
+    int			/* sz_points */
+);
+
+extern XkbShapePtr
+XkbAddGeomShape(
+    XkbGeometryPtr	/* geom */,
+    Atom		/* name */,
+    int			/* sz_outlines */
+);
+
+extern XkbKeyPtr
+XkbAddGeomKey(
+    XkbRowPtr		/* row */
+);
+
+extern XkbRowPtr
+XkbAddGeomRow(
+    XkbSectionPtr	/* section */,
+    int			/* sz_keys */
+);
+
+extern XkbSectionPtr
+XkbAddGeomSection(
+    XkbGeometryPtr	/* geom */,
+    Atom		/* name */,
+    int			/* sz_rows */,
+    int			/* sz_doodads */,
+    int			/* sz_overlays */
+);
+
+extern XkbOverlayPtr
+XkbAddGeomOverlay(
+    XkbSectionPtr	/* section */,
+    Atom		/* name */,
+    int			/* sz_rows */
+);
+
+extern XkbOverlayRowPtr
+XkbAddGeomOverlayRow(
+    XkbOverlayPtr	/* overlay */,
+    int			/* row_under */,
+    int			/* sz_keys */
+);
+
+extern XkbOverlayKeyPtr
+XkbAddGeomOverlayKey(
+    XkbOverlayPtr	/* overlay */,
+    XkbOverlayRowPtr	/* row */,
+    char *		/* over */,
+    char *		/* under */
+);
+
+extern XkbDoodadPtr
+XkbAddGeomDoodad(
+    XkbGeometryPtr	/* geom */,
+    XkbSectionPtr	/* section */,
+    Atom		/* name */
+);
+
+
+extern void
+XkbFreeGeomKeyAliases(
+    XkbGeometryPtr	/* geom */,
+    int			/* first */,
+    int			/* count */,
+    Bool		/* freeAll */
+);
+
+extern void
+XkbFreeGeomColors(
+    XkbGeometryPtr	/* geom */,
+    int			/* first */,
+    int			/* count */,
+    Bool		/* freeAll */
+);
+
+extern void
+XkbFreeGeomDoodads(
+    XkbDoodadPtr	/* doodads */,
+    int			/* nDoodads */,
+    Bool		/* freeAll */
+);
+
+
+extern void
+XkbFreeGeomProperties(
+    XkbGeometryPtr	/* geom */,
+    int			/* first */,
+    int			/* count */,
+    Bool		/* freeAll */
+);
+
+extern void
+XkbFreeGeomOverlayKeys(
+    XkbOverlayRowPtr	/* row */,
+    int			/* first */,
+    int			/* count */,
+    Bool		/* freeAll */
+);
+
+extern void
+XkbFreeGeomOverlayRows(
+    XkbOverlayPtr	/* overlay */,
+    int			/* first */,
+    int			/* count */,
+    Bool		/* freeAll */
+);
+
+extern void
+XkbFreeGeomOverlays(
+    XkbSectionPtr	/* section */,
+    int			/* first */,
+    int			/* count */,
+    Bool		/* freeAll */
+);
+
+extern void
+XkbFreeGeomKeys(
+    XkbRowPtr		/* row */,
+    int			/* first */,
+    int			/* count */,
+    Bool		/* freeAll */
+);
+
+extern void
+XkbFreeGeomRows(
+    XkbSectionPtr	/* section */,
+    int			/* first */,
+    int			/* count */,
+    Bool		/* freeAll */
+);
+
+extern void
+XkbFreeGeomSections(
+    XkbGeometryPtr	/* geom */,
+    int			/* first */,
+    int			/* count */,
+    Bool		/* freeAll */
+);
+
+
+extern void
+XkbFreeGeomPoints(
+    XkbOutlinePtr	/* outline */,
+    int			/* first */,
+    int			/* count */,
+    Bool		/* freeAll */
+);
+
+extern void
+XkbFreeGeomOutlines(
+    XkbShapePtr		/* shape */,
+    int			/* first */,
+    int			/* count */,
+    Bool		/* freeAll */
+);
+
+extern void
+XkbFreeGeomShapes(
+    XkbGeometryPtr	/* geom */,
+    int			/* first */,
+    int			/* count */,
+    Bool		/* freeAll */
+);
+
+extern void
+XkbFreeGeometry(
+    XkbGeometryPtr	/* geom */,
+    unsigned int	/* which */,
+    Bool		/* freeMap */
+);
+
+extern Status
+XkbAllocGeomProps(
+    XkbGeometryPtr	/* geom */,
+    int			/* nProps */
+);
+
+extern Status
+XkbAllocGeomKeyAliases(
+    XkbGeometryPtr	/* geom */,
+    int			/* nAliases */
+);
+
+extern Status
+XkbAllocGeomColors(
+    XkbGeometryPtr	/* geom */,
+    int			/* nColors */
+);
+
+extern Status
+XkbAllocGeomShapes(
+    XkbGeometryPtr	/* geom */,
+    int			/* nShapes */
+);
+
+extern Status
+XkbAllocGeomSections(
+    XkbGeometryPtr	/* geom */,
+    int			/* nSections */
+);
+
+extern Status
+XkbAllocGeomOverlays(
+    XkbSectionPtr	/* section */,
+    int			/* num_needed */
+);
+
+extern Status
+XkbAllocGeomOverlayRows(
+    XkbOverlayPtr	/* overlay */,
+    int			/* num_needed */
+);
+
+extern Status
+XkbAllocGeomOverlayKeys(
+    XkbOverlayRowPtr	/* row */,
+    int			/* num_needed */
+);
+
+extern Status
+XkbAllocGeomDoodads(
+    XkbGeometryPtr	/* geom */,
+    int			/* nDoodads */
+);
+
+extern Status
+XkbAllocGeomSectionDoodads(
+    XkbSectionPtr	/* section */,
+    int			/* nDoodads */
+);
+
+extern Status
+XkbAllocGeomOutlines(
+    XkbShapePtr		/* shape */,
+    int			/* nOL */
+);
+
+extern Status
+XkbAllocGeomRows(
+    XkbSectionPtr	/* section */,
+    int			/* nRows */
+);
+
+extern Status
+XkbAllocGeomPoints(
+    XkbOutlinePtr	/* ol */,
+    int			/* nPts */
+);
+
+extern Status
+XkbAllocGeomKeys(
+    XkbRowPtr		/* row */,
+    int			/* nKeys */
+);
+
+extern	Status
+XkbAllocGeometry(
+	XkbDescPtr		/* xkb */,
+	XkbGeometrySizesPtr	/* sizes */
+);
+
+extern	Status
+XkbSetGeometry(
+	Display *		/* dpy */,
+	unsigned		/* deviceSpec */,
+	XkbGeometryPtr		/* geom */
+);
+
+extern	Bool
+XkbComputeShapeTop(
+	XkbShapePtr		/* shape */,
+	XkbBoundsPtr		/* bounds */
+);
+
+extern	Bool
+XkbComputeShapeBounds(
+	XkbShapePtr		/* shape */
+);
+
+extern	Bool
+XkbComputeRowBounds(
+	XkbGeometryPtr		/* geom */,
+	XkbSectionPtr		/* section */,
+	XkbRowPtr		/* row */
+);
+
+extern	Bool
+XkbComputeSectionBounds(
+	XkbGeometryPtr		/* geom */,
+	XkbSectionPtr		/* section */
+);
+
+extern	char *
+XkbFindOverlayForKey(
+	XkbGeometryPtr		/* geom */,
+	XkbSectionPtr		/* wanted */,
+	char *			/* under */
+);
+
+extern	Status
+XkbGetGeometry(
+    Display *			/* dpy */,
+    XkbDescPtr			/* xkb */
+);
+
+extern	Status
+XkbGetNamedGeometry(
+    Display *			/* dpy */,
+    XkbDescPtr			/* xkb */,
+    Atom			/* name */
+);
+
+_XFUNCPROTOEND
+
+#endif /* _XKBSTR_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/XKBproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/XKBproto.h
new file mode 100644
index 0000000..6eaec95
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/XKBproto.h
@@ -0,0 +1,1282 @@
+/************************************************************
+Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
+
+Permission to use, copy, modify, and distribute this
+software and its documentation for any purpose and without
+fee is hereby granted, provided that the above copyright
+notice appear in all copies and that both that copyright
+notice and this permission notice appear in supporting
+documentation, and that the name of Silicon Graphics not be
+used in advertising or publicity pertaining to distribution
+of the software without specific prior written permission.
+Silicon Graphics makes no representation about the suitability
+of this software for any purpose. It is provided "as is"
+without any express or implied warranty.
+
+SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+********************************************************/
+
+#ifndef _XKBPROTO_H_
+#define	_XKBPROTO_H_
+
+#include <X11/Xmd.h>
+#include <X11/Xfuncproto.h>
+#include <X11/extensions/XKB.h>
+
+#define Window CARD32
+#define Atom CARD32
+#define Time CARD32
+#define KeyCode CARD8
+#define KeySym CARD32
+
+#define	XkbPaddedSize(n)	((((unsigned int)(n)+3) >> 2) << 2)
+
+typedef struct _xkbUseExtension {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* always X_KBUseExtension */
+    CARD16	length;
+    CARD16	wantedMajor;
+    CARD16	wantedMinor;
+} xkbUseExtensionReq;
+#define	sz_xkbUseExtensionReq	8
+
+typedef struct _xkbUseExtensionReply {
+    BYTE	type;		/* X_Reply */
+    BOOL	supported;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	serverMajor;
+    CARD16	serverMinor;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xkbUseExtensionReply;
+#define	sz_xkbUseExtensionReply	32
+
+typedef	struct _xkbSelectEvents {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* X_KBSelectEvents */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD16	affectWhich;
+    CARD16	clear;
+    CARD16	selectAll;
+    CARD16	affectMap;
+    CARD16	map;
+} xkbSelectEventsReq;
+#define	sz_xkbSelectEventsReq	16
+
+typedef struct _xkbBell {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* X_KBBell */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD16	bellClass;
+    CARD16	bellID;
+    INT8	percent;
+    BOOL	forceSound;
+    BOOL	eventOnly;
+    CARD8	pad1;
+    INT16	pitch;
+    INT16	duration;
+    CARD16	pad2;
+    Atom	name;
+    Window	window;
+} xkbBellReq;
+#define	sz_xkbBellReq		28
+
+typedef struct _xkbGetState {
+	CARD8		reqType;
+	CARD8		xkbReqType;	/* always X_KBGetState */
+	CARD16		length;
+	CARD16		deviceSpec;
+	CARD16		pad;
+} xkbGetStateReq;
+#define	sz_xkbGetStateReq	8
+
+typedef	struct _xkbGetStateReply {
+    BYTE	type;
+    BYTE	deviceID;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD8	mods;
+    CARD8	baseMods;
+    CARD8	latchedMods;
+    CARD8	lockedMods;
+    CARD8	group;
+    CARD8	lockedGroup;
+    INT16	baseGroup;
+    INT16	latchedGroup;
+    CARD8	compatState;
+    CARD8	grabMods;
+    CARD8	compatGrabMods;
+    CARD8	lookupMods;
+    CARD8	compatLookupMods;
+    CARD8	pad1;
+    CARD16	ptrBtnState;
+    CARD16	pad2;
+    CARD32	pad3;
+} xkbGetStateReply;
+#define	sz_xkbGetStateReply	32
+
+typedef struct _xkbLatchLockState {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* always X_KBLatchLockState */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD8	affectModLocks;
+    CARD8	modLocks;
+    BOOL	lockGroup;
+    CARD8	groupLock;
+    CARD8	affectModLatches;
+    CARD8	modLatches;
+    CARD8	pad;
+    BOOL	latchGroup;
+    INT16	groupLatch;
+} xkbLatchLockStateReq;
+#define	sz_xkbLatchLockStateReq		16
+
+typedef struct _xkbGetControls {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* always X_KBGetControls */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD16	pad;
+} xkbGetControlsReq;
+#define	sz_xkbGetControlsReq	8
+
+typedef struct _xkbGetControlsReply {
+    BYTE	type;		/* X_Reply */
+    CARD8	deviceID;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD8	mkDfltBtn;
+    CARD8	numGroups;
+    CARD8	groupsWrap;
+    CARD8	internalMods;
+    CARD8	ignoreLockMods;
+    CARD8	internalRealMods;
+    CARD8	ignoreLockRealMods;
+    CARD8	pad1;
+    CARD16	internalVMods;
+    CARD16	ignoreLockVMods;
+    CARD16	repeatDelay;
+    CARD16	repeatInterval;
+    CARD16	slowKeysDelay;
+    CARD16	debounceDelay;
+    CARD16	mkDelay;
+    CARD16	mkInterval;
+    CARD16	mkTimeToMax;
+    CARD16	mkMaxSpeed;
+    INT16	mkCurve;
+    CARD16	axOptions;
+    CARD16	axTimeout;
+    CARD16	axtOptsMask;
+    CARD16	axtOptsValues;
+    CARD16	pad2;
+    CARD32	axtCtrlsMask;
+    CARD32	axtCtrlsValues;
+    CARD32	enabledCtrls;
+    BYTE	perKeyRepeat[XkbPerKeyBitArraySize];
+} xkbGetControlsReply;
+#define	sz_xkbGetControlsReply	92
+
+typedef struct _xkbSetControls {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* always X_KBSetControls */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD8	affectInternalMods;
+    CARD8	internalMods;
+    CARD8	affectIgnoreLockMods;
+    CARD8	ignoreLockMods;
+    CARD16	affectInternalVMods;
+    CARD16	internalVMods;
+    CARD16	affectIgnoreLockVMods;
+    CARD16	ignoreLockVMods;
+    CARD8	mkDfltBtn;
+    CARD8	groupsWrap;
+    CARD16	axOptions;
+    CARD16	pad1;
+    CARD32	affectEnabledCtrls;
+    CARD32	enabledCtrls;
+    CARD32	changeCtrls;
+    CARD16	repeatDelay;
+    CARD16	repeatInterval;
+    CARD16	slowKeysDelay;
+    CARD16	debounceDelay;
+    CARD16	mkDelay;
+    CARD16	mkInterval;
+    CARD16	mkTimeToMax;
+    CARD16	mkMaxSpeed;
+    INT16	mkCurve;
+    CARD16	axTimeout;
+    CARD32	axtCtrlsMask;
+    CARD32	axtCtrlsValues;
+    CARD16	axtOptsMask;
+    CARD16	axtOptsValues;
+    BYTE	perKeyRepeat[XkbPerKeyBitArraySize];
+} xkbSetControlsReq;
+#define	sz_xkbSetControlsReq	100
+
+typedef	struct _xkbKTMapEntryWireDesc {
+    BOOL	active;
+    CARD8	mask;
+    CARD8	level;
+    CARD8	realMods;
+    CARD16	virtualMods;
+    CARD16	pad;
+} xkbKTMapEntryWireDesc;
+#define sz_xkbKTMapEntryWireDesc	8
+
+typedef struct _xkbKTSetMapEntryWireDesc {
+    CARD8	level;
+    CARD8	realMods;
+    CARD16	virtualMods;
+} xkbKTSetMapEntryWireDesc;
+#define	sz_xkbKTSetMapEntryWireDesc	4
+
+typedef struct _xkbModsWireDesc {
+    CARD8	mask;		/* GetMap only */
+    CARD8	realMods;
+    CARD16	virtualMods;
+} xkbModsWireDesc;
+#define	sz_xkbModsWireDesc	4
+
+typedef struct _xkbKeyTypeWireDesc {
+    CARD8	mask;
+    CARD8	realMods;
+    CARD16	virtualMods;
+    CARD8	numLevels;
+    CARD8	nMapEntries;
+    BOOL	preserve;
+    CARD8	pad;
+} xkbKeyTypeWireDesc;
+#define	sz_xkbKeyTypeWireDesc	8
+
+typedef struct _xkbSymMapWireDesc {
+    CARD8	ktIndex[XkbNumKbdGroups];
+    CARD8	groupInfo;
+    CARD8	width;
+    CARD16	nSyms;
+} xkbSymMapWireDesc;
+#define	sz_xkbSymMapWireDesc	8
+
+typedef struct _xkbVModMapWireDesc {
+    KeyCode	key;
+    CARD8	pad;
+    CARD16	vmods;
+} xkbVModMapWireDesc;
+#define	sz_xkbVModMapWireDesc	4
+
+typedef struct _xkbBehaviorWireDesc {
+	CARD8	key;
+	CARD8	type;
+	CARD8	data;
+	CARD8	pad;
+} xkbBehaviorWireDesc;
+#define	sz_xkbBehaviorWireDesc	4
+
+typedef	struct _xkbActionWireDesc {
+    CARD8	type;
+    CARD8	data[7];
+} xkbActionWireDesc;
+#define	sz_xkbActionWireDesc	8
+
+typedef struct _xkbGetMap {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* always X_KBGetMap */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD16	full;
+    CARD16	partial;
+    CARD8	firstType;
+    CARD8	nTypes;
+    KeyCode	firstKeySym;
+    CARD8	nKeySyms;
+    KeyCode	firstKeyAct;
+    CARD8	nKeyActs;
+    KeyCode	firstKeyBehavior;
+    CARD8	nKeyBehaviors;
+    CARD16	virtualMods;
+    KeyCode	firstKeyExplicit;
+    CARD8	nKeyExplicit;
+    KeyCode	firstModMapKey;
+    CARD8	nModMapKeys;
+    KeyCode	firstVModMapKey;
+    CARD8	nVModMapKeys;
+    CARD16	pad1;
+} xkbGetMapReq;
+#define	sz_xkbGetMapReq	28
+
+typedef struct _xkbGetMapReply {
+    CARD8	type;		/* always X_Reply */
+    CARD8	deviceID;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	pad1;
+    KeyCode	minKeyCode;
+    KeyCode	maxKeyCode;
+    CARD16	present;
+    CARD8	firstType;
+    CARD8	nTypes;
+    CARD8	totalTypes;
+    KeyCode	firstKeySym;
+    CARD16	totalSyms;
+    CARD8	nKeySyms;
+    KeyCode	firstKeyAct;
+    CARD16	totalActs;
+    CARD8	nKeyActs;
+    KeyCode	firstKeyBehavior;
+    CARD8	nKeyBehaviors;
+    CARD8	totalKeyBehaviors;
+    KeyCode	firstKeyExplicit;
+    CARD8	nKeyExplicit;
+    CARD8	totalKeyExplicit;
+    KeyCode	firstModMapKey;
+    CARD8	nModMapKeys;
+    CARD8	totalModMapKeys;
+    KeyCode	firstVModMapKey;
+    CARD8	nVModMapKeys;
+    CARD8	totalVModMapKeys;
+    CARD8	pad2;
+    CARD16	virtualMods;
+} xkbGetMapReply;
+#define	sz_xkbGetMapReply		40
+
+#define	XkbSetMapResizeTypes		(1L<<0)
+#define	XkbSetMapRecomputeActions	(1L<<1)
+#define	XkbSetMapAllFlags		(0x3)
+
+typedef struct _xkbSetMap {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* always X_KBSetMap */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD16	present;
+    CARD16	flags;
+    KeyCode	minKeyCode;
+    KeyCode	maxKeyCode;
+    CARD8	firstType;
+    CARD8	nTypes;
+    KeyCode	firstKeySym;
+    CARD8	nKeySyms;
+    CARD16	totalSyms;
+    KeyCode	firstKeyAct;
+    CARD8	nKeyActs;
+    CARD16	totalActs;
+    KeyCode	firstKeyBehavior;
+    CARD8	nKeyBehaviors;
+    CARD8	totalKeyBehaviors;
+    KeyCode	firstKeyExplicit;
+    CARD8	nKeyExplicit;
+    CARD8	totalKeyExplicit;
+    KeyCode	firstModMapKey;
+    CARD8	nModMapKeys;
+    CARD8	totalModMapKeys;
+    KeyCode	firstVModMapKey;
+    CARD8	nVModMapKeys;
+    CARD8	totalVModMapKeys;
+    CARD16	virtualMods;
+} xkbSetMapReq;
+#define	sz_xkbSetMapReq	36
+
+typedef struct _xkbSymInterpretWireDesc {
+    CARD32		sym;
+    CARD8		mods;
+    CARD8		match;
+    CARD8		virtualMod;
+    CARD8		flags;
+    xkbActionWireDesc	act;
+} xkbSymInterpretWireDesc;
+#define	sz_xkbSymInterpretWireDesc	16
+
+typedef struct _xkbGetCompatMap {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* always X_KBGetCompatMap */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD8	groups;
+    BOOL	getAllSI;
+    CARD16	firstSI;
+    CARD16	nSI;
+} xkbGetCompatMapReq;
+#define	sz_xkbGetCompatMapReq	12
+
+typedef struct _xkbGetCompatMapReply {
+    CARD8	type;		/* always X_Reply */
+    CARD8	deviceID;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD8	groups;
+    CARD8	pad1;
+    CARD16	firstSI;
+    CARD16	nSI;
+    CARD16	nTotalSI;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xkbGetCompatMapReply;
+#define	sz_xkbGetCompatMapReply		32
+
+typedef struct _xkbSetCompatMap {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* always X_KBSetCompatMap */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD8	pad1;
+    BOOL	recomputeActions;
+    BOOL	truncateSI;
+    CARD8	groups;
+    CARD16	firstSI;
+    CARD16	nSI;
+    CARD16	pad2;
+} xkbSetCompatMapReq;
+#define	sz_xkbSetCompatMapReq	16
+
+typedef struct _xkbGetIndicatorState {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* always X_KBGetIndicatorState */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD16	pad1;
+} xkbGetIndicatorStateReq;
+#define	sz_xkbGetIndicatorStateReq	8
+
+typedef struct _xkbGetIndicatorStateReply {
+    CARD8	type;		/* always X_Reply */
+    CARD8	deviceID;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	state;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xkbGetIndicatorStateReply;
+#define	sz_xkbGetIndicatorStateReply	32
+
+typedef struct _xkbGetIndicatorMap {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* always X_KBGetIndicatorMap */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD16	pad;
+    CARD32	which;
+} xkbGetIndicatorMapReq;
+#define	sz_xkbGetIndicatorMapReq	12
+
+typedef struct _xkbGetIndicatorMapReply {
+    CARD8	type;		/* always X_Reply */
+    CARD8	deviceID;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	which;
+    CARD32	realIndicators;
+    CARD8	nIndicators;
+    CARD8	pad1;
+    CARD16	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xkbGetIndicatorMapReply;
+#define	sz_xkbGetIndicatorMapReply	32
+
+typedef struct _xkbIndicatorMapWireDesc {
+    CARD8	flags;
+    CARD8	whichGroups;
+    CARD8	groups;
+    CARD8	whichMods;
+    CARD8	mods;
+    CARD8	realMods;
+    CARD16	virtualMods;
+    CARD32	ctrls;
+} xkbIndicatorMapWireDesc;
+#define	sz_xkbIndicatorMapWireDesc	12
+
+typedef struct _xkbSetIndicatorMap {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* always X_KBSetIndicatorMap */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD16	pad1;
+    CARD32	which;
+} xkbSetIndicatorMapReq;
+#define	sz_xkbSetIndicatorMapReq	12
+
+typedef struct _xkbGetNamedIndicator {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* X_KBGetNamedIndicator */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD16	ledClass;
+    CARD16	ledID;
+    CARD16	pad1;
+    Atom	indicator;
+} xkbGetNamedIndicatorReq;
+#define	sz_xkbGetNamedIndicatorReq		16
+
+typedef	struct _xkbGetNamedIndicatorReply {
+    BYTE	type;
+    BYTE	deviceID;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    Atom	indicator;
+    BOOL	found;
+    BOOL	on;
+    BOOL	realIndicator;
+    CARD8	ndx;
+    CARD8	flags;
+    CARD8	whichGroups;
+    CARD8	groups;
+    CARD8	whichMods;
+    CARD8	mods;
+    CARD8	realMods;
+    CARD16	virtualMods;
+    CARD32	ctrls;
+    BOOL	supported;
+    CARD8	pad1;
+    CARD16	pad2;
+} xkbGetNamedIndicatorReply;
+#define	sz_xkbGetNamedIndicatorReply	32
+
+typedef struct _xkbSetNamedIndicator {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* X_KBSetNamedIndicator */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD16	ledClass;
+    CARD16	ledID;
+    CARD16	pad1;
+    Atom	indicator;
+    BOOL	setState;
+    BOOL	on;
+    BOOL	setMap;
+    BOOL	createMap;
+    CARD8	pad2;
+    CARD8	flags;
+    CARD8	whichGroups;
+    CARD8	groups;
+    CARD8	whichMods;
+    CARD8	realMods;
+    CARD16	virtualMods;
+    CARD32	ctrls;
+} xkbSetNamedIndicatorReq;
+#define	sz_xkbSetNamedIndicatorReq	32
+
+typedef struct _xkbGetNames {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* always X_KBGetNames */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD16	pad;
+    CARD32	which;
+} xkbGetNamesReq;
+#define	sz_xkbGetNamesReq		12
+
+typedef	struct _xkbGetNamesReply {
+    BYTE	type;
+    BYTE	deviceID;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	which;
+    KeyCode	minKeyCode;
+    KeyCode	maxKeyCode;
+    CARD8	nTypes;
+    CARD8	groupNames;
+    CARD16	virtualMods;
+    KeyCode	firstKey;
+    CARD8	nKeys;
+    CARD32	indicators;
+    CARD8	nRadioGroups;
+    CARD8	nKeyAliases;
+    CARD16	nKTLevels;
+    CARD32	pad3;
+} xkbGetNamesReply;
+#define	sz_xkbGetNamesReply	32
+
+typedef struct _xkbSetNames {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* always X_KBSetNames */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD16	virtualMods;
+    CARD32	which;
+    CARD8	firstType;
+    CARD8	nTypes;
+    CARD8	firstKTLevel;
+    CARD8	nKTLevels;
+    CARD32	indicators;
+    CARD8	groupNames;
+    CARD8	nRadioGroups;
+    KeyCode	firstKey;
+    CARD8	nKeys;
+    CARD8	nKeyAliases;
+    CARD8	pad1;
+    CARD16	totalKTLevelNames;
+} xkbSetNamesReq;
+#define	sz_xkbSetNamesReq	28
+
+typedef struct _xkbPointWireDesc {
+    INT16	x;
+    INT16	y;
+} xkbPointWireDesc;
+#define	sz_xkbPointWireDesc	4
+
+typedef struct _xkbOutlineWireDesc {
+    CARD8	nPoints;
+    CARD8	cornerRadius;
+    CARD16	pad;
+} xkbOutlineWireDesc;
+#define	sz_xkbOutlineWireDesc	4
+
+typedef struct _xkbShapeWireDesc {
+    Atom	name;
+    CARD8	nOutlines;
+    CARD8	primaryNdx;
+    CARD8	approxNdx;
+    CARD8	pad;
+} xkbShapeWireDesc;
+#define	sz_xkbShapeWireDesc	8
+
+typedef struct _xkbSectionWireDesc {
+    Atom	name;
+    INT16	top;
+    INT16	left;
+    CARD16	width;
+    CARD16	height;
+    INT16	angle;
+    CARD8	priority;
+    CARD8	nRows;
+    CARD8	nDoodads;
+    CARD8	nOverlays;
+    CARD16	pad;
+} xkbSectionWireDesc;
+#define	sz_xkbSectionWireDesc	20
+
+typedef struct _xkbRowWireDesc {
+    INT16	top;
+    INT16	left;
+    CARD8	nKeys;
+    BOOL	vertical;
+    CARD16	pad;
+} xkbRowWireDesc;
+#define	sz_xkbRowWireDesc	8
+
+typedef struct _xkbKeyWireDesc {
+    CARD8	name[XkbKeyNameLength]	_X_NONSTRING;
+    INT16	gap;
+    CARD8	shapeNdx;
+    CARD8	colorNdx;
+} xkbKeyWireDesc;
+#define	sz_xkbKeyWireDesc	8
+
+typedef struct _xkbOverlayWireDesc {
+    Atom	name;
+    CARD8	nRows;
+    CARD8	pad1;
+    CARD16	pad2;
+} xkbOverlayWireDesc;
+#define	sz_xkbOverlayWireDesc	8
+
+typedef struct _xkbOverlayRowWireDesc {
+   CARD8	rowUnder;
+   CARD8	nKeys;
+   CARD16	pad1;
+} xkbOverlayRowWireDesc;
+#define	sz_xkbOverlayRowWireDesc	4
+
+typedef struct _xkbOverlayKeyWireDesc {
+   CARD8	over[XkbKeyNameLength]	_X_NONSTRING;
+   CARD8	under[XkbKeyNameLength]	_X_NONSTRING;
+} xkbOverlayKeyWireDesc;
+#define	sz_xkbOverlayKeyWireDesc	8
+
+typedef struct _xkbShapeDoodadWireDesc {
+    Atom	name;
+    CARD8	type;
+    CARD8	priority;
+    INT16	top;
+    INT16	left;
+    INT16	angle;
+    CARD8	colorNdx;
+    CARD8	shapeNdx;
+    CARD16	pad1;
+    CARD32	pad2;
+} xkbShapeDoodadWireDesc;
+#define	sz_xkbShapeDoodadWireDesc	20
+
+typedef struct _xkbTextDoodadWireDesc {
+    Atom	name;
+    CARD8	type;
+    CARD8	priority;
+    INT16	top;
+    INT16	left;
+    INT16	angle;
+    CARD16	width;
+    CARD16	height;
+    CARD8	colorNdx;
+    CARD8	pad1;
+    CARD16	pad2;
+} xkbTextDoodadWireDesc;
+#define	sz_xkbTextDoodadWireDesc	20
+
+typedef struct _xkbIndicatorDoodadWireDesc {
+    Atom	name;
+    CARD8	type;
+    CARD8	priority;
+    INT16	top;
+    INT16	left;
+    INT16	angle;
+    CARD8	shapeNdx;
+    CARD8	onColorNdx;
+    CARD8	offColorNdx;
+    CARD8	pad1;
+    CARD32	pad2;
+} xkbIndicatorDoodadWireDesc;
+#define	sz_xkbIndicatorDoodadWireDesc	20
+
+typedef struct _xkbLogoDoodadWireDesc {
+    Atom	name;
+    CARD8	type;
+    CARD8	priority;
+    INT16	top;
+    INT16	left;
+    INT16	angle;
+    CARD8	colorNdx;
+    CARD8	shapeNdx;
+    CARD16	pad1;
+    CARD32	pad2;
+} xkbLogoDoodadWireDesc;
+#define	sz_xkbLogoDoodadWireDesc	20
+
+typedef struct _xkbAnyDoodadWireDesc {
+    Atom	name;
+    CARD8	type;
+    CARD8	priority;
+    INT16	top;
+    INT16	left;
+    INT16	angle;
+    CARD32	pad2;
+    CARD32	pad3;
+} xkbAnyDoodadWireDesc;
+#define	sz_xkbAnyDoodadWireDesc	20
+
+typedef union _xkbDoodadWireDesc {
+    xkbAnyDoodadWireDesc	any;
+    xkbShapeDoodadWireDesc	shape;
+    xkbTextDoodadWireDesc	text;
+    xkbIndicatorDoodadWireDesc	indicator;
+    xkbLogoDoodadWireDesc	logo;
+} xkbDoodadWireDesc;
+#define	sz_xkbDoodadWireDesc	20
+
+typedef struct _xkbGetGeometry {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* always X_KBGetGeometry */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD16	pad;
+    Atom	name;
+} xkbGetGeometryReq;
+#define	sz_xkbGetGeometryReq	12
+
+typedef struct _xkbGetGeometryReply {
+    CARD8	type;		/* always X_Reply */
+    CARD8	deviceID;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    Atom	name;
+    BOOL	found;
+    CARD8	pad;
+    CARD16	widthMM;
+    CARD16	heightMM;
+    CARD16	nProperties;
+    CARD16	nColors;
+    CARD16	nShapes;
+    CARD16	nSections;
+    CARD16	nDoodads;
+    CARD16	nKeyAliases;
+    CARD8	baseColorNdx;
+    CARD8	labelColorNdx;
+} xkbGetGeometryReply;
+#define	sz_xkbGetGeometryReply	32
+
+typedef struct _xkbSetGeometry {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* always X_KBSetGeometry */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD8	nShapes;
+    CARD8	nSections;
+    Atom	name;
+    CARD16	widthMM;
+    CARD16	heightMM;
+    CARD16	nProperties;
+    CARD16	nColors;
+    CARD16	nDoodads;
+    CARD16	nKeyAliases;
+    CARD8	baseColorNdx;
+    CARD8	labelColorNdx;
+    CARD16	pad;
+} xkbSetGeometryReq;
+#define	sz_xkbSetGeometryReq	28
+
+typedef struct _xkbPerClientFlags {
+    CARD8	reqType;
+    CARD8	xkbReqType;/* always X_KBPerClientFlags */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD16	pad1;
+    CARD32	change;
+    CARD32	value;
+    CARD32	ctrlsToChange;
+    CARD32	autoCtrls;
+    CARD32	autoCtrlValues;
+} xkbPerClientFlagsReq;
+#define	sz_xkbPerClientFlagsReq	28
+
+typedef struct _xkbPerClientFlagsReply {
+    CARD8	type;		/* always X_Reply */
+    CARD8	deviceID;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	supported;
+    CARD32	value;
+    CARD32	autoCtrls;
+    CARD32	autoCtrlValues;
+    CARD32	pad1;
+    CARD32	pad2;
+} xkbPerClientFlagsReply;
+#define	sz_xkbPerClientFlagsReply	32
+
+typedef struct _xkbListComponents {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* always X_KBListComponents */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD16	maxNames;
+} xkbListComponentsReq;
+#define	sz_xkbListComponentsReq	8
+
+typedef struct _xkbListComponentsReply {
+    CARD8	type;		/* always X_Reply */
+    CARD8	deviceID;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	nKeymaps;
+    CARD16	nKeycodes;
+    CARD16	nTypes;
+    CARD16	nCompatMaps;
+    CARD16	nSymbols;
+    CARD16	nGeometries;
+    CARD16	extra;
+    CARD16	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+} xkbListComponentsReply;
+#define	sz_xkbListComponentsReply	32
+
+typedef struct _xkbGetKbdByName {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* always X_KBGetKbdByName */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD16	need;		/* combination of XkbGBN_* */
+    CARD16	want;		/* combination of XkbGBN_* */
+    BOOL	load;
+    CARD8	pad;
+} xkbGetKbdByNameReq;
+#define	sz_xkbGetKbdByNameReq	12
+
+typedef struct _xkbGetKbdByNameReply {
+    CARD8	type;		/* always X_Reply */
+    CARD8	deviceID;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    KeyCode	minKeyCode;
+    KeyCode	maxKeyCode;
+    BOOL	loaded;
+    BOOL	newKeyboard;
+    CARD16	found;		/* combination of XkbGBN_* */
+    CARD16	reported;	/* combination of XkbAllComponents */
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+} xkbGetKbdByNameReply;
+#define	sz_xkbGetKbdByNameReply	32
+
+typedef	struct _xkbDeviceLedsWireDesc {
+    CARD16	ledClass;
+    CARD16	ledID;
+    CARD32	namesPresent;
+    CARD32	mapsPresent;
+    CARD32	physIndicators;
+    CARD32	state;
+} xkbDeviceLedsWireDesc;
+#define sz_xkbDeviceLedsWireDesc	20
+
+typedef struct _xkbGetDeviceInfo {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* always X_KBGetDeviceInfo */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD16	wanted;
+    BOOL	allBtns;
+    CARD8	firstBtn;
+    CARD8	nBtns;
+    CARD8	pad;
+    CARD16	ledClass;
+    CARD16	ledID;
+} xkbGetDeviceInfoReq;
+#define	sz_xkbGetDeviceInfoReq	16
+
+typedef struct _xkbGetDeviceInfoReply {
+    CARD8	type;		/* always X_Reply */
+    CARD8	deviceID;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	present;
+    CARD16	supported;
+    CARD16	unsupported;
+    CARD16	nDeviceLedFBs;
+    CARD8	firstBtnWanted;
+    CARD8	nBtnsWanted;
+    CARD8	firstBtnRtrn;
+    CARD8	nBtnsRtrn;
+    CARD8	totalBtns;
+    BOOL	hasOwnState;
+    CARD16	dfltKbdFB;
+    CARD16	dfltLedFB;
+    CARD16	pad;
+    Atom	devType;
+} xkbGetDeviceInfoReply;
+#define	sz_xkbGetDeviceInfoReply	32
+
+typedef struct _xkbSetDeviceInfo {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* always X_KBSetDeviceInfo */
+    CARD16	length;
+    CARD16	deviceSpec;
+    CARD8	firstBtn;
+    CARD8	nBtns;
+    CARD16	change;
+    CARD16	nDeviceLedFBs;
+} xkbSetDeviceInfoReq;
+#define	sz_xkbSetDeviceInfoReq	12
+
+typedef struct _xkbSetDebuggingFlags {
+    CARD8	reqType;
+    CARD8	xkbReqType;	/* always X_KBSetDebuggingFlags */
+    CARD16	length;
+    CARD16	msgLength;
+    CARD16	pad;
+    CARD32	affectFlags;
+    CARD32	flags;
+    CARD32	affectCtrls;
+    CARD32	ctrls;
+} xkbSetDebuggingFlagsReq;
+#define	sz_xkbSetDebuggingFlagsReq	24
+
+typedef struct _xkbSetDebuggingFlagsReply {
+    BYTE	type;		/* X_Reply */
+    CARD8	pad0;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	currentFlags;
+    CARD32	currentCtrls;
+    CARD32	supportedFlags;
+    CARD32	supportedCtrls;
+    CARD32	pad1;
+    CARD32	pad2;
+} xkbSetDebuggingFlagsReply;
+#define	sz_xkbSetDebuggingFlagsReply	32
+
+	/*
+	 * X KEYBOARD EXTENSION EVENT STRUCTURES
+	 */
+
+typedef struct _xkbAnyEvent {
+    BYTE	type;
+    BYTE	xkbType;
+    CARD16	sequenceNumber;
+    Time	time;
+    CARD8	deviceID;
+    CARD8	pad1;
+    CARD16	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+    CARD32	pad7;
+} xkbAnyEvent;
+#define	sz_xkbAnyEvent 32
+
+typedef	struct _xkbNewKeyboardNotify {
+    BYTE	type;
+    BYTE	xkbType;
+    CARD16	sequenceNumber;
+    Time	time;
+    CARD8	deviceID;
+    CARD8	oldDeviceID;
+    KeyCode	minKeyCode;
+    KeyCode	maxKeyCode;
+    KeyCode	oldMinKeyCode;
+    KeyCode	oldMaxKeyCode;
+    CARD8	requestMajor;
+    CARD8	requestMinor;
+    CARD16	changed;
+    CARD8	detail;
+    CARD8	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+} xkbNewKeyboardNotify;
+#define	sz_xkbNewKeyboardNotify	32
+
+typedef	struct _xkbMapNotify {
+    BYTE	type;
+    BYTE	xkbType;
+    CARD16	sequenceNumber;
+    Time	time;
+    CARD8	deviceID;
+    CARD8	ptrBtnActions;
+    CARD16	changed;
+    KeyCode	minKeyCode;
+    KeyCode	maxKeyCode;
+    CARD8	firstType;
+    CARD8	nTypes;
+    KeyCode	firstKeySym;
+    CARD8	nKeySyms;
+    KeyCode	firstKeyAct;
+    CARD8	nKeyActs;
+    KeyCode	firstKeyBehavior;
+    CARD8	nKeyBehaviors;
+    KeyCode	firstKeyExplicit;
+    CARD8	nKeyExplicit;
+    KeyCode	firstModMapKey;
+    CARD8	nModMapKeys;
+    KeyCode	firstVModMapKey;
+    CARD8	nVModMapKeys;
+    CARD16	virtualMods;
+    CARD16	pad1;
+} xkbMapNotify;
+#define	sz_xkbMapNotify	32
+
+typedef	struct _xkbStateNotify {
+    BYTE	type;
+    BYTE	xkbType;
+    CARD16	sequenceNumber;
+    Time	time;
+    CARD8	deviceID;
+    CARD8	mods;
+    CARD8	baseMods;
+    CARD8	latchedMods;
+    CARD8	lockedMods;
+    CARD8	group;
+    INT16	baseGroup;
+    INT16	latchedGroup;
+    CARD8	lockedGroup;
+    CARD8	compatState;
+    CARD8	grabMods;
+    CARD8	compatGrabMods;
+    CARD8	lookupMods;
+    CARD8	compatLookupMods;
+    CARD16	ptrBtnState;
+    CARD16	changed;
+    KeyCode	keycode;
+    CARD8	eventType;
+    CARD8	requestMajor;
+    CARD8	requestMinor;
+} xkbStateNotify;
+#define	sz_xkbStateNotify	32
+
+typedef struct _xkbControlsNotify {
+    BYTE	type;
+    BYTE	xkbType;
+    CARD16	sequenceNumber;
+    Time	time;
+    CARD8	deviceID;
+    CARD8	numGroups;
+    CARD16	pad1;
+    CARD32	changedControls;
+    CARD32	enabledControls;
+    CARD32	enabledControlChanges;
+    KeyCode	keycode;
+    CARD8	eventType;
+    CARD8	requestMajor;
+    CARD8	requestMinor;
+    CARD32	pad2;
+} xkbControlsNotify;
+#define	sz_xkbControlsNotify	32
+
+typedef struct _xkbIndicatorNotify {
+    BYTE	type;
+    BYTE	xkbType;
+    CARD16	sequenceNumber;
+    Time	time;
+    CARD8	deviceID;
+    CARD8	pad1;
+    CARD16	pad2;
+    CARD32	state;
+    CARD32	changed;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xkbIndicatorNotify;
+#define	sz_xkbIndicatorNotify	32
+
+typedef struct _xkbNamesNotify {
+    BYTE	type;
+    BYTE	xkbType;
+    CARD16	sequenceNumber;
+    Time	time;
+    CARD8	deviceID;
+    CARD8	pad1;
+    CARD16	changed;
+    CARD8	firstType;
+    CARD8	nTypes;
+    CARD8	firstLevelName;
+    CARD8	nLevelNames;
+    CARD8	pad2;
+    CARD8	nRadioGroups;
+    CARD8	nAliases;
+    CARD8	changedGroupNames;
+    CARD16	changedVirtualMods;
+    CARD8	firstKey;
+    CARD8	nKeys;
+    CARD32	changedIndicators;
+    CARD32	pad3;
+} xkbNamesNotify;
+#define	sz_xkbNamesNotify	32
+
+typedef struct _xkbCompatMapNotify {
+    BYTE	type;
+    BYTE	xkbType;
+    CARD16	sequenceNumber;
+    Time	time;
+    CARD8	deviceID;
+    CARD8	changedGroups;
+    CARD16	firstSI;
+    CARD16	nSI;
+    CARD16	nTotalSI;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+} xkbCompatMapNotify;
+#define sz_xkbCompatMapNotify	32
+
+typedef struct _xkbBellNotify {
+    BYTE	type;
+    BYTE	xkbType;
+    CARD16	sequenceNumber;
+    Time	time;
+    CARD8	deviceID;
+    CARD8	bellClass;
+    CARD8	bellID;
+    CARD8	percent;
+    CARD16	pitch;
+    CARD16	duration;
+    Atom	name;
+    Window	window;
+    BOOL	eventOnly;
+    CARD8	pad1;
+    CARD16	pad2;
+    CARD32	pad3;
+} xkbBellNotify;
+#define	sz_xkbBellNotify	32
+
+typedef struct _xkbActionMessage {
+    BYTE	type;
+    BYTE	xkbType;
+    CARD16	sequenceNumber;
+    Time	time;
+    CARD8	deviceID;
+    KeyCode	keycode;
+    BOOL	press;
+    BOOL	keyEventFollows;
+    CARD8	mods;
+    CARD8	group;
+    CARD8	message[8];
+    CARD16	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+} xkbActionMessage;
+#define	sz_xkbActionMessage		32
+
+typedef struct _xkbAccessXNotify {
+    BYTE	type;
+    BYTE	xkbType;
+    CARD16	sequenceNumber;
+    Time	time;
+    CARD8	deviceID;
+    KeyCode	keycode;
+    CARD16	detail;
+    CARD16	slowKeysDelay;
+    CARD16	debounceDelay;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+} xkbAccessXNotify;
+#define	sz_xkbAccessXNotify	32
+
+typedef struct _xkbExtensionDeviceNotify {
+    BYTE	type;
+    BYTE	xkbType;
+    CARD16	sequenceNumber;
+    Time	time;
+    CARD8	deviceID;
+    CARD8	pad1;
+    CARD16	reason;
+    CARD16	ledClass;
+    CARD16	ledID;
+    CARD32	ledsDefined;
+    CARD32	ledState;
+    CARD8	firstBtn;
+    CARD8	nBtns;
+    CARD16	supported;
+    CARD16	unsupported;
+    CARD16	pad3;
+} xkbExtensionDeviceNotify;
+#define	sz_xkbExtensionDeviceNotify		32
+
+typedef struct _xkbEvent {
+    union {
+	xkbAnyEvent		any;
+	xkbNewKeyboardNotify	new_kbd;
+	xkbMapNotify		map;
+	xkbStateNotify		state;
+	xkbControlsNotify	ctrls;
+	xkbIndicatorNotify	indicators;
+	xkbNamesNotify		names;
+	xkbCompatMapNotify	compat;
+	xkbBellNotify		bell;
+	xkbActionMessage	message;
+	xkbAccessXNotify	accessx;
+	xkbExtensionDeviceNotify device;
+    } u;
+} xkbEvent;
+#define sz_xkbEvent	32
+
+#undef Window
+#undef Atom
+#undef Time
+#undef KeyCode
+#undef KeySym
+
+#endif /* _XKBPROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/XKBsrv.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/XKBsrv.h
new file mode 100644
index 0000000..deb7197
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/XKBsrv.h
@@ -0,0 +1,1184 @@
+/************************************************************
+Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
+
+Permission to use, copy, modify, and distribute this
+software and its documentation for any purpose and without
+fee is hereby granted, provided that the above copyright
+notice appear in all copies and that both that copyright
+notice and this permission notice appear in supporting
+documentation, and that the name of Silicon Graphics not be
+used in advertising or publicity pertaining to distribution
+of the software without specific prior written permission.
+Silicon Graphics makes no representation about the suitability
+of this software for any purpose. It is provided "as is"
+without any express or implied warranty.
+
+SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+********************************************************/
+
+#ifndef _XKBSRV_H_
+#define	_XKBSRV_H_
+
+#ifdef XKB_IN_SERVER
+#define XkbAllocClientMap		SrvXkbAllocClientMap
+#define XkbAllocServerMap		SrvXkbAllocServerMap
+#define XkbChangeTypesOfKey		SrvXkbChangeTypesOfKey
+#define	XkbAddKeyType			SrvXkbAddKeyType
+#define XkbCopyKeyType			SrvXkbCopyKeyType
+#define XkbCopyKeyTypes			SrvXkbCopyKeyTypes
+#define XkbFreeClientMap		SrvXkbFreeClientMap
+#define XkbFreeServerMap		SrvXkbFreeServerMap
+#define XkbInitCanonicalKeyTypes	SrvXkbInitCanonicalKeyTypes
+#define	XkbKeyTypesForCoreSymbols	SrvXkbKeyTypesForCoreSymbols
+#define	XkbApplyCompatMapToKey		SrvXkbApplyCompatMapToKey
+#define	XkbUpdateMapFromCore		SrvXkbUpdateMapFromCore
+#define XkbResizeKeyActions		SrvXkbResizeKeyActions
+#define XkbResizeKeySyms		SrvXkbResizeKeySyms
+#define XkbResizeKeyType		SrvXkbResizeKeyType
+#define XkbAllocCompatMap		SrvXkbAllocCompatMap
+#define XkbAllocControls		SrvXkbAllocControls
+#define XkbAllocIndicatorMaps		SrvXkbAllocIndicatorMaps
+#define XkbAllocKeyboard		SrvXkbAllocKeyboard
+#define XkbAllocNames			SrvXkbAllocNames
+#define XkbFreeCompatMap		SrvXkbFreeCompatMap
+#define XkbFreeControls			SrvXkbFreeControls
+#define XkbFreeIndicatorMaps		SrvXkbFreeIndicatorMaps
+#define XkbFreeKeyboard			SrvXkbFreeKeyboard
+#define XkbFreeNames			SrvXkbFreeNames
+#define	XkbAddDeviceLedInfo		SrvXkbAddDeviceLedInfo
+#define	XkbAllocDeviceInfo		SrvXkbAllocDeviceInfo
+#define	XkbFreeDeviceInfo		SrvXkbFreeDeviceInfo
+#define	XkbResizeDeviceButtonActions	SrvXkbResizeDeviceButtonActions
+#define XkbLatchModifiers		SrvXkbLatchModifiers
+#define XkbLatchGroup			SrvXkbLatchGroup
+#define XkbVirtualModsToReal		SrvXkbVirtualModsToReal
+#define	XkbChangeKeycodeRange		SrvXkbChangeKeycodeRange
+#define	XkbApplyVirtualModChanges	SrvXkbApplyVirtualModChanges
+#define	XkbUpdateActionVirtualMods	SrvXkbUpdateActionVirtualMods
+#define XkbUpdateKeyTypeVirtualMods	SrvXkbUpdateKeyTypeVirtualMods
+#endif
+
+#include <X11/extensions/XKBstr.h>
+#include <X11/extensions/XKBproto.h>
+#include "inputstr.h"
+
+typedef struct _XkbInterest {
+	DeviceIntPtr		dev;
+	ClientPtr		client;
+	XID			resource;
+	struct _XkbInterest *	next;
+	CARD16			extDevNotifyMask;
+	CARD16			stateNotifyMask;
+	CARD16			namesNotifyMask;
+	CARD32 			ctrlsNotifyMask;
+	CARD8			compatNotifyMask;
+	BOOL			bellNotifyMask;
+	BOOL			actionMessageMask;
+	CARD16			accessXNotifyMask;
+	CARD32			iStateNotifyMask;
+	CARD32			iMapNotifyMask;
+	CARD16			altSymsNotifyMask;
+	CARD32			autoCtrls;
+	CARD32			autoCtrlValues;
+} XkbInterestRec,*XkbInterestPtr;
+
+typedef struct _XkbRadioGroup {
+	CARD8		flags;
+	CARD8		nMembers;
+	CARD8		dfltDown;
+	CARD8		currentDown;
+	CARD8		members[XkbRGMaxMembers];
+} XkbRadioGroupRec, *XkbRadioGroupPtr;
+
+typedef struct	_XkbEventCause {
+	CARD8		kc;
+	CARD8		event;
+	CARD8		mjr;
+	CARD8		mnr;
+	ClientPtr	client;
+} XkbEventCauseRec,*XkbEventCausePtr;
+#define	XkbSetCauseKey(c,k,e)	{ (c)->kc= (k),(c)->event= (e),\
+				  (c)->mjr= (c)->mnr= 0; \
+				  (c)->client= NULL; }
+#define	XkbSetCauseReq(c,j,n,cl) { (c)->kc= (c)->event= 0,\
+				  (c)->mjr= (j),(c)->mnr= (n);\
+				  (c)->client= (cl); }
+#define	XkbSetCauseCoreReq(c,e,cl) XkbSetCauseReq(c,e,0,cl)
+#define	XkbSetCauseXkbReq(c,e,cl)  XkbSetCauseReq(c,XkbReqCode,e,cl)
+#define	XkbSetCauseUnknown(c)	   XkbSetCauseKey(c,0,0)
+
+#define	_OFF_TIMER		0
+#define	_KRG_WARN_TIMER		1
+#define	_KRG_TIMER		2
+#define	_SK_TIMEOUT_TIMER	3
+#define	_ALL_TIMEOUT_TIMER	4
+
+#define	_BEEP_NONE		0
+#define	_BEEP_FEATURE_ON	1
+#define	_BEEP_FEATURE_OFF	2
+#define	_BEEP_FEATURE_CHANGE	3
+#define	_BEEP_SLOW_WARN		4
+#define	_BEEP_SLOW_PRESS	5
+#define	_BEEP_SLOW_ACCEPT	6
+#define	_BEEP_SLOW_REJECT	7
+#define	_BEEP_SLOW_RELEASE	8
+#define	_BEEP_STICKY_LATCH	9
+#define	_BEEP_STICKY_LOCK	10
+#define	_BEEP_STICKY_UNLOCK	11
+#define	_BEEP_LED_ON		12
+#define	_BEEP_LED_OFF		13
+#define	_BEEP_LED_CHANGE	14
+#define	_BEEP_BOUNCE_REJECT	15
+
+typedef struct _XkbSrvInfo {
+	XkbStateRec	 prev_state;
+	XkbStateRec	 state;
+	XkbDescPtr	 desc;
+
+	DeviceIntPtr	 device;
+	KbdCtrlProcPtr	 kbdProc;
+
+	XkbRadioGroupPtr radioGroups;
+	CARD8		 nRadioGroups;
+	CARD8		 clearMods;
+	CARD8		 setMods;
+	INT16		 groupChange;
+
+	CARD16		 dfltPtrDelta;
+
+	double		 mouseKeysCurve;
+	double		 mouseKeysCurveFactor;
+	INT16		 mouseKeysDX;
+	INT16		 mouseKeysDY;
+	CARD8		 mouseKeysFlags;
+	Bool		 mouseKeysAccel;
+	CARD8		 mouseKeysCounter;
+
+	CARD8		 lockedPtrButtons;
+	CARD8		 shiftKeyCount;
+	KeyCode		 mouseKey;
+	KeyCode		 inactiveKey;
+	KeyCode		 slowKey;
+	KeyCode		 repeatKey;
+	CARD8		 krgTimerActive;
+	CARD8		 beepType;
+	CARD8		 beepCount;
+
+	CARD32		 flags;
+	CARD32		 lastPtrEventTime;
+	CARD32		 lastShiftEventTime;
+	OsTimerPtr	 beepTimer;
+	OsTimerPtr	 mouseKeyTimer;
+	OsTimerPtr	 slowKeysTimer;
+	OsTimerPtr	 bounceKeysTimer;
+	OsTimerPtr	 repeatKeyTimer;
+	OsTimerPtr	 krgTimer;
+} XkbSrvInfoRec, *XkbSrvInfoPtr;
+
+#define	XkbSLI_IsDefault	(1L<<0)
+#define	XkbSLI_HasOwnState	(1L<<1)
+
+typedef struct	_XkbSrvLedInfo {
+	CARD16			flags;
+	CARD16			class;
+	CARD16			id;
+	union {
+	    KbdFeedbackPtr	kf;
+	    LedFeedbackPtr	lf;
+	} 			fb;
+
+	CARD32			physIndicators;
+	CARD32			autoState;
+	CARD32			explicitState;
+	CARD32			effectiveState;
+
+	CARD32			mapsPresent;
+	CARD32			namesPresent;
+	XkbIndicatorMapPtr	maps;
+	Atom *			names;
+
+	CARD32			usesBase;
+	CARD32			usesLatched;
+	CARD32			usesLocked;
+	CARD32			usesEffective;
+	CARD32			usesCompat;
+	CARD32			usesControls;
+
+	CARD32			usedComponents;
+} XkbSrvLedInfoRec, *XkbSrvLedInfoPtr;
+
+/*
+ * Settings for xkbClientFlags field (used by DIX)
+ * These flags _must_ not overlap with XkbPCF_*
+ */
+#define	_XkbClientInitialized		(1<<15)
+
+#define	_XkbWantsDetectableAutoRepeat(c)\
+	((c)->xkbClientFlags&XkbPCF_DetectableAutoRepeatMask)
+
+/*
+ * Settings for flags field
+ */
+#define	_XkbStateNotifyInProgress	(1<<0)
+
+typedef struct
+{
+    ProcessInputProc processInputProc;
+    ProcessInputProc realInputProc;
+    DeviceUnwrapProc unwrapProc;
+} xkbDeviceInfoRec, *xkbDeviceInfoPtr;
+
+#define WRAP_PROCESS_INPUT_PROC(device, oldprocs, proc, unwrapproc) \
+	device->public.processInputProc = proc; \
+	oldprocs->processInputProc = \
+	oldprocs->realInputProc = device->public.realInputProc; \
+	device->public.realInputProc = proc; \
+	oldprocs->unwrapProc = device->unwrapProc; \
+	device->unwrapProc = unwrapproc;
+
+#define COND_WRAP_PROCESS_INPUT_PROC(device, oldprocs, proc, unwrapproc) \
+	if (device->public.processInputProc == device->public.realInputProc)\
+	    device->public.processInputProc = proc; \
+	oldprocs->processInputProc = \
+	oldprocs->realInputProc = device->public.realInputProc; \
+	device->public.realInputProc = proc; \
+	oldprocs->unwrapProc = device->unwrapProc; \
+	device->unwrapProc = unwrapproc;
+
+#define UNWRAP_PROCESS_INPUT_PROC(device, oldprocs) \
+	device->public.processInputProc = oldprocs->processInputProc; \
+	device->public.realInputProc = oldprocs->realInputProc; \
+	device->unwrapProc = oldprocs->unwrapProc;
+
+#define XKBDEVICEINFO(dev) ((xkbDeviceInfoPtr) (dev)->devPrivates[xkbDevicePrivateIndex].ptr)
+
+/***====================================================================***/
+
+
+/***====================================================================***/
+
+#define XkbAX_KRGMask	 (XkbSlowKeysMask|XkbBounceKeysMask)
+#define	XkbAllFilteredEventsMask \
+	(XkbAccessXKeysMask|XkbRepeatKeysMask|XkbMouseKeysAccelMask|XkbAX_KRGMask)
+
+/***====================================================================***/
+
+extern int	XkbReqCode;
+extern int	XkbEventBase;
+extern int	XkbKeyboardErrorCode;
+extern int	XkbDisableLockActions;
+extern char *	XkbBaseDirectory;
+extern char *	XkbBinDirectory;
+extern char *	XkbInitialMap;
+extern int	_XkbClientMajor;
+extern int	_XkbClientMinor;
+extern unsigned	int XkbXIUnsupported;
+
+extern char *	XkbModelUsed,*XkbLayoutUsed,*XkbVariantUsed,*XkbOptionsUsed;
+extern Bool	noXkbExtension;
+extern Bool	XkbWantRulesProp;
+
+extern pointer	XkbLastRepeatEvent;
+
+extern CARD32	xkbDebugFlags;
+extern CARD32	xkbDebugCtrls;
+
+#define	_XkbAlloc(s)		xalloc((s))
+#define	_XkbCalloc(n,s)		Xcalloc((n)*(s))
+#define	_XkbRealloc(o,s)	Xrealloc((o),(s))
+#define	_XkbTypedAlloc(t)	((t *)xalloc(sizeof(t)))
+#define	_XkbTypedCalloc(n,t)	((t *)Xcalloc((n)*sizeof(t)))
+#define	_XkbTypedRealloc(o,n,t) \
+	((o)?(t *)Xrealloc((o),(n)*sizeof(t)):_XkbTypedCalloc(n,t))
+#define	_XkbClearElems(a,f,l,t)	bzero(&(a)[f],((l)-(f)+1)*sizeof(t))
+#define	_XkbFree(p)		Xfree(p)
+
+#define	_XkbLibError(c,l,d) \
+	{ _XkbErrCode= (c); _XkbErrLocation= (l); _XkbErrData= (d); }
+#define	_XkbErrCode2(a,b) ((XID)((((unsigned int)(a))<<24)|((b)&0xffffff)))
+#define	_XkbErrCode3(a,b,c)	_XkbErrCode2(a,(((unsigned int)(b))<<16)|(c))
+#define	_XkbErrCode4(a,b,c,d) _XkbErrCode3(a,b,((((unsigned int)(c))<<8)|(d)))
+
+extern	int	DeviceKeyPress,DeviceKeyRelease;
+extern	int	DeviceButtonPress,DeviceButtonRelease;
+
+#ifdef XINPUT
+#define	_XkbIsPressEvent(t)	(((t)==KeyPress)||((t)==DeviceKeyPress))
+#define	_XkbIsReleaseEvent(t)	(((t)==KeyRelease)||((t)==DeviceKeyRelease))
+#else
+#define	_XkbIsPressEvent(t)	((t)==KeyPress)
+#define	_XkbIsReleaseEvent(t)	((t)==KeyRelease)
+#endif
+
+#define	_XkbCoreKeycodeInRange(c,k)	(((k)>=(c)->curKeySyms.minKeyCode)&&\
+					 ((k)<=(c)->curKeySyms.maxKeyCode))
+#define	_XkbCoreNumKeys(c)	((c)->curKeySyms.maxKeyCode-\
+				 (c)->curKeySyms.minKeyCode+1)
+
+#define	XConvertCase(s,l,u)	XkbConvertCase(s,l,u)
+#undef	IsKeypadKey
+#define	IsKeypadKey(s)		XkbKSIsKeypad(s)
+
+typedef int Status;
+typedef pointer XPointer;
+typedef struct _XDisplay Display;
+
+#ifndef True
+#define	True	1
+#define	False	0
+#endif
+
+#ifndef PATH_MAX
+#ifdef MAXPATHLEN
+#define	PATH_MAX MAXPATHLEN
+#else
+#define	PATH_MAX 1024
+#endif
+#endif
+
+_XFUNCPROTOBEGIN
+
+extern void XkbUseMsg(
+    void
+);
+
+extern int XkbProcessArguments(
+    int				/* argc */,
+    char **			/* argv */,
+    int				/* i */
+);
+
+extern	void	XkbSetExtension(DeviceIntPtr device, ProcessInputProc proc);
+
+extern	void	XkbFreeCompatMap(
+    XkbDescPtr			/* xkb */,
+    unsigned int		/* which */,
+    Bool			/* freeMap */
+);
+
+extern	void XkbFreeNames(
+	XkbDescPtr		/* xkb */,
+	unsigned int		/* which */,
+	Bool			/* freeMap */
+);
+
+extern DeviceIntPtr _XkbLookupAnyDevice(
+    int			/* id */,
+    int *		/* why_rtrn */
+);
+
+extern DeviceIntPtr _XkbLookupKeyboard(
+    int			/* id */,
+    int *		/* why_rtrn */
+);
+
+extern DeviceIntPtr _XkbLookupBellDevice(
+    int			/* id */,
+    int *		/* why_rtrn */
+);
+
+extern DeviceIntPtr _XkbLookupLedDevice(
+    int			/* id */,
+    int *		/* why_rtrn */
+);
+
+extern DeviceIntPtr _XkbLookupButtonDevice(
+    int			/* id */,
+    int *		/* why_rtrn */
+);
+
+extern	XkbDescPtr XkbAllocKeyboard(
+	void
+);
+
+extern	Status XkbAllocClientMap(
+	XkbDescPtr		/* xkb */,
+	unsigned int		/* which */,
+	unsigned int		/* nTypes */
+);
+
+extern	Status XkbAllocServerMap(
+	XkbDescPtr		/* xkb */,
+	unsigned int		/* which */,
+	unsigned int		/* nNewActions */
+);
+
+extern	void	XkbFreeClientMap(
+    XkbDescPtr			/* xkb */,
+    unsigned int		/* what */,
+    Bool			/* freeMap */
+);
+
+extern	void	XkbFreeServerMap(
+    XkbDescPtr			/* xkb */,
+    unsigned int		/* what */,
+    Bool			/* freeMap */
+);
+
+extern	Status XkbAllocIndicatorMaps(
+	XkbDescPtr		/* xkb */
+);
+
+extern	Status	XkbAllocCompatMap(
+    XkbDescPtr			/* xkb */,
+    unsigned int		/* which */,
+    unsigned int		/* nInterpret */
+);
+
+extern	Status XkbAllocNames(
+	XkbDescPtr		/* xkb */,
+	unsigned int		/* which */,
+	int			/* nTotalRG */,
+	int			/* nTotalAliases */
+);
+
+extern	Status	XkbAllocControls(
+	XkbDescPtr		/* xkb */,
+	unsigned int		/* which*/
+);
+
+extern	Status	XkbCopyKeyType(
+    XkbKeyTypePtr		/* from */,
+    XkbKeyTypePtr		/* into */
+);
+
+extern	Status	XkbCopyKeyTypes(
+    XkbKeyTypePtr		/* from */,
+    XkbKeyTypePtr		/* into */,
+    int				/* num_types */
+);
+
+extern	Status	XkbResizeKeyType(
+    XkbDescPtr		/* xkb */,
+    int			/* type_ndx */,
+    int			/* map_count */,
+    Bool		/* want_preserve */,
+    int			/* new_num_lvls */
+);
+
+extern	void	XkbFreeKeyboard(
+	XkbDescPtr		/* xkb */,
+	unsigned int		/* which */,
+	Bool			/* freeDesc */
+);
+
+extern  void XkbSetActionKeyMods(
+	XkbDescPtr		/* xkb */,
+	XkbAction *		/* act */,
+	unsigned int 		/* mods */
+);
+
+extern Bool XkbCheckActionVMods(
+	XkbDescPtr		/* xkb */,
+	XkbAction *		/* act */,
+	unsigned int 		/* changed */
+);
+
+extern Bool XkbApplyVModChanges(
+    XkbSrvInfoPtr	/* xkbi */,
+    unsigned int	/* changed */,
+    XkbChangesPtr	/* pChanges */,
+    unsigned int *	/* needChecksRtrn */,
+    XkbEventCausePtr	/* cause */
+);
+
+extern void XkbApplyVModChangesToAllDevices(
+    DeviceIntPtr	/* dev */,
+    XkbDescPtr 		/* xkb */,
+    unsigned int 	/* changed */,
+    XkbEventCausePtr	/* cause */
+);
+
+extern	unsigned int XkbMaskForVMask(
+    XkbDescPtr		/* xkb */,
+    unsigned int	/* vmask */
+);
+
+extern Bool XkbVirtualModsToReal(
+	XkbDescPtr	/* xkb */,
+	unsigned int	/* virtua_mask */,
+	unsigned int *	/* mask_rtrn */
+);
+
+extern	unsigned int	XkbAdjustGroup(
+    int			/* group */,
+    XkbControlsPtr	/* ctrls */
+);
+
+extern KeySym *XkbResizeKeySyms(
+    XkbDescPtr		/* xkb */,
+    int 		/* key */,
+    int 		/* needed */
+);
+
+extern XkbAction *XkbResizeKeyActions(
+    XkbDescPtr		/* xkb */,
+    int 		/* key */,
+    int 		/* needed */
+);
+
+extern void XkbUpdateKeyTypesFromCore(
+    DeviceIntPtr	/* pXDev */,
+    KeyCode 		/* first */,
+    CARD8 		/* num */,
+    XkbChangesPtr	/* pChanges */
+);
+
+extern	void XkbUpdateDescActions(
+    XkbDescPtr		/* xkb */,
+    KeyCode		/* first */,
+    CARD8		/* num */,
+    XkbChangesPtr	/* changes */
+);
+
+extern void XkbUpdateActions(
+    DeviceIntPtr	/* pXDev */,
+    KeyCode 		/* first */,
+    CARD8 		/* num */,
+    XkbChangesPtr  	/* pChanges */,
+    unsigned int *	/* needChecksRtrn */,
+    XkbEventCausePtr	/* cause */
+);
+
+extern void XkbUpdateCoreDescription(
+    DeviceIntPtr	/* keybd */,
+    Bool		/* resize */
+);
+
+extern void XkbApplyMappingChange(
+    DeviceIntPtr	/* pXDev */,
+    CARD8 		/* request */,
+    KeyCode 		/* firstKey */,
+    CARD8 		/* num */,
+    ClientPtr		/* client */
+);
+
+extern void XkbSetIndicators(
+    DeviceIntPtr		/* pXDev */,
+    CARD32			/* affect */,
+    CARD32			/* values */,
+    XkbEventCausePtr		/* cause */
+);
+
+extern void XkbUpdateIndicators(
+    DeviceIntPtr		/* keybd */,
+    CARD32		 	/* changed */,
+    Bool			/* check_edevs */,
+    XkbChangesPtr		/* pChanges */,
+    XkbEventCausePtr		/* cause */
+);
+
+extern XkbSrvLedInfoPtr XkbAllocSrvLedInfo(
+    DeviceIntPtr		/* dev */,
+    KbdFeedbackPtr		/* kf */,
+    LedFeedbackPtr		/* lf */,
+    unsigned int		/* needed_parts */
+);
+
+extern XkbSrvLedInfoPtr XkbFindSrvLedInfo(
+    DeviceIntPtr		/* dev */,
+    unsigned int		/* class */,
+    unsigned int		/* id */,
+    unsigned int		/* needed_parts */
+);
+
+extern void XkbApplyLedNameChanges(
+    DeviceIntPtr		/* dev */,
+    XkbSrvLedInfoPtr		/* sli */,
+    unsigned int		/* changed_names */,
+    xkbExtensionDeviceNotify *	/* ed */,
+    XkbChangesPtr		/* changes */,
+    XkbEventCausePtr		/* cause */
+);
+
+extern void XkbApplyLedMapChanges(
+    DeviceIntPtr		/* dev */,
+    XkbSrvLedInfoPtr		/* sli */,
+    unsigned int		/* changed_maps */,
+    xkbExtensionDeviceNotify *	/* ed */,
+    XkbChangesPtr		/* changes */,
+    XkbEventCausePtr		/* cause */
+);
+
+extern void XkbApplyLedStateChanges(
+    DeviceIntPtr		/* dev */,
+    XkbSrvLedInfoPtr		/* sli */,
+    unsigned int		/* changed_leds */,
+    xkbExtensionDeviceNotify *	/* ed */,
+    XkbChangesPtr		/* changes */,
+    XkbEventCausePtr		/* cause */
+);
+
+extern void XkbUpdateLedAutoState(
+    DeviceIntPtr		/* dev */,
+    XkbSrvLedInfoPtr		/* sli */,
+    unsigned int		/* maps_to_check */,
+    xkbExtensionDeviceNotify *	/* ed */,
+    XkbChangesPtr		/* changes */,
+    XkbEventCausePtr		/* cause */
+);
+
+extern void XkbFlushLedEvents(
+    DeviceIntPtr		/* dev */,
+    DeviceIntPtr		/* kbd */,
+    XkbSrvLedInfoPtr		/* sli */,
+    xkbExtensionDeviceNotify *	/* ed */,
+    XkbChangesPtr		/* changes */,
+    XkbEventCausePtr		/* cause */
+);
+
+extern void XkbUpdateAllDeviceIndicators(
+    XkbChangesPtr		/* changes */,
+    XkbEventCausePtr		/* cause */
+);
+
+extern unsigned int XkbIndicatorsToUpdate(
+    DeviceIntPtr		/* dev */,
+    unsigned long		/* state_changes */,
+    Bool			/* enabled_ctrl_changes */
+);
+
+extern void XkbComputeDerivedState(
+    XkbSrvInfoPtr		/* xkbi */
+);
+
+extern void XkbCheckSecondaryEffects(
+    XkbSrvInfoPtr		/* xkbi */,
+    unsigned int		/* which */,
+    XkbChangesPtr		/* changes */,
+    XkbEventCausePtr		/* cause */
+);
+
+extern void XkbCheckIndicatorMaps(
+    DeviceIntPtr		/* dev */,
+    XkbSrvLedInfoPtr		/* sli */,
+    unsigned int		/* which */
+);
+
+extern unsigned int XkbStateChangedFlags(
+    XkbStatePtr			/* old */,
+    XkbStatePtr			/* new */
+);
+
+extern	void XkbSendStateNotify(
+       DeviceIntPtr	/* kbd */,
+       xkbStateNotify *	/* pSN */
+);
+
+extern	void XkbSendMapNotify(
+       DeviceIntPtr	/* kbd */,
+       xkbMapNotify *	/* ev */
+);
+
+extern	int  XkbComputeControlsNotify(
+	DeviceIntPtr		/* kbd */,
+	XkbControlsPtr		/* old */,
+	XkbControlsPtr		/* new */,
+	xkbControlsNotify *	/* pCN */,
+	Bool			/* forceCtrlProc */
+);
+
+extern	void XkbSendControlsNotify(
+       DeviceIntPtr		/* kbd */,
+       xkbControlsNotify *	/* ev */
+);
+
+extern	void XkbSendCompatMapNotify(
+	DeviceIntPtr		/* kbd */,
+	xkbCompatMapNotify *	/* ev */
+);
+
+extern	void XkbSendIndicatorNotify(
+       DeviceIntPtr		/* kbd */,
+       int			/* xkbType */,
+       xkbIndicatorNotify *	/* ev */
+);
+
+extern	void XkbHandleBell(
+       BOOL		/* force */,
+       BOOL		/* eventOnly */,
+       DeviceIntPtr	/* kbd */,
+       CARD8		/* percent */,
+       pointer 		/* ctrl */,
+       CARD8		/* class */,
+       Atom		/* name */,
+       WindowPtr	/* pWin */,
+       ClientPtr	/* pClient */
+);
+
+extern	void XkbSendAccessXNotify(
+       DeviceIntPtr		/* kbd */,
+       xkbAccessXNotify *	/* pEv */
+);
+
+extern	void XkbSendNamesNotify(
+       DeviceIntPtr	/* kbd */,
+       xkbNamesNotify *	/* ev */
+);
+
+extern	void XkbSendCompatNotify(
+       DeviceIntPtr		/* kbd */,
+       xkbCompatMapNotify *	/* ev */
+);
+
+extern	void XkbSendActionMessage(
+       DeviceIntPtr		/* kbd */,
+       xkbActionMessage *	/* ev */
+);
+
+extern	void XkbSendExtensionDeviceNotify(
+       DeviceIntPtr			/* kbd */,
+       ClientPtr			/* client */,
+       xkbExtensionDeviceNotify *	/* ev */
+);
+
+extern void XkbSendNotification(
+    DeviceIntPtr		/* kbd */,
+    XkbChangesPtr		/* pChanges */,
+    XkbEventCausePtr		/* cause */
+);
+
+extern void XkbProcessKeyboardEvent(
+    struct _xEvent * 		/* xE */,
+    DeviceIntPtr		/* keybd */,
+    int 			/* count */
+);
+
+extern void XkbProcessOtherEvent(
+    struct _xEvent * 		/* xE */,
+    DeviceIntPtr		/* keybd */,
+    int 			/* count */
+);
+
+extern void XkbHandleActions(
+    DeviceIntPtr		/* dev */,
+    DeviceIntPtr		/* kbd */,
+    struct _xEvent * 		/* xE */,
+    int 			/* count */
+);
+
+extern Bool XkbEnableDisableControls(
+    XkbSrvInfoPtr	/* xkbi */,
+    unsigned long	/* change */,
+    unsigned long	/* newValues */,
+    XkbChangesPtr	/* changes */,
+    XkbEventCausePtr	/* cause */
+);
+
+extern void AccessXInit(
+    DeviceIntPtr        /* dev */
+);
+
+extern Bool AccessXFilterPressEvent(
+    register struct _xEvent *	/* xE */,
+    register DeviceIntPtr	/* keybd */,
+    int				/* count */
+);
+
+extern Bool AccessXFilterReleaseEvent(
+    register struct _xEvent *	/* xE */,
+    register DeviceIntPtr	/* keybd */,
+    int				/* count */
+);
+
+extern void AccessXCancelRepeatKey(
+    XkbSrvInfoPtr	/* xkbi */,
+    KeyCode		/* key */
+);
+
+extern void AccessXComputeCurveFactor(
+    XkbSrvInfoPtr	/* xkbi */,
+    XkbControlsPtr	/* ctrls */
+);
+
+extern	XkbDeviceLedInfoPtr	XkbAddDeviceLedInfo(
+	XkbDeviceInfoPtr	/* devi */,
+	unsigned int		/* ledClass */,
+	unsigned int		/* ledId */
+);
+
+extern	XkbDeviceInfoPtr	XkbAllocDeviceInfo(
+	unsigned int		/* deviceSpec */,
+	unsigned int		/* nButtons */,
+	unsigned int		/* szLeds */
+);
+
+extern	void XkbFreeDeviceInfo(
+	XkbDeviceInfoPtr	/* devi */,
+	unsigned int		/* which */,
+	Bool			/* freeDevI */
+);
+
+extern Status XkbResizeDeviceButtonActions(
+	XkbDeviceInfoPtr        /* devi */,
+	unsigned int            /* newTotal */
+);
+
+extern	XkbInterestPtr XkbFindClientResource(
+       DevicePtr	/* inDev */,
+       ClientPtr	/* client */
+);
+
+extern	XkbInterestPtr XkbAddClientResource(
+       DevicePtr	/* inDev */,
+       ClientPtr	/* client */,
+       XID		/* id */
+);
+
+extern	int XkbRemoveClient(
+       DevicePtr	/* inDev */,
+       ClientPtr	/* client */
+);
+
+extern	int XkbRemoveResourceClient(
+       DevicePtr	/* inDev */,
+       XID		/* id */
+);
+
+extern int XkbDDXInitDevice(
+    DeviceIntPtr        /* dev */
+);
+
+extern	int XkbDDXAccessXBeep(
+    DeviceIntPtr        /* dev */,
+    unsigned int	/* what */,
+    unsigned int	/* which */
+);
+
+extern	void XkbDDXKeyClick(
+    DeviceIntPtr	/* dev */,
+    int			/* keycode */,
+    int			/* synthetic */
+);
+
+extern 	int XkbDDXUsesSoftRepeat(
+    DeviceIntPtr	/* dev */
+);
+
+extern	void XkbDDXKeybdCtrlProc(
+	DeviceIntPtr	/* dev */,
+	KeybdCtrl *	/* ctrl */
+);
+
+extern void XkbDDXChangeControls(
+	DeviceIntPtr	/* dev */,
+	XkbControlsPtr 	/* old */,
+	XkbControlsPtr 	/* new */
+);
+
+extern void XkbDDXUpdateIndicators(
+	DeviceIntPtr	/* keybd */,
+	CARD32		/* newState */
+);
+
+extern void XkbDDXUpdateDeviceIndicators(
+	DeviceIntPtr		/* dev */,
+	XkbSrvLedInfoPtr	/* sli */,
+	CARD32			/* newState */
+);
+
+extern void XkbDDXFakePointerButton(
+	int 		/* event */,
+	int		/* button */
+);
+
+extern void XkbDDXFakePointerMotion(
+ 	unsigned int	/* flags */,
+	int		/* x */,
+	int		/* y */
+);
+
+extern void XkbDDXFakeDeviceButton(
+	DeviceIntPtr	/* dev */,
+	Bool		/* press */,
+	int		/* button */
+);
+
+extern int XkbDDXTerminateServer(
+	DeviceIntPtr	/* dev */,
+	KeyCode		/* key */,
+	XkbAction *	/* act */
+);
+
+extern int XkbDDXSwitchScreen(
+	DeviceIntPtr	/* dev */,
+	KeyCode		/* key */,
+	XkbAction *	/* act */
+);
+
+extern int XkbDDXPrivate(
+	DeviceIntPtr	/* dev */,
+	KeyCode		/* key */,
+	XkbAction *	/* act */
+);
+
+extern void XkbDisableComputedAutoRepeats(
+	DeviceIntPtr 	/* pXDev */,
+	unsigned int	/* key */
+);
+
+extern void XkbSetRepeatKeys(
+	DeviceIntPtr 	/* pXDev */,
+	int		/* key */,
+	int	 	/* onoff */
+);
+
+extern	int XkbLatchModifiers(
+	DeviceIntPtr 	/* pXDev */,
+	CARD8 		/* mask */,
+	CARD8 		/* latches */
+);
+
+extern	int XkbLatchGroup(
+	DeviceIntPtr  	/* pXDev */,
+	int	  	/* group */
+);
+
+extern	void XkbClearAllLatchesAndLocks(
+	DeviceIntPtr		/* dev */,
+	XkbSrvInfoPtr		/* xkbi */,
+	Bool			/* genEv */,
+	XkbEventCausePtr	/* cause */
+);
+
+extern	void	XkbSetRulesDflts(
+	char *			/* rulesFile */,
+	char *			/* model */,
+	char *			/* layout */,
+	char *			/* variant */,
+	char *			/* options */
+);
+
+extern	void	XkbInitDevice(
+	DeviceIntPtr 	/* pXDev */
+);
+
+extern	Bool	XkbInitKeyboardDeviceStruct(
+	DeviceIntPtr 		/* pXDev */,
+	XkbComponentNamesPtr	/* pNames */,
+	KeySymsPtr		/* pSyms */,
+	CARD8 			/* pMods */[],
+	BellProcPtr		/* bellProc */,
+	KbdCtrlProcPtr		/* ctrlProc */
+);
+
+extern	int SProcXkbDispatch(
+	ClientPtr		/* client */
+);
+
+extern XkbGeometryPtr XkbLookupNamedGeometry(
+	DeviceIntPtr		/* dev */,
+	Atom			/* name */,
+	Bool *			/* shouldFree */
+);
+
+extern char *	_XkbDupString(
+	char *			/* str */
+);
+
+extern void	XkbConvertCase(
+	KeySym 			/* sym */,
+	KeySym *		/* lower */,
+	KeySym *		/* upper */
+);
+
+extern	Status	 XkbChangeKeycodeRange(
+	XkbDescPtr		/* xkb */,
+	int 			/* minKC */,
+	int 			/* maxKC */,
+	XkbChangesPtr		/* changes */
+);
+
+extern int XkbFinishDeviceInit(
+	DeviceIntPtr		/* pXDev */
+);
+
+extern void XkbFreeSrvLedInfo(
+	XkbSrvLedInfoPtr	/* sli */
+);
+
+extern void XkbFreeInfo(
+	XkbSrvInfoPtr		/* xkbi */
+);
+
+extern Status XkbChangeTypesOfKey(
+	XkbDescPtr		/* xkb */,
+	int			/* key */,
+	int			/* nGroups */,
+	unsigned int		/* groups */,
+	int *			/* newTypesIn */,
+	XkbMapChangesPtr	/* changes */
+);
+
+extern XkbKeyTypePtr XkbAddKeyType(
+	XkbDescPtr		/* xkb */,
+	Atom			/* name */,
+	int			/* map_count */,
+	Bool			/* want_preserve */,
+	int			/* num_lvls */
+);
+
+extern Status XkbInitCanonicalKeyTypes(
+	XkbDescPtr		/* xkb */,
+	unsigned int		/* which */,
+	int			/* keypadVMod */
+);
+
+extern int XkbKeyTypesForCoreSymbols(
+	XkbDescPtr		/* xkb */,
+	int			/* map_width */,
+	KeySym *		/* core_syms */,
+	unsigned int		/* protected */,
+	int *			/* types_inout */,
+	KeySym *		/* xkb_syms_rtrn */
+);
+
+extern Bool XkbApplyCompatMapToKey(
+	XkbDescPtr		/* xkb */,
+	KeyCode			/* key */,
+	XkbChangesPtr		/* changes */
+);
+
+extern Bool XkbUpdateMapFromCore(
+	XkbDescPtr		/* xkb */,
+	KeyCode			/* first_key */,
+	int			/* num_keys */,
+	int			/* map_width */,
+	KeySym *		/* core_keysyms */,
+	XkbChangesPtr		/* changes */
+);
+
+extern void XkbFreeControls(
+	XkbDescPtr		/* xkb */,
+	unsigned int		/* which */,
+	Bool			/* freeMap */
+);
+
+extern void XkbFreeIndicatorMaps(
+	XkbDescPtr		/* xkb */
+);
+
+extern Bool XkbApplyVirtualModChanges(
+	XkbDescPtr		/* xkb */,
+	unsigned int		/* changed */,
+	XkbChangesPtr		/* changes */
+);
+
+extern Bool XkbUpdateActionVirtualMods(
+	XkbDescPtr		/* xkb */,
+	XkbAction *		/* act */,
+	unsigned int		/* changed */
+);
+
+extern void XkbUpdateKeyTypeVirtualMods(
+	XkbDescPtr		/* xkb */,
+	XkbKeyTypePtr		/* type */,
+	unsigned int		/* changed */,
+	XkbChangesPtr		/* changes */
+);
+
+extern void XkbSendNewKeyboardNotify(
+	DeviceIntPtr		/* kbd */,
+	xkbNewKeyboardNotify *	/* pNKN */
+);
+
+#ifdef XKBSRV_NEED_FILE_FUNCS
+
+#include <X11/extensions/XKMformat.h>
+#include <X11/extensions/XKBfile.h>
+#include <X11/extensions/XKBrules.h>
+
+#define	_XkbListKeymaps		0
+#define	_XkbListKeycodes	1
+#define	_XkbListTypes		2
+#define	_XkbListCompat		3
+#define	_XkbListSymbols		4
+#define	_XkbListGeometry	5
+#define	_XkbListNumComponents	6
+
+typedef struct _XkbSrvListInfo {
+	int		szPool;
+	int		nPool;
+	char *		pool;
+
+	int		maxRtrn;
+	int		nTotal;
+
+	char *		pattern[_XkbListNumComponents];
+	int		nFound[_XkbListNumComponents];
+} XkbSrvListInfoRec,*XkbSrvListInfoPtr;
+
+char *
+XkbGetRulesDflts(
+	XkbRF_VarDefsPtr	/* defs */
+);
+
+extern void	XkbSetRulesUsed(
+	XkbRF_VarDefsPtr	/* defs */
+);
+
+
+extern	Status	XkbDDXList(
+	DeviceIntPtr		/* dev */,
+	XkbSrvListInfoPtr	/* listing */,
+	ClientPtr		/* client */
+);
+
+extern	unsigned int XkbDDXLoadKeymapByNames(
+	DeviceIntPtr		/* keybd */,
+	XkbComponentNamesPtr	/* names */,
+	unsigned int		/* want */,
+	unsigned int		/* need */,
+	XkbFileInfoPtr		/* finfoRtrn */,
+	char *			/* keymapNameRtrn */,
+	int 			/* keymapNameRtrnLen */
+);
+
+extern	Bool XkbDDXNamesFromRules(
+	DeviceIntPtr		/* keybd */,
+	char *			/* rules */,
+	XkbRF_VarDefsPtr	/* defs */,
+	XkbComponentNamesPtr	/* names */
+);
+
+extern	FILE *XkbDDXOpenConfigFile(
+	char *	/* mapName */,
+	char *	/* fileNameRtrn */,
+	int	/* fileNameRtrnLen */
+);
+
+extern	Bool XkbDDXApplyConfig(
+	XPointer	/* cfg_in */,
+	XkbSrvInfoPtr	/* xkbi */
+);
+
+extern XPointer XkbDDXPreloadConfig(
+	char **			/* rulesFileRtrn */,
+	XkbRF_VarDefsPtr	/* defs */,
+	XkbComponentNamesPtr	/* names */,
+	DeviceIntPtr		/* dev */
+);
+
+extern	int _XkbStrCaseCmp(
+	char *			/* str1 */,
+	char *			/* str2 */
+);
+
+#endif /* XKBSRV_NEED_FILE_FUNCS */
+
+
+_XFUNCPROTOEND
+
+#define	XkbAtomGetString(d,s)	NameForAtom(s)
+
+#endif /* _XKBSRV_H_ */
+
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/XKBstr.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/XKBstr.h
new file mode 100644
index 0000000..eaefae8
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/XKBstr.h
@@ -0,0 +1,643 @@
+/************************************************************
+Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
+
+Permission to use, copy, modify, and distribute this
+software and its documentation for any purpose and without
+fee is hereby granted, provided that the above copyright
+notice appear in all copies and that both that copyright
+notice and this permission notice appear in supporting
+documentation, and that the name of Silicon Graphics not be
+used in advertising or publicity pertaining to distribution
+of the software without specific prior written permission.
+Silicon Graphics makes no representation about the suitability
+of this software for any purpose. It is provided "as is"
+without any express or implied warranty.
+
+SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
+GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
+THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+********************************************************/
+
+#ifndef _XKBSTR_H_
+#define	_XKBSTR_H_
+
+#include <X11/Xfuncproto.h>
+#include <X11/extensions/XKB.h>
+
+#define	XkbCharToInt(v)		((v)&0x80?(int)((v)|(~0xff)):(int)((v)&0x7f))
+#define	XkbIntTo2Chars(i,h,l)	(((h)=((i>>8)&0xff)),((l)=((i)&0xff)))
+#define	Xkb2CharsToInt(h,l)	((short)(((h)<<8)|(l)))
+
+/*
+ * The Xkb structs are full of implicit padding to properly align members.
+ * We can't clean that up without breaking ABI, so tell clang not to bother
+ * complaining about it.
+ */
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+	/*
+	 * Common data structures and access macros
+	 */
+
+typedef struct _XkbStateRec {
+	unsigned char	group;
+	unsigned char   locked_group;
+	unsigned short	base_group;
+	unsigned short	latched_group;
+	unsigned char	mods;
+	unsigned char	base_mods;
+	unsigned char	latched_mods;
+	unsigned char	locked_mods;
+	unsigned char	compat_state;
+	unsigned char	grab_mods;
+	unsigned char	compat_grab_mods;
+	unsigned char	lookup_mods;
+	unsigned char	compat_lookup_mods;
+	unsigned short	ptr_buttons;
+} XkbStateRec,*XkbStatePtr;
+#define	XkbModLocks(s)	 ((s)->locked_mods)
+#define	XkbStateMods(s)	 ((s)->base_mods|(s)->latched_mods|XkbModLocks(s))
+#define	XkbGroupLock(s)	 ((s)->locked_group)
+#define	XkbStateGroup(s) ((s)->base_group+(s)->latched_group+XkbGroupLock(s))
+#define	XkbStateFieldFromRec(s)	XkbBuildCoreState((s)->lookup_mods,(s)->group)
+#define	XkbGrabStateFromRec(s)	XkbBuildCoreState((s)->grab_mods,(s)->group)
+
+typedef struct _XkbMods {
+	unsigned char	mask;	/* effective mods */
+	unsigned char	real_mods;
+	unsigned short	vmods;
+} XkbModsRec,*XkbModsPtr;
+
+typedef struct _XkbKTMapEntry {
+	Bool		active;
+	unsigned char	level;
+	XkbModsRec	mods;
+} XkbKTMapEntryRec,*XkbKTMapEntryPtr;
+
+typedef struct _XkbKeyType {
+	XkbModsRec		mods;
+	unsigned char	  	num_levels;
+	unsigned char	  	map_count;
+	/* map is an array of map_count XkbKTMapEntryRec structs */
+	XkbKTMapEntryPtr  	map;
+	/* preserve is an array of map_count XkbModsRec structs */
+	XkbModsPtr  		preserve;
+	Atom		  	name;
+	/* level_names is an array of num_levels Atoms */
+	Atom *			level_names;
+} XkbKeyTypeRec, *XkbKeyTypePtr;
+
+#define	XkbNumGroups(g)			((g)&0x0f)
+#define	XkbOutOfRangeGroupInfo(g)	((g)&0xf0)
+#define	XkbOutOfRangeGroupAction(g)	((g)&0xc0)
+#define	XkbOutOfRangeGroupNumber(g)	(((g)&0x30)>>4)
+#define	XkbSetGroupInfo(g,w,n)	(((w)&0xc0)|(((n)&3)<<4)|((g)&0x0f))
+#define	XkbSetNumGroups(g,n)	(((g)&0xf0)|((n)&0x0f))
+
+	/*
+	 * Structures and access macros used primarily by the server
+	 */
+
+typedef struct _XkbBehavior {
+	unsigned char	type;
+	unsigned char	data;
+} XkbBehavior;
+
+#define	XkbAnyActionDataSize 7
+typedef	struct _XkbAnyAction {
+	unsigned char	type;
+	unsigned char	data[XkbAnyActionDataSize];
+} XkbAnyAction;
+
+typedef struct _XkbModAction {
+	unsigned char	type;
+	unsigned char	flags;
+	unsigned char	mask;
+	unsigned char	real_mods;
+	unsigned char	vmods1;
+	unsigned char	vmods2;
+} XkbModAction;
+#define	XkbModActionVMods(a)      \
+	((short)(((a)->vmods1<<8)|((a)->vmods2)))
+#define	XkbSetModActionVMods(a,v) \
+	(((a)->vmods1=(((v)>>8)&0xff)),(a)->vmods2=((v)&0xff))
+
+typedef struct _XkbGroupAction {
+	unsigned char	type;
+	unsigned char	flags;
+	char		group_XXX;
+} XkbGroupAction;
+#define	XkbSAGroup(a)		(XkbCharToInt((a)->group_XXX))
+#define	XkbSASetGroup(a,g)	((a)->group_XXX=(g))
+
+typedef struct _XkbISOAction {
+	unsigned char	type;
+	unsigned char	flags;
+	unsigned char	mask;
+	unsigned char	real_mods;
+	char		group_XXX;
+	unsigned char	affect;
+	unsigned char	vmods1;
+	unsigned char	vmods2;
+} XkbISOAction;
+
+typedef struct _XkbPtrAction {
+	unsigned char	type;
+	unsigned char	flags;
+	unsigned char	high_XXX;
+	unsigned char	low_XXX;
+	unsigned char	high_YYY;
+	unsigned char	low_YYY;
+} XkbPtrAction;
+#define	XkbPtrActionX(a)      (Xkb2CharsToInt((a)->high_XXX,(a)->low_XXX))
+#define	XkbPtrActionY(a)      (Xkb2CharsToInt((a)->high_YYY,(a)->low_YYY))
+#define	XkbSetPtrActionX(a,x) (XkbIntTo2Chars(x,(a)->high_XXX,(a)->low_XXX))
+#define	XkbSetPtrActionY(a,y) (XkbIntTo2Chars(y,(a)->high_YYY,(a)->low_YYY))
+
+typedef struct _XkbPtrBtnAction {
+	unsigned char	type;
+	unsigned char	flags;
+	unsigned char	count;
+	unsigned char	button;
+} XkbPtrBtnAction;
+
+typedef struct _XkbPtrDfltAction {
+	unsigned char	type;
+	unsigned char	flags;
+	unsigned char	affect;
+	char		valueXXX;
+} XkbPtrDfltAction;
+#define	XkbSAPtrDfltValue(a)		(XkbCharToInt((a)->valueXXX))
+#define	XkbSASetPtrDfltValue(a,c)	((a)->valueXXX= ((c)&0xff))
+
+typedef struct _XkbSwitchScreenAction {
+	unsigned char	type;
+	unsigned char	flags;
+	char		screenXXX;
+} XkbSwitchScreenAction;
+#define	XkbSAScreen(a)			(XkbCharToInt((a)->screenXXX))
+#define	XkbSASetScreen(a,s)		((a)->screenXXX= ((s)&0xff))
+
+typedef struct _XkbCtrlsAction {
+	unsigned char	type;
+	unsigned char	flags;
+	unsigned char	ctrls3;
+	unsigned char	ctrls2;
+	unsigned char	ctrls1;
+	unsigned char	ctrls0;
+} XkbCtrlsAction;
+#define	XkbActionSetCtrls(a,c)	(((a)->ctrls3=(((c)>>24)&0xff)),\
+					((a)->ctrls2=(((c)>>16)&0xff)),\
+					((a)->ctrls1=(((c)>>8)&0xff)),\
+					((a)->ctrls0=((c)&0xff)))
+#define	XkbActionCtrls(a) ((((unsigned int)(a)->ctrls3)<<24)|\
+			   (((unsigned int)(a)->ctrls2)<<16)|\
+			   (((unsigned int)(a)->ctrls1)<<8)|\
+			   ((unsigned int)((a)->ctrls0)))
+
+typedef struct _XkbMessageAction {
+	unsigned char	type;
+	unsigned char	flags;
+	unsigned char	message[6];
+} XkbMessageAction;
+
+typedef struct	_XkbRedirectKeyAction {
+	unsigned char	type;
+	unsigned char	new_key;
+	unsigned char	mods_mask;
+	unsigned char	mods;
+	unsigned char	vmods_mask0;
+	unsigned char	vmods_mask1;
+	unsigned char	vmods0;
+	unsigned char	vmods1;
+} XkbRedirectKeyAction;
+
+#define	XkbSARedirectVMods(a)		((((unsigned int)(a)->vmods1)<<8)|\
+					((unsigned int)(a)->vmods0))
+#define	XkbSARedirectSetVMods(a,m)	(((a)->vmods1=(((m)>>8)&0xff)),\
+					 ((a)->vmods0=((m)&0xff)))
+#define	XkbSARedirectVModsMask(a)	((((unsigned int)(a)->vmods_mask1)<<8)|\
+					((unsigned int)(a)->vmods_mask0))
+#define	XkbSARedirectSetVModsMask(a,m)	(((a)->vmods_mask1=(((m)>>8)&0xff)),\
+					 ((a)->vmods_mask0=((m)&0xff)))
+
+typedef struct _XkbDeviceBtnAction {
+	unsigned char	type;
+	unsigned char	flags;
+	unsigned char	count;
+	unsigned char	button;
+	unsigned char	device;
+} XkbDeviceBtnAction;
+
+typedef struct _XkbDeviceValuatorAction {
+	unsigned char	type;
+	unsigned char	device;
+	unsigned char	v1_what;
+	unsigned char	v1_ndx;
+	unsigned char	v1_value;
+	unsigned char	v2_what;
+	unsigned char	v2_ndx;
+	unsigned char	v2_value;
+} XkbDeviceValuatorAction;
+
+typedef	union _XkbAction {
+	XkbAnyAction		any;
+	XkbModAction		mods;
+	XkbGroupAction		group;
+	XkbISOAction		iso;
+	XkbPtrAction		ptr;
+	XkbPtrBtnAction		btn;
+	XkbPtrDfltAction	dflt;
+	XkbSwitchScreenAction	screen;
+	XkbCtrlsAction		ctrls;
+	XkbMessageAction	msg;
+	XkbRedirectKeyAction	redirect;
+	XkbDeviceBtnAction	devbtn;
+	XkbDeviceValuatorAction	devval;
+	unsigned char 		type;
+} XkbAction;
+
+typedef	struct _XkbControls {
+	unsigned char	mk_dflt_btn;
+	unsigned char	num_groups;
+	unsigned char	groups_wrap;
+	XkbModsRec	internal;
+	XkbModsRec	ignore_lock;
+	unsigned int	enabled_ctrls;
+	unsigned short	repeat_delay;
+	unsigned short	repeat_interval;
+	unsigned short	slow_keys_delay;
+	unsigned short	debounce_delay;
+	unsigned short	mk_delay;
+	unsigned short	mk_interval;
+	unsigned short	mk_time_to_max;
+	unsigned short	mk_max_speed;
+		 short	mk_curve;
+	unsigned short	ax_options;
+	unsigned short	ax_timeout;
+	unsigned short	axt_opts_mask;
+	unsigned short	axt_opts_values;
+	unsigned int	axt_ctrls_mask;
+	unsigned int	axt_ctrls_values;
+	unsigned char	per_key_repeat[XkbPerKeyBitArraySize];
+} XkbControlsRec, *XkbControlsPtr;
+
+#define	XkbAX_AnyFeedback(c)	((c)->enabled_ctrls&XkbAccessXFeedbackMask)
+#define	XkbAX_NeedOption(c,w)	((c)->ax_options&(w))
+#define	XkbAX_NeedFeedback(c,w)	(XkbAX_AnyFeedback(c)&&XkbAX_NeedOption(c,w))
+
+typedef struct _XkbServerMapRec {
+	/* acts is an array of XkbActions structs, with size_acts entries
+	   allocated, and num_acts entries used. */
+	unsigned short		 num_acts;
+	unsigned short		 size_acts;
+	XkbAction		*acts;
+
+	/* behaviors, key_acts, explicit, & vmodmap are all arrays with
+	   (xkb->max_key_code + 1) entries allocated for each. */
+	XkbBehavior		*behaviors;
+	unsigned short		*key_acts;
+#if defined(__cplusplus) || defined(c_plusplus)
+	/* explicit is a C++ reserved word */
+	unsigned char		*c_explicit;
+#else
+	unsigned char		*explicit;
+#endif
+	unsigned char		 vmods[XkbNumVirtualMods];
+	unsigned short		*vmodmap;
+} XkbServerMapRec, *XkbServerMapPtr;
+
+#define	XkbSMKeyActionsPtr(m,k) (&(m)->acts[(m)->key_acts[k]])
+
+	/*
+	 * Structures and access macros used primarily by clients
+	 */
+
+typedef	struct _XkbSymMapRec {
+	unsigned char	 kt_index[XkbNumKbdGroups];
+	unsigned char	 group_info;
+	unsigned char	 width;
+	unsigned short	 offset;
+} XkbSymMapRec, *XkbSymMapPtr;
+
+typedef struct _XkbClientMapRec {
+	/* types is an array of XkbKeyTypeRec structs, with size_types entries
+	   allocated, and num_types entries used. */
+	unsigned char		 size_types;
+	unsigned char		 num_types;
+	XkbKeyTypePtr		 types;
+
+	/* syms is an array of size_syms KeySyms, in which num_syms are used */
+	unsigned short		 size_syms;
+	unsigned short		 num_syms;
+	KeySym			*syms;
+	/* key_sym_map is an array of (max_key_code + 1) XkbSymMapRec structs */
+	XkbSymMapPtr		 key_sym_map;
+
+	/* modmap is an array of (max_key_code + 1) unsigned chars */
+	unsigned char		*modmap;
+} XkbClientMapRec, *XkbClientMapPtr;
+
+#define	XkbCMKeyGroupInfo(m,k)  ((m)->key_sym_map[k].group_info)
+#define	XkbCMKeyNumGroups(m,k)	 (XkbNumGroups((m)->key_sym_map[k].group_info))
+#define	XkbCMKeyGroupWidth(m,k,g) (XkbCMKeyType(m,k,g)->num_levels)
+#define	XkbCMKeyGroupsWidth(m,k) ((m)->key_sym_map[k].width)
+#define	XkbCMKeyTypeIndex(m,k,g) ((m)->key_sym_map[k].kt_index[g&0x3])
+#define	XkbCMKeyType(m,k,g)	 (&(m)->types[XkbCMKeyTypeIndex(m,k,g)])
+#define	XkbCMKeyNumSyms(m,k) (XkbCMKeyGroupsWidth(m,k)*XkbCMKeyNumGroups(m,k))
+#define	XkbCMKeySymsOffset(m,k)	((m)->key_sym_map[k].offset)
+#define	XkbCMKeySymsPtr(m,k)	(&(m)->syms[XkbCMKeySymsOffset(m,k)])
+
+	/*
+	 * Compatibility structures and access macros
+	 */
+
+typedef struct _XkbSymInterpretRec {
+	KeySym		sym;
+	unsigned char	flags;
+	unsigned char	match;
+	unsigned char	mods;
+	unsigned char	virtual_mod;
+	XkbAnyAction	act;
+} XkbSymInterpretRec,*XkbSymInterpretPtr;
+
+typedef struct _XkbCompatMapRec {
+	/* sym_interpret is an array of XkbSymInterpretRec structs,
+	   in which size_si are allocated & num_si are used. */
+	XkbSymInterpretPtr	 sym_interpret;
+	XkbModsRec		 groups[XkbNumKbdGroups];
+	unsigned short		 num_si;
+	unsigned short		 size_si;
+} XkbCompatMapRec, *XkbCompatMapPtr;
+
+typedef struct _XkbIndicatorMapRec {
+	unsigned char	flags;
+	unsigned char	which_groups;
+	unsigned char	groups;
+	unsigned char	which_mods;
+	XkbModsRec	mods;
+	unsigned int	ctrls;
+} XkbIndicatorMapRec, *XkbIndicatorMapPtr;
+
+#define	XkbIM_IsAuto(i)	((((i)->flags&XkbIM_NoAutomatic)==0)&&\
+			    (((i)->which_groups&&(i)->groups)||\
+			     ((i)->which_mods&&(i)->mods.mask)||\
+			     ((i)->ctrls)))
+#define	XkbIM_InUse(i)	(((i)->flags)||((i)->which_groups)||\
+					((i)->which_mods)||((i)->ctrls))
+
+
+typedef struct _XkbIndicatorRec {
+	unsigned long	  	phys_indicators;
+	XkbIndicatorMapRec	maps[XkbNumIndicators];
+} XkbIndicatorRec,*XkbIndicatorPtr;
+
+typedef	struct _XkbKeyNameRec {
+	char	name[XkbKeyNameLength]	_X_NONSTRING;
+} XkbKeyNameRec,*XkbKeyNamePtr;
+
+typedef struct _XkbKeyAliasRec {
+	char	real[XkbKeyNameLength]	_X_NONSTRING;
+	char	alias[XkbKeyNameLength]	_X_NONSTRING;
+} XkbKeyAliasRec,*XkbKeyAliasPtr;
+
+	/*
+	 * Names for everything
+	 */
+typedef struct _XkbNamesRec {
+	Atom		  keycodes;
+	Atom		  geometry;
+	Atom		  symbols;
+	Atom              types;
+	Atom		  compat;
+	Atom		  vmods[XkbNumVirtualMods];
+	Atom		  indicators[XkbNumIndicators];
+	Atom		  groups[XkbNumKbdGroups];
+	/* keys is an array of (xkb->max_key_code + 1) XkbKeyNameRec entries */
+	XkbKeyNamePtr	  keys;
+	/* key_aliases is an array of num_key_aliases XkbKeyAliasRec entries */
+	XkbKeyAliasPtr	  key_aliases;
+	/* radio_groups is an array of num_rg Atoms */
+	Atom		 *radio_groups;
+	Atom		  phys_symbols;
+
+	/* num_keys seems to be unused in libX11 */
+	unsigned char	  num_keys;
+	unsigned char	  num_key_aliases;
+	unsigned short	  num_rg;
+} XkbNamesRec,*XkbNamesPtr;
+
+typedef	struct _XkbGeometry	*XkbGeometryPtr;
+	/*
+	 * Tie it all together into one big keyboard description
+	 */
+typedef	struct _XkbDesc {
+	struct _XDisplay *	dpy;
+	unsigned short	 	flags;
+	unsigned short		device_spec;
+	KeyCode			min_key_code;
+	KeyCode			max_key_code;
+
+	XkbControlsPtr		ctrls;
+	XkbServerMapPtr		server;
+	XkbClientMapPtr		map;
+	XkbIndicatorPtr		indicators;
+	XkbNamesPtr		names;
+	XkbCompatMapPtr		compat;
+	XkbGeometryPtr		geom;
+} XkbDescRec, *XkbDescPtr;
+#define	XkbKeyKeyTypeIndex(d,k,g)	(XkbCMKeyTypeIndex((d)->map,k,g))
+#define	XkbKeyKeyType(d,k,g)		(XkbCMKeyType((d)->map,k,g))
+#define	XkbKeyGroupWidth(d,k,g)		(XkbCMKeyGroupWidth((d)->map,k,g))
+#define	XkbKeyGroupsWidth(d,k)		(XkbCMKeyGroupsWidth((d)->map,k))
+#define	XkbKeyGroupInfo(d,k)		(XkbCMKeyGroupInfo((d)->map,(k)))
+#define	XkbKeyNumGroups(d,k)		(XkbCMKeyNumGroups((d)->map,(k)))
+#define	XkbKeyNumSyms(d,k)		(XkbCMKeyNumSyms((d)->map,(k)))
+#define	XkbKeySymsPtr(d,k)		(XkbCMKeySymsPtr((d)->map,(k)))
+#define	XkbKeySym(d,k,n)		(XkbKeySymsPtr(d,k)[n])
+#define	XkbKeySymEntry(d,k,sl,g) \
+	(XkbKeySym(d,k,((XkbKeyGroupsWidth(d,k)*(g))+(sl))))
+#define	XkbKeyAction(d,k,n) \
+	(XkbKeyHasActions(d,k)?&XkbKeyActionsPtr(d,k)[n]:NULL)
+#define	XkbKeyActionEntry(d,k,sl,g) \
+	(XkbKeyHasActions(d,k)?\
+		XkbKeyAction(d,k,((XkbKeyGroupsWidth(d,k)*(g))+(sl))):NULL)
+
+#define	XkbKeyHasActions(d,k)	((d)->server->key_acts[k]!=0)
+#define	XkbKeyNumActions(d,k)	(XkbKeyHasActions(d,k)?XkbKeyNumSyms(d,k):1)
+#define	XkbKeyActionsPtr(d,k)	(XkbSMKeyActionsPtr((d)->server,k))
+#define	XkbKeycodeInRange(d,k)	(((k)>=(d)->min_key_code)&&\
+				 ((k)<=(d)->max_key_code))
+#define	XkbNumKeys(d)		((d)->max_key_code-(d)->min_key_code+1)
+
+
+	/*
+	 * The following structures can be used to track changes
+	 * to a keyboard device
+	 */
+typedef struct _XkbMapChanges {
+	unsigned short		 changed;
+	KeyCode			 min_key_code;
+	KeyCode			 max_key_code;
+	unsigned char		 first_type;
+	unsigned char		 num_types;
+	KeyCode			 first_key_sym;
+	unsigned char		 num_key_syms;
+	KeyCode			 first_key_act;
+	unsigned char		 num_key_acts;
+	KeyCode			 first_key_behavior;
+	unsigned char		 num_key_behaviors;
+	KeyCode 		 first_key_explicit;
+	unsigned char		 num_key_explicit;
+	KeyCode			 first_modmap_key;
+	unsigned char		 num_modmap_keys;
+	KeyCode			 first_vmodmap_key;
+	unsigned char		 num_vmodmap_keys;
+	unsigned char		 pad;
+	unsigned short		 vmods;
+} XkbMapChangesRec,*XkbMapChangesPtr;
+
+typedef struct _XkbControlsChanges {
+	unsigned int 		 changed_ctrls;
+	unsigned int		 enabled_ctrls_changes;
+	Bool			 num_groups_changed;
+} XkbControlsChangesRec,*XkbControlsChangesPtr;
+
+typedef struct _XkbIndicatorChanges {
+	unsigned int		 state_changes;
+	unsigned int		 map_changes;
+} XkbIndicatorChangesRec,*XkbIndicatorChangesPtr;
+
+typedef struct _XkbNameChanges {
+	unsigned int 		changed;
+	unsigned char		first_type;
+	unsigned char		num_types;
+	unsigned char		first_lvl;
+	unsigned char		num_lvls;
+	unsigned char		num_aliases;
+	unsigned char		num_rg;
+	unsigned char		first_key;
+	unsigned char		num_keys;
+	unsigned short		changed_vmods;
+	unsigned long		changed_indicators;
+	unsigned char		changed_groups;
+} XkbNameChangesRec,*XkbNameChangesPtr;
+
+typedef struct _XkbCompatChanges {
+	unsigned char		changed_groups;
+	unsigned short		first_si;
+	unsigned short		num_si;
+} XkbCompatChangesRec,*XkbCompatChangesPtr;
+
+typedef struct _XkbChanges {
+	unsigned short		 device_spec;
+	unsigned short		 state_changes;
+	XkbMapChangesRec	 map;
+	XkbControlsChangesRec	 ctrls;
+	XkbIndicatorChangesRec	 indicators;
+	XkbNameChangesRec	 names;
+	XkbCompatChangesRec	 compat;
+} XkbChangesRec, *XkbChangesPtr;
+
+	/*
+	 * These data structures are used to construct a keymap from
+	 * a set of components or to list components in the server
+	 * database.
+	 */
+typedef struct _XkbComponentNames {
+	char *			 keymap;
+	char *			 keycodes;
+	char *			 types;
+	char *			 compat;
+	char *			 symbols;
+	char *			 geometry;
+} XkbComponentNamesRec, *XkbComponentNamesPtr;
+
+typedef struct _XkbComponentName {
+	unsigned short		flags;
+	char *			name;
+} XkbComponentNameRec,*XkbComponentNamePtr;
+
+typedef struct _XkbComponentList {
+	int			num_keymaps;
+	int			num_keycodes;
+	int			num_types;
+	int			num_compat;
+	int			num_symbols;
+	int			num_geometry;
+	XkbComponentNamePtr	keymaps;
+	XkbComponentNamePtr 	keycodes;
+	XkbComponentNamePtr	types;
+	XkbComponentNamePtr	compat;
+	XkbComponentNamePtr	symbols;
+	XkbComponentNamePtr	geometry;
+} XkbComponentListRec, *XkbComponentListPtr;
+
+	/*
+	 * The following data structures describe and track changes to a
+	 * non-keyboard extension device
+	 */
+typedef struct _XkbDeviceLedInfo {
+	unsigned short			led_class;
+	unsigned short			led_id;
+	unsigned int			phys_indicators;
+	unsigned int			maps_present;
+	unsigned int			names_present;
+	unsigned int			state;
+	Atom 				names[XkbNumIndicators];
+	XkbIndicatorMapRec		maps[XkbNumIndicators];
+} XkbDeviceLedInfoRec,*XkbDeviceLedInfoPtr;
+
+typedef struct _XkbDeviceInfo {
+	char *			name;
+	Atom			type;
+	unsigned short		device_spec;
+	Bool			has_own_state;
+	unsigned short		supported;
+	unsigned short		unsupported;
+
+	/* btn_acts is an array of num_btn XkbAction entries */
+	unsigned short		num_btns;
+	XkbAction *		btn_acts;
+
+	unsigned short		sz_leds;
+	unsigned short		num_leds;
+	unsigned short		dflt_kbd_fb;
+	unsigned short		dflt_led_fb;
+	/* leds is an array of XkbDeviceLedInfoRec in which
+	   sz_leds entries are allocated and num_leds entries are used */
+	XkbDeviceLedInfoPtr	leds;
+} XkbDeviceInfoRec,*XkbDeviceInfoPtr;
+
+#define	XkbXI_DevHasBtnActs(d)	(((d)->num_btns>0)&&((d)->btn_acts!=NULL))
+#define	XkbXI_LegalDevBtn(d,b)	(XkbXI_DevHasBtnActs(d)&&((b)<(d)->num_btns))
+#define	XkbXI_DevHasLeds(d)	(((d)->num_leds>0)&&((d)->leds!=NULL))
+
+typedef struct _XkbDeviceLedChanges {
+	unsigned short		led_class;
+	unsigned short		led_id;
+	unsigned int		defined; /* names or maps changed */
+	struct _XkbDeviceLedChanges *next;
+} XkbDeviceLedChangesRec,*XkbDeviceLedChangesPtr;
+
+typedef struct _XkbDeviceChanges {
+	unsigned int		changed;
+	unsigned short		first_btn;
+	unsigned short		num_btns;
+	XkbDeviceLedChangesRec 	leds;
+} XkbDeviceChangesRec,*XkbDeviceChangesPtr;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif /* _XKBSTR_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/XResproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/XResproto.h
new file mode 100644
index 0000000..74cc876
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/XResproto.h
@@ -0,0 +1,227 @@
+/*
+   Copyright (c) 2002  XFree86 Inc
+*/
+
+#ifndef _XRESPROTO_H
+#define _XRESPROTO_H
+
+#define XRES_MAJOR_VERSION 1
+#define XRES_MINOR_VERSION 2
+
+#define XRES_NAME "X-Resource"
+
+/* v1.0 */
+#define X_XResQueryVersion            0
+#define X_XResQueryClients            1
+#define X_XResQueryClientResources    2
+#define X_XResQueryClientPixmapBytes  3
+
+/* Version 1.1 has been accidentally released from the version           */
+/* control and while it doesn't have differences to version 1.0, the     */
+/* next version is labeled 1.2 in order to remove the risk of confusion. */
+
+/* v1.2 */
+#define X_XResQueryClientIds          4
+#define X_XResQueryResourceBytes      5
+
+typedef struct {
+   CARD32 resource_base;
+   CARD32 resource_mask;
+} xXResClient;
+#define sz_xXResClient 8
+
+typedef struct {
+   CARD32 resource_type;
+   CARD32 count;
+} xXResType;
+#define sz_xXResType 8
+
+/* XResQueryVersion */
+
+typedef struct _XResQueryVersion {
+   CARD8   reqType;
+   CARD8   XResReqType;
+   CARD16  length;
+   CARD8   client_major;
+   CARD8   client_minor;
+   CARD16  unused;
+} xXResQueryVersionReq;
+#define sz_xXResQueryVersionReq 8
+
+typedef struct {
+   CARD8   type;
+   CARD8   pad1;
+   CARD16  sequenceNumber;
+   CARD32  length;
+   CARD16  server_major;
+   CARD16  server_minor;
+   CARD32  pad2;
+   CARD32  pad3;
+   CARD32  pad4;
+   CARD32  pad5;
+   CARD32  pad6;
+} xXResQueryVersionReply;
+#define sz_xXResQueryVersionReply  32
+
+/* XResQueryClients */
+
+typedef struct _XResQueryClients {
+   CARD8   reqType;
+   CARD8   XResReqType;
+   CARD16  length;
+} xXResQueryClientsReq;
+#define sz_xXResQueryClientsReq 4
+
+typedef struct {
+   CARD8   type;
+   CARD8   pad1;
+   CARD16  sequenceNumber;
+   CARD32  length;
+   CARD32  num_clients;
+   CARD32  pad2;
+   CARD32  pad3;
+   CARD32  pad4;
+   CARD32  pad5;
+   CARD32  pad6;
+} xXResQueryClientsReply;
+#define sz_xXResQueryClientsReply  32
+
+/* XResQueryClientResources */
+
+typedef struct _XResQueryClientResources {
+   CARD8   reqType;
+   CARD8   XResReqType;
+   CARD16  length;
+   CARD32  xid;
+} xXResQueryClientResourcesReq;
+#define sz_xXResQueryClientResourcesReq 8
+
+typedef struct {
+   CARD8   type;
+   CARD8   pad1;
+   CARD16  sequenceNumber;
+   CARD32  length;
+   CARD32  num_types;
+   CARD32  pad2;
+   CARD32  pad3;
+   CARD32  pad4;
+   CARD32  pad5;
+   CARD32  pad6;
+} xXResQueryClientResourcesReply;
+#define sz_xXResQueryClientResourcesReply  32
+
+/* XResQueryClientPixmapBytes */
+
+typedef struct _XResQueryClientPixmapBytes {
+   CARD8   reqType;
+   CARD8   XResReqType;
+   CARD16  length;
+   CARD32  xid;
+} xXResQueryClientPixmapBytesReq;
+#define sz_xXResQueryClientPixmapBytesReq 8
+
+typedef struct {
+   CARD8   type;
+   CARD8   pad1;
+   CARD16  sequenceNumber;
+   CARD32  length;
+   CARD32  bytes;
+   CARD32  bytes_overflow;
+   CARD32  pad2;
+   CARD32  pad3;
+   CARD32  pad4;
+   CARD32  pad5;
+} xXResQueryClientPixmapBytesReply;
+#define sz_xXResQueryClientPixmapBytesReply  32
+
+/* v1.2 XResQueryClientIds */
+
+#define X_XResClientXIDMask      0x01
+#define X_XResLocalClientPIDMask 0x02
+
+typedef struct _XResClientIdSpec {
+   CARD32  client;
+   CARD32  mask;
+} xXResClientIdSpec;
+#define sz_xXResClientIdSpec 8
+
+typedef struct _XResClientIdValue {
+   xXResClientIdSpec spec;
+   CARD32  length;
+   // followed by length CARD32s
+} xXResClientIdValue;
+#define sz_xResClientIdValue (sz_xXResClientIdSpec + 4)
+
+typedef struct _XResQueryClientIds {
+   CARD8   reqType;
+   CARD8   XResReqType;
+   CARD16  length;
+   CARD32  numSpecs;
+   // followed by numSpecs times XResClientIdSpec
+} xXResQueryClientIdsReq;
+#define sz_xXResQueryClientIdsReq 8
+
+typedef struct {
+   CARD8   type;
+   CARD8   pad1;
+   CARD16  sequenceNumber;
+   CARD32  length;
+   CARD32  numIds;
+   CARD32  pad2;
+   CARD32  pad3;
+   CARD32  pad4;
+   CARD32  pad5;
+   CARD32  pad6;
+   // followed by numIds times XResClientIdValue
+} xXResQueryClientIdsReply;
+#define sz_xXResQueryClientIdsReply  32
+
+/* v1.2 XResQueryResourceBytes */
+
+typedef struct _XResResourceIdSpec {
+   CARD32  resource;
+   CARD32  type;
+} xXResResourceIdSpec;
+#define sz_xXResResourceIdSpec 8
+
+typedef struct _XResQueryResourceBytes {
+   CARD8   reqType;
+   CARD8   XResReqType;
+   CARD16  length;
+   CARD32  client;
+   CARD32  numSpecs;
+   // followed by numSpecs times XResResourceIdSpec
+} xXResQueryResourceBytesReq;
+#define sz_xXResQueryResourceBytesReq 12
+
+typedef struct _XResResourceSizeSpec {
+   xXResResourceIdSpec spec;
+   CARD32  bytes;
+   CARD32  refCount;
+   CARD32  useCount;
+} xXResResourceSizeSpec;
+#define sz_xXResResourceSizeSpec (sz_xXResResourceIdSpec + 12)
+
+typedef struct _XResResourceSizeValue {
+   xXResResourceSizeSpec size;
+   CARD32  numCrossReferences;
+   // followed by numCrossReferences times XResResourceSizeSpec
+} xXResResourceSizeValue;
+#define sz_xXResResourceSizeValue (sz_xXResResourceSizeSpec + 4)
+
+typedef struct {
+   CARD8   type;
+   CARD8   pad1;
+   CARD16  sequenceNumber;
+   CARD32  length;
+   CARD32  numSizes;
+   CARD32  pad2;
+   CARD32  pad3;
+   CARD32  pad4;
+   CARD32  pad5;
+   CARD32  pad6;
+   // followed by numSizes times XResResourceSizeValue
+} xXResQueryResourceBytesReply;
+#define sz_xXResQueryResourceBytesReply  32
+
+#endif /* _XRESPROTO_H */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/Xeviestr.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/Xeviestr.h
new file mode 100644
index 0000000..78871f1
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/Xeviestr.h
@@ -0,0 +1,3 @@
+#warning "Xeviestr.h is obsolete and may be removed in the future."
+#warning "include <X11/extensions/evieproto.h> for the protocol defines."
+#include <X11/extensions/evieproto.h>
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/Xv.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/Xv.h
new file mode 100644
index 0000000..f662df6
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/Xv.h
@@ -0,0 +1,128 @@
+/***********************************************************
+Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts,
+and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Digital or MIT not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+#ifndef XV_H
+#define XV_H
+/*
+** File:
+**
+**   Xv.h --- Xv shared library and server header file
+**
+** Author:
+**
+**   David Carver (Digital Workstation Engineering/Project Athena)
+**
+** Revisions:
+**
+**   05.15.91 Carver
+**     - version 2.0 upgrade
+**
+**   01.24.91 Carver
+**     - version 1.4 upgrade
+**
+*/
+
+#include <X11/X.h>
+
+#define XvName "XVideo"
+#define XvVersion 2
+#define XvRevision 2
+
+/* Symbols */
+
+typedef XID XvPortID;
+typedef XID XvEncodingID;
+
+#define XvNone 0
+
+#define XvInput          0
+#define XvOutput         1
+
+#define XvInputMask      (1<<XvInput)
+#define XvOutputMask     (1<<XvOutput)
+#define XvVideoMask	 0x00000004
+#define XvStillMask	 0x00000008
+#define XvImageMask	 0x00000010
+
+/* These two are not client viewable */
+#define XvPixmapMask	 0x00010000
+#define XvWindowMask	 0x00020000
+
+
+#define XvGettable	0x01
+#define XvSettable	0x02
+
+#define XvRGB		0
+#define XvYUV		1
+
+#define XvPacked	0
+#define XvPlanar	1
+
+#define XvTopToBottom	0
+#define XvBottomToTop	1
+
+
+/* Events */
+
+#define XvVideoNotify 0
+#define XvPortNotify 1
+#define XvNumEvents 2
+
+/* Video Notify Reasons */
+
+#define XvStarted 0
+#define XvStopped 1
+#define XvBusy 2
+#define XvPreempted 3
+#define XvHardError 4
+#define XvLastReason 4
+
+#define XvNumReasons (XvLastReason + 1)
+
+#define XvStartedMask     (1<<XvStarted)
+#define XvStoppedMask     (1<<XvStopped)
+#define XvBusyMask        (1<<XvBusy)
+#define XvPreemptedMask   (1<<XvPreempted)
+#define XvHardErrorMask   (1<<XvHardError)
+
+#define XvAnyReasonMask   ((1<<XvNumReasons) - 1)
+#define XvNoReasonMask    0
+
+/* Errors */
+
+#define XvBadPort 0
+#define XvBadEncoding 1
+#define XvBadControl 2
+#define XvNumErrors 3
+
+/* Status */
+
+#define XvBadExtension 1
+#define XvAlreadyGrabbed 2
+#define XvInvalidTime 3
+#define XvBadReply 4
+#define XvBadAlloc 5
+
+#endif /* XV_H */
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/XvMC.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/XvMC.h
new file mode 100644
index 0000000..47cc6db
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/XvMC.h
@@ -0,0 +1,138 @@
+#ifndef _XVMC_H_
+#define _XVMC_H_
+
+#include <X11/X.h>
+#include <X11/extensions/Xv.h>
+
+#define XvMCName "XVideo-MotionCompensation"
+#define XvMCNumEvents 0
+#define XvMCNumErrors 3
+#define XvMCVersion 1
+#define XvMCRevision 1
+
+#define XvMCBadContext          0
+#define XvMCBadSurface          1
+#define XvMCBadSubpicture       2
+
+/* Chroma formats */
+#define XVMC_CHROMA_FORMAT_420          0x00000001
+#define XVMC_CHROMA_FORMAT_422          0x00000002
+#define XVMC_CHROMA_FORMAT_444          0x00000003
+
+/* XvMCSurfaceInfo Flags */
+#define XVMC_OVERLAID_SURFACE                   0x00000001
+#define XVMC_BACKEND_SUBPICTURE                 0x00000002
+#define XVMC_SUBPICTURE_INDEPENDENT_SCALING     0x00000004
+#define XVMC_INTRA_UNSIGNED                     0x00000008
+
+/* Motion Compensation types */
+#define XVMC_MOCOMP                     0x00000000
+#define XVMC_IDCT                       0x00010000
+
+#define XVMC_MPEG_1                     0x00000001
+#define XVMC_MPEG_2                     0x00000002
+#define XVMC_H263                       0x00000003
+#define XVMC_MPEG_4                     0x00000004
+
+#define XVMC_MB_TYPE_MOTION_FORWARD     0x02
+#define XVMC_MB_TYPE_MOTION_BACKWARD    0x04
+#define XVMC_MB_TYPE_PATTERN            0x08
+#define XVMC_MB_TYPE_INTRA              0x10
+
+#define XVMC_PREDICTION_FIELD           0x01
+#define XVMC_PREDICTION_FRAME           0x02
+#define XVMC_PREDICTION_DUAL_PRIME      0x03
+#define XVMC_PREDICTION_16x8            0x02
+#define XVMC_PREDICTION_4MV             0x04
+
+#define XVMC_SELECT_FIRST_FORWARD       0x01
+#define XVMC_SELECT_FIRST_BACKWARD      0x02
+#define XVMC_SELECT_SECOND_FORWARD      0x04
+#define XVMC_SELECT_SECOND_BACKWARD     0x08
+
+#define XVMC_DCT_TYPE_FRAME             0x00
+#define XVMC_DCT_TYPE_FIELD             0x01
+
+#define XVMC_TOP_FIELD          0x00000001
+#define XVMC_BOTTOM_FIELD       0x00000002
+#define XVMC_FRAME_PICTURE      (XVMC_TOP_FIELD | XVMC_BOTTOM_FIELD)
+
+#define XVMC_SECOND_FIELD       0x00000004
+
+#define XVMC_DIRECT             0x00000001
+
+#define XVMC_RENDERING          0x00000001
+#define XVMC_DISPLAYING         0x00000002
+
+
+typedef struct {
+   int surface_type_id;
+   int chroma_format;
+   unsigned short max_width;
+   unsigned short max_height;
+   unsigned short subpicture_max_width;
+   unsigned short subpicture_max_height;
+   int mc_type;
+   int flags;
+} XvMCSurfaceInfo;
+
+typedef struct {
+   XID context_id;
+   int surface_type_id;
+   unsigned short width;
+   unsigned short height;
+   XvPortID port;
+   int flags;
+   void * privData;  /* private to the library */
+} XvMCContext;
+
+typedef struct {
+  XID surface_id;
+  XID context_id;
+  int surface_type_id;
+  unsigned short width;
+  unsigned short height;
+  void *privData;  /* private to the library */
+} XvMCSurface;
+
+typedef struct {
+  XID subpicture_id;
+  XID context_id;
+  int xvimage_id;
+  unsigned short width;
+  unsigned short height;
+  int num_palette_entries;
+  int entry_bytes;
+  char component_order[4];
+  void *privData;    /* private to the library */
+} XvMCSubpicture;
+
+typedef struct {
+  unsigned int num_blocks;
+  XID context_id;
+  void *privData;
+  short *blocks;
+} XvMCBlockArray;
+
+typedef struct {
+   unsigned short x;
+   unsigned short y;
+   unsigned char macroblock_type;
+   unsigned char motion_type;
+   unsigned char motion_vertical_field_select;
+   unsigned char dct_type;
+   short PMV[2][2][2];
+   unsigned int index;
+   unsigned short coded_block_pattern;
+   unsigned short pad0;
+} XvMCMacroBlock;
+
+
+typedef struct {
+  unsigned int num_blocks;
+  XID context_id;
+  void *privData;
+  XvMCMacroBlock *macro_blocks;
+} XvMCMacroBlockArray;
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/XvMCproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/XvMCproto.h
new file mode 100644
index 0000000..d3b0171
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/XvMCproto.h
@@ -0,0 +1,226 @@
+#ifndef _XVMCPROTO_H_
+#define _XVMCPROTO_H_
+
+#define xvmc_QueryVersion		0
+#define xvmc_ListSurfaceTypes		1
+#define xvmc_CreateContext		2
+#define xvmc_DestroyContext		3
+#define xvmc_CreateSurface		4
+#define xvmc_DestroySurface		5
+#define xvmc_CreateSubpicture		6
+#define xvmc_DestroySubpicture		7
+#define xvmc_ListSubpictureTypes	8
+#define xvmc_GetDRInfo                  9
+#define xvmc_LastRequest		xvmc_GetDRInfo
+
+#define xvmcNumRequest			(xvmc_LastRequest + 1)
+
+
+typedef struct {
+  CARD32 surface_type_id;
+  CARD16 chroma_format;
+  CARD16 pad0;
+  CARD16 max_width;
+  CARD16 max_height;
+  CARD16 subpicture_max_width;
+  CARD16 subpicture_max_height;
+  CARD32 mc_type;
+  CARD32 flags;
+} xvmcSurfaceInfo;
+#define sz_xvmcSurfaceInfo 24
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvmcReqType;
+  CARD16 length;
+} xvmcQueryVersionReq;
+#define sz_xvmcQueryVersionReq 4
+
+typedef struct {
+  BYTE type;  /* X_Reply */
+  BYTE padb1;
+  CARD16 sequenceNumber;
+  CARD32 length;
+  CARD32 major;
+  CARD32 minor;
+  CARD32 padl4;
+  CARD32 padl5;
+  CARD32 padl6;
+  CARD32 padl7;
+} xvmcQueryVersionReply;
+#define sz_xvmcQueryVersionReply 32
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvmcReqType;
+  CARD16 length;
+  CARD32 port;
+} xvmcListSurfaceTypesReq;
+#define sz_xvmcListSurfaceTypesReq 8
+
+typedef struct {
+  BYTE type;  /* X_Reply */
+  BYTE padb1;
+  CARD16 sequenceNumber;
+  CARD32 length;
+  CARD32 num;
+  CARD32 padl3;
+  CARD32 padl4;
+  CARD32 padl5;
+  CARD32 padl6;
+  CARD32 padl7;
+} xvmcListSurfaceTypesReply;
+#define sz_xvmcListSurfaceTypesReply 32
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvmcReqType;
+  CARD16 length;
+  CARD32 context_id;
+  CARD32 port;
+  CARD32 surface_type_id;
+  CARD16 width;
+  CARD16 height;
+  CARD32 flags;
+} xvmcCreateContextReq;
+#define sz_xvmcCreateContextReq 24
+
+typedef struct {
+  BYTE type;  /* X_Reply */
+  BYTE padb1;
+  CARD16 sequenceNumber;
+  CARD32 length;
+  CARD16 width_actual;
+  CARD16 height_actual;
+  CARD32 flags_return;
+  CARD32 padl4;
+  CARD32 padl5;
+  CARD32 padl6;
+  CARD32 padl7;
+} xvmcCreateContextReply;
+#define sz_xvmcCreateContextReply 32
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvmcReqType;
+  CARD16 length;
+  CARD32 context_id;
+} xvmcDestroyContextReq;
+#define sz_xvmcDestroyContextReq 8
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvmcReqType;
+  CARD16 length;
+  CARD32 surface_id;
+  CARD32 context_id;
+} xvmcCreateSurfaceReq;
+#define sz_xvmcCreateSurfaceReq 12
+
+typedef struct {
+  BYTE type;  /* X_Reply */
+  BYTE padb1;
+  CARD16 sequenceNumber;
+  CARD32 length;
+  CARD32 padl2;
+  CARD32 padl3;
+  CARD32 padl4;
+  CARD32 padl5;
+  CARD32 padl6;
+  CARD32 padl7;
+} xvmcCreateSurfaceReply;
+#define sz_xvmcCreateSurfaceReply 32
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvmcReqType;
+  CARD16 length;
+  CARD32 surface_id;
+} xvmcDestroySurfaceReq;
+#define sz_xvmcDestroySurfaceReq 8
+
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvmcReqType;
+  CARD16 length;
+  CARD32 subpicture_id;
+  CARD32 context_id;
+  CARD32 xvimage_id;
+  CARD16 width;
+  CARD16 height;
+} xvmcCreateSubpictureReq;
+#define sz_xvmcCreateSubpictureReq 20
+
+typedef struct {
+  BYTE type;  /* X_Reply */
+  BYTE padb1;
+  CARD16 sequenceNumber;
+  CARD32 length;
+  CARD16 width_actual;
+  CARD16 height_actual;
+  CARD16 num_palette_entries;
+  CARD16 entry_bytes;
+  CARD8  component_order[4];
+  CARD32 padl5;
+  CARD32 padl6;
+  CARD32 padl7;
+} xvmcCreateSubpictureReply;
+#define sz_xvmcCreateSubpictureReply 32
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvmcReqType;
+  CARD16 length;
+  CARD32 subpicture_id;
+} xvmcDestroySubpictureReq;
+#define sz_xvmcDestroySubpictureReq 8
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvmcReqType;
+  CARD16 length;
+  CARD32 port;
+  CARD32 surface_type_id;
+} xvmcListSubpictureTypesReq;
+#define sz_xvmcListSubpictureTypesReq 12
+
+typedef struct {
+  BYTE type;  /* X_Reply */
+  BYTE padb1;
+  CARD16 sequenceNumber;
+  CARD32 length;
+  CARD32 num;
+  CARD32 padl2;
+  CARD32 padl3;
+  CARD32 padl4;
+  CARD32 padl5;
+  CARD32 padl6;
+} xvmcListSubpictureTypesReply;
+#define sz_xvmcListSubpictureTypesReply 32
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvmcReqType;
+  CARD16 length;
+  CARD32 port;
+  CARD32 shmKey;
+  CARD32 magic;
+} xvmcGetDRInfoReq;
+#define sz_xvmcGetDRInfoReq 16
+
+typedef struct {
+  BYTE type;  /* X_Reply */
+  BYTE padb1;
+  CARD16 sequenceNumber;
+  CARD32 length;
+  CARD32 major;
+  CARD32 minor;
+  CARD32 patchLevel;
+  CARD32 nameLen;
+  CARD32 busIDLen;
+  CARD32 isLocal;
+} xvmcGetDRInfoReply;
+#define sz_xvmcGetDRInfoReply 32
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/Xvproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/Xvproto.h
new file mode 100644
index 0000000..6e7ea08
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/Xvproto.h
@@ -0,0 +1,603 @@
+/***********************************************************
+Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts,
+and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Digital or MIT not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+#ifndef XVPROTO_H
+#define XVPROTO_H
+/*
+** File:
+**
+**   Xvproto.h --- Xv protocol header file
+**
+** Author:
+**
+**   David Carver (Digital Workstation Engineering/Project Athena)
+**
+** Revisions:
+**
+**   11.06.91 Carver
+**     - changed SetPortControl to SetPortAttribute
+**     - changed GetPortControl to GetPortAttribute
+**     - changed QueryBestSize
+**
+**   15.05.91 Carver
+**     - version 2.0 upgrade
+**
+**   24.01.91 Carver
+**     - version 1.4 upgrade
+**
+*/
+
+#include <X11/Xmd.h>
+
+/* Symbols: These are undefined at the end of this file to restore the
+   values they have in Xv.h */
+
+#define XvPortID CARD32
+#define XvEncodingID CARD32
+#define ShmSeg CARD32
+#define VisualID CARD32
+#define Drawable CARD32
+#define GContext CARD32
+#define Time CARD32
+#define Atom CARD32
+
+/* Structures */
+
+typedef struct {
+  INT32 numerator;
+  INT32 denominator;
+} xvRational;
+#define sz_xvRational 8
+
+typedef struct {
+  XvPortID base_id;
+  CARD16 name_size;
+  CARD16 num_ports;
+  CARD16 num_formats;
+  CARD8 type;
+  CARD8 pad;
+} xvAdaptorInfo;
+#define sz_xvAdaptorInfo 12
+
+typedef struct {
+  XvEncodingID encoding;
+  CARD16 name_size;
+  CARD16 width, height;
+  CARD16 pad;
+  xvRational rate;
+} xvEncodingInfo;
+#define sz_xvEncodingInfo (12 + sz_xvRational)
+
+typedef struct {
+  VisualID visual;
+  CARD8 depth;
+  CARD8 pad1;
+  CARD16 pad2;
+} xvFormat;
+#define sz_xvFormat 8
+
+typedef struct {
+  CARD32 flags;
+  INT32 min;
+  INT32 max;
+  CARD32 size;
+} xvAttributeInfo;
+#define sz_xvAttributeInfo 16
+
+typedef struct {
+  CARD32 id;
+  CARD8 type;
+  CARD8 byte_order;
+  CARD16 pad1;
+  CARD8 guid[16];
+  CARD8 bpp;
+  CARD8 num_planes;
+  CARD16 pad2;
+  CARD8 depth;
+  CARD8 pad3;
+  CARD16 pad4;
+  CARD32 red_mask;
+  CARD32 green_mask;
+  CARD32 blue_mask;
+  CARD8 format;
+  CARD8 pad5;
+  CARD16 pad6;
+  CARD32 y_sample_bits;
+  CARD32 u_sample_bits;
+  CARD32 v_sample_bits;
+  CARD32 horz_y_period;
+  CARD32 horz_u_period;
+  CARD32 horz_v_period;
+  CARD32 vert_y_period;
+  CARD32 vert_u_period;
+  CARD32 vert_v_period;
+  CARD8 comp_order[32];
+  CARD8 scanline_order;
+  CARD8 pad7;
+  CARD16 pad8;
+  CARD32 pad9;
+  CARD32 pad10;
+} xvImageFormatInfo;
+#define sz_xvImageFormatInfo 128
+
+
+/* Requests */
+
+#define xv_QueryExtension                  0
+#define	xv_QueryAdaptors                   1
+#define	xv_QueryEncodings                  2
+#define xv_GrabPort                        3
+#define xv_UngrabPort                      4
+#define xv_PutVideo                        5
+#define xv_PutStill                        6
+#define xv_GetVideo                        7
+#define xv_GetStill                        8
+#define xv_StopVideo                       9
+#define xv_SelectVideoNotify              10
+#define xv_SelectPortNotify               11
+#define xv_QueryBestSize                  12
+#define xv_SetPortAttribute               13
+#define xv_GetPortAttribute               14
+#define xv_QueryPortAttributes            15
+#define xv_ListImageFormats               16
+#define xv_QueryImageAttributes           17
+#define xv_PutImage                       18
+#define xv_ShmPutImage                    19
+#define xv_LastRequest                    xv_ShmPutImage
+
+#define xvNumRequests                     (xv_LastRequest + 1)
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvReqType;
+  CARD16 length;
+} xvQueryExtensionReq;
+#define sz_xvQueryExtensionReq 4
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvReqType;
+  CARD16 length;
+  CARD32 window;
+} xvQueryAdaptorsReq;
+#define sz_xvQueryAdaptorsReq 8
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvReqType;
+  CARD16 length;
+  CARD32 port;
+} xvQueryEncodingsReq;
+#define sz_xvQueryEncodingsReq 8
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvReqType;
+  CARD16 length;
+  XvPortID port;
+  Drawable drawable;
+  GContext gc;
+  INT16 vid_x;
+  INT16 vid_y;
+  CARD16 vid_w;
+  CARD16 vid_h;
+  INT16 drw_x;
+  INT16 drw_y;
+  CARD16 drw_w;
+  CARD16 drw_h;
+} xvPutVideoReq;
+#define sz_xvPutVideoReq 32
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvReqType;
+  CARD16 length;
+  XvPortID port;
+  Drawable drawable;
+  GContext gc;
+  INT16 vid_x;
+  INT16 vid_y;
+  CARD16 vid_w;
+  CARD16 vid_h;
+  INT16 drw_x;
+  INT16 drw_y;
+  CARD16 drw_w;
+  CARD16 drw_h;
+} xvPutStillReq;
+#define sz_xvPutStillReq 32
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvReqType;
+  CARD16 length;
+  XvPortID port;
+  Drawable drawable;
+  GContext gc;
+  INT16 vid_x;
+  INT16 vid_y;
+  CARD16 vid_w;
+  CARD16 vid_h;
+  INT16 drw_x;
+  INT16 drw_y;
+  CARD16 drw_w;
+  CARD16 drw_h;
+} xvGetVideoReq;
+#define sz_xvGetVideoReq 32
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvReqType;
+  CARD16 length;
+  XvPortID port;
+  Drawable drawable;
+  GContext gc;
+  INT16 vid_x;
+  INT16 vid_y;
+  CARD16 vid_w;
+  CARD16 vid_h;
+  INT16 drw_x;
+  INT16 drw_y;
+  CARD16 drw_w;
+  CARD16 drw_h;
+} xvGetStillReq;
+#define sz_xvGetStillReq 32
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvReqType;
+  CARD16 length;
+  XvPortID port;
+  Time time;
+} xvGrabPortReq;
+#define sz_xvGrabPortReq 12
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvReqType;
+  CARD16 length;
+  XvPortID port;
+  Time time;
+} xvUngrabPortReq;
+#define sz_xvUngrabPortReq 12
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvReqType;
+  CARD16 length;
+  Drawable drawable;
+  BOOL onoff;
+  CARD8 pad1;
+  CARD16 pad2;
+} xvSelectVideoNotifyReq;
+#define sz_xvSelectVideoNotifyReq 12
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvReqType;
+  CARD16 length;
+  XvPortID port;
+  BOOL onoff;
+  CARD8 pad1;
+  CARD16 pad2;
+} xvSelectPortNotifyReq;
+#define sz_xvSelectPortNotifyReq 12
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvReqType;
+  CARD16 length;
+  XvPortID port;
+  Drawable drawable;
+} xvStopVideoReq;
+#define sz_xvStopVideoReq 12
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvReqType;
+  CARD16 length;
+  XvPortID port;
+  Atom attribute;
+  INT32 value;
+} xvSetPortAttributeReq;
+#define sz_xvSetPortAttributeReq 16
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvReqType;
+  CARD16 length;
+  XvPortID port;
+  Atom attribute;
+} xvGetPortAttributeReq;
+#define sz_xvGetPortAttributeReq 12
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvReqType;
+  CARD16 length;
+  XvPortID port;
+  CARD16 vid_w;
+  CARD16 vid_h;
+  CARD16 drw_w;
+  CARD16 drw_h;
+  CARD8 motion;
+  CARD8 pad1;
+  CARD16 pad2;
+} xvQueryBestSizeReq;
+#define sz_xvQueryBestSizeReq 20
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvReqType;
+  CARD16 length;
+  XvPortID port;
+} xvQueryPortAttributesReq;
+#define sz_xvQueryPortAttributesReq 8
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvReqType;
+  CARD16 length;
+  XvPortID port;
+  Drawable drawable;
+  GContext gc;
+  CARD32 id;
+  INT16 src_x;
+  INT16 src_y;
+  CARD16 src_w;
+  CARD16 src_h;
+  INT16 drw_x;
+  INT16 drw_y;
+  CARD16 drw_w;
+  CARD16 drw_h;
+  CARD16 width;
+  CARD16 height;
+} xvPutImageReq;
+#define sz_xvPutImageReq 40
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvReqType;
+  CARD16 length;
+  XvPortID port;
+  Drawable drawable;
+  GContext gc;
+  ShmSeg shmseg;
+  CARD32 id;
+  CARD32 offset;
+  INT16 src_x;
+  INT16 src_y;
+  CARD16 src_w;
+  CARD16 src_h;
+  INT16 drw_x;
+  INT16 drw_y;
+  CARD16 drw_w;
+  CARD16 drw_h;
+  CARD16 width;
+  CARD16 height;
+  CARD8 send_event;
+  CARD8 pad1;
+  CARD16 pad2;
+} xvShmPutImageReq;
+#define sz_xvShmPutImageReq 52
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvReqType;
+  CARD16 length;
+  XvPortID port;
+} xvListImageFormatsReq;
+#define sz_xvListImageFormatsReq 8
+
+typedef struct {
+  CARD8 reqType;
+  CARD8 xvReqType;
+  CARD16 length;
+  CARD32 port;
+  CARD32 id;
+  CARD16 width;
+  CARD16 height;
+} xvQueryImageAttributesReq;
+#define sz_xvQueryImageAttributesReq 16
+
+
+/* Replies */
+
+typedef struct _QueryExtensionReply {
+  BYTE type;   /* X_Reply */
+  CARD8 padb1;
+  CARD16 sequenceNumber;
+  CARD32 length;
+  CARD16 version;
+  CARD16 revision;
+  CARD32 padl4;
+  CARD32 padl5;
+  CARD32 padl6;
+  CARD32 padl7;
+  CARD32 padl8;
+} xvQueryExtensionReply;
+#define sz_xvQueryExtensionReply 32
+
+typedef struct _QueryAdaptorsReply {
+  BYTE type;   /* X_Reply */
+  CARD8 padb1;
+  CARD16 sequenceNumber;
+  CARD32 length;
+  CARD16 num_adaptors;
+  CARD16 pads3;
+  CARD32 padl4;
+  CARD32 padl5;
+  CARD32 padl6;
+  CARD32 padl7;
+  CARD32 padl8;
+} xvQueryAdaptorsReply;
+#define sz_xvQueryAdaptorsReply 32
+
+typedef struct _QueryEncodingsReply {
+  BYTE type;   /* X_Reply */
+  CARD8 padb1;
+  CARD16 sequenceNumber;
+  CARD32 length;
+  CARD16 num_encodings;
+  CARD16 padl3;
+  CARD32 padl4;
+  CARD32 padl5;
+  CARD32 padl6;
+  CARD32 padl7;
+  CARD32 padl8;
+} xvQueryEncodingsReply;
+#define sz_xvQueryEncodingsReply 32
+
+typedef struct {
+  BYTE type;  /* X_Reply */
+  BYTE result;
+  CARD16 sequenceNumber;
+  CARD32 length;  /* 0 */
+  CARD32 padl3;
+  CARD32 padl4;
+  CARD32 padl5;
+  CARD32 padl6;
+  CARD32 padl7;
+  CARD32 padl8;
+} xvGrabPortReply;
+#define sz_xvGrabPortReply 32
+
+typedef struct {
+  BYTE type;  /* X_Reply */
+  BYTE padb1;
+  CARD16 sequenceNumber;
+  CARD32 length;  /* 0 */
+  INT32 value;
+  CARD32 padl4;
+  CARD32 padl5;
+  CARD32 padl6;
+  CARD32 padl7;
+  CARD32 padl8;
+} xvGetPortAttributeReply;
+#define sz_xvGetPortAttributeReply 32
+
+typedef struct {
+  BYTE type;  /* X_Reply */
+  BYTE padb1;
+  CARD16 sequenceNumber;
+  CARD32 length;  /* 0 */
+  CARD16 actual_width;
+  CARD16 actual_height;
+  CARD32 padl4;
+  CARD32 padl5;
+  CARD32 padl6;
+  CARD32 padl7;
+  CARD32 padl8;
+} xvQueryBestSizeReply;
+#define sz_xvQueryBestSizeReply 32
+
+typedef struct {
+  BYTE type;  /* X_Reply */
+  BYTE padb1;
+  CARD16 sequenceNumber;
+  CARD32 length;  /* 0 */
+  CARD32 num_attributes;
+  CARD32 text_size;
+  CARD32 padl5;
+  CARD32 padl6;
+  CARD32 padl7;
+  CARD32 padl8;
+} xvQueryPortAttributesReply;
+#define sz_xvQueryPortAttributesReply 32
+
+typedef struct {
+  BYTE type;  /* X_Reply */
+  BYTE padb1;
+  CARD16 sequenceNumber;
+  CARD32 length;
+  CARD32 num_formats;
+  CARD32 padl4;
+  CARD32 padl5;
+  CARD32 padl6;
+  CARD32 padl7;
+  CARD32 padl8;
+} xvListImageFormatsReply;
+#define sz_xvListImageFormatsReply 32
+
+typedef struct {
+  BYTE type;  /* X_Reply */
+  BYTE padb1;
+  CARD16 sequenceNumber;
+  CARD32 length;
+  CARD32 num_planes;
+  CARD32 data_size;
+  CARD16 width;
+  CARD16 height;
+  CARD32 padl6;
+  CARD32 padl7;
+  CARD32 padl8;
+} xvQueryImageAttributesReply;
+#define sz_xvQueryImageAttributesReply 32
+
+/* DEFINE EVENT STRUCTURE */
+
+typedef struct {
+  union {
+    struct {
+      BYTE type;
+      BYTE detail;
+      CARD16 sequenceNumber;
+    } u;
+    struct {
+      BYTE type;
+      BYTE reason;
+      CARD16 sequenceNumber;
+      Time time;
+      Drawable drawable;
+      XvPortID port;
+      CARD32 padl5;
+      CARD32 padl6;
+      CARD32 padl7;
+      CARD32 padl8;
+    } videoNotify;
+    struct {
+      BYTE type;
+      BYTE padb1;
+      CARD16 sequenceNumber;
+      Time time;
+      XvPortID port;
+      Atom attribute;
+      INT32 value;
+      CARD32 padl6;
+      CARD32 padl7;
+      CARD32 padl8;
+    } portNotify;
+  } u;
+} xvEvent;
+
+#undef XvPortID
+#undef XvEncodingID
+#undef ShmSeg
+#undef VisualID
+#undef Drawable
+#undef GContext
+#undef Time
+#undef Atom
+
+#endif /* XVPROTO_H */
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/ag.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/ag.h
new file mode 100644
index 0000000..be5883a
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/ag.h
@@ -0,0 +1,52 @@
+/*
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+*/
+
+#ifndef _AG_H_
+#define _AG_H_
+
+#define XAGNAME "XC-APPGROUP"
+
+#define XAG_MAJOR_VERSION	1	/* current version numbers */
+#define XAG_MINOR_VERSION	0
+
+#define XagWindowTypeX11	0
+#define XagWindowTypeMacintosh	1
+#define XagWindowTypeWin32	2
+#define XagWindowTypeWin16	3
+
+#define XagBadAppGroup			0
+#define XagNumberErrors			(XagBadAppGroup + 1)
+
+#define XagNsingleScreen		7
+#define XagNdefaultRoot			1
+#define XagNrootVisual			2
+#define XagNdefaultColormap		3
+#define XagNblackPixel			4
+#define XagNwhitePixel			5
+#define XagNappGroupLeader		6
+
+#endif /* _AG_H_ */
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/agproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/agproto.h
new file mode 100644
index 0000000..803099d
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/agproto.h
@@ -0,0 +1,178 @@
+/*
+Copyright 1996, 1998, 2001  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+*/
+
+#ifndef _AGPROTO_H_ /* { */
+#define _AGPROTO_H_
+
+#include <X11/extensions/ag.h>
+
+#define X_XagQueryVersion		0
+#define X_XagCreate			1
+#define X_XagDestroy			2
+#define X_XagGetAttr			3
+#define X_XagQuery			4
+#define X_XagCreateAssoc		5
+#define X_XagDestroyAssoc		6
+
+#define XAppGroup CARD32
+
+/*
+* Redefine some basic types used by structures defined herein.  This allows
+* both the library and server to view communicated data as 32-bit entities,
+* thus preventing problems on 64-bit architectures where libXext sees this
+* data as 64 bits and the server sees it as 32 bits.
+*/
+
+#define Colormap CARD32
+#define VisualID CARD32
+#define Window CARD32
+
+typedef struct _XagQueryVersion {
+    CARD8	reqType;	/* always XagReqCode */
+    CARD8	xagReqType;	/* always X_XagQueryVersion */
+    CARD16	length;
+    CARD16	client_major_version;
+    CARD16	client_minor_version;
+} xXagQueryVersionReq;
+#define sz_xXagQueryVersionReq		8
+
+typedef struct {
+    BYTE	type;		/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequence_number;
+    CARD32	length;
+    CARD16	server_major_version;
+    CARD16	server_minor_version;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXagQueryVersionReply;
+#define sz_xXagQueryVersionReply	32
+
+/* Set AppGroup Attributes masks */
+#define XagSingleScreenMask		1 << 0
+#define XagDefaultRootMask		1 << XagNdefaultRoot
+#define XagRootVisualMask		1 << XagNrootVisual
+#define XagDefaultColormapMask		1 << XagNdefaultColormap
+#define XagBlackPixelMask		1 << XagNblackPixel
+#define XagWhitePixelMask		1 << XagNwhitePixel
+#define XagAppGroupLeaderMask		1 << XagNappGroupLeader
+
+typedef struct _XagCreate {
+    CARD8	reqType;	/* always XagReqCode */
+    CARD8	xagReqType;	/* always X_XagCreate */
+    CARD16	length;
+    XAppGroup	app_group;
+    CARD32	attrib_mask;	/* LISTofVALUE follows */
+} xXagCreateReq;
+#define sz_xXagCreateReq		12
+
+typedef struct _XagDestroy {
+    CARD8	reqType;	/* always XagReqCode */
+    CARD8	xagReqType;	/* always X_XagDestroy */
+    CARD16	length;
+    XAppGroup	app_group;
+} xXagDestroyReq;
+#define sz_xXagDestroyReq		8
+
+typedef struct _XagGetAttr {
+    CARD8	reqType;	/* always XagReqCode */
+    CARD8	xagReqType;	/* always X_XagGetAttr */
+    CARD16	length;
+    XAppGroup	app_group;
+} xXagGetAttrReq;
+#define sz_xXagGetAttrReq		8
+
+typedef struct {
+    BYTE	type;		/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequence_number;
+    CARD32	length;
+    Window	default_root;
+    VisualID	root_visual;
+    Colormap	default_colormap;
+    CARD32	black_pixel;
+    CARD32	white_pixel;
+    BOOL	single_screen;
+    BOOL	app_group_leader;
+    CARD16	pad2;
+} xXagGetAttrReply;
+#define sz_xXagGetAttrReply		32
+
+typedef struct _XagQuery {
+    CARD8	reqType;	/* always XagReqCode */
+    CARD8	xagReqType;	/* always X_XagQuery */
+    CARD16	length;
+    CARD32	resource;
+} xXagQueryReq;
+#define sz_xXagQueryReq			8
+
+typedef struct {
+    BYTE	type;		/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequence_number;
+    CARD32	length;
+    XAppGroup	app_group;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXagQueryReply;
+#define sz_xXagQueryReply		32
+
+typedef struct _XagCreateAssoc {
+    CARD8	reqType;	/* always XagReqCode */
+    CARD8	xagReqType;	/* always X_XagCreateAssoc */
+    CARD16	length;
+    Window	window;
+    CARD16	window_type;
+    CARD16	system_window_len; /* LISTofCARD8 follows */
+} xXagCreateAssocReq;
+#define sz_xXagCreateAssocReq		12
+
+typedef struct _XagDestroyAssoc {
+    CARD8	reqType;	/* always XagReqCode */
+    CARD8	xagReqType;	/* always X_XagDestroyAssoc */
+    CARD16	length;
+    Window	window;
+} xXagDestroyAssocReq;
+#define sz_xXagDestroyAssocReq		8
+
+#undef XAppGroup
+/*
+ * Cancel the previous redefinition of the basic types, thus restoring their
+ * X.h definitions.
+ */
+
+#undef Window
+#undef Colormap
+#undef VisualID
+
+#endif /* } _AGPROTO_H_ */
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/applewmconst.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/applewmconst.h
new file mode 100644
index 0000000..4877c34
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/applewmconst.h
@@ -0,0 +1,84 @@
+/**************************************************************************
+
+Copyright (c) 2002 Apple Computer, Inc.
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sub license, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice (including the
+next paragraph) shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+**************************************************************************/
+
+#ifndef _APPLEWMCONST_H_
+#define _APPLEWMCONST_H_
+
+/* Events */
+#define AppleWMControllerNotify		0
+#define AppleWMActivationNotify		1
+#define AppleWMPasteboardNotify		2
+#define AppleWMNumberEvents		3
+
+#define AppleWMControllerNotifyMask	(1L << 0)
+#define AppleWMActivationNotifyMask	(1L << 1)
+#define AppleWMPasteboardNotifyMask	(1L << 2)
+
+/* "Kinds" of ControllerNotify events */
+#define AppleWMMinimizeWindow		0
+#define AppleWMZoomWindow		1
+#define AppleWMCloseWindow		2
+#define AppleWMBringAllToFront		3
+#define AppleWMHideWindow		4
+#define AppleWMHideAll			5
+#define AppleWMShowAll			6
+#define AppleWMWindowMenuItem		9
+#define AppleWMWindowMenuNotify		10
+#define AppleWMNextWindow		11
+#define AppleWMPreviousWindow		12
+
+/* "Kinds" of ActivationNotify events */
+#define AppleWMIsActive			0
+#define AppleWMIsInactive		1
+#define AppleWMReloadPreferences	2
+
+/* "Kinds" of PasteboardNotify events */
+#define AppleWMCopyToPasteboard		0
+
+/* Errors */
+#define AppleWMClientNotLocal		0
+#define AppleWMOperationNotSupported	1
+#define AppleWMNumberErrors		(AppleWMOperationNotSupported + 1)
+
+/* Window level ids */
+#define AppleWMWindowLevelNormal	0
+#define AppleWMWindowLevelFloating	1
+#define AppleWMWindowLevelTornOff	2
+#define AppleWMWindowLevelDock		3
+#define AppleWMWindowLevelDesktop	4
+#define AppleWMNumWindowLevels		5
+
+/* Possible value for frame_rect argument to XAppleWMFrameGetRect() */
+/* Use xp_frame_rect_enum from <Xplugin.h> */
+
+/* Window frame classes */
+/* Use xp_frame_class_enum from <Xplugin.h> */
+
+/* Window frame attributes */
+/* Use xp_frame_attr_enum from <Xplugin.h> */
+
+#endif /* _APPLEWMCONST_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/applewmproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/applewmproto.h
new file mode 100644
index 0000000..9141736
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/applewmproto.h
@@ -0,0 +1,293 @@
+/**************************************************************************
+
+Copyright (c) 2002 Apple Computer, Inc.
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sub license, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice (including the
+next paragraph) shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+**************************************************************************/
+
+#ifndef _APPLEWMPROTO_H_
+#define _APPLEWMPROTO_H_
+
+#include <X11/extensions/applewmconst.h>
+#include <X11/X.h>
+#include <X11/Xmd.h>
+
+#define APPLEWMNAME "Apple-WM"
+
+#define APPLE_WM_MAJOR_VERSION	1	/* current version numbers */
+#define APPLE_WM_MINOR_VERSION	3
+#define APPLE_WM_PATCH_VERSION	0
+
+#define X_AppleWMQueryVersion		0
+#define X_AppleWMFrameGetRect		1
+#define X_AppleWMFrameHitTest		2
+#define X_AppleWMFrameDraw		3
+#define X_AppleWMDisableUpdate		4
+#define X_AppleWMReenableUpdate		5
+#define X_AppleWMSelectInput		6
+#define X_AppleWMSetWindowMenuCheck	7
+#define X_AppleWMSetFrontProcess	8
+#define X_AppleWMSetWindowLevel		9
+#define X_AppleWMSetCanQuit		10
+#define X_AppleWMSetWindowMenu		11
+#define X_AppleWMSendPSN		12
+#define X_AppleWMAttachTransient	13
+
+/* For the purpose of the structure definitions in this file,
+we must redefine the following types in terms of Xmd.h's types, which may
+include bit fields.  All of these are #undef'd at the end of this file,
+restoring the definitions in X.h.  */
+
+#define Window CARD32
+#define Drawable CARD32
+#define Font CARD32
+#define Pixmap CARD32
+#define Cursor CARD32
+#define Colormap CARD32
+#define GContext CARD32
+#define Atom CARD32
+#define VisualID CARD32
+#define Time CARD32
+#define KeyCode CARD8
+#define KeySym CARD32
+
+typedef struct _AppleWMQueryVersion {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_AppleWMQueryVersion */
+    CARD16	length;
+} xAppleWMQueryVersionReq;
+#define sz_xAppleWMQueryVersionReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	majorVersion;		/* major version of WM protocol */
+    CARD16	minorVersion;		/* minor version of WM protocol */
+    CARD32	patchVersion;		/* patch version of WM protocol */
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xAppleWMQueryVersionReply;
+#define sz_xAppleWMQueryVersionReply	32
+
+typedef struct _AppleWMDisableUpdate {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_AppleWMDisableUpdate */
+    CARD16	length;
+    CARD32	screen;
+} xAppleWMDisableUpdateReq;
+#define sz_xAppleWMDisableUpdateReq	8
+
+typedef struct _AppleWMReenableUpdate {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_AppleWMReenableUpdate */
+    CARD16	length;
+    CARD32	screen;
+} xAppleWMReenableUpdateReq;
+#define sz_xAppleWMReenableUpdateReq	8
+
+typedef struct _AppleWMSelectInput {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_AppleWMSelectInput */
+    CARD16	length;
+    CARD32	mask;
+} xAppleWMSelectInputReq;
+#define sz_xAppleWMSelectInputReq	8
+
+typedef struct _AppleWMNotify {
+	BYTE	type;		/* always eventBase + event type */
+	BYTE	kind;
+	CARD16	sequenceNumber;
+	Time	time;		/* time of change */
+	CARD16	pad1;
+	CARD32	arg;
+	CARD32	pad3;
+	CARD32  pad4;
+	CARD32  pad5;
+	CARD32  pad6;
+} xAppleWMNotifyEvent;
+#define sz_xAppleWMNotifyEvent	32
+
+typedef struct _AppleWMSetWindowMenu {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_AppleWMSetWindowMenu */
+    CARD16	length;
+    CARD16	nitems;
+    CARD16	pad1;
+} xAppleWMSetWindowMenuReq;
+#define sz_xAppleWMSetWindowMenuReq	8
+
+typedef struct _AppleWMSetWindowMenuCheck {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_AppleWMSetWindowMenuCheck */
+    CARD16	length;
+    CARD32	index;
+} xAppleWMSetWindowMenuCheckReq;
+#define sz_xAppleWMSetWindowMenuCheckReq 8
+
+typedef struct _AppleWMSetFrontProcess {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_AppleWMSetFrontProcess */
+    CARD16	length;
+} xAppleWMSetFrontProcessReq;
+#define sz_xAppleWMSetFrontProcessReq 4
+
+typedef struct _AppleWMSetWindowLevel {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_AppleWMSetWindowLevel */
+    CARD16	length;
+    CARD32	window;
+    CARD32	level;
+} xAppleWMSetWindowLevelReq;
+#define sz_xAppleWMSetWindowLevelReq 12
+
+typedef struct _AppleWMSendPSN {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_AppleWMSendPSN */
+    CARD16	length;
+    CARD32	psn_hi;
+    CARD32	psn_lo;
+} xAppleWMSendPSNReq;
+#define sz_xAppleWMSendPSNReq 12
+
+typedef struct _AppleWMAttachTransient {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_AppleWMAttachTransient */
+    CARD16	length;
+    CARD32	child;
+    CARD32	parent;
+} xAppleWMAttachTransientReq;
+#define sz_xAppleWMAttachTransientReq 12
+
+typedef struct _AppleWMSetCanQuit {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_AppleWMSetCanQuit */
+    CARD16	length;
+    CARD32	state;
+} xAppleWMSetCanQuitReq;
+#define sz_xAppleWMSetCanQuitReq 8
+
+typedef struct _AppleWMFrameGetRect {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_AppleWMFrameGetRect */
+    CARD16	length;
+    CARD16	frame_class;
+    CARD16	frame_rect;
+    CARD16	ix;
+    CARD16	iy;
+    CARD16	iw;
+    CARD16	ih;
+    CARD16	ox;
+    CARD16	oy;
+    CARD16	ow;
+    CARD16	oh;
+} xAppleWMFrameGetRectReq;
+#define sz_xAppleWMFrameGetRectReq	24
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	x;
+    CARD16	y;
+    CARD16	w;
+    CARD16	h;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xAppleWMFrameGetRectReply;
+#define sz_xAppleWMFrameGetRectReply	32
+
+typedef struct _AppleWMFrameHitTest {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_AppleWMFrameHitTest */
+    CARD16	length;
+    CARD16	frame_class;
+    CARD16	pad1;
+    CARD16	px;
+    CARD16	py;
+    CARD16	ix;
+    CARD16	iy;
+    CARD16	iw;
+    CARD16	ih;
+    CARD16	ox;
+    CARD16	oy;
+    CARD16	ow;
+    CARD16	oh;
+} xAppleWMFrameHitTestReq;
+#define sz_xAppleWMFrameHitTestReq	28
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	ret;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xAppleWMFrameHitTestReply;
+#define sz_xAppleWMFrameHitTestReply	32
+
+typedef struct _AppleWMFrameDraw {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_AppleWMFrameDraw */
+    CARD16	length;
+    CARD32	screen;
+    CARD32	window;
+    CARD16	frame_class;
+    CARD16	frame_attr;
+    CARD16	ix;
+    CARD16	iy;
+    CARD16	iw;
+    CARD16	ih;
+    CARD16	ox;
+    CARD16	oy;
+    CARD16	ow;
+    CARD16	oh;
+    CARD32	title_length;
+} xAppleWMFrameDrawReq;
+#define sz_xAppleWMFrameDrawReq	36
+
+/* restore these definitions back to the typedefs in X.h */
+#undef Window
+#undef Drawable
+#undef Font
+#undef Pixmap
+#undef Cursor
+#undef Colormap
+#undef GContext
+#undef Atom
+#undef VisualID
+#undef Time
+#undef KeyCode
+#undef KeySym
+
+#endif /* _APPLEWMPROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/bigreqsproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/bigreqsproto.h
new file mode 100644
index 0000000..df96a76
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/bigreqsproto.h
@@ -0,0 +1,67 @@
+/*
+
+Copyright 1992, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+#ifndef _BIGREQSPROTO_H_
+#define _BIGREQSPROTO_H_
+
+#define X_BigReqEnable		0
+
+#define XBigReqNumberEvents	0
+
+#define XBigReqNumberErrors	0
+
+#define XBigReqExtensionName	"BIG-REQUESTS"
+
+typedef struct {
+    CARD8	reqType;	/* always XBigReqCode */
+    CARD8	brReqType;	/* always X_BigReqEnable */
+    CARD16	length;
+} xBigReqEnableReq;
+#define sz_xBigReqEnableReq 4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	pad0;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	max_request_size;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xBigReqEnableReply;
+#define sz_xBigReqEnableReply 32
+
+
+typedef struct {
+	CARD8 reqType;
+	CARD8 data;
+	CARD16 zero;
+	CARD32 length;
+} xBigReq;
+
+#endif /* _BIGREQSPROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/bigreqstr.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/bigreqstr.h
new file mode 100644
index 0000000..0a023db
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/bigreqstr.h
@@ -0,0 +1,3 @@
+#warning "bigreqstr.h is obsolete and may be removed in the future."
+#warning "include <X11/extensions/bigreqsproto.h> for the protocol defines."
+#include <X11/extensions/bigreqsproto.h>
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/composite.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/composite.h
new file mode 100644
index 0000000..e942700
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/composite.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2006, Oracle and/or its affiliates.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+/*
+ * Copyright © 2003 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _COMPOSITE_H_
+#define _COMPOSITE_H_
+
+#include <X11/extensions/xfixeswire.h>
+
+#define COMPOSITE_NAME				"Composite"
+#define COMPOSITE_MAJOR				0
+#define COMPOSITE_MINOR				4
+
+#define CompositeRedirectAutomatic		0
+#define CompositeRedirectManual			1
+
+#define X_CompositeQueryVersion			0
+#define X_CompositeRedirectWindow		1
+#define X_CompositeRedirectSubwindows		2
+#define X_CompositeUnredirectWindow		3
+#define X_CompositeUnredirectSubwindows		4
+#define X_CompositeCreateRegionFromBorderClip	5
+#define X_CompositeNameWindowPixmap		6
+#define X_CompositeGetOverlayWindow             7
+#define X_CompositeReleaseOverlayWindow         8
+
+#define CompositeNumberRequests	    (X_CompositeReleaseOverlayWindow + 1)
+
+#define CompositeNumberEvents			0
+
+#endif /* _COMPOSITE_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/compositeproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/compositeproto.h
new file mode 100644
index 0000000..5a9ca6f
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/compositeproto.h
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2006, Oracle and/or its affiliates.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+/*
+ * Copyright © 2003 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _COMPOSITEPROTO_H_
+#define _COMPOSITEPROTO_H_
+
+#include <X11/Xmd.h>
+#include <X11/extensions/composite.h>
+
+#define Window CARD32
+#define Region CARD32
+#define Pixmap CARD32
+
+/*
+ * requests and replies
+ */
+typedef struct {
+    CARD8   reqType;
+    CARD8   compositeReqType;
+    CARD16  length;
+    CARD32  majorVersion;
+    CARD32  minorVersion;
+} xCompositeQueryVersionReq;
+
+#define sz_xCompositeQueryVersionReq   12
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  majorVersion;
+    CARD32  minorVersion;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+} xCompositeQueryVersionReply;
+
+#define sz_xCompositeQueryVersionReply	32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   compositeReqType;
+    CARD16  length;
+    Window  window;
+    CARD8   update;
+    CARD8   pad1;
+    CARD16  pad2;
+} xCompositeRedirectWindowReq;
+
+#define sz_xCompositeRedirectWindowReq	12
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   compositeReqType;
+    CARD16  length;
+    Window  window;
+    CARD8   update;
+    CARD8   pad1;
+    CARD16  pad2;
+} xCompositeRedirectSubwindowsReq;
+
+#define sz_xCompositeRedirectSubwindowsReq	    12
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   compositeReqType;
+    CARD16  length;
+    Window  window;
+    CARD8   update;
+    CARD8   pad1;
+    CARD16  pad2;
+} xCompositeUnredirectWindowReq;
+
+#define sz_xCompositeUnredirectWindowReq    12
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   compositeReqType;
+    CARD16  length;
+    Window  window;
+    CARD8   update;
+    CARD8   pad1;
+    CARD16  pad2;
+} xCompositeUnredirectSubwindowsReq;
+
+#define sz_xCompositeUnredirectSubwindowsReq   12
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   compositeReqType;
+    CARD16  length;
+    Region  region;
+    Window  window;
+} xCompositeCreateRegionFromBorderClipReq;
+
+#define sz_xCompositeCreateRegionFromBorderClipReq  12
+
+/* Version 0.2 additions */
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   compositeReqType;
+    CARD16  length;
+    Window  window;
+    Pixmap  pixmap;
+} xCompositeNameWindowPixmapReq;
+
+#define sz_xCompositeNameWindowPixmapReq	    12
+
+/* Version 0.3 additions */
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   compositeReqType;
+    CARD16  length;
+    Window  window;
+} xCompositeGetOverlayWindowReq;
+
+#define sz_xCompositeGetOverlayWindowReq sizeof(xCompositeGetOverlayWindowReq)
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    Window  overlayWin;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+    CARD32  pad6;
+} xCompositeGetOverlayWindowReply;
+
+#define sz_xCompositeGetOverlayWindowReply sizeof(xCompositeGetOverlayWindowReply)
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   compositeReqType;
+    CARD16  length;
+    Window  window;
+} xCompositeReleaseOverlayWindowReq;
+
+#define sz_xCompositeReleaseOverlayWindowReq sizeof(xCompositeReleaseOverlayWindowReq)
+
+#undef Window
+#undef Region
+#undef Pixmap
+
+#endif /* _COMPOSITEPROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/cup.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/cup.h
new file mode 100644
index 0000000..cbbc34b
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/cup.h
@@ -0,0 +1,38 @@
+/*
+
+Copyright 1987, 1988, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+#ifndef _CUP_H_
+#define _CUP_H_
+
+#define XCUPNAME "TOG-CUP"
+
+#define XCUP_MAJOR_VERSION	1	/* current version numbers */
+#define XCUP_MINOR_VERSION	0
+
+#define XcupNumberErrors			0
+
+#endif /* _CUP_H_ */
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/cupproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/cupproto.h
new file mode 100644
index 0000000..a0c3d16
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/cupproto.h
@@ -0,0 +1,105 @@
+/*
+
+Copyright 1987, 1988, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+#ifndef _XCUPPROTO_H_ /* { */
+#define _XCUPPROTO_H_
+
+#include <X11/extensions/cup.h>
+
+#define X_XcupQueryVersion			0
+#define X_XcupGetReservedColormapEntries	1
+#define X_XcupStoreColors			2
+
+typedef struct _XcupQueryVersion {
+    CARD8	reqType;	/* always XcupReqCode */
+    CARD8	xcupReqType;	/* always X_XcupQueryVersion */
+    CARD16	length;
+    CARD16	client_major_version;
+    CARD16	client_minor_version;
+} xXcupQueryVersionReq;
+#define sz_xXcupQueryVersionReq		8
+
+typedef struct {
+    BYTE	type;		/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequence_number;
+    CARD32	length;
+    CARD16	server_major_version;
+    CARD16	server_minor_version;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXcupQueryVersionReply;
+#define sz_xXcupQueryVersionReply	32
+
+typedef struct _XcupGetReservedColormapEntries {
+    CARD8	reqType;	/* always XcupReqCode */
+    CARD8	xcupReqType;	/* always X_XcupGetReservedColormapEntries */
+    CARD16	length;
+    CARD32	screen;
+} xXcupGetReservedColormapEntriesReq;
+#define sz_xXcupGetReservedColormapEntriesReq 8
+
+typedef struct {
+    BYTE	type;		/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequence_number;
+    CARD32	length;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+    CARD32	pad7;
+} xXcupGetReservedColormapEntriesReply;
+#define sz_xXcupGetReservedColormapEntriesReply		32
+
+typedef struct _XcupStoreColors {
+    CARD8	reqType;	/* always XcupReqCode */
+    CARD8	xcupReqType;	/* always X_XcupStoreColors */
+    CARD16	length;
+    CARD32	cmap;
+} xXcupStoreColorsReq;
+#define sz_xXcupStoreColorsReq		8
+
+typedef struct {
+    BYTE	type;		/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequence_number;
+    CARD32	length;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+    CARD32	pad7;
+} xXcupStoreColorsReply;
+#define sz_xXcupStoreColorsReply	32
+
+#endif /* } _XCUPPROTO_H_ */
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/damageproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/damageproto.h
new file mode 100644
index 0000000..bff6c18
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/damageproto.h
@@ -0,0 +1,158 @@
+/*
+ * Copyright © 2003 Keith Packard
+ * Copyright © 2007 Eric Anholt
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _DAMAGEPROTO_H_
+#define _DAMAGEPROTO_H_
+
+#include <X11/Xmd.h>
+#include <X11/extensions/xfixesproto.h>
+#include <X11/extensions/damagewire.h>
+
+#define Window CARD32
+#define Drawable CARD32
+#define Font CARD32
+#define Pixmap CARD32
+#define Cursor CARD32
+#define Colormap CARD32
+#define GContext CARD32
+#define Atom CARD32
+#define VisualID CARD32
+#define Time CARD32
+#define KeyCode CARD8
+#define KeySym CARD32
+#define Picture CARD32
+#define Region CARD32
+#define Damage CARD32
+
+/************** Version 0 ******************/
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   damageReqType;
+    CARD16  length;
+} xDamageReq;
+
+/*
+ * requests and replies
+ */
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   damageReqType;
+    CARD16  length;
+    CARD32  majorVersion;
+    CARD32  minorVersion;
+} xDamageQueryVersionReq;
+
+#define sz_xDamageQueryVersionReq   12
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  majorVersion;
+    CARD32  minorVersion;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+} xDamageQueryVersionReply;
+
+#define sz_xDamageQueryVersionReply	32
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	damageReqType;
+    CARD16	length;
+    Damage	damage;
+    Drawable	drawable;
+    CARD8	level;
+    CARD8	pad1;
+    CARD16	pad2;
+} xDamageCreateReq;
+
+#define sz_xDamageCreateReq		16
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	damageReqType;
+    CARD16	length;
+    Damage	damage;
+} xDamageDestroyReq;
+
+#define sz_xDamageDestroyReq		8
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	damageReqType;
+    CARD16	length;
+    Damage	damage;
+    Region	repair;
+    Region	parts;
+} xDamageSubtractReq;
+
+#define sz_xDamageSubtractReq		16
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	damageReqType;
+    CARD16	length;
+    Drawable	drawable;
+    Region	region;
+} xDamageAddReq;
+
+#define sz_xDamageAddReq		12
+
+/* Events */
+
+#define DamageNotifyMore    0x80
+
+typedef struct {
+    CARD8	type;
+    CARD8	level;
+    CARD16	sequenceNumber;
+    Drawable	drawable;
+    Damage	damage;
+    Time	timestamp;
+    xRectangle	area;
+    xRectangle	geometry;
+} xDamageNotifyEvent;
+
+#undef Damage
+#undef Region
+#undef Picture
+#undef Window
+#undef Drawable
+#undef Font
+#undef Pixmap
+#undef Cursor
+#undef Colormap
+#undef GContext
+#undef Atom
+#undef VisualID
+#undef Time
+#undef KeyCode
+#undef KeySym
+
+#endif /* _DAMAGEPROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/damagewire.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/damagewire.h
new file mode 100644
index 0000000..d90a0dd
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/damagewire.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright © 2003 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _DAMAGEWIRE_H_
+#define _DAMAGEWIRE_H_
+
+#define	DAMAGE_NAME	"DAMAGE"
+#define DAMAGE_MAJOR	1
+#define DAMAGE_MINOR	1
+
+/************* Version 1 ****************/
+
+/* Constants */
+#define XDamageReportRawRectangles	0
+#define XDamageReportDeltaRectangles	1
+#define XDamageReportBoundingBox	2
+#define XDamageReportNonEmpty		3
+
+/* Requests */
+#define X_DamageQueryVersion		0
+#define X_DamageCreate			1
+#define X_DamageDestroy			2
+#define X_DamageSubtract		3
+#define X_DamageAdd			4
+
+#define XDamageNumberRequests		(X_DamageAdd + 1)
+
+/* Events */
+#define XDamageNotify			0
+
+#define XDamageNumberEvents		(XDamageNotify + 1)
+
+/* Errors */
+#define BadDamage			0
+#define XDamageNumberErrors		(BadDamage + 1)
+
+#endif /* _DAMAGEWIRE_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/dbe.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/dbe.h
new file mode 100644
index 0000000..7968552
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/dbe.h
@@ -0,0 +1,57 @@
+/******************************************************************************
+ *
+ * Copyright (c) 1994, 1995  Hewlett-Packard Company
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of the Hewlett-Packard
+ * Company shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the Hewlett-Packard Company.
+ *
+ *     Header file for Xlib-related DBE
+ *
+ *****************************************************************************/
+
+#ifndef DBE_H
+#define DBE_H
+
+/* Values for swap_action field of XdbeSwapInfo structure */
+#define XdbeUndefined    0
+#define XdbeBackground   1
+#define XdbeUntouched    2
+#define XdbeCopied       3
+
+/* Errors */
+#define XdbeBadBuffer    0
+
+#define DBE_PROTOCOL_NAME "DOUBLE-BUFFER"
+
+/* Current version numbers */
+#define DBE_MAJOR_VERSION       1
+#define DBE_MINOR_VERSION       0
+
+/* Used when adding extension; also used in Xdbe macros */
+#define DbeNumberEvents			0
+#define DbeBadBuffer			0
+#define DbeNumberErrors			(DbeBadBuffer + 1)
+
+#endif /* DBE_H */
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/dbeproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/dbeproto.h
new file mode 100644
index 0000000..d6f7123
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/dbeproto.h
@@ -0,0 +1,224 @@
+/******************************************************************************
+ *
+ * Copyright (c) 1994, 1995  Hewlett-Packard Company
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the name of the Hewlett-Packard
+ * Company shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the Hewlett-Packard Company.
+ *
+ *     Header file for Xlib-related DBE
+ *
+ *****************************************************************************/
+
+#ifndef DBE_PROTO_H
+#define DBE_PROTO_H
+
+#include <X11/extensions/dbe.h>
+
+/* Request values used in (S)ProcDbeDispatch() */
+#define X_DbeGetVersion                 0
+#define X_DbeAllocateBackBufferName     1
+#define X_DbeDeallocateBackBufferName   2
+#define X_DbeSwapBuffers                3
+#define X_DbeBeginIdiom                 4
+#define X_DbeEndIdiom                   5
+#define X_DbeGetVisualInfo              6
+#define X_DbeGetBackBufferAttributes    7
+
+typedef CARD8  xDbeSwapAction;
+typedef CARD32 xDbeBackBuffer;
+
+/* TYPEDEFS */
+
+/* Protocol data types */
+
+typedef struct
+{
+    CARD32		window;		/* window      */
+    xDbeSwapAction	swapAction;	/* swap action */
+    CARD8		pad1;		/* unused      */
+    CARD16		pad2;
+
+} xDbeSwapInfo;
+
+typedef struct
+{
+    CARD32	visualID;	/* associated visual      */
+    CARD8	depth;		/* depth of visual        */
+    CARD8	perfLevel;	/* performance level hint */
+    CARD16	pad1;
+
+} xDbeVisInfo;
+#define sz_xDbeVisInfo	8
+
+typedef struct
+{
+    CARD32	n;	/* number of visual info items in list  */
+
+} xDbeScreenVisInfo;	/* followed by n xDbeVisInfo items */
+
+typedef struct
+{
+    CARD32	window;		/* window */
+
+} xDbeBufferAttributes;
+
+
+/* Requests and replies */
+
+typedef struct
+{
+    CARD8	reqType;	/* major-opcode: always codes->major_opcode */
+    CARD8	dbeReqType;	/* minor-opcode: always X_DbeGetVersion (0) */
+    CARD16	length;		/* request length: (2)                      */
+    CARD8	majorVersion;	/* client-major-version                     */
+    CARD8	minorVersion;	/* client-minor-version                     */
+    CARD16	unused;		/* unused                                   */
+
+} xDbeGetVersionReq;
+#define sz_xDbeGetVersionReq	8
+
+typedef struct
+{
+    BYTE	type;			/* Reply: X_Reply (1)   */
+    CARD8	unused;			/* unused               */
+    CARD16	sequenceNumber;		/* sequence number      */
+    CARD32	length;			/* reply length: (0)    */
+    CARD8	majorVersion;		/* server-major-version */
+    CARD8	minorVersion;		/* server-minor-version */
+    CARD16	pad1;			/* unused               */
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+
+} xDbeGetVersionReply;
+#define sz_xDbeGetVersionReply	32
+
+typedef struct
+{
+    CARD8		reqType;	/* major-opcode: codes->major_opcode */
+    CARD8		dbeReqType;	/* X_DbeAllocateBackBufferName (1)   */
+    CARD16		length;		/* request length: (4)               */
+    CARD32		window;		/* window                            */
+    xDbeBackBuffer	buffer;		/* back buffer name                  */
+    xDbeSwapAction	swapAction;	/* swap action hint                  */
+    CARD8		pad1;		/* unused                            */
+    CARD16		pad2;
+
+} xDbeAllocateBackBufferNameReq;
+#define sz_xDbeAllocateBackBufferNameReq	16
+
+typedef struct
+{
+    CARD8		reqType;	/* major-opcode: codes->major_opcode */
+    CARD8		dbeReqType;	/* X_DbeDeallocateBackBufferName (2) */
+    CARD16		length;		/* request length: (2)               */
+    xDbeBackBuffer	buffer;		/* back buffer name                  */
+
+} xDbeDeallocateBackBufferNameReq;
+#define sz_xDbeDeallocateBackBufferNameReq	8
+
+typedef struct
+{
+    CARD8	reqType;	/* major-opcode: always codes->major_opcode  */
+    CARD8	dbeReqType;	/* minor-opcode: always X_DbeSwapBuffers (3) */
+    CARD16	length;		/* request length: (2+2n)                    */
+    CARD32	n;		/* n, number of window/swap action pairs     */
+
+} xDbeSwapBuffersReq;		/* followed by n window/swap action pairs    */
+#define sz_xDbeSwapBuffersReq	8
+
+typedef struct
+{
+    CARD8	reqType;	/* major-opcode: always codes->major_opcode */
+    CARD8	dbeReqType;	/* minor-opcode: always X_DbeBeginIdom (4)  */
+    CARD16	length;		/* request length: (1)                      */
+
+} xDbeBeginIdiomReq;
+#define sz_xDbeBeginIdiomReq	4
+
+typedef struct
+{
+    CARD8	reqType;	/* major-opcode: always codes->major_opcode */
+    CARD8	dbeReqType;	/* minor-opcode: always X_DbeEndIdom (5)    */
+    CARD16	length;		/* request length: (1)                      */
+
+} xDbeEndIdiomReq;
+#define sz_xDbeEndIdiomReq	4
+
+typedef struct
+{
+    CARD8	reqType;	/* always codes->major_opcode     */
+    CARD8	dbeReqType;	/* always X_DbeGetVisualInfo (6)  */
+    CARD16	length;		/* request length: (2+n)          */
+    CARD32	n;		/* n, number of drawables in list */
+
+} xDbeGetVisualInfoReq;		/* followed by n drawables        */
+#define sz_xDbeGetVisualInfoReq	8
+
+typedef struct
+{
+    BYTE	type;			/* Reply: X_Reply (1)                */
+    CARD8	unused;			/* unused                            */
+    CARD16	sequenceNumber;		/* sequence number                   */
+    CARD32	length;			/* reply length                      */
+    CARD32	m;			/* m, number of visual infos in list */
+    CARD32	pad1;			/* unused                            */
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+
+} xDbeGetVisualInfoReply;		/* followed by m visual infos        */
+#define sz_xDbeGetVisualInfoReply	32
+
+typedef struct
+{
+    CARD8		reqType;	/* always codes->major_opcode       */
+    CARD8		dbeReqType;	/* X_DbeGetBackBufferAttributes (7) */
+    CARD16		length;		/* request length: (2)              */
+    xDbeBackBuffer	buffer;		/* back buffer name                 */
+
+} xDbeGetBackBufferAttributesReq;
+#define sz_xDbeGetBackBufferAttributesReq	8
+
+typedef struct
+{
+    BYTE	type;			/* Reply: X_Reply (1) */
+    CARD8	unused;			/* unused             */
+    CARD16	sequenceNumber;		/* sequence number    */
+    CARD32	length;			/* reply length: (0)  */
+    CARD32	attributes;		/* attributes         */
+    CARD32	pad1;			/* unused             */
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+
+} xDbeGetBackBufferAttributesReply;
+#define sz_xDbeGetBackBufferAttributesReply	32
+
+#endif /* DBE_PROTO_H */
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/dmx.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/dmx.h
new file mode 100644
index 0000000..8cbd4d3
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/dmx.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2002-2004 Red Hat Inc., Durham, North Carolina.
+ *
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation on the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/*
+ * Authors:
+ *   Rickard E. (Rik) Faith <faith@redhat.com>
+ *
+ */
+
+/** \file
+ * This file describes the interface to the client-side libdmx.a
+ * library.  All DMX-aware client-side applications should include this
+ * file. */
+
+#ifndef _DMX_H_
+#define _DMX_H_
+
+/* These values must be larger than LastExtensionError.
+   The values in dmxext.h and dmxproto.h *MUST* match. */
+#define DmxBadXinerama         1001
+#define DmxBadValue            1002
+#define DmxBadReply            1003
+
+#define DMXScreenWindowWidth   (1L<<0)
+#define DMXScreenWindowHeight  (1L<<1)
+#define DMXScreenWindowXoffset (1L<<2)
+#define DMXScreenWindowYoffset (1L<<3)
+#define DMXRootWindowWidth     (1L<<4)
+#define DMXRootWindowHeight    (1L<<5)
+#define DMXRootWindowXoffset   (1L<<6)
+#define DMXRootWindowYoffset   (1L<<7)
+#define DMXRootWindowXorigin   (1L<<8)
+#define DMXRootWindowYorigin   (1L<<9)
+
+#define DMXDesktopWidth        (1L<<0)
+#define DMXDesktopHeight       (1L<<1)
+#define DMXDesktopShiftX       (1L<<2)
+#define DMXDesktopShiftY       (1L<<3)
+
+#define DMXInputType           (1L<<0)
+#define DMXInputPhysicalScreen (1L<<1)
+#define DMXInputSendsCore      (1L<<2)
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/dmxproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/dmxproto.h
new file mode 100644
index 0000000..c8bc862
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/dmxproto.h
@@ -0,0 +1,445 @@
+/*
+ * Copyright 2002-2004 Red Hat Inc., Durham, North Carolina.
+ *
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation on the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/*
+ * Authors:
+ *   Rickard E. (Rik) Faith <faith@redhat.com>
+ *
+ */
+
+/** \file
+ * This file describes the structures necessary to implement the wire
+ * protocol for the DMX protocol extension.  It should be included only
+ * in files that implement the client-side (or server-side) part of the
+ * protocol (i.e., client-side applications should \b not include this
+ * file). */
+
+#ifndef _DMXSTR_H_
+#define _DMXSTR_H_
+
+#define DMX_EXTENSION_NAME  "DMX"
+#define DMX_EXTENSION_MAJOR 2
+#define DMX_EXTENSION_MINOR 2
+#define DMX_EXTENSION_PATCH 20040604
+
+/* These values must be larger than LastExtensionError.
+   The values in dmxext.h and dmxproto.h *MUST* match. */
+#define DMX_BAD_XINERAMA     1001
+#define DMX_BAD_VALUE        1002
+
+#define X_DMXQueryVersion                   0
+#define X_DMXGetScreenCount                 1
+#define X_DMXGetScreenInformationDEPRECATED 2
+#define X_DMXGetWindowAttributes            3
+#define X_DMXGetInputCount                  4
+#define X_DMXGetInputAttributes             5
+#define X_DMXForceWindowCreationDEPRECATED  6
+#define X_DMXReconfigureScreenDEPRECATED    7
+#define X_DMXSync                           8
+#define X_DMXForceWindowCreation            9
+#define X_DMXGetScreenAttributes           10
+#define X_DMXChangeScreensAttributes       11
+#define X_DMXAddScreen                     12
+#define X_DMXRemoveScreen                  13
+#define X_DMXGetDesktopAttributes          14
+#define X_DMXChangeDesktopAttributes       15
+#define X_DMXAddInput                      16
+#define X_DMXRemoveInput                   17
+
+/** Wire-level description of DMXQueryVersion protocol request. */
+typedef struct {
+    CARD8   reqType;            /* dmxcode */
+    CARD8   dmxReqType;         /* X_DMXQueryVersion */
+    CARD16  length;
+} xDMXQueryVersionReq;
+#define sz_xDMXQueryVersionReq 4
+
+/** Wire-level description of DMXQueryVersion protocol reply. */
+typedef struct {
+    BYTE    type;               /* X_Reply */
+    CARD8   ununsed;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  majorVersion;
+    CARD32  minorVersion;
+    CARD32  patchVersion;
+    CARD32  pad0;
+    CARD32  pad1;
+    CARD32  pad2;
+} xDMXQueryVersionReply;
+#define sz_xDMXQueryVersionReply 32
+
+/** Wire-level description of DMXSync protocol request. */
+typedef struct {
+    CARD8   reqType;            /* DMXCode */
+    CARD8   dmxReqType;         /* X_DMXSync */
+    CARD16  length;
+} xDMXSyncReq;
+#define sz_xDMXSyncReq 4
+
+/** Wire-level description of DMXSync protocol reply. */
+typedef struct {
+    BYTE    type;               /* X_Reply */
+    CARD8   unused;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  status;
+    CARD32  pad0;
+    CARD32  pad1;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+} xDMXSyncReply;
+#define sz_xDMXSyncReply 32
+
+/** Wire-level description of DMXForceWindowCreation protocol request. */
+typedef struct {
+    CARD8   reqType;            /* DMXCode */
+    CARD8   dmxReqType;         /* X_DMXForceWindowCreation */
+    CARD16  length;
+    CARD32  window;
+} xDMXForceWindowCreationReq;
+#define sz_xDMXForceWindowCreationReq 8
+
+/** Wire-level description of DMXForceWindowCreation protocol reply. */
+typedef struct {
+    BYTE    type;               /* X_Reply */
+    CARD8   unused;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  status;
+    CARD32  pad0;
+    CARD32  pad1;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+} xDMXForceWindowCreationReply;
+#define sz_xDMXForceWindowCreationReply 32
+
+/** Wire-level description of DMXGetScreenCount protocol request. */
+typedef struct {
+    CARD8   reqType;            /* DMXCode */
+    CARD8   dmxReqType;         /* X_DMXGetScreenCount */
+    CARD16  length;
+} xDMXGetScreenCountReq;
+#define sz_xDMXGetScreenCountReq 4
+
+/** Wire-level description of DMXGetScreenCount protocol reply. */
+typedef struct {
+    BYTE    type;               /* X_Reply */
+    CARD8   unused;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  screenCount;
+    CARD32  pad0;
+    CARD32  pad1;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+} xDMXGetScreenCountReply;
+#define sz_xDMXGetScreenCountReply 32
+
+/** Wire-level description of DMXGetScreenAttributes protocol request. */
+typedef struct {
+    CARD8   reqType;            /* DMXCode */
+    CARD8   dmxReqType;         /* X_DMXGetScreenAttributes */
+    CARD16  length;
+    CARD32  physicalScreen;
+} xDMXGetScreenAttributesReq;
+#define sz_xDMXGetScreenAttributesReq 8
+
+/** Wire-level description of DMXGetScreenAttributes protocol reply. */
+typedef struct {
+    BYTE    type;               /* X_Reply */
+    CARD8   unused;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  displayNameLength;
+    CARD32  logicalScreen;
+
+    CARD16  screenWindowWidth;
+    CARD16  screenWindowHeight;
+    INT16   screenWindowXoffset;
+    INT16   screenWindowYoffset;
+
+    CARD16  rootWindowWidth;
+    CARD16  rootWindowHeight;
+    INT16   rootWindowXoffset;
+    INT16   rootWindowYoffset;
+    INT16   rootWindowXorigin;
+    INT16   rootWindowYorigin;
+} xDMXGetScreenAttributesReply;
+#define sz_xDMXGetScreenAttributesReply 36
+
+/** Wire-level description of DMXChangeScreensAttributes protocol request. */
+typedef struct {
+    CARD8   reqType;            /* DMXCode */
+    CARD8   dmxReqType;         /* X_DMXChangeScreensAttributes */
+    CARD16  length;
+    CARD32  screenCount;
+    CARD32  maskCount;
+} xDMXChangeScreensAttributesReq;
+#define sz_xDMXChangeScreensAttributesReq 12
+
+/** Wire-level description of DMXChangeScreensAttributes protocol reply. */
+typedef struct {
+    BYTE    type;               /* X_Reply */
+    CARD8   unused;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  status;
+    CARD32  errorScreen;
+    CARD32  pad0;
+    CARD32  pad1;
+    CARD32  pad2;
+    CARD32  pad3;
+} xDMXChangeScreensAttributesReply;
+#define sz_xDMXChangeScreensAttributesReply 32
+
+/** Wire-level description of DMXAddScreen protocol request. */
+typedef struct {
+    CARD8   reqType;            /* DMXCode */
+    CARD8   dmxReqType;         /* X_DMXAddScreen */
+    CARD16  length;
+    CARD32  displayNameLength;
+    CARD32  physicalScreen;
+    CARD32  valueMask;
+} xDMXAddScreenReq;
+#define sz_xDMXAddScreenReq 16
+
+/** Wire-level description of DMXAddScreen protocol reply. */
+typedef struct {
+    BYTE    type;               /* X_Reply */
+    CARD8   unused;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  status;
+    CARD32  physicalScreen;
+    CARD32  pad0;
+    CARD32  pad1;
+    CARD32  pad2;
+    CARD32  pad3;
+} xDMXAddScreenReply;
+#define sz_xDMXAddScreenReply 32
+
+/** Wire-level description of DMXRemoveScreen protocol request. */
+typedef struct {
+    CARD8   reqType;            /* DMXCode */
+    CARD8   dmxReqType;         /* X_DMXRemoveScreen */
+    CARD16  length;
+    CARD32  physicalScreen;
+} xDMXRemoveScreenReq;
+#define sz_xDMXRemoveScreenReq 8
+
+/** Wire-level description of DMXRemoveScreen protocol reply. */
+typedef struct {
+    BYTE    type;               /* X_Reply */
+    CARD8   unused;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  status;
+    CARD32  pad0;
+    CARD32  pad1;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+} xDMXRemoveScreenReply;
+#define sz_xDMXRemoveScreenReply 32
+
+/** Wire-level description of DMXGetWindowAttributes protocol request. */
+typedef struct {
+    CARD8   reqType;            /* DMXCode */
+    CARD8   dmxReqType;         /* X_DMXGetWindowAttributes */
+    CARD16  length;
+    CARD32  window;
+} xDMXGetWindowAttributesReq;
+#define sz_xDMXGetWindowAttributesReq 8
+
+/** Wire-level description of DMXGetWindowAttributes protocol reply. */
+typedef struct {
+    BYTE    type;               /* X_Reply */
+    CARD8   unused;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  screenCount;
+    CARD32  pad0;
+    CARD32  pad1;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+} xDMXGetWindowAttributesReply;
+#define sz_xDMXGetWindowAttributesReply 32
+
+/** Wire-level description of DMXGetDesktopAttributes protocol request. */
+typedef struct {
+    CARD8   reqType;            /* DMXCode */
+    CARD8   dmxReqType;         /* X_DMXGetDesktopAttributes */
+    CARD16  length;
+} xDMXGetDesktopAttributesReq;
+#define sz_xDMXGetDesktopAttributesReq 4
+
+/** Wire-level description of DMXGetDesktopAttributes protocol reply. */
+typedef struct {
+    BYTE    type;               /* X_Reply */
+    CARD8   unused;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    INT16   width;
+    INT16   height;
+    INT16   shiftX;
+    INT16   shiftY;
+    CARD32  pad0;
+    CARD32  pad1;
+    CARD32  pad2;
+    CARD32  pad3;
+} xDMXGetDesktopAttributesReply;
+#define sz_xDMXGetDesktopAttributesReply 32
+
+/** Wire-level description of DMXChangeDesktopAttributes protocol request. */
+typedef struct {
+    CARD8   reqType;            /* DMXCode */
+    CARD8   dmxReqType;         /* X_DMXChangeDesktopAttributes */
+    CARD16  length;
+    CARD32  valueMask;
+} xDMXChangeDesktopAttributesReq;
+#define sz_xDMXChangeDesktopAttributesReq 8
+
+/** Wire-level description of DMXChangeDesktopAttributes protocol reply. */
+typedef struct {
+    BYTE    type;               /* X_Reply */
+    CARD8   unused;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  status;
+    CARD32  pad0;
+    CARD32  pad1;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+} xDMXChangeDesktopAttributesReply;
+#define sz_xDMXChangeDesktopAttributesReply 32
+
+/** Wire-level description of DMXGetInputCount protocol request. */
+typedef struct {
+    CARD8   reqType;            /* DMXCode */
+    CARD8   dmxReqType;         /* X_DMXGetInputCount */
+    CARD16  length;
+} xDMXGetInputCountReq;
+#define sz_xDMXGetInputCountReq 4
+
+/** Wire-level description of DMXGetInputCount protocol reply. */
+typedef struct {
+    BYTE    type;               /* X_Reply */
+    CARD8   unused;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  inputCount;
+    CARD32  pad0;
+    CARD32  pad1;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+} xDMXGetInputCountReply;
+#define sz_xDMXGetInputCountReply 32
+
+/** Wire-level description of DMXGetInputAttributes protocol request. */
+typedef struct {
+    CARD8   reqType;            /* DMXCode */
+    CARD8   dmxReqType;         /* X_DMXGetInputAttributes */
+    CARD16  length;
+    CARD32  deviceId;
+} xDMXGetInputAttributesReq;
+#define sz_xDMXGetInputAttributesReq 8
+
+/** Wire-level description of DMXGetInputAttributes protocol reply. */
+typedef struct {
+    BYTE    type;               /* X_Reply */
+    CARD8   unused;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  inputType;
+    CARD32  physicalScreen;
+    CARD32  physicalId;
+    CARD32  nameLength;
+    BOOL    isCore;
+    BOOL    sendsCore;
+    BOOL    detached;
+    CARD8   pad0;
+    CARD32  pad1;
+} xDMXGetInputAttributesReply;
+#define sz_xDMXGetInputAttributesReply 32
+
+/** Wire-level description of DMXAddInput protocol request. */
+typedef struct {
+    CARD8   reqType;            /* DMXCode */
+    CARD8   dmxReqType;         /* X_DMXAddInput */
+    CARD16  length;
+    CARD32  displayNameLength;
+    CARD32  valueMask;
+} xDMXAddInputReq;
+#define sz_xDMXAddInputReq 12
+
+/** Wire-level description of DMXAddInput protocol reply. */
+typedef struct {
+    BYTE    type;               /* X_Reply */
+    CARD8   unused;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  status;
+    CARD32  physicalId;
+    CARD32  pad0;
+    CARD32  pad1;
+    CARD32  pad2;
+    CARD32  pad3;
+} xDMXAddInputReply;
+#define sz_xDMXAddInputReply 32
+
+/** Wire-level description of DMXRemoveInput protocol request. */
+typedef struct {
+    CARD8   reqType;            /* DMXCode */
+    CARD8   dmxReqType;         /* X_DMXRemoveInput */
+    CARD16  length;
+    CARD32  physicalId;
+} xDMXRemoveInputReq;
+#define sz_xDMXRemoveInputReq 8
+
+/** Wire-level description of DMXRemoveInput protocol reply. */
+typedef struct {
+    BYTE     type;
+    CARD8    unused;
+    CARD16   sequenceNumber;
+    CARD32   length;
+    CARD32   status;
+    CARD32   pad0;
+    CARD32   pad1;
+    CARD32   pad2;
+    CARD32   pad3;
+    CARD32   pad4;
+} xDMXRemoveInputReply;
+#define sz_xDMXRemoveInputReply 32
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/dpmsconst.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/dpmsconst.h
new file mode 100644
index 0000000..f46d2d9
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/dpmsconst.h
@@ -0,0 +1,46 @@
+/*****************************************************************
+
+Copyright (c) 1996 Digital Equipment Corporation, Maynard, Massachusetts.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING,
+BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL DAMAGES, OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of Digital Equipment Corporation
+shall not be used in advertising or otherwise to promote the sale, use or other
+dealings in this Software without prior written authorization from Digital
+Equipment Corporation.
+
+******************************************************************/
+
+#ifndef _DPMSCONST_H
+#define _DPMSCONST_H 1
+
+#define DPMSMajorVersion	1
+#define DPMSMinorVersion	2
+
+#define DPMSExtensionName	"DPMS"
+
+#define DPMSModeOn	0
+#define DPMSModeStandby	1
+#define DPMSModeSuspend	2
+#define DPMSModeOff	3
+
+#define DPMSInfoNotifyMask	(1L << 0)
+#define DPMSInfoNotify		0
+
+#endif /* !_DPMSCONST_H */
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/dpmsproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/dpmsproto.h
new file mode 100644
index 0000000..6b7e419
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/dpmsproto.h
@@ -0,0 +1,201 @@
+/*****************************************************************
+
+Copyright (c) 1996 Digital Equipment Corporation, Maynard, Massachusetts.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING,
+BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL DAMAGES, OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of Digital Equipment Corporation
+shall not be used in advertising or otherwise to promote the sale, use or other
+dealings in this Software without prior written authorization from Digital
+Equipment Corporation.
+
+******************************************************************/
+
+#ifndef _DPMSPROTO_H_
+#define _DPMSPROTO_H_
+
+#include <X11/extensions/dpmsconst.h>
+
+#define X_DPMSGetVersion	0
+#define X_DPMSCapable		1
+#define X_DPMSGetTimeouts	2
+#define X_DPMSSetTimeouts	3
+#define X_DPMSEnable		4
+#define X_DPMSDisable		5
+#define X_DPMSForceLevel       	6
+#define X_DPMSInfo       	7
+#define X_DPMSSelectInput	8
+
+#define DPMSNumberEvents	0
+
+#define DPMSNumberErrors	0
+
+
+typedef struct {
+    CARD8	reqType;	/* always DPMSCode */
+    CARD8	dpmsReqType;	/* always X_DPMSGetVersion */
+    CARD16	length;
+    CARD16	majorVersion;
+    CARD16	minorVersion;
+} xDPMSGetVersionReq;
+#define sz_xDPMSGetVersionReq 8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	pad0;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	majorVersion;
+    CARD16	minorVersion;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xDPMSGetVersionReply;
+#define sz_xDPMSGetVersionReply 32
+
+typedef struct {
+    CARD8	reqType;	/* always DPMSCode */
+    CARD8	dpmsReqType;	/* always X_DPMSCapable */
+    CARD16	length;
+} xDPMSCapableReq;
+#define sz_xDPMSCapableReq 4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	pad0;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    BOOL	capable;
+    CARD8	pad1;
+    CARD16	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+    CARD32	pad7;
+} xDPMSCapableReply;
+#define sz_xDPMSCapableReply 32
+
+typedef struct {
+    CARD8	reqType;	/* always DPMSCode */
+    CARD8	dpmsReqType;	/* always X_DPMSGetTimeouts */
+    CARD16	length;
+} xDPMSGetTimeoutsReq;
+#define sz_xDPMSGetTimeoutsReq 4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	pad0;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	standby;
+    CARD16	suspend;
+    CARD16	off;
+    CARD16	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xDPMSGetTimeoutsReply;
+#define sz_xDPMSGetTimeoutsReply 32
+
+typedef struct {
+    CARD8	reqType;	/* always DPMSCode */
+    CARD8	dpmsReqType;	/* always X_DPMSSetTimeouts */
+    CARD16	length;
+    CARD16	standby;
+    CARD16	suspend;
+    CARD16	off;
+    CARD16	pad0;
+} xDPMSSetTimeoutsReq;
+#define sz_xDPMSSetTimeoutsReq 12
+
+typedef struct {
+    CARD8	reqType;	/* always DPMSCode */
+    CARD8	dpmsReqType;	/* always X_DPMSEnable */
+    CARD16	length;
+} xDPMSEnableReq;
+#define sz_xDPMSEnableReq 4
+
+typedef struct {
+    CARD8	reqType;	/* always DPMSCode */
+    CARD8	dpmsReqType;	/* always X_DPMSDisable */
+    CARD16	length;
+} xDPMSDisableReq;
+#define sz_xDPMSDisableReq 4
+
+typedef struct {
+    CARD8	reqType;	/* always DPMSCode */
+    CARD8	dpmsReqType;	/* always X_DPMSForceLevel */
+    CARD16	length;
+    CARD16	level;		/* power level requested */
+    CARD16	pad0;
+} xDPMSForceLevelReq;
+#define sz_xDPMSForceLevelReq 8
+
+typedef struct {
+    CARD8	reqType;	/* always DPMSCode */
+    CARD8	dpmsReqType;	/* always X_DPMSInfo */
+    CARD16	length;
+} xDPMSInfoReq;
+#define sz_xDPMSInfoReq 4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	pad0;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	power_level;
+    BOOL	state;
+    CARD8	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xDPMSInfoReply;
+#define sz_xDPMSInfoReply 32
+
+typedef struct {
+    CARD8	reqType;	/* always DPMSCode */
+    CARD8	dpmsReqType;	/* always X_DPMSSelectInput */
+    CARD16	length B16;
+    CARD32	eventMask B32;
+} xDPMSSelectInputReq;
+#define sz_xDPMSSelectInputReq 8
+
+typedef struct {
+    CARD8	type;
+    CARD8	extension;
+    CARD16	sequenceNumber B16;
+    CARD32	length;
+    CARD16	evtype B16;
+    CARD16	pad0 B16;
+    Time	timestamp B32;
+    CARD16	power_level B16;
+    BOOL	state;
+    CARD8	pad1;
+    CARD32	pad2 B32;
+    CARD32	pad3 B32;
+    CARD32	pad4 B32;
+} xDPMSInfoNotifyEvent;
+#define sz_xDPMSInfoNotifyEvent 32
+
+#endif /* _DPMSPROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/dri2proto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/dri2proto.h
new file mode 100644
index 0000000..c1775fd
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/dri2proto.h
@@ -0,0 +1,357 @@
+/*
+ * Copyright © 2008 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Soft-
+ * ware"), to deal in the Software without restriction, including without
+ * limitation the rights to use, copy, modify, merge, publish, distribute,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, provided that the above copyright
+ * notice(s) and this permission notice appear in all copies of the Soft-
+ * ware and that both the above copyright notice(s) and this permission
+ * notice appear in supporting documentation.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+ * ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY
+ * RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN
+ * THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE-
+ * QUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFOR-
+ * MANCE OF THIS SOFTWARE.
+ *
+ * Except as contained in this notice, the name of a copyright holder shall
+ * not be used in advertising or otherwise to promote the sale, use or
+ * other dealings in this Software without prior written authorization of
+ * the copyright holder.
+ *
+ * Authors:
+ *   Kristian Høgsberg (krh@redhat.com)
+ */
+
+#ifndef _DRI2_PROTO_H_
+#define _DRI2_PROTO_H_
+
+#define DRI2_NAME			"DRI2"
+#define DRI2_MAJOR			1
+#define DRI2_MINOR			4
+
+#define DRI2NumberErrors		0
+#define DRI2NumberEvents		2
+#define DRI2NumberRequests		14
+
+#define X_DRI2QueryVersion		0
+#define X_DRI2Connect			1
+#define X_DRI2Authenticate		2
+#define X_DRI2CreateDrawable		3
+#define X_DRI2DestroyDrawable		4
+#define X_DRI2GetBuffers		5
+#define X_DRI2CopyRegion		6
+#define X_DRI2GetBuffersWithFormat	7
+#define X_DRI2SwapBuffers		8
+#define X_DRI2GetMSC			9
+#define X_DRI2WaitMSC			10
+#define X_DRI2WaitSBC			11
+#define X_DRI2SwapInterval		12
+#define X_DRI2GetParam			13
+
+/*
+ * Events
+ */
+#define DRI2_BufferSwapComplete	0
+#define DRI2_InvalidateBuffers	1
+
+typedef struct {
+    CARD32  attachment;
+    CARD32  name;
+    CARD32  pitch;
+    CARD32  cpp;
+    CARD32  flags;
+} xDRI2Buffer;
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri2ReqType;
+    CARD16  length;
+    CARD32  majorVersion;
+    CARD32  minorVersion;
+} xDRI2QueryVersionReq;
+#define sz_xDRI2QueryVersionReq   12
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  majorVersion;
+    CARD32  minorVersion;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+} xDRI2QueryVersionReply;
+#define sz_xDRI2QueryVersionReply	32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri2ReqType;
+    CARD16  length;
+    CARD32  window;
+    CARD32  driverType;
+} xDRI2ConnectReq;
+#define sz_xDRI2ConnectReq	12
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  driverNameLength;
+    CARD32  deviceNameLength;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+} xDRI2ConnectReply;
+#define sz_xDRI2ConnectReply	32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri2ReqType;
+    CARD16  length;
+    CARD32  window;
+    CARD32  magic;
+} xDRI2AuthenticateReq;
+#define sz_xDRI2AuthenticateReq   12
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  authenticated;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+    CARD32  pad6;
+} xDRI2AuthenticateReply;
+#define sz_xDRI2AuthenticateReply	32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri2ReqType;
+    CARD16  length;
+    CARD32  drawable;
+} xDRI2CreateDrawableReq;
+#define sz_xDRI2CreateDrawableReq   8
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri2ReqType;
+    CARD16  length;
+    CARD32  drawable;
+} xDRI2DestroyDrawableReq;
+#define sz_xDRI2DestroyDrawableReq   8
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri2ReqType;
+    CARD16  length;
+    CARD32  drawable;
+    CARD32  count;
+} xDRI2GetBuffersReq;
+#define sz_xDRI2GetBuffersReq   12
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  width;
+    CARD32  height;
+    CARD32  count;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+} xDRI2GetBuffersReply;
+#define sz_xDRI2GetBuffersReply	32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri2ReqType;
+    CARD16  length;
+    CARD32  drawable;
+    CARD32  region;
+    CARD32  dest;
+    CARD32  src;
+} xDRI2CopyRegionReq;
+#define sz_xDRI2CopyRegionReq   20
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+    CARD32  pad6;
+    CARD32  pad7;
+} xDRI2CopyRegionReply;
+#define sz_xDRI2CopyRegionReply	32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri2ReqType;
+    CARD16  length;
+    CARD32  drawable;
+    CARD32  target_msc_hi;
+    CARD32  target_msc_lo;
+    CARD32  divisor_hi;
+    CARD32  divisor_lo;
+    CARD32  remainder_hi;
+    CARD32  remainder_lo;
+} xDRI2SwapBuffersReq;
+#define sz_xDRI2SwapBuffersReq  32
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  swap_hi;
+    CARD32  swap_lo;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+} xDRI2SwapBuffersReply;
+#define sz_xDRI2SwapBuffersReply 32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri2ReqType;
+    CARD16  length;
+    CARD32  drawable;
+} xDRI2GetMSCReq;
+#define sz_xDRI2GetMSCReq 8
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri2ReqType;
+    CARD16  length;
+    CARD32  drawable;
+    CARD32  target_msc_hi;
+    CARD32  target_msc_lo;
+    CARD32  divisor_hi;
+    CARD32  divisor_lo;
+    CARD32  remainder_hi;
+    CARD32  remainder_lo;
+} xDRI2WaitMSCReq;
+#define sz_xDRI2WaitMSCReq 32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri2ReqType;
+    CARD16  length;
+    CARD32  drawable;
+    CARD32  target_sbc_hi;
+    CARD32  target_sbc_lo;
+} xDRI2WaitSBCReq;
+#define sz_xDRI2WaitSBCReq 16
+
+typedef struct {
+    CARD8   type;
+    CARD8   pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  ust_hi;
+    CARD32  ust_lo;
+    CARD32  msc_hi;
+    CARD32  msc_lo;
+    CARD32  sbc_hi;
+    CARD32  sbc_lo;
+} xDRI2MSCReply;
+#define sz_xDRI2MSCReply 32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri2ReqType;
+    CARD16  length;
+    CARD32  drawable;
+    CARD32  interval;
+} xDRI2SwapIntervalReq;
+#define sz_xDRI2SwapIntervalReq 12
+
+typedef struct {
+    CARD8 type;
+    CARD8 pad;
+    CARD16 sequenceNumber;
+    CARD16 event_type;
+    CARD16 pad2;
+    CARD32 drawable;
+    CARD32 ust_hi;
+    CARD32 ust_lo;
+    CARD32 msc_hi;
+    CARD32 msc_lo;
+    CARD32 sbc_hi;
+    CARD32 sbc_lo;
+} xDRI2BufferSwapComplete;
+#define sz_xDRI2BufferSwapComplete 32
+
+typedef struct {
+    CARD8 type;
+    CARD8 pad;
+    CARD16 sequenceNumber;
+    CARD16 event_type;
+    CARD16 pad2;
+    CARD32 drawable;
+    CARD32 ust_hi;
+    CARD32 ust_lo;
+    CARD32 msc_hi;
+    CARD32 msc_lo;
+    CARD32 sbc;
+} xDRI2BufferSwapComplete2;
+#define sz_xDRI2BufferSwapComplete2 32
+
+typedef struct {
+    CARD8 type;
+    CARD8 pad;
+    CARD16 sequenceNumber;
+    CARD32 drawable;
+    CARD32 pad1;
+    CARD32 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+} xDRI2InvalidateBuffers;
+#define sz_xDRI2InvalidateBuffers 32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri2ReqType;
+    CARD16  length;
+    CARD32  drawable;
+    CARD32  param;
+} xDRI2GetParamReq;
+#define sz_xDRI2GetParamReq 12
+
+typedef struct {
+    BYTE    type; /*X_Reply*/
+    BOOL    is_param_recognized;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  value_hi;
+    CARD32  value_lo;
+    CARD32  pad1;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+} xDRI2GetParamReply;
+#define sz_xDRI2GetParamReply 32
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/dri2tokens.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/dri2tokens.h
new file mode 100644
index 0000000..bdca866
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/dri2tokens.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright © 2008 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Soft-
+ * ware"), to deal in the Software without restriction, including without
+ * limitation the rights to use, copy, modify, merge, publish, distribute,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, provided that the above copyright
+ * notice(s) and this permission notice appear in all copies of the Soft-
+ * ware and that both the above copyright notice(s) and this permission
+ * notice appear in supporting documentation.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+ * ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY
+ * RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN
+ * THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE-
+ * QUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFOR-
+ * MANCE OF THIS SOFTWARE.
+ *
+ * Except as contained in this notice, the name of a copyright holder shall
+ * not be used in advertising or otherwise to promote the sale, use or
+ * other dealings in this Software without prior written authorization of
+ * the copyright holder.
+ *
+ * Authors:
+ *   Kristian Høgsberg (krh@redhat.com)
+ */
+
+#ifndef _DRI2_TOKENS_H_
+#define _DRI2_TOKENS_H_
+
+#define DRI2BufferFrontLeft		0
+#define DRI2BufferBackLeft		1
+#define DRI2BufferFrontRight		2
+#define DRI2BufferBackRight		3
+#define DRI2BufferDepth			4
+#define DRI2BufferStencil		5
+#define DRI2BufferAccum			6
+#define DRI2BufferFakeFrontLeft		7
+#define DRI2BufferFakeFrontRight	8
+#define DRI2BufferDepthStencil		9
+#define DRI2BufferHiz			10
+
+/* keep bits 16 and above for prime IDs */
+#define DRI2DriverPrimeMask             7 /* 0 - 7 - allows for 6 devices*/
+#define DRI2DriverPrimeShift           16
+#define DRI2DriverPrimeId(x)         (((x) >> DRI2DriverPrimeShift) & (DRI2DriverPrimeMask))
+
+#define DRI2DriverDRI			0
+#define DRI2DriverVDPAU			1
+
+/* Event sub-types for the swap complete event */
+#define DRI2_EXCHANGE_COMPLETE		0x1
+#define DRI2_BLIT_COMPLETE		0x2
+#define DRI2_FLIP_COMPLETE		0x3
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/dri3proto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/dri3proto.h
new file mode 100644
index 0000000..9cba105
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/dri3proto.h
@@ -0,0 +1,264 @@
+/*
+ * Copyright © 2013 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no representations
+ * about the suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#ifndef _DRI3_PROTO_H_
+#define _DRI3_PROTO_H_
+
+#define DRI3_NAME			"DRI3"
+#define DRI3_MAJOR			1
+#define DRI3_MINOR			3
+
+#define DRI3NumberErrors		0
+#define DRI3NumberEvents		0
+
+#define X_DRI3QueryVersion		0
+#define X_DRI3Open			1
+#define X_DRI3PixmapFromBuffer          2
+#define X_DRI3BufferFromPixmap          3
+#define X_DRI3FenceFromFD               4
+#define X_DRI3FDFromFence               5
+
+/* v1.2 */
+#define xDRI3GetSupportedModifiers      6
+#define xDRI3PixmapFromBuffers          7
+#define xDRI3BuffersFromPixmap          8
+
+/* v1.3 */
+#define xDRI3SetDRMDeviceInUse  9
+
+#define DRI3NumberRequests		10
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri3ReqType;
+    CARD16  length;
+    CARD32  majorVersion;
+    CARD32  minorVersion;
+} xDRI3QueryVersionReq;
+#define sz_xDRI3QueryVersionReq   12
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  majorVersion;
+    CARD32  minorVersion;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+} xDRI3QueryVersionReply;
+#define sz_xDRI3QueryVersionReply	32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri3ReqType;
+    CARD16  length;
+    CARD32  drawable;
+    CARD32  provider;
+} xDRI3OpenReq;
+#define sz_xDRI3OpenReq	12
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    CARD8   nfd;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+    CARD32  pad6;
+    CARD32  pad7;
+} xDRI3OpenReply;
+#define sz_xDRI3OpenReply	32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri3ReqType;
+    CARD16  length;
+    CARD32  pixmap;
+    CARD32  drawable;
+    CARD32  size;
+    CARD16  width;
+    CARD16  height;
+    CARD16  stride;
+    CARD8   depth;
+    CARD8   bpp;
+} xDRI3PixmapFromBufferReq;
+
+#define sz_xDRI3PixmapFromBufferReq     24
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri3ReqType;
+    CARD16  length;
+    CARD32  pixmap;
+} xDRI3BufferFromPixmapReq;
+#define sz_xDRI3BufferFromPixmapReq     8
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    CARD8   nfd;    /* Number of file descriptors returned (1) */
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  size;
+    CARD16  width;
+    CARD16  height;
+    CARD16  stride;
+    CARD8   depth;
+    CARD8   bpp;
+    CARD32  pad20;
+    CARD32  pad24;
+    CARD32  pad28;
+} xDRI3BufferFromPixmapReply;
+#define sz_xDRI3BufferFromPixmapReply   32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri3ReqType;
+    CARD16  length;
+    CARD32  drawable;
+    CARD32  fence;
+    BOOL    initially_triggered;
+    CARD8   pad13;
+    CARD16  pad14;
+} xDRI3FenceFromFDReq;
+
+#define sz_xDRI3FenceFromFDReq  16
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri3ReqType;
+    CARD16  length;
+    CARD32  drawable;
+    CARD32  fence;
+} xDRI3FDFromFenceReq;
+
+#define sz_xDRI3FDFromFenceReq  12
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    CARD8   nfd;    /* Number of file descriptors returned (1) */
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  pad08;
+    CARD32  pad12;
+    CARD32  pad16;
+    CARD32  pad20;
+    CARD32  pad24;
+    CARD32  pad28;
+} xDRI3FDFromFenceReply;
+
+#define sz_xDRI3FDFromFenceReply   32
+
+/* v1.2 */
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri3ReqType;
+    CARD16  length;
+    CARD32  window;
+    CARD8   depth;
+    CARD8   bpp;
+    CARD16  pad10;
+} xDRI3GetSupportedModifiersReq;
+#define sz_xDRI3GetSupportedModifiersReq     12
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    CARD8   pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  numWindowModifiers;
+    CARD32  numScreenModifiers;
+    CARD32  pad16;
+    CARD32  pad20;
+    CARD32  pad24;
+    CARD32  pad28;
+} xDRI3GetSupportedModifiersReply;
+#define sz_xDRI3GetSupportedModifiersReply   32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri3ReqType;
+    CARD16  length;
+    CARD32  pixmap;
+    CARD32  window;
+    CARD8   num_buffers; /* Number of file descriptors passed */
+    CARD8   pad13;
+    CARD16  pad14;
+    CARD16  width;
+    CARD16  height;
+    CARD32  stride0;
+    CARD32  offset0;
+    CARD32  stride1;
+    CARD32  offset1;
+    CARD32  stride2;
+    CARD32  offset2;
+    CARD32  stride3;
+    CARD32  offset3;
+    CARD8   depth;
+    CARD8   bpp;
+    CARD16  pad54;
+    CARD64  modifier;
+} xDRI3PixmapFromBuffersReq;
+#define sz_xDRI3PixmapFromBuffersReq 64
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri3ReqType;
+    CARD16  length;
+    CARD32  pixmap;
+} xDRI3BuffersFromPixmapReq;
+#define sz_xDRI3BuffersFromPixmapReq     8
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    CARD8   nfd;    /* Number of file descriptors returned */
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD16  width;
+    CARD16  height;
+    CARD32  pad12;
+    CARD64  modifier;
+    CARD8   depth;
+    CARD8   bpp;
+    CARD16  pad26;
+    CARD32  pad28;
+} xDRI3BuffersFromPixmapReply;
+#define sz_xDRI3BuffersFromPixmapReply   32
+
+/* v1.3 */
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   dri3ReqType;
+    CARD16  length;
+    CARD32  window;
+    CARD32  drmMajor;
+    CARD32  drmMinor;
+} xDRI3SetDRMDeviceInUseReq;
+#define sz_xDRI3SetDRMDeviceInUseReq    16
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/evieproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/evieproto.h
new file mode 100644
index 0000000..743c3c2
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/evieproto.h
@@ -0,0 +1,156 @@
+/************************************************************
+
+Copyright (c) 2003, Oracle and/or its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next
+paragraph) shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+************************************************************/
+
+#ifndef _XEVIEPROTO_H_
+#define _XEVIEPROTO_H_
+
+#define XEVIENAME "XEVIE"
+
+#define XEVIE_MAJOR_VERSION 1
+#define XEVIE_MINOR_VERSION 0
+
+#define X_XevieQueryVersion			0
+#define X_XevieStart				1
+#define X_XevieEnd				2
+#define X_XevieSend				3
+#define X_XevieSelectInput			4
+
+#define XevieNumberErrors			0
+
+typedef struct _XevieQueryVersion {
+    CARD8   reqType;
+    CARD8   xevieReqType;
+    CARD16  length;
+    CARD16  client_major_version;
+    CARD16  client_minor_version;
+} xXevieQueryVersionReq;
+#define sz_xXevieQueryVersionReq            8
+
+typedef struct {
+    BYTE    type;
+    BOOL    pad1;
+    CARD16  sequence_number;
+    CARD32  length;
+    CARD16  server_major_version;
+    CARD16  server_minor_version;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+    CARD32  pad6;
+} xXevieQueryVersionReply;
+#define sz_xXevieQueryVersionReply  32
+
+typedef struct _XevieStart {
+    CARD8   reqType;
+    CARD8   xevieReqType;
+    CARD16  length;
+    CARD32  screen;
+} xXevieStartReq;
+#define sz_xXevieStartReq 8
+
+typedef struct {
+    BYTE    type;
+    BOOL    pad1;
+    CARD16  sequence_number;
+    CARD32  length;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+    CARD32  pad6;
+    CARD32  pad7;
+} xXevieStartReply;
+#define sz_xXevieStartReply         32
+
+typedef struct _XevieEnd {
+    CARD8   reqType;
+    CARD8   xevieReqType;
+    CARD16  length;
+    CARD32  cmap;
+} xXevieEndReq;
+#define sz_xXevieEndReq             8
+
+typedef struct {
+    BYTE    type;           /* X_Reply */
+    BOOL    pad1;
+    CARD16  sequence_number;
+    CARD32  length;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+    CARD32  pad6;
+    CARD32  pad7;
+} xXevieEndReply;
+#define sz_xXevieEndReply   32
+
+typedef struct _XevieSend {
+    CARD8       reqType;
+    CARD8       xevieReqType;
+    CARD16      length;
+    xEvent      event;
+    CARD32      dataType;
+} xXevieSendReq;
+#define sz_xXevieSendReq           104
+
+typedef struct {
+    BYTE        type;
+    BOOL        pad1;
+    CARD16      sequence_number;
+    CARD32      length;
+    CARD32      pad2;
+    CARD32      pad3;
+    CARD32      pad4;
+    CARD32      pad5;
+    CARD32      pad6;
+    CARD32      pad7;
+} xXevieSendReply;
+#define sz_xXevieSendReply        32
+
+typedef struct _XevieSelectInput {
+    CARD8  reqType;
+    CARD8  xevieReqType;
+    CARD16 length;
+    CARD32 event_mask;
+} xXevieSelectInputReq;
+#define sz_xXevieSelectInputReq          8
+
+typedef struct {
+    BYTE   type;
+    BOOL   pad1;
+    CARD16 sequence_number;
+    CARD32 length;
+    CARD32 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    CARD32 pad6;
+    CARD32 pad7;
+} xXevieSelectInputReply;
+#define sz_xXevieSelectInputReply        32
+
+#endif /* } _XEVIEPROTO_H_ */
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/fontcache.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/fontcache.h
new file mode 100644
index 0000000..b767db1
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/fontcache.h
@@ -0,0 +1,106 @@
+/*-
+ * Copyright (c) 1998-1999 Shunsuke Akiyama <akiyama@jp.FreeBSD.org>.
+ * All rights reserved.
+ * Copyright (c) 1998-1999 X-TrueType Server Project, All rights
+ * reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	Id: fontcache.h,v 1.6 1999/01/31 12:41:32 akiyama Exp $
+ */
+/* $XFree86: xc/include/extensions/fontcache.h,v 1.3 2001/08/01 00:44:35 tsi Exp $ */
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD */
+
+#ifndef _EXT_FONTCACHE_H_
+#define _EXT_FONTCACHE_H_
+
+#define X_FontCacheQueryVersion		0
+#define X_FontCacheGetCacheSettings	1
+#define X_FontCacheChangeCacheSettings	2
+#define X_FontCacheGetCacheStatistics	3
+
+#define FontCacheNumberEvents		0
+
+#define FontCacheBadProtocol		0
+#define FontCacheCannotAllocMemory	1
+#define FontCacheNumberErrors		(FontCacheCannotAllocMemory + 1)
+
+typedef struct {
+    long	himark;
+    long	lowmark;
+    long	balance;
+} FontCacheSettings, *FontCacheSettingsPtr;
+
+struct cacheinfo {
+    long	hits;
+    long	misshits;
+    long	purged;
+    long	usage;
+};
+
+typedef struct {
+    long		purge_runs;
+    long		purge_stat;
+    long		balance;
+    struct cacheinfo	f;
+    struct cacheinfo	v;
+} FontCacheStatistics, *FontCacheStatisticsPtr;
+
+#ifndef _FONTCACHE_SERVER_
+
+#include <X11/Xlib.h>
+
+_XFUNCPROTOBEGIN
+
+Bool FontCacheQueryVersion(
+    Display*		/* dpy */,
+    int* 		/* majorVersion */,
+    int* 		/* minorVersion */
+);
+
+Bool FontCacheQueryExtension(
+    Display*		/* dpy */,
+    int*		/* event_base */,
+    int*		/* error_base */
+);
+
+Status FontCacheGetCacheSettings(
+    Display*			/* dpy */,
+    FontCacheSettings*		/* cache info */
+);
+
+Status FontCacheChangeCacheSettings(
+    Display*			/* dpy */,
+    FontCacheSettings*		/* cache info */
+);
+
+Status FontCacheGetCacheStatistics(
+    Display*			/* dpy */,
+    FontCacheStatistics*	/* cache statistics info */
+);
+
+_XFUNCPROTOEND
+
+#endif /* !_FONTCACHE_SERVER_ */
+
+#endif /* _EXT_FONTCACHE_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/fontcacheP.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/fontcacheP.h
new file mode 100644
index 0000000..75677f3
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/fontcacheP.h
@@ -0,0 +1,40 @@
+/*-
+ * Copyright (c) 1998-1999 Shunsuke Akiyama <akiyama@jp.FreeBSD.org>.
+ * All rights reserved.
+ * Copyright (c) 1998-1999 X-TrueType Server Project, All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	Id: fontcacheP.h,v 1.6 1999/01/31 12:43:53 akiyama Exp $
+ */
+/* $XFree86: xc/include/extensions/fontcacheP.h,v 1.4 2000/03/01 01:04:21 dawes Exp $ */
+
+#ifndef _FONTCACHEP_H_
+#define _FONTCACHEP_H_
+
+#include <X11/extensions/fontcache.h>
+
+int	FontCacheChangeSettings(FontCacheSettingsPtr /* cinfo */);
+void	FontCacheGetSettings(FontCacheSettingsPtr /* cinfo */);
+void	FontCacheGetStatistics(FontCacheStatisticsPtr /* cstats */);
+
+#endif /* _FONTCACHEP_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/fontcachstr.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/fontcachstr.h
new file mode 100644
index 0000000..50f05d0
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/fontcachstr.h
@@ -0,0 +1,130 @@
+/*-
+ * Copyright (c) 1998-1999 Shunsuke Akiyama <akiyama@jp.FreeBSD.org>.
+ * All rights reserved.
+ * Copyright (c) 1998-1999 X-TrueType Server Project, All rights
+ * reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	Id: fontcachstr.h,v 1.7 1999/01/31 14:58:40 akiyama Exp $
+ */
+/* $XFree86$ */
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD */
+
+#ifndef _FONTCACHESTR_H_
+#define _FONTCACHESTR_H_
+
+#include <X11/extensions/fontcache.h>
+
+#define FONTCACHENAME		"FontCache"
+
+#define FONTCACHE_MAJOR_VERSION	0	/* current version numbers */
+#define FONTCACHE_MINOR_VERSION	1
+
+typedef struct _FontCacheQueryVersion {
+    CARD8	reqType;		/* always FontCacheReqCode */
+    CARD8	fontcacheReqType;	/* always X_FontCacheQueryVersion */
+    CARD16	length;
+} xFontCacheQueryVersionReq;
+#define sz_xFontCacheQueryVersionReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	majorVersion;		/* major version of Font-Cache */
+    CARD16	minorVersion;		/* minor version of Font-Cache */
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xFontCacheQueryVersionReply;
+#define sz_xFontCacheQueryVersionReply	32
+
+typedef struct _FontCacheGetCacheSettings {
+    CARD8	reqType;		/* always FontCacheReqCode */
+    CARD8	fontcacheReqType;	/* always X_FontCacheGetCacheSettings */
+    CARD16	length;
+} xFontCacheGetCacheSettingsReq;
+#define sz_xFontCacheGetCacheSettingsReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	himark;
+    CARD32	lowmark;
+    CARD32	balance;
+    CARD32	reserve0;
+    CARD32	reserve1;
+    CARD32	reserve2;
+} xFontCacheGetCacheSettingsReply;
+#define sz_xFontCacheGetCacheSettingsReply	32
+
+typedef struct _FontCacheChangeCacheSettings {
+    CARD8	reqType;		/* always FontCacheReqCode */
+    CARD8	fontcacheReqType;	/* always X_FontCacheChangeCacheSettings */
+    CARD16	length;
+    CARD32	himark;
+    CARD32	lowmark;
+    CARD32	balance;
+    CARD32	reserve0;
+    CARD32	reserve1;
+    CARD32	reserve2;
+    CARD32	reserve3;
+} xFontCacheChangeCacheSettingsReq;
+#define sz_xFontCacheChangeCacheSettingsReq	32
+
+typedef struct _FontCacheGetCacheStatistics {
+    CARD8	reqType;		/* always FontCacheReqCode */
+    CARD8	fontcacheReqType;	/* always X_FontCacheGetCacheStatistics */
+    CARD16	length;
+} xFontCacheGetCacheStatisticsReq;
+#define sz_xFontCacheGetCacheStatisticsReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	purge_runs;
+    CARD32	purge_stat;
+    CARD32	balance;
+    CARD32	reserve0;
+    CARD32	f_hits;
+    CARD32	f_misshits;
+    CARD32	f_purged;
+    CARD32	f_usage;
+    CARD32	f_reserve0;
+    CARD32	v_hits;
+    CARD32	v_misshits;
+    CARD32	v_purged;
+    CARD32	v_usage;
+    CARD32	v_reserve0;
+} xFontCacheGetCacheStatisticsReply;
+#define sz_xFontCacheGetCacheStatisticsReply	64
+
+#endif /* _FONTCACHESTR_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/ge.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/ge.h
new file mode 100644
index 0000000..aca1d8a
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/ge.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright © 2007-2008 Peter Hutterer
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: Peter Hutterer, University of South Australia, NICTA
+ *
+ */
+
+#ifndef _GE_H_
+#define _GE_H_
+
+#define GE_NAME         "Generic Event Extension"
+#define GE_MAJOR        1
+#define GE_MINOR        0
+
+/*********************************************************
+ *
+ * Requests
+ *
+ */
+
+#define X_GEQueryVersion        0
+
+#define GENumberRequests       (X_GEQueryVersion + 1)
+
+/*********************************************************
+ *
+ * Events
+ *
+ */
+
+#define GENumberEvents        0
+
+/*********************************************************
+ *
+ * Errors
+ *
+ */
+
+#define GENumberErrors        0
+
+#endif /* _GE_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/geproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/geproto.h
new file mode 100644
index 0000000..7b34be2
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/geproto.h
@@ -0,0 +1,85 @@
+/*
+ * Copyright © 2007-2008 Peter Hutterer
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: Peter Hutterer, University of South Australia, NICTA
+ *
+ */
+
+#ifndef _GEPROTO_H_
+#define _GEPROTO_H_
+
+#include<X11/Xproto.h>
+#include<X11/X.h>
+#include<X11/extensions/ge.h>
+
+
+/*********************************************************
+ *
+ * Protocol request constants
+ *
+ */
+
+#define X_GEGetExtensionVersion 1
+
+/*********************************************************
+ *
+ * XGE protocol requests/replies
+ *
+ */
+
+/* generic request */
+typedef struct {
+    CARD8   reqType;
+    CARD8   ReqType;
+    CARD16  length;
+} xGEReq;
+
+
+/* QueryVersion */
+typedef struct {
+    CARD8	reqType;       /* input extension major code   */
+    CARD8	ReqType;       /* always X_GEQueryVersion */
+    CARD16	length;
+    CARD16	majorVersion;
+    CARD16	minorVersion;
+} xGEQueryVersionReq;
+
+#define sz_xGEQueryVersionReq    8
+
+typedef struct {
+    CARD8	repType;	/* X_Reply			*/
+    CARD8	RepType;	/* always X_GEQueryVersion */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	majorVersion;
+    CARD16	minorVersion;
+    CARD32	pad00;
+    CARD32	pad01;
+    CARD32	pad02;
+    CARD32	pad03;
+    CARD32	pad04;
+} xGEQueryVersionReply;
+
+#define sz_xGEQueryVersionReply    32
+
+#endif /* _GEPROTO_H_ */
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/lbx.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/lbx.h
new file mode 100644
index 0000000..ecd24ff
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/lbx.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright 1992 Network Computing Devices
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of NCD. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  NCD. makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD.
+ * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ */
+
+#ifndef _LBX_H_
+#define _LBX_H_
+
+#define LBXNAME "LBX"
+
+#define LBX_MAJOR_VERSION	1
+#define LBX_MINOR_VERSION	0
+
+#define LbxNumberReqs			44
+#define LbxEvent			0
+#define LbxQuickMotionDeltaEvent	1
+#define LbxNumberEvents			2
+
+/* This is always the master client */
+#define LbxMasterClientIndex		0
+
+/* LbxEvent lbxType sub-fields */
+#define LbxSwitchEvent			0
+#define LbxCloseEvent			1
+#define LbxDeltaEvent			2
+#define LbxInvalidateTagEvent		3
+#define LbxSendTagDataEvent		4
+#define LbxListenToOne			5
+#define LbxListenToAll			6
+#define LbxMotionDeltaEvent		7
+#define LbxReleaseCmapEvent		8
+#define LbxFreeCellsEvent		9
+
+/*
+ * Lbx image compression methods
+ *
+ * No compression is always assigned the value of 0.
+ *
+ * The rest of the compression method opcodes are assigned dynamically
+ * at option negotiation time.
+ */
+
+#define LbxImageCompressNone		0
+
+
+#define BadLbxClient			0
+#define LbxNumberErrors			(BadLbxClient + 1)
+
+/* tagged data types */
+#define	LbxTagTypeModmap		1
+#define	LbxTagTypeKeymap		2
+#define	LbxTagTypeProperty		3
+#define	LbxTagTypeFont			4
+#define	LbxTagTypeConnInfo		5
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/lbxproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/lbxproto.h
new file mode 100644
index 0000000..8e858aa
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/lbxproto.h
@@ -0,0 +1,975 @@
+/*
+ * Copyright 1992 Network Computing Devices
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of NCD. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  NCD. makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD.
+ * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ */
+
+#ifndef _LBXPROTO_H_
+#define _LBXPROTO_H_
+
+#include <X11/extensions/lbx.h>
+/*
+ * NOTE:  any changes or additions to the opcodes needs to be reflected
+ * in the lbxCacheable array in Xserver/lbx/lbxmain.c
+ */
+
+#define X_LbxQueryVersion		0
+#define X_LbxStartProxy			1
+#define X_LbxStopProxy			2
+#define X_LbxSwitch			3
+#define X_LbxNewClient			4
+#define X_LbxCloseClient		5
+#define X_LbxModifySequence		6
+#define X_LbxAllowMotion		7
+#define X_LbxIncrementPixel		8
+#define X_LbxDelta			9
+#define	X_LbxGetModifierMapping		10
+#define	X_LbxInvalidateTag		12
+#define X_LbxPolyPoint			13
+#define X_LbxPolyLine			14
+#define X_LbxPolySegment		15
+#define X_LbxPolyRectangle		16
+#define X_LbxPolyArc			17
+#define X_LbxFillPoly			18
+#define X_LbxPolyFillRectangle		19
+#define X_LbxPolyFillArc		20
+#define	X_LbxGetKeyboardMapping		21
+#define	X_LbxQueryFont			22
+#define	X_LbxChangeProperty		23
+#define	X_LbxGetProperty		24
+#define	X_LbxTagData			25
+
+#define X_LbxCopyArea			26
+#define X_LbxCopyPlane			27
+#define X_LbxPolyText8			28
+#define X_LbxPolyText16			29
+#define X_LbxImageText8			30
+#define X_LbxImageText16		31
+
+#define X_LbxQueryExtension		32
+#define X_LbxPutImage			33
+#define X_LbxGetImage			34
+
+#define X_LbxBeginLargeRequest		35
+#define X_LbxLargeRequestData		36
+#define X_LbxEndLargeRequest		37
+
+#define X_LbxInternAtoms		38
+#define X_LbxGetWinAttrAndGeom		39
+
+#define X_LbxGrabCmap			40
+#define X_LbxReleaseCmap		41
+#define X_LbxAllocColor			42
+
+#define X_LbxSync			43
+
+/*
+ * Redefine some basic types used by structures defined herein.  This removes
+ * any possibility on 64-bit architectures of one entity viewing communicated
+ * data as 32-bit quantities and another entity viewing the same data as 64-bit
+ * quantities.
+ */
+#define XID CARD32
+#define Atom CARD32
+#define Colormap CARD32
+#define Drawable CARD32
+#define VisualID CARD32
+#define Window CARD32
+
+typedef struct {
+    BOOL	success;		/* TRUE */
+    BOOL	changeType;
+    CARD16	majorVersion,
+		minorVersion;
+    CARD16	length;			/* 1/4 additional bytes in setup info */
+    CARD32	tag;
+} xLbxConnSetupPrefix;
+
+typedef struct _LbxQueryVersion {
+    CARD8	reqType;		/* always LbxReqCode */
+    CARD8	lbxReqType;		/* always X_LbxQueryVersion */
+    CARD16	length;
+} xLbxQueryVersionReq;
+#define sz_xLbxQueryVersionReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	majorVersion;		/* major version of LBX protocol */
+    CARD16	minorVersion;		/* minor version of LBX protocol */
+    CARD32	pad0;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+} xLbxQueryVersionReply;
+#define sz_xLbxQueryVersionReply	32
+
+typedef struct _LbxStartProxy {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxStartProxy */
+    CARD16	length;
+} xLbxStartProxyReq;
+#define sz_xLbxStartProxyReq	    4
+
+typedef struct _LbxStopProxy {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxStopProxy */
+    CARD16	length;
+} xLbxStopProxyReq;
+#define sz_xLbxStopProxyReq	    4
+
+typedef struct _LbxSwitch {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxSwitch */
+    CARD16	length;
+    CARD32	client;		/* new client */
+} xLbxSwitchReq;
+#define sz_xLbxSwitchReq	8
+
+typedef struct _LbxNewClient {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxNewClient */
+    CARD16	length;
+    CARD32	client;		/* new client */
+} xLbxNewClientReq;
+#define sz_xLbxNewClientReq	8
+
+typedef struct _LbxCloseClient {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxCloseClient */
+    CARD16	length;
+    CARD32	client;		/* new client */
+} xLbxCloseClientReq;
+#define sz_xLbxCloseClientReq	8
+
+typedef struct _LbxModifySequence {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxModifySequence */
+    CARD16	length;
+    CARD32	adjust;
+} xLbxModifySequenceReq;
+#define sz_xLbxModifySequenceReq    8
+
+typedef struct _LbxAllowMotion {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxAllowMotion */
+    CARD16	length;
+    CARD32	num;
+} xLbxAllowMotionReq;
+#define sz_xLbxAllowMotionReq    8
+
+typedef struct {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxGrabCmap */
+    CARD16	length;
+    Colormap	cmap;
+} xLbxGrabCmapReq;
+#define sz_xLbxGrabCmapReq	8
+
+#define LBX_SMART_GRAB		0x80
+#define LBX_AUTO_RELEASE	0x40
+#define LBX_3CHANNELS		0x20
+#define LBX_2BYTE_PIXELS	0x10
+#define LBX_RGB_BITS_MASK	0x0f
+
+#define LBX_LIST_END		0
+#define LBX_PIXEL_PRIVATE	1
+#define LBX_PIXEL_SHARED	2
+#define LBX_PIXEL_RANGE_PRIVATE	3
+#define LBX_PIXEL_RANGE_SHARED	4
+#define LBX_NEXT_CHANNEL	5
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	flags;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	pad0;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xLbxGrabCmapReply;
+#define sz_xLbxGrabCmapReply	32
+#define sz_xLbxGrabCmapReplyHdr	8
+
+
+typedef struct {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxReleaseCmap */
+    CARD16	length;
+    Colormap	cmap;
+} xLbxReleaseCmapReq;
+#define sz_xLbxReleaseCmapReq	8
+
+typedef struct {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxAllocColor */
+    CARD16	length;
+    Colormap	cmap;
+    CARD32	pixel;
+    CARD16	red, green, blue;
+    CARD16	pad;
+} xLbxAllocColorReq;
+#define sz_xLbxAllocColorReq	20
+
+typedef struct _LbxIncrementPixel {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxIncrementPixel */
+    CARD16	length;
+    CARD32	cmap;
+    CARD32	pixel;
+} xLbxIncrementPixelReq;
+#define sz_xLbxIncrementPixelReq    12
+
+typedef struct _LbxDelta {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxDelta */
+    CARD16	length;
+    CARD8	diffs;		/* number of diffs */
+    CARD8	cindex;		/* cache index */
+				/* list of diffs follows */
+} xLbxDeltaReq;
+#define sz_xLbxDeltaReq    6
+
+typedef struct _LbxGetModifierMapping {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxGetModifierMapping */
+    CARD16	length;
+} xLbxGetModifierMappingReq;
+#define	sz_xLbxGetModifierMappingReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	keyspermod;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	tag;
+    CARD32	pad0;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+} xLbxGetModifierMappingReply;
+#define sz_xLbxGetModifierMappingReply	32
+
+typedef struct _LbxGetKeyboardMapping {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxGetKeyboardMapping */
+    CARD16	length;
+    KeyCode	firstKeyCode;
+    CARD8	count;
+    CARD16	pad1;
+} xLbxGetKeyboardMappingReq;
+#define	sz_xLbxGetKeyboardMappingReq	8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	keysperkeycode;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	tag;
+    CARD32	pad0;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+} xLbxGetKeyboardMappingReply;
+#define sz_xLbxGetKeyboardMappingReply	32
+
+typedef struct _LbxQueryFont {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxQueryFont */
+    CARD16	length;
+    CARD32	fid;
+} xLbxQueryFontReq;
+#define	sz_xLbxQueryFontReq	8
+
+typedef struct _LbxInternAtoms {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxInternAtoms */
+    CARD16	length;
+    CARD16	num;
+} xLbxInternAtomsReq;
+#define sz_xLbxInternAtomsReq	6
+
+typedef struct {
+    BYTE	type;		/* X_Reply */
+    CARD8	unused;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	atomsStart;
+    CARD32	pad0;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+} xLbxInternAtomsReply;
+#define sz_xLbxInternAtomsReply		32
+#define sz_xLbxInternAtomsReplyHdr	8
+
+
+typedef struct _LbxGetWinAttrAndGeom {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxGetWinAttrAndGeom */
+    CARD16	length;
+    CARD32	id;		/* window id */
+} xLbxGetWinAttrAndGeomReq;
+#define sz_xLbxGetWinAttrAndGeomReq 8
+
+typedef struct {
+    BYTE type;  /* X_Reply */
+    CARD8 backingStore;
+    CARD16 sequenceNumber;
+    CARD32 length;		/* NOT 0; this is an extra-large reply */
+    VisualID visualID;
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD16 c_class;
+#else
+    CARD16 class;
+#endif
+    CARD8 bitGravity;
+    CARD8 winGravity;
+    CARD32 backingBitPlanes;
+    CARD32 backingPixel;
+    BOOL saveUnder;
+    BOOL mapInstalled;
+    CARD8 mapState;
+    BOOL override;
+    Colormap colormap;
+    CARD32 allEventMasks;
+    CARD32 yourEventMask;
+    CARD16 doNotPropagateMask;
+    CARD16 pad1;
+    Window root;
+    INT16 x, y;
+    CARD16 width, height;
+    CARD16 borderWidth;
+    CARD8 depth;
+    CARD8 pad2;
+} xLbxGetWinAttrAndGeomReply;
+#define sz_xLbxGetWinAttrAndGeomReply 60
+
+
+typedef struct {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxSync */
+    CARD16	length;
+} xLbxSyncReq;
+#define sz_xLbxSyncReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	pad0;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xLbxSyncReply;
+#define sz_xLbxSyncReply 32
+
+
+/* an LBX squished charinfo packs the data in a CARD32 as follows */
+#define	LBX_WIDTH_SHIFT		26
+#define	LBX_LEFT_SHIFT		20
+#define	LBX_RIGHT_SHIFT		13
+#define	LBX_ASCENT_SHIFT	7
+#define	LBX_DESCENT_SHIFT	0
+
+#define	LBX_WIDTH_BITS		6
+#define	LBX_LEFT_BITS		6
+#define	LBX_RIGHT_BITS		7
+#define	LBX_ASCENT_BITS		6
+#define	LBX_DESCENT_BITS	7
+
+#define	LBX_WIDTH_MASK		0xfc000000
+#define	LBX_LEFT_MASK		0x03f00000
+#define	LBX_RIGHT_MASK		0x000fe000
+#define	LBX_ASCENT_MASK		0x00001f80
+#define	LBX_DESCENT_MASK	0x0000007f
+
+#define	LBX_MASK_BITS(val, n)	((unsigned int) ((val) & ((1 << (n)) - 1)))
+
+typedef struct {
+    CARD32	metrics;
+} xLbxCharInfo;
+
+/* note that this is identical to xQueryFontReply except for missing
+ * first 2 words
+ */
+typedef struct {
+    xCharInfo minBounds;
+/* XXX do we need to leave this gunk? */
+#ifndef WORD64
+    CARD32 walign1;
+#endif
+    xCharInfo maxBounds;
+#ifndef WORD64
+    CARD32 walign2;
+#endif
+    CARD16 minCharOrByte2, maxCharOrByte2;
+    CARD16 defaultChar;
+    CARD16 nFontProps;	/* followed by this many xFontProp structures */
+    CARD8 drawDirection;
+    CARD8 minByte1, maxByte1;
+    BOOL allCharsExist;
+    INT16 fontAscent, fontDescent;
+    CARD32 nCharInfos;	/* followed by this many xLbxCharInfo structures */
+} xLbxFontInfo;
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	compression;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	tag;
+    CARD32	pad0;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    /* X_QueryFont sticks much of the data in the base reply packet,
+     * but we hope that it won't be needed, (and it won't fit in 32 bytes
+     * with the tag anyways)
+     *
+     * if any additional data is needed, its sent in a xLbxFontInfo
+     */
+} xLbxQueryFontReply;
+#define sz_xLbxQueryFontReply	32
+
+typedef struct _LbxChangeProperty {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxChangeProperty */
+    CARD16	length;
+    Window	window;
+    Atom	property;
+    Atom	type;
+    CARD8	format;
+    CARD8	mode;
+    BYTE	pad[2];
+    CARD32	nUnits;
+} xLbxChangePropertyReq;
+#define	sz_xLbxChangePropertyReq	24
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	pad;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	tag;
+    CARD32	pad0;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+} xLbxChangePropertyReply;
+#define sz_xLbxChangePropertyReply	32
+
+typedef struct _LbxGetProperty {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxGetProperty */
+    CARD16	length;
+    Window	window;
+    Atom	property;
+    Atom	type;
+    CARD8	delete;
+    BYTE	pad[3];
+    CARD32	longOffset;
+    CARD32	longLength;
+} xLbxGetPropertyReq;
+#define	sz_xLbxGetPropertyReq	28
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	format;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    Atom	propertyType;
+    CARD32	bytesAfter;
+    CARD32	nItems;
+    CARD32	tag;
+    CARD32	pad1;
+    CARD32	pad2;
+} xLbxGetPropertyReply;
+#define sz_xLbxGetPropertyReply	32
+
+typedef struct _LbxTagData {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxTagData */
+    CARD16	length;
+    XID 	tag;
+    CARD32	real_length;
+    /* data */
+} xLbxTagDataReq;
+#define	sz_xLbxTagDataReq	12
+
+typedef struct _LbxInvalidateTag {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxInvalidateTag */
+    CARD16	length;
+    CARD32	tag;
+} xLbxInvalidateTagReq;
+#define	sz_xLbxInvalidateTagReq	8
+
+typedef struct _LbxPutImage {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxPutImage */
+    CARD16	length;
+    CARD8	compressionMethod;
+    CARD8	cacheEnts;
+    CARD8	bitPacked;
+    /* rest is variable */
+} xLbxPutImageReq;
+#define sz_xLbxPutImageReq	7
+
+typedef struct {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxGetImage */
+    CARD16	length;
+    Drawable	drawable;
+    INT16	x, y;
+    CARD16	width, height;
+    CARD32	planeMask;
+    CARD8	format;
+    CARD8	pad1;
+    CARD16	pad2;
+} xLbxGetImageReq;
+
+#define sz_xLbxGetImageReq 24
+
+typedef struct {
+    BYTE type;			/* X_Reply */
+    CARD8 depth;
+    CARD16 sequenceNumber;
+    CARD32 lbxLength;
+    CARD32 xLength;
+    VisualID visual;
+    CARD8 compressionMethod;
+    CARD8 pad1;
+    CARD16 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+} xLbxGetImageReply;
+
+#define sz_xLbxGetImageReply 32
+
+/* Following used for LbxPolyPoint, LbxPolyLine, LbxPolySegment,
+   LbxPolyRectangle, LbxPolyArc, LbxPolyFillRectangle and LbxPolyFillArc */
+
+#define GFX_CACHE_SIZE  15
+
+#define GFXdCacheEnt(e)	    ((e) & 0xf)
+#define GFXgCacheEnt(e)	    (((e) >> 4) & 0xf)
+#define GFXCacheEnts(d,g)   (((d) & 0xf) | (((g) & 0xf) << 4))
+
+#define GFXCacheNone   0xf
+
+typedef struct _LbxPolyPoint {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;
+    CARD16	length;
+    CARD8	cacheEnts;
+    CARD8	padBytes;
+} xLbxPolyPointReq;
+
+#define sz_xLbxPolyPointReq	6
+
+typedef xLbxPolyPointReq xLbxPolyLineReq;
+typedef xLbxPolyPointReq xLbxPolySegmentReq;
+typedef xLbxPolyPointReq xLbxPolyRectangleReq;
+typedef xLbxPolyPointReq xLbxPolyArcReq;
+typedef xLbxPolyPointReq xLbxPolyFillRectangleReq;
+typedef xLbxPolyPointReq xLbxPolyFillArcReq;
+
+#define sz_xLbxPolyLineReq		sz_xLbxPolyPointReq
+#define sz_xLbxPolySegmentReq		sz_xLbxPolyPointReq
+#define sz_xLbxPolyRectangleReq		sz_xLbxPolyPointReq
+#define sz_xLbxPolyArcReq		sz_xLbxPolyPointReq
+#define sz_xLbxPolyFillRectangleReq	sz_xLbxPolyPointReq
+#define sz_xLbxPolyFillArc		sz_xLbxPolyPointReq
+
+typedef struct _LbxFillPoly {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;
+    CARD16	length;
+    CARD8	cacheEnts;
+    BYTE	shape;
+    CARD8	padBytes;
+} xLbxFillPolyReq;
+#define sz_xLbxFillPolyReq	7
+
+typedef struct _LbxCopyArea {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;
+    CARD16	length;
+    CARD8	srcCache;	/* source drawable */
+    CARD8	cacheEnts;	/* dest drawable and gc */
+    /* followed by encoded src x, src y, dst x, dst y, width, height */
+} xLbxCopyAreaReq;
+
+#define sz_xLbxCopyAreaReq  6
+
+typedef struct _LbxCopyPlane {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;
+    CARD16	length;
+    CARD32	bitPlane;
+    CARD8	srcCache;	/* source drawable */
+    CARD8	cacheEnts;	/* dest drawable and gc */
+    /* followed by encoded src x, src y, dst x, dst y, width, height */
+} xLbxCopyPlaneReq;
+
+#define sz_xLbxCopyPlaneReq  10
+
+typedef struct _LbxPolyText {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;
+    CARD16	length;
+    CARD8	cacheEnts;
+    /* followed by encoded src x, src y coordinates and text elts */
+} xLbxPolyTextReq;
+
+#define sz_xLbxPolyTextReq  5
+
+typedef xLbxPolyTextReq xLbxPolyText8Req;
+typedef xLbxPolyTextReq xLbxPolyText16Req;
+
+#define sz_xLbxPolyTextReq	5
+#define sz_xLbxPolyText8Req	5
+#define sz_xLbxPolyText16Req	5
+
+typedef struct _LbxImageText {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;
+    CARD16	length;
+    CARD8	cacheEnts;
+    CARD8	nChars;
+    /* followed by encoded src x, src y coordinates and string */
+} xLbxImageTextReq;
+
+typedef xLbxImageTextReq xLbxImageText8Req;
+typedef xLbxImageTextReq xLbxImageText16Req;
+
+#define sz_xLbxImageTextReq	6
+#define sz_xLbxImageText8Req	6
+#define sz_xLbxImageText16Req	6
+
+typedef struct {
+    CARD8       offset;
+    CARD8       diff;
+} xLbxDiffItem;
+#define sz_xLbxDiffItem    2
+
+typedef struct {
+    BYTE	type;		/* X_Reply */
+    CARD8	nOpts;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	optDataStart;
+    CARD32	pad0;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+} xLbxStartReply;
+#define sz_xLbxStartReply	32
+#define sz_xLbxStartReplyHdr	8
+
+typedef struct _LbxQueryExtension {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxQueryExtension */
+    CARD16	length;
+    CARD32	nbytes;
+} xLbxQueryExtensionReq;
+#define	sz_xLbxQueryExtensionReq	8
+
+typedef struct _LbxQueryExtensionReply {
+    BYTE	type;			/* X_Reply */
+    CARD8	numReqs;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    BOOL	present;
+    CARD8	major_opcode;
+    CARD8	first_event;
+    CARD8	first_error;
+    CARD32	pad0;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+
+    /* reply & event generating requests */
+} xLbxQueryExtensionReply;
+#define sz_xLbxQueryExtensionReply	32
+
+
+typedef struct _LbxBeginLargeRequest {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxBeginLargeRequest */
+    CARD16	length;
+    CARD32	largeReqLength;
+} xLbxBeginLargeRequestReq;
+#define	sz_BeginLargeRequestReq 8
+
+typedef struct _LbxLargeRequestData {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxLargeRequestData */
+    CARD16	length;
+    /* followed by LISTofCARD8 data */
+} xLbxLargeRequestDataReq;
+#define	sz_LargeRequestDataReq 4
+
+typedef struct _LbxEndLargeRequest {
+    CARD8	reqType;	/* always LbxReqCode */
+    CARD8	lbxReqType;	/* always X_LbxEndLargeRequest */
+    CARD16	length;
+} xLbxEndLargeRequestReq;
+#define	sz_EndLargeRequestReq 4
+
+
+
+typedef struct _LbxSwitchEvent {
+    BYTE	type;		/* always eventBase + LbxEvent */
+    BYTE	lbxType;	/* LbxSwitchEvent */
+    CARD16	pad;
+    CARD32	client;
+} xLbxSwitchEvent;
+#define sz_xLbxSwitchEvent	8
+
+typedef struct _LbxCloseEvent {
+    BYTE	type;		/* always eventBase + LbxEvent */
+    BYTE	lbxType;	/* LbxCloseEvent */
+    CARD16	sequenceNumber;
+    CARD32	client;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xLbxCloseEvent;
+#define sz_xLbxCloseEvent	32
+
+typedef struct _LbxInvalidateTagEvent {
+    BYTE	type;		/* always eventBase + LbxEvent */
+    BYTE	lbxType;	/* LbxInvalidateTagEvent */
+    CARD16	sequenceNumber;
+    CARD32	tag;
+    CARD32	tagType;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xLbxInvalidateTagEvent;
+#define sz_xLbxInvalidateTagEvent 32
+
+typedef struct _LbxSendTagDataEvent {
+    BYTE	type;		/* always eventBase + LbxEvent */
+    BYTE	lbxType;	/* LbxSendTagDataEvent */
+    CARD16	sequenceNumber;
+    CARD32	tag;
+    CARD32	tagType;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xLbxSendTagDataEvent;
+#define sz_xLbxSendTagDataEvent 32
+
+typedef struct _LbxListenToOneEvent {
+    BYTE	type;		/* always eventBase + LbxEvent */
+    BYTE	lbxType;	/* LbxListenToOneEvent */
+    CARD16	sequenceNumber;
+    CARD32	client;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xLbxListenToOneEvent;
+#define sz_xLbxListenToOneEvent 32
+
+typedef struct _LbxListenToAllEvent {
+    BYTE	type;		/* always eventBase + LbxEvent */
+    BYTE	lbxType;	/* LbxListenToAllEvent */
+    CARD16	sequenceNumber;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+    CARD32	pad7;
+} xLbxListenToAllEvent;
+#define sz_xLbxListenToOneEvent 32
+
+typedef struct _LbxReleaseCmapEvent {
+    BYTE	type;		/* always eventBase + LbxEvent */
+    BYTE	lbxType;	/* LbxReleaseCmapEvent */
+    CARD16	sequenceNumber;
+    Colormap	colormap;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xLbxReleaseCmapEvent;
+#define sz_xLbxReleaseCmapEvent	32
+
+
+typedef struct _LbxFreeCellsEvent {
+    BYTE	type;		/* always eventBase + LbxEvent */
+    BYTE	lbxType;	/* LbxFreeCellsEvent */
+    CARD16	sequenceNumber;
+    Colormap	colormap;
+    CARD32	pixelStart;
+    CARD32	pixelEnd;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+} xLbxFreeCellsEvent;
+#define sz_xLbxFreeCellsEvent	32
+
+
+/*
+ * squished X event sizes.  If these change, be sure to update lbxquish.c
+ * and unsquish.c appropriately
+ *
+ * lbxsz_* is the padded squished length
+ * lbxupsz_* is the unpadded squished length
+ */
+
+#define	  lbxsz_KeyButtonEvent		32
+#define	lbxupsz_KeyButtonEvent		31
+
+#define	  lbxsz_EnterLeaveEvent		32
+#define	lbxupsz_EnterLeaveEvent		32
+
+#define	  lbxsz_FocusEvent		12
+#define	lbxupsz_FocusEvent		9
+
+#define	  lbxsz_KeymapEvent		32
+#define	lbxupsz_KeymapEvent		32
+
+#define	  lbxsz_ExposeEvent		20
+#define	lbxupsz_ExposeEvent		18
+
+#define	  lbxsz_GfxExposeEvent		24
+#define	lbxupsz_GfxExposeEvent		21
+
+#define	  lbxsz_NoExposeEvent		12
+#define	lbxupsz_NoExposeEvent		11
+
+#define	  lbxsz_VisibilityEvent		12
+#define	lbxupsz_VisibilityEvent		9
+
+#define	  lbxsz_CreateNotifyEvent	24
+#define	lbxupsz_CreateNotifyEvent	23
+
+#define	  lbxsz_DestroyNotifyEvent	12
+#define	lbxupsz_DestroyNotifyEvent	12
+
+#define	  lbxsz_UnmapNotifyEvent	16
+#define	lbxupsz_UnmapNotifyEvent	13
+
+#define	  lbxsz_MapNotifyEvent		16
+#define	lbxupsz_MapNotifyEvent		13
+
+#define	  lbxsz_MapRequestEvent		12
+#define	lbxupsz_MapRequestEvent		12
+
+#define	  lbxsz_ReparentEvent		24
+#define	lbxupsz_ReparentEvent		21
+
+#define	  lbxsz_ConfigureNotifyEvent	28
+#define	lbxupsz_ConfigureNotifyEvent	27
+
+#define	  lbxsz_ConfigureRequestEvent	28
+#define	lbxupsz_ConfigureRequestEvent	28
+
+#define	  lbxsz_GravityEvent		16
+#define	lbxupsz_GravityEvent		16
+
+#define	  lbxsz_ResizeRequestEvent	12
+#define	lbxupsz_ResizeRequestEvent	12
+
+#define	  lbxsz_CirculateEvent		20
+#define	lbxupsz_CirculateEvent		17
+
+#define	  lbxsz_PropertyEvent		20
+#define	lbxupsz_PropertyEvent		17
+
+#define	  lbxsz_SelectionClearEvent	16
+#define	lbxupsz_SelectionClearEvent	16
+
+#define	  lbxsz_SelectionRequestEvent	28
+#define	lbxupsz_SelectionRequestEvent	28
+
+#define	  lbxsz_SelectionNotifyEvent	24
+#define	lbxupsz_SelectionNotifyEvent	24
+
+#define	  lbxsz_ColormapEvent		16
+#define	lbxupsz_ColormapEvent		14
+
+#define	  lbxsz_MappingNotifyEvent	8
+#define	lbxupsz_MappingNotifyEvent	7
+
+#define	  lbxsz_ClientMessageEvent	32
+#define	lbxupsz_ClientMessageEvent	32
+
+#define	lbxsz_UnknownEvent		32
+
+#ifdef DEBUG
+
+#define DBG_SWITCH	0x00000001
+#define DBG_CLOSE	0x00000002
+#define DBG_IO		0x00000004
+#define DBG_READ_REQ	0x00000008
+#define DBG_LEN		0x00000010
+#define DBG_BLOCK	0x00000020
+#define DBG_CLIENT	0x00000040
+#define DBG_DELTA	0x00000080
+#endif
+/*
+ * Cancel the previous redefinition of the basic types, thus restoring their
+ * X.h definitions.
+ */
+
+#undef XID
+#undef Atom
+#undef Colormap
+#undef Drawable
+#undef VisualID
+#undef Window
+
+#endif	/* _LBXPROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/lgewire.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/lgewire.h
new file mode 100644
index 0000000..ba40bd6
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/lgewire.h
@@ -0,0 +1,120 @@
+/************************************************************
+
+Copyright (c) 2004, Sun Microsystems, Inc.
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+********************************************************/
+
+/*
+ * lge.h - Looking Glass Extension Definitions
+ */
+
+#ifndef _LGEWIRE_H
+#define _LGEWIRE_H
+
+#include "X11/Xfuncproto.h"
+
+#define LGE_NAME "LGE"
+
+/* Current interface version numbers */
+#define LGE_MAJOR_VERSION   5
+#define LGE_MINOR_VERSION   0
+
+/* Display Server is alive */
+#define  X_LgeQueryVersion	     0
+#define  X_LgeRegisterClient         1
+#define  X_LgeRegisterScreen         2
+#define  X_LgeControlLgMode          3
+#define  X_LgeSendEvent              4
+
+/* Arguments to XLgeRegisterClient */
+#define LGE_CLIENT_GENERIC	     0
+#define LGE_CLIENT_PICKER            1
+#define LGE_CLIENT_EVENT_DELIVERER   2
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       lgeReqType;
+    CARD16	length;
+} xLgeQueryVersionReq;
+
+#define sz_xLgeQueryVersionReq	sizeof(xLgeQueryVersionReq)
+
+typedef struct {
+    /* Always X_Reply */
+    BYTE        type;
+    CARD8       unused;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	majorVersion;
+    CARD32	minorVersion;
+    CARD32	implementation;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xLgeQueryVersionReply;
+
+#define sz_xLgeQueryVersionReply sizeof(xLgeQueryVersionReply)
+
+typedef struct {
+    CARD8  reqType;
+    CARD8  lgeReqType;
+    CARD16 length;
+    CARD8  clientType;
+    BOOL   sendEventDirect;
+    CARD16 pad2;
+} xLgeRegisterClientReq;
+
+#define sz_xLgeRegisterClientReq sizeof(xLgeRegisterClientReq)
+
+typedef struct {
+    CARD8  reqType;
+    CARD8  lgeReqType;
+    CARD16 length;
+    /* The pseudo-root window of the screen */
+    Window prw;
+} xLgeRegisterScreenReq;
+
+#define sz_xLgeRegisterScreenReq sizeof(xLgeRegisterScreenReq)
+
+typedef struct {
+    CARD8     reqType;
+    CARD8     lgeReqType;
+    CARD16    length;
+    BOOL      enable;
+    CARD8     pad1;
+    CARD16    pad2;
+} xLgeControlLgModeReq;
+
+#define sz_xLgeControlLgModeReq sizeof(xLgeControlLgModeReq)
+
+typedef struct {
+    CARD8     reqType;
+    CARD8     lgeReqType;
+    CARD16    length;
+    xEvent    event;
+} xLgeSendEventReq;
+
+#define sz_xLgeSendEventReq sizeof(xLgeSendEventReq)
+
+#endif /* LGEWIRE_H */
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/meson.build b/depends/libxcb/depends/xorgproto/include/X11/extensions/meson.build
new file mode 100644
index 0000000..9c91f22
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/meson.build
@@ -0,0 +1,123 @@
+install_headers(
+    'ag.h',
+    'agproto.h',
+    'applewmconst.h',
+    'applewmproto.h',
+    'bigreqsproto.h',
+    'bigreqstr.h',
+    'composite.h',
+    'compositeproto.h',
+    'cup.h',
+    'cupproto.h',
+    'damageproto.h',
+    'damagewire.h',
+    'dbe.h',
+    'dbeproto.h',
+    'dmx.h',
+    'dmxproto.h',
+    'dpmsconst.h',
+    'dpmsproto.h',
+    'dri2proto.h',
+    'dri2tokens.h',
+    'dri3proto.h',
+    'EVI.h',
+    'EVIproto.h',
+    'ge.h',
+    'geproto.h',
+    'lbx.h',
+    'lbxproto.h',
+    'mitmiscconst.h',
+    'mitmiscproto.h',
+    'multibufconst.h',
+    'multibufproto.h',
+    'panoramiXproto.h',
+    'presentproto.h',
+    'presenttokens.h',
+    'randr.h',
+    'randrproto.h',
+    'recordconst.h',
+    'recordproto.h',
+    'recordstr.h',
+    'render.h',
+    'renderproto.h',
+    'saver.h',
+    'saverproto.h',
+    'secur.h',
+    'securproto.h',
+    'shapeconst.h',
+    'shapeproto.h',
+    'shapestr.h',
+    'shm.h',
+    'shmproto.h',
+    'shmstr.h',
+    'syncconst.h',
+    'syncproto.h',
+    'syncstr.h',
+    'xcmiscproto.h',
+    'xcmiscstr.h',
+    'xf86bigfont.h',
+    'xf86bigfproto.h',
+    'xf86bigfstr.h',
+    'xf86dga1const.h',
+    'xf86dga1proto.h',
+    'xf86dga1str.h',
+    'xf86dgaconst.h',
+    'xf86dga.h',
+    'xf86dgaproto.h',
+    'xf86dgastr.h',
+    'xf86vm.h',
+    'xf86vmproto.h',
+    'xf86vmstr.h',
+    'xfixesproto.h',
+    'xfixeswire.h',
+    'XI2.h',
+    'XI2proto.h',
+    'XI.h',
+    'XIproto.h',
+    'XKB.h',
+    'XKBproto.h',
+    'XKBsrv.h',
+    'XKBstr.h',
+    'XResproto.h',
+    'xtestconst.h',
+    'xtestext1const.h',
+    'xtestext1proto.h',
+    'xtestproto.h',
+    'Xv.h',
+    'XvMC.h',
+    'XvMCproto.h',
+    'Xvproto.h',
+    'xwaylandproto.h',
+    subdir : 'X11/extensions'
+)
+
+if get_option('legacy') == true
+    install_headers(
+        'evieproto.h',
+        'fontcache.h',
+        'fontcacheP.h',
+        'fontcachstr.h',
+        'lgewire.h',
+        'Print.h',
+        'Printstr.h',
+        'vldXvMC.h',
+        'windowswm.h',
+        'windowswmstr.h',
+        'xcalibrateproto.h',
+        'xcalibratewire.h',
+        'xtrapbits.h',
+        'xtrapddmi.h',
+        'xtrapdi.h',
+        'xtrapemacros.h',
+        'xtraplib.h',
+        'xtraplibp.h',
+        'xtrapproto.h',
+        'Xeviestr.h',
+        'xf86misc.h',
+        'xf86mscstr.h',
+        'xf86rush.h',
+        'xf86rushstr.h',
+        'XKBgeom.h',
+        subdir : 'X11/extensions'
+    )
+endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/mitmiscconst.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/mitmiscconst.h
new file mode 100644
index 0000000..adc5f94
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/mitmiscconst.h
@@ -0,0 +1,38 @@
+/************************************************************
+
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+********************************************************/
+
+/* RANDOM CRUFT! THIS HAS NO OFFICIAL X CONSORTIUM OR X PROJECT TEAM BLESSING */
+
+
+#ifndef _MITMISCCONST_H_
+#define _MITMISCCONST_H_
+
+#define MITMiscNumberEvents		0
+#define MITMiscNumberErrors		0
+
+#define MITMISCNAME "MIT-SUNDRY-NONSTANDARD"
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/mitmiscproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/mitmiscproto.h
new file mode 100644
index 0000000..d42e4fc
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/mitmiscproto.h
@@ -0,0 +1,68 @@
+/************************************************************
+
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+********************************************************/
+
+/* RANDOM CRUFT! THIS HAS NO OFFICIAL X CONSORTIUM OR X PROJECT TEAM BLESSING */
+
+#ifndef _MITMISCPROTO_H_
+#define _MITMISCPROTO_H_
+
+#include <X11/extensions/mitmiscconst.h>
+
+#define X_MITSetBugMode			0
+#define X_MITGetBugMode			1
+
+typedef struct _SetBugMode {
+    CARD8	reqType;	/* always MITReqCode */
+    CARD8	mitReqType;	/* always X_MITSetBugMode */
+    CARD16	length;
+    BOOL	onOff;
+    BYTE	pad0;
+    CARD16	pad1;
+} xMITSetBugModeReq;
+#define sz_xMITSetBugModeReq	8
+
+typedef struct _GetBugMode {
+    CARD8	reqType;	/* always MITReqCode */
+    CARD8	mitReqType;	/* always X_MITGetBugMode */
+    CARD16	length;
+} xMITGetBugModeReq;
+#define sz_xMITGetBugModeReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	onOff;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	pad0;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xMITGetBugModeReply;
+#define sz_xMITGetBugModeReply	32
+
+#endif /* _MITMISCPROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/multibufconst.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/multibufconst.h
new file mode 100644
index 0000000..2d1238c
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/multibufconst.h
@@ -0,0 +1,83 @@
+/*
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ */
+
+#ifndef _MULTIBUFCONST_H_
+#define _MULTIBUFCONST_H_
+
+#define MULTIBUFFER_PROTOCOL_NAME "Multi-Buffering"
+
+#define MULTIBUFFER_MAJOR_VERSION	1	/* current version numbers */
+#define MULTIBUFFER_MINOR_VERSION	1	/* has ClearImageBufferArea */
+
+/*
+ * update_action field
+ */
+#define MultibufferUpdateActionUndefined	0
+#define MultibufferUpdateActionBackground	1
+#define MultibufferUpdateActionUntouched	2
+#define MultibufferUpdateActionCopied		3
+
+/*
+ * update_hint field
+ */
+#define MultibufferUpdateHintFrequent		0
+#define MultibufferUpdateHintIntermittent	1
+#define MultibufferUpdateHintStatic		2
+
+/*
+ * valuemask fields
+ */
+#define MultibufferWindowUpdateHint	(1L << 0)
+#define MultibufferBufferEventMask	(1L << 0)
+
+/*
+ * mono vs. stereo and left vs. right
+ */
+#define MultibufferModeMono		0
+#define MultibufferModeStereo		1
+#define MultibufferSideMono		0
+#define MultibufferSideLeft	  	1
+#define MultibufferSideRight		2
+
+/*
+ * clobber state
+ */
+#define MultibufferUnclobbered		0
+#define MultibufferPartiallyClobbered	1
+#define MultibufferFullyClobbered	2
+
+/*
+ * event stuff
+ */
+#define MultibufferClobberNotifyMask	0x02000000
+#define MultibufferUpdateNotifyMask	0x04000000
+
+#define MultibufferClobberNotify	0
+#define MultibufferUpdateNotify		1
+#define MultibufferNumberEvents		(MultibufferUpdateNotify + 1)
+
+#define MultibufferBadBuffer		0
+#define MultibufferNumberErrors		(MultibufferBadBuffer + 1)
+
+#endif /* _MULTIBUFCONST_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/multibufproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/multibufproto.h
new file mode 100644
index 0000000..19a6401
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/multibufproto.h
@@ -0,0 +1,295 @@
+/*
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+ */
+
+#ifndef _MULTIBUFPROTO_H_
+#define _MULTIBUFPROTO_H_
+
+#include <X11/extensions/multibufconst.h>
+
+/*
+ * Protocol requests constants and alignment values
+ */
+
+#define Window CARD32
+#define Drawable CARD32
+#define VisualID CARD32
+#define Multibuffer CARD32
+
+#define X_MbufGetBufferVersion		0
+#define X_MbufCreateImageBuffers	1
+#define X_MbufDestroyImageBuffers	2
+#define X_MbufDisplayImageBuffers	3
+#define X_MbufSetMBufferAttributes	4
+#define X_MbufGetMBufferAttributes	5
+#define X_MbufSetBufferAttributes	6
+#define X_MbufGetBufferAttributes	7
+#define X_MbufGetBufferInfo		8
+#define X_MbufCreateStereoWindow	9
+#define X_MbufClearImageBufferArea	10
+
+
+typedef struct xMbufBufferInfo {
+	CARD32	visualID;		/* associated visual */
+	CARD16	maxBuffers;		/* maximum supported buffers */
+	CARD8	depth;			/* depth of visual (redundant) */
+	CARD8	unused;
+} xMbufBufferInfo;
+#define sz_xMbufBufferInfo 8
+
+typedef struct {
+    BYTE    type;
+    BYTE    unused;
+    CARD16  sequenceNumber;
+    CARD32  buffer;			/* affected buffer */
+    BYTE    state;			/* current status */
+    CARD8   unused1;
+    CARD16  unused2;
+    CARD32  unused3;
+    CARD32  unused4;
+    CARD32  unused5;
+    CARD32  unused6;
+    CARD32  unused7;
+} xMbufClobberNotifyEvent;
+
+typedef struct {
+    BYTE    type;
+    BYTE    unused;
+    CARD16  sequenceNumber;
+    CARD32  buffer;			/* affected buffer */
+    CARD32  timeStamp;			/* update time */
+    CARD32  unused1;
+    CARD32  unused2;
+    CARD32  unused3;
+    CARD32  unused4;
+    CARD32  unused5;
+    CARD32  unused6;
+} xMbufUpdateNotifyEvent;
+
+typedef struct {
+    CARD8	reqType;		/* always codes->major_opcode */
+    CARD8	mbufReqType;		/* always X_MbufGetBufferVersion */
+    CARD16	length;
+} xMbufGetBufferVersionReq;
+#define sz_xMbufGetBufferVersionReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD8	majorVersion;	/* major version of Multi-Buffering protocol */
+    CARD8	minorVersion;	/* minor version of Multi-Buffering protocol */
+    CARD16	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xMbufGetBufferVersionReply;
+#define sz_xMbufGetBufferVersionReply	32
+
+typedef struct {
+    CARD8	reqType;	/* always codes->major_opcode */
+    CARD8	mbufReqType;	/* always X_MbufCreateImageBuffers */
+    CARD16	length;
+    CARD32	window; 	/* associated window */
+    CARD8	updateAction;	/* action at update */
+    CARD8	updateHint;	/* hint as to frequency of updates */
+    CARD16	unused;
+} xMbufCreateImageBuffersReq;	/* followed by buffer ids */
+#define sz_xMbufCreateImageBuffersReq	12
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	numberBuffer;		/* number successfully allocated */
+    CARD16	unused1;
+    CARD32	unused2;
+    CARD32	unused3;
+    CARD32	unused4;
+    CARD32	unused5;
+    CARD32	unused6;
+} xMbufCreateImageBuffersReply;
+#define sz_xMbufCreateImageBuffersReply 32
+
+typedef struct {
+    CARD8	reqType;	/* always codes->major_opcode */
+    CARD8	mbufReqType;	/* always X_MbufDestroyImageBuffers */
+    CARD16	length;
+    CARD32	window; 	/* associated window */
+} xMbufDestroyImageBuffersReq;
+#define sz_xMbufDestroyImageBuffersReq	8
+
+typedef struct {
+    CARD8	reqType;	/* always codes->major_opcode */
+    CARD8	mbufReqType;	/* always X_MbufDisplayImageBuffers */
+    CARD16	length;
+    CARD16	minDelay;	/* minimum time between last update and now */
+    CARD16	maxDelay;	/* maximum time between last update and now */
+} xMbufDisplayImageBuffersReq;	/* followed by list of buffers */
+#define sz_xMbufDisplayImageBuffersReq	8
+
+typedef struct {
+    CARD8	reqType;	/* always codes->major_opcode */
+    CARD8	mbufReqType;	/* always X_MbufSetMBufferAttributes */
+    CARD16	length;
+    CARD32	window; 	/* associated window */
+    CARD32	valueMask;	/* modified entries */
+} xMbufSetMBufferAttributesReq;	/* followed by values */
+#define sz_xMbufSetMBufferAttributesReq 12
+
+typedef struct {
+    CARD8	reqType;	/* always codes->major_opcode */
+    CARD8	mbufReqType;	/* always X_MbufGetMBufferAttributes */
+    CARD16	length;
+    CARD32	window; 	/* associated window */
+} xMbufGetMBufferAttributesReq;
+#define sz_xMbufGetMBufferAttributesReq 8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	displayedBuffer;	/* currently visible buffer */
+    CARD8	updateAction;
+    CARD8	updateHint;
+    CARD8	windowMode;
+    CARD8	unused0;
+    CARD16	unused1;
+    CARD32	unused2;
+    CARD32	unused3;
+    CARD32	unused4;
+    CARD32	unused5;
+} xMbufGetMBufferAttributesReply;
+#define sz_xMbufGetMBufferAttributesReply 32
+
+typedef struct {
+    CARD8	reqType;	/* always codes->major_opcode */
+    CARD8	mbufReqType;	/* always X_MbufSetBufferAttributes */
+    CARD16	length;
+    CARD32	buffer;
+    CARD32	valueMask;
+} xMbufSetBufferAttributesReq;	/* followed by values */
+#define sz_xMbufSetBufferAttributesReq 12
+
+typedef struct {
+    CARD8	reqType;	/* always codes->major_opcode */
+    CARD8	mbufReqType;	/* always X_MbufGetBufferAttributes */
+    CARD16	length;
+    CARD32	buffer;
+} xMbufGetBufferAttributesReq;
+#define sz_xMbufGetBufferAttributesReq 8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	window;
+    CARD32	eventMask;
+    CARD16	bufferIndex;
+    CARD8	side;
+    CARD8	unused0;
+    CARD32	unused1;
+    CARD32	unused2;
+    CARD32	unused3;
+} xMbufGetBufferAttributesReply;
+#define sz_xMbufGetBufferAttributesReply 32
+
+typedef struct {
+    CARD8	reqType;	/* always codes->major_opcode */
+    CARD8	mbufReqType;	/* always X_MbufGetBufferInfo */
+    CARD16	length;
+    Drawable	drawable;
+} xMbufGetBufferInfoReq;
+#define sz_xMbufGetBufferInfoReq 8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	unused;			/* not used */
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	normalInfo;
+    CARD16	stereoInfo;
+    CARD32	unused1;
+    CARD32	unused2;
+    CARD32	unused3;
+    CARD32	unused4;
+    CARD32	unused5;
+} xMbufGetBufferInfoReply;			/* followed by buffer infos */
+#define sz_xMbufGetBufferInfoReply 32
+
+
+typedef struct {
+    CARD8	reqType;	/* always codes->major_opcode */
+    CARD8	mbufReqType;	/* always X_MbufCreateStereoWindow */
+    CARD16	length;
+    CARD8	unused0;
+    CARD8	unused1;
+    CARD8	unused2;
+    CARD8	depth;
+    Window	wid;
+    Window	parent;
+    Multibuffer	left;		/* associated buffers */
+    Multibuffer	right;
+    INT16	x;
+    INT16	y;
+    CARD16	width;
+    CARD16	height;
+    CARD16	borderWidth;
+#if defined(__cplusplus) || defined(c_plusplus)
+    CARD16	c_class;
+#else
+    CARD16	class;
+#endif
+    VisualID	visual;
+    CARD32	mask;
+} xMbufCreateStereoWindowReq;		/* followed by value list */
+#define sz_xMbufCreateStereoWindowReq 44
+
+typedef struct {
+    CARD8     reqType;        /* always codes->major_opcode */
+    CARD8     mbufReqType;    /* always X_MbufClearImageBufferArea */
+    CARD16    length;
+    Multibuffer       buffer;
+    INT16     x;
+    INT16     y;
+    CARD16    width;
+    CARD16    height;
+    CARD8     unused0;
+    CARD8     unused1;
+    CARD8     unused2;
+    BOOL      exposures;
+} xMbufClearImageBufferAreaReq;
+#define sz_xMbufClearImageBufferAreaReq 20
+
+#undef Window
+#undef Drawable
+#undef VisualID
+#undef Multibuffer
+
+#endif /* _MULTIBUFPROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/panoramiXproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/panoramiXproto.h
new file mode 100644
index 0000000..5de1cf0
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/panoramiXproto.h
@@ -0,0 +1,193 @@
+/*****************************************************************
+Copyright (c) 1991, 1997 Digital Equipment Corporation, Maynard, Massachusetts.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING,
+BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL DAMAGES, OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of Digital Equipment Corporation
+shall not be used in advertising or otherwise to promote the sale, use or other
+dealings in this Software without prior written authorization from Digital
+Equipment Corporation.
+******************************************************************/
+
+/* THIS IS NOT AN X PROJECT TEAM SPECIFICATION */
+
+#ifndef _PANORAMIXPROTO_H_
+#define _PANORAMIXPROTO_H_
+
+#define PANORAMIX_MAJOR_VERSION         1       /* current version number */
+#define PANORAMIX_MINOR_VERSION         1
+
+#define PANORAMIX_PROTOCOL_NAME "XINERAMA"
+
+#define X_PanoramiXQueryVersion		0
+#define X_PanoramiXGetState		1
+#define X_PanoramiXGetScreenCount	2
+#define X_PanoramiXGetScreenSize	3
+
+#define X_XineramaIsActive		4
+#define X_XineramaQueryScreens		5
+
+typedef struct _PanoramiXQueryVersion {
+	CARD8	reqType;		/* always PanoramiXReqCode */
+	CARD8	panoramiXReqType;	/* always X_PanoramiXQueryVersion */
+	CARD16	length;
+	CARD8	clientMajor;
+	CARD8	clientMinor;
+	CARD16	unused;
+} xPanoramiXQueryVersionReq;
+
+#define sz_xPanoramiXQueryVersionReq	8
+
+typedef struct {
+	CARD8	type;			/* must be X_Reply */
+	CARD8	pad1;			/* unused	*/
+	CARD16	sequenceNumber;		/* last sequence number */
+	CARD32	length;			/* 0 */
+	CARD16	majorVersion;
+	CARD16	minorVersion;
+	CARD32	pad2;			/* unused */
+	CARD32	pad3;			/* unused */
+	CARD32	pad4;			/* unused */
+	CARD32	pad5;			/* unused */
+	CARD32	pad6;			/* unused */
+} xPanoramiXQueryVersionReply;
+
+#define sz_xPanoramiXQueryVersionReply	32
+
+
+typedef	struct	_PanoramiXGetState {
+        CARD8   reqType;	        /* always PanoramiXReqCode */
+        CARD8   panoramiXReqType;    	/* always X_PanoramiXGetState */
+        CARD16  length;
+        CARD32  window;
+} xPanoramiXGetStateReq;
+#define sz_xPanoramiXGetStateReq	8
+
+typedef struct {
+	BYTE	type;
+	BYTE	state;
+	CARD16	sequenceNumber;
+	CARD32	length;
+	CARD32  window;
+	CARD32	pad1;			/* unused */
+	CARD32	pad2;			/* unused */
+	CARD32	pad3;			/* unused */
+	CARD32	pad4;			/* unused */
+	CARD32	pad5;			/* unused */
+} xPanoramiXGetStateReply;
+
+#define sz_panoramiXGetStateReply	32
+
+typedef	struct	_PanoramiXGetScreenCount {
+        CARD8   reqType;             /* always PanoramiXReqCode */
+        CARD8   panoramiXReqType;    /* always X_PanoramiXGetScreenCount */
+        CARD16  length;
+        CARD32  window;
+} xPanoramiXGetScreenCountReq;
+#define sz_xPanoramiXGetScreenCountReq	8
+
+typedef struct {
+	BYTE	type;
+	BYTE	ScreenCount;
+	CARD16	sequenceNumber;
+	CARD32	length;
+	CARD32  window;
+	CARD32	pad1;			/* unused */
+	CARD32	pad2;			/* unused */
+	CARD32	pad3;			/* unused */
+	CARD32	pad4;			/* unused */
+	CARD32	pad5;			/* unused */
+} xPanoramiXGetScreenCountReply;
+#define sz_panoramiXGetScreenCountReply	32
+
+typedef	struct	_PanoramiXGetScreenSize {
+        CARD8   reqType;                /* always PanoramiXReqCode */
+        CARD8   panoramiXReqType;	/* always X_PanoramiXGetState */
+        CARD16  length;
+        CARD32  window;
+        CARD32  screen;
+} xPanoramiXGetScreenSizeReq;
+#define sz_xPanoramiXGetScreenSizeReq	12
+
+typedef struct {
+	BYTE	type;
+	CARD8	pad1;
+	CARD16	sequenceNumber;
+	CARD32	length;
+	CARD32	width;
+	CARD32	height;
+	CARD32  window;
+	CARD32  screen;
+	CARD32	pad2;			/* unused */
+	CARD32	pad3;			/* unused */
+} xPanoramiXGetScreenSizeReply;
+#define sz_panoramiXGetScreenSizeReply 32
+
+/************  Alternate protocol  ******************/
+
+typedef struct {
+        CARD8   reqType;
+        CARD8   panoramiXReqType;
+        CARD16  length;
+} xXineramaIsActiveReq;
+#define sz_xXineramaIsActiveReq 4
+
+typedef struct {
+	BYTE	type;
+	CARD8	pad1;
+	CARD16	sequenceNumber;
+	CARD32	length;
+	CARD32	state;
+	CARD32	pad2;
+	CARD32  pad3;
+	CARD32  pad4;
+	CARD32	pad5;
+	CARD32	pad6;
+} xXineramaIsActiveReply;
+#define sz_XineramaIsActiveReply 32
+
+
+typedef struct {
+        CARD8   reqType;
+        CARD8   panoramiXReqType;
+        CARD16  length;
+} xXineramaQueryScreensReq;
+#define sz_xXineramaQueryScreensReq 4
+
+typedef struct {
+	BYTE	type;
+	CARD8	pad1;
+	CARD16	sequenceNumber;
+	CARD32	length;
+	CARD32	number;
+	CARD32	pad2;
+	CARD32  pad3;
+	CARD32  pad4;
+	CARD32	pad5;
+	CARD32	pad6;
+} xXineramaQueryScreensReply;
+#define sz_XineramaQueryScreensReply 32
+
+typedef struct {
+	INT16   x_org;
+	INT16   y_org;
+	CARD16  width;
+	CARD16  height;
+} xXineramaScreenInfo;
+#define sz_XineramaScreenInfo 8
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/presentproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/presentproto.h
new file mode 100644
index 0000000..d8dc6d2
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/presentproto.h
@@ -0,0 +1,248 @@
+/*
+ * Copyright © 2013 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no representations
+ * about the suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#ifndef _PRESENT_PROTO_H_
+#define _PRESENT_PROTO_H_
+
+#include <X11/extensions/presenttokens.h>
+
+#define Window CARD32
+#define Pixmap CARD32
+#define Region CARD32
+#define XSyncFence CARD32
+#define EventID CARD32
+
+typedef struct {
+    Window  window;
+    CARD32  serial;
+} xPresentNotify;
+#define sz_xPresentNotify               8
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   presentReqType;
+    CARD16  length;
+    CARD32  majorVersion;
+    CARD32  minorVersion;
+} xPresentQueryVersionReq;
+#define sz_xPresentQueryVersionReq   12
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  majorVersion;
+    CARD32  minorVersion;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+} xPresentQueryVersionReply;
+#define sz_xPresentQueryVersionReply	32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   presentReqType;
+    CARD16  length;
+    Window  window;
+
+    Pixmap  pixmap;
+    CARD32  serial;
+
+    Region  valid;
+    Region  update;
+
+    INT16   x_off;
+    INT16   y_off;
+    CARD32  target_crtc;
+
+    XSyncFence wait_fence;
+    XSyncFence idle_fence;
+
+    CARD32  options;
+    CARD32  pad1;
+
+    CARD64  target_msc;
+    CARD64  divisor;
+    CARD64  remainder;
+    /* followed by a LISTofPRESENTNOTIFY */
+} xPresentPixmapReq;
+#define sz_xPresentPixmapReq	72
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   presentReqType;
+    CARD16  length;
+    Window  window;
+
+    CARD32  serial;
+    CARD32  pad0;
+
+    CARD64  target_msc;
+    CARD64  divisor;
+    CARD64  remainder;
+} xPresentNotifyMSCReq;
+#define sz_xPresentNotifyMSCReq	40
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   presentReqType;
+    CARD16  length;
+    CARD32  eid;
+    CARD32  window;
+    CARD32  eventMask;
+} xPresentSelectInputReq;
+#define sz_xPresentSelectInputReq   16
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   presentReqType;
+    CARD16  length;
+    CARD32  target;
+} xPresentQueryCapabilitiesReq;
+#define sz_xPresentQueryCapabilitiesReq   8
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  capabilities;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+    CARD32  pad6;
+    CARD32  pad7;
+} xPresentQueryCapabilitiesReply;
+#define sz_xPresentQueryCapabilitiesReply       32
+
+/*
+ * Events
+ *
+ * All Present events are X Generic Events
+ */
+
+typedef struct {
+    CARD8 type;
+    CARD8 extension;
+    CARD16 sequenceNumber;
+    CARD32 length;
+    CARD16 evtype;
+    CARD16 pad2;
+    CARD32 eid;
+    CARD32 window;
+    INT16  x;
+    INT16  y;
+    CARD16 width;
+    CARD16 height;
+    INT16  off_x;
+    INT16  off_y;
+
+    CARD16 pixmap_width;
+    CARD16 pixmap_height;
+    CARD32 pixmap_flags;
+} xPresentConfigureNotify;
+#define sz_xPresentConfigureNotify 40
+
+typedef struct {
+    CARD8 type;
+    CARD8 extension;
+    CARD16 sequenceNumber;
+    CARD32 length;
+    CARD16 evtype;
+    CARD8  kind;
+    CARD8  mode;
+    CARD32 eid;
+    Window window;
+    CARD32 serial;
+    CARD64 ust;
+
+    CARD64 msc;
+} xPresentCompleteNotify;
+#define sz_xPresentCompleteNotify 40
+
+typedef struct {
+    CARD8 type;
+    CARD8 extension;
+    CARD16 sequenceNumber;
+    CARD32 length;
+    CARD16 evtype;
+    CARD16 pad2;
+    CARD32 eid;
+    Window window;
+    CARD32 serial;
+    Pixmap pixmap;
+    CARD32 idle_fence;
+} xPresentIdleNotify;
+#define sz_xPresentIdleNotify   32
+
+#if PRESENT_FUTURE_VERSION
+typedef struct {
+    CARD8 type;
+    CARD8 extension;
+    CARD16 sequenceNumber;
+    CARD32 length;
+    CARD16 evtype;
+    CARD8 update_window;
+    CARD8 pad1;
+    CARD32 eid;
+    Window event_window;
+    Window window;
+    Pixmap pixmap;
+    CARD32 serial;
+
+    /* 32-byte boundary */
+
+    Region valid_region;
+    Region update_region;
+
+    xRectangle valid_rect;
+
+    xRectangle update_rect;
+
+    INT16 x_off;
+    INT16 y_off;
+    CARD32 target_crtc;
+
+    XSyncFence wait_fence;
+    XSyncFence idle_fence;
+
+    CARD32 options;
+    CARD32 pad2;
+
+    CARD64 target_msc;
+    CARD64 divisor;
+    CARD64 remainder;
+
+} xPresentRedirectNotify;
+
+#define sz_xPresentRedirectNotify 104
+#endif
+
+#undef Window
+#undef Pixmap
+#undef Region
+#undef XSyncFence
+#undef EventID
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/presenttokens.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/presenttokens.h
new file mode 100644
index 0000000..806cbe5
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/presenttokens.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright © 2013 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no representations
+ * about the suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#ifndef _PRESENT_TOKENS_H_
+#define _PRESENT_TOKENS_H_
+
+#define PRESENT_NAME			"Present"
+#define PRESENT_MAJOR			1
+#define PRESENT_MINOR			2
+
+#define PresentNumberErrors		0
+#define PresentNumberEvents		0
+
+/* Requests */
+#define X_PresentQueryVersion		0
+#define X_PresentPixmap			1
+#define X_PresentNotifyMSC		2
+#define X_PresentSelectInput		3
+#define X_PresentQueryCapabilities      4
+
+#define PresentNumberRequests		5
+
+/* Present operation options */
+#define PresentOptionNone               0
+#define PresentOptionAsync              (1 << 0)
+#define PresentOptionCopy               (1 << 1)
+#define PresentOptionUST                (1 << 2)
+#define PresentOptionSuboptimal         (1 << 3)
+#define PresentOptionAsyncMayTear       (1 << 4)
+
+#define PresentAllOptions       (PresentOptionAsync | \
+                                 PresentOptionCopy | \
+                                 PresentOptionUST | \
+                                 PresentOptionSuboptimal | \
+                                 PresentOptionAsyncMayTear)
+
+#define PresentAllAsyncOptions (PresentOptionAsync | PresentOptionAsyncMayTear)
+
+/* Present capabilities */
+
+#define PresentCapabilityNone           0
+#define PresentCapabilityAsync          1
+#define PresentCapabilityFence          2
+#define PresentCapabilityUST            4
+#define PresentCapabilityAsyncMayTear   8
+
+#define PresentAllCapabilities  (PresentCapabilityAsync | \
+                                 PresentCapabilityFence | \
+                                 PresentCapabilityUST | \
+                                 PresentCapabilityAsyncMayTear)
+
+#define PresentAllAsyncCapabilities (PresentCapabilityAsync | PresentCapabilityAsyncMayTear)
+
+/* Events */
+#define PresentConfigureNotify	0
+#define PresentCompleteNotify	1
+#define PresentIdleNotify       2
+#if PRESENT_FUTURE_VERSION
+#define PresentRedirectNotify	3
+#endif
+
+/* Event Masks */
+#define PresentConfigureNotifyMask      1
+#define PresentCompleteNotifyMask       2
+#define PresentIdleNotifyMask           4
+#if PRESENT_FUTURE_VERSION
+#define PresentRedirectNotifyMask       8
+#endif
+
+#if PRESENT_FUTURE_VERSION
+#define PRESENT_REDIRECT_NOTIFY_MASK    PresentRedirectNotifyMask
+#else
+#define PRESENT_REDIRECT_NOTIFY_MASK    0
+#endif
+
+#define PresentAllEvents   (PresentConfigureNotifyMask |        \
+                            PresentCompleteNotifyMask |         \
+                            PresentIdleNotifyMask |             \
+                            PRESENT_REDIRECT_NOTIFY_MASK)
+
+/* Complete Kinds */
+
+#define PresentCompleteKindPixmap       0
+#define PresentCompleteKindNotifyMSC    1
+
+/* Complete Modes */
+
+#define PresentCompleteModeCopy           0
+#define PresentCompleteModeFlip           1
+#define PresentCompleteModeSkip           2
+#define PresentCompleteModeSuboptimalCopy 3
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/randr.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/randr.h
new file mode 100644
index 0000000..e7caab1
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/randr.h
@@ -0,0 +1,208 @@
+/*
+ * Copyright © 2000 Compaq Computer Corporation
+ * Copyright © 2002 Hewlett Packard Company
+ * Copyright © 2006 Intel Corporation
+ * Copyright © 2008 Red Hat, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no representations
+ * about the suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ *
+ * Author:  Jim Gettys, HP Labs, Hewlett-Packard, Inc.
+ *	    Keith Packard, Intel Corporation
+ */
+
+#ifndef _RANDR_H_
+#define _RANDR_H_
+
+typedef unsigned short	Rotation;
+typedef unsigned short	SizeID;
+typedef unsigned short	SubpixelOrder;
+typedef unsigned short	Connection;
+typedef unsigned short	XRandrRotation;
+typedef unsigned short	XRandrSizeID;
+typedef unsigned short	XRandrSubpixelOrder;
+typedef unsigned long	XRandrModeFlags;
+
+#define RANDR_NAME		"RANDR"
+#define RANDR_MAJOR		1
+#define RANDR_MINOR		6
+
+#define RRNumberErrors		5
+#define RRNumberEvents		2
+#define RRNumberRequests	47
+
+#define X_RRQueryVersion	0
+/* we skip 1 to make old clients fail pretty immediately */
+#define X_RROldGetScreenInfo	1
+#define X_RR1_0SetScreenConfig	2
+/* V1.0 apps share the same set screen config request id */
+#define X_RRSetScreenConfig	2
+#define X_RROldScreenChangeSelectInput	3
+/* 3 used to be ScreenChangeSelectInput; deprecated */
+#define X_RRSelectInput		4
+#define X_RRGetScreenInfo	5
+
+/* V1.2 additions */
+#define X_RRGetScreenSizeRange	    6
+#define X_RRSetScreenSize	    7
+#define X_RRGetScreenResources	    8
+#define X_RRGetOutputInfo	    9
+#define X_RRListOutputProperties    10
+#define X_RRQueryOutputProperty	    11
+#define X_RRConfigureOutputProperty 12
+#define X_RRChangeOutputProperty    13
+#define X_RRDeleteOutputProperty    14
+#define X_RRGetOutputProperty	    15
+#define X_RRCreateMode		    16
+#define X_RRDestroyMode		    17
+#define X_RRAddOutputMode	    18
+#define X_RRDeleteOutputMode	    19
+#define X_RRGetCrtcInfo		    20
+#define X_RRSetCrtcConfig	    21
+#define X_RRGetCrtcGammaSize	    22
+#define X_RRGetCrtcGamma	    23
+#define X_RRSetCrtcGamma	    24
+
+/* V1.3 additions */
+#define X_RRGetScreenResourcesCurrent	25
+#define X_RRSetCrtcTransform	    26
+#define X_RRGetCrtcTransform	    27
+#define X_RRGetPanning		    28
+#define X_RRSetPanning		    29
+#define X_RRSetOutputPrimary	    30
+#define X_RRGetOutputPrimary	    31
+
+#define RRTransformUnit		    (1L << 0)
+#define RRTransformScaleUp	    (1L << 1)
+#define RRTransformScaleDown	    (1L << 2)
+#define RRTransformProjective	    (1L << 3)
+
+/* v1.4 */
+#define X_RRGetProviders	      32
+#define X_RRGetProviderInfo	      33
+#define X_RRSetProviderOffloadSink    34
+#define X_RRSetProviderOutputSource   35
+#define X_RRListProviderProperties    36
+#define X_RRQueryProviderProperty     37
+#define X_RRConfigureProviderProperty 38
+#define X_RRChangeProviderProperty    39
+#define X_RRDeleteProviderProperty    40
+#define X_RRGetProviderProperty	      41
+
+/* v1.5 */
+#define X_RRGetMonitors		      42
+#define X_RRSetMonitor		      43
+#define X_RRDeleteMonitor	      44
+
+/* v1.6 */
+#define X_RRCreateLease		      45
+#define X_RRFreeLease		      46
+
+/* Event selection bits */
+#define RRScreenChangeNotifyMask  (1L << 0)
+/* V1.2 additions */
+#define RRCrtcChangeNotifyMask	    (1L << 1)
+#define RROutputChangeNotifyMask    (1L << 2)
+#define RROutputPropertyNotifyMask  (1L << 3)
+/* V1.4 additions */
+#define RRProviderChangeNotifyMask   (1L << 4)
+#define RRProviderPropertyNotifyMask (1L << 5)
+#define RRResourceChangeNotifyMask   (1L << 6)
+/* V1.6 additions */
+#define RRLeaseNotifyMask            (1L << 7)
+
+/* Event codes */
+#define RRScreenChangeNotify	0
+/* V1.2 additions */
+#define RRNotify		    1
+/* RRNotify Subcodes */
+#define  RRNotify_CrtcChange	    0
+#define  RRNotify_OutputChange	    1
+#define  RRNotify_OutputProperty    2
+#define  RRNotify_ProviderChange    3
+#define  RRNotify_ProviderProperty  4
+#define  RRNotify_ResourceChange    5
+/* V1.6 additions */
+#define  RRNotify_Lease             6
+/* used in the rotation field; rotation and reflection in 0.1 proto. */
+#define RR_Rotate_0		1
+#define RR_Rotate_90		2
+#define RR_Rotate_180		4
+#define RR_Rotate_270		8
+
+/* new in 1.0 protocol, to allow reflection of screen */
+
+#define RR_Reflect_X		16
+#define RR_Reflect_Y		32
+
+#define RRSetConfigSuccess		0
+#define RRSetConfigInvalidConfigTime	1
+#define RRSetConfigInvalidTime		2
+#define RRSetConfigFailed		3
+
+/* new in 1.2 protocol */
+
+#define RR_HSyncPositive	0x00000001
+#define RR_HSyncNegative	0x00000002
+#define RR_VSyncPositive	0x00000004
+#define RR_VSyncNegative	0x00000008
+#define RR_Interlace		0x00000010
+#define RR_DoubleScan		0x00000020
+#define RR_CSync		0x00000040
+#define RR_CSyncPositive	0x00000080
+#define RR_CSyncNegative	0x00000100
+#define RR_HSkewPresent		0x00000200
+#define RR_BCast		0x00000400
+#define RR_PixelMultiplex	0x00000800
+#define RR_DoubleClock		0x00001000
+#define RR_ClockDivideBy2	0x00002000
+
+#define RR_Connected		0
+#define RR_Disconnected		1
+#define RR_UnknownConnection	2
+
+#define BadRROutput		0
+#define BadRRCrtc		1
+#define BadRRMode		2
+#define BadRRProvider		3
+#define BadRRLease		4
+
+/* Conventional RandR output properties */
+
+#define RR_PROPERTY_BACKLIGHT		"Backlight"
+#define RR_PROPERTY_RANDR_EDID		"EDID"
+#define RR_PROPERTY_SIGNAL_FORMAT	"SignalFormat"
+#define RR_PROPERTY_SIGNAL_PROPERTIES	"SignalProperties"
+#define RR_PROPERTY_CONNECTOR_TYPE	"ConnectorType"
+#define RR_PROPERTY_CONNECTOR_NUMBER	"ConnectorNumber"
+#define RR_PROPERTY_COMPATIBILITY_LIST	"CompatibilityList"
+#define RR_PROPERTY_CLONE_LIST		"CloneList"
+#define RR_PROPERTY_BORDER		"Border"
+#define RR_PROPERTY_BORDER_DIMENSIONS	"BorderDimensions"
+#define RR_PROPERTY_GUID		"GUID"
+#define RR_PROPERTY_RANDR_TILE		"TILE"
+#define RR_PROPERTY_NON_DESKTOP		"non-desktop"
+
+/* roles this device can carry out */
+#define RR_Capability_None 0
+#define RR_Capability_SourceOutput 1
+#define RR_Capability_SinkOutput 2
+#define RR_Capability_SourceOffload 4
+#define RR_Capability_SinkOffload 8
+
+#endif	/* _RANDR_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/randrproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/randrproto.h
new file mode 100644
index 0000000..624c254
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/randrproto.h
@@ -0,0 +1,1152 @@
+/*
+ * Copyright © 2000 Compaq Computer Corporation
+ * Copyright © 2002 Hewlett-Packard Company
+ * Copyright © 2006 Intel Corporation
+ * Copyright © 2008 Red Hat, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no representations
+ * about the suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ *
+ * Author:  Jim Gettys, Hewlett-Packard Company, Inc.
+ *	    Keith Packard, Intel Corporation
+ */
+
+/* note that RANDR 1.0 is incompatible with version 0.0, or 0.1 */
+/* V1.0 removes depth switching from the protocol */
+#ifndef _XRANDRP_H_
+#define _XRANDRP_H_
+
+#include <X11/extensions/randr.h>
+#include <X11/extensions/renderproto.h>
+
+#define Window CARD32
+#define Drawable CARD32
+#define Font CARD32
+#define Pixmap CARD32
+#define Cursor CARD32
+#define Colormap CARD32
+#define GContext CARD32
+#define Atom CARD32
+#define Time CARD32
+#define KeyCode CARD8
+#define KeySym CARD32
+#define RROutput CARD32
+#define RRMode CARD32
+#define RRCrtc CARD32
+#define RRProvider CARD32
+#define RRModeFlags CARD32
+#define RRLease CARD32
+
+#define Rotation CARD16
+#define SizeID CARD16
+#define SubpixelOrder CARD16
+
+/*
+ * data structures
+ */
+
+typedef struct {
+    CARD16 widthInPixels;
+    CARD16 heightInPixels;
+    CARD16 widthInMillimeters;
+    CARD16 heightInMillimeters;
+} xScreenSizes;
+#define sz_xScreenSizes 8
+
+/*
+ * requests and replies
+ */
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   randrReqType;
+    CARD16  length;
+    CARD32  majorVersion;
+    CARD32  minorVersion;
+} xRRQueryVersionReq;
+#define sz_xRRQueryVersionReq   12
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  majorVersion;
+    CARD32  minorVersion;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+} xRRQueryVersionReply;
+#define sz_xRRQueryVersionReply	32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   randrReqType;
+    CARD16  length;
+    Window  window;
+} xRRGetScreenInfoReq;
+#define sz_xRRGetScreenInfoReq   8
+
+/*
+ * the xRRScreenInfoReply structure is followed by:
+ *
+ * the size information
+ */
+
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    setOfRotations;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    Window  root;
+    Time    timestamp;
+    Time    configTimestamp;
+    CARD16  nSizes;
+    SizeID  sizeID;
+    Rotation  rotation;
+    CARD16  rate;
+    CARD16  nrateEnts;
+    CARD16  pad;
+} xRRGetScreenInfoReply;
+#define sz_xRRGetScreenInfoReply	32
+
+typedef struct {
+    CARD8    reqType;
+    CARD8    randrReqType;
+    CARD16   length;
+    Drawable drawable;
+    Time     timestamp;
+    Time     configTimestamp;
+    SizeID   sizeID;
+    Rotation rotation;
+} xRR1_0SetScreenConfigReq;
+#define sz_xRR1_0SetScreenConfigReq   20
+
+typedef struct {
+    CARD8    reqType;
+    CARD8    randrReqType;
+    CARD16   length;
+    Drawable drawable;
+    Time     timestamp;
+    Time     configTimestamp;
+    SizeID   sizeID;
+    Rotation rotation;
+    CARD16   rate;
+    CARD16   pad;
+} xRRSetScreenConfigReq;
+#define sz_xRRSetScreenConfigReq   24
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    CARD8   status;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    Time    newTimestamp;
+    Time    newConfigTimestamp;
+    Window  root;
+    CARD16  subpixelOrder;
+    CARD16  pad4;
+    CARD32  pad5;
+    CARD32  pad6;
+} xRRSetScreenConfigReply;
+#define sz_xRRSetScreenConfigReply 32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   randrReqType;
+    CARD16  length;
+    Window  window;
+    CARD16  enable;
+    CARD16  pad2;
+} xRRSelectInputReq;
+#define sz_xRRSelectInputReq   12
+
+/*
+ * Additions for version 1.2
+ */
+
+typedef struct _xRRModeInfo {
+    RRMode		id;
+    CARD16		width;
+    CARD16		height;
+    CARD32		dotClock;
+    CARD16		hSyncStart;
+    CARD16		hSyncEnd;
+    CARD16		hTotal;
+    CARD16		hSkew;
+    CARD16		vSyncStart;
+    CARD16		vSyncEnd;
+    CARD16		vTotal;
+    CARD16		nameLength;
+    RRModeFlags		modeFlags;
+} xRRModeInfo;
+#define sz_xRRModeInfo		    32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   randrReqType;
+    CARD16  length;
+    Window  window;
+} xRRGetScreenSizeRangeReq;
+#define sz_xRRGetScreenSizeRangeReq 8
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    CARD8   pad;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD16  minWidth;
+    CARD16  minHeight;
+    CARD16  maxWidth;
+    CARD16  maxHeight;
+    CARD32  pad0;
+    CARD32  pad1;
+    CARD32  pad2;
+    CARD32  pad3;
+} xRRGetScreenSizeRangeReply;
+#define sz_xRRGetScreenSizeRangeReply 32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   randrReqType;
+    CARD16  length;
+    Window  window;
+    CARD16  width;
+    CARD16  height;
+    CARD32  widthInMillimeters;
+    CARD32  heightInMillimeters;
+} xRRSetScreenSizeReq;
+#define sz_xRRSetScreenSizeReq	    20
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   randrReqType;
+    CARD16  length;
+    Window  window;
+} xRRGetScreenResourcesReq;
+#define sz_xRRGetScreenResourcesReq 8
+
+typedef struct {
+    BYTE	type;
+    CARD8	pad;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    Time	timestamp;
+    Time	configTimestamp;
+    CARD16	nCrtcs;
+    CARD16	nOutputs;
+    CARD16	nModes;
+    CARD16	nbytesNames;
+    CARD32	pad1;
+    CARD32	pad2;
+} xRRGetScreenResourcesReply;
+#define sz_xRRGetScreenResourcesReply	32
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RROutput	output;
+    Time	configTimestamp;
+} xRRGetOutputInfoReq;
+#define sz_xRRGetOutputInfoReq		12
+
+typedef struct {
+    BYTE	type;
+    CARD8	status;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    Time	timestamp;
+    RRCrtc	crtc;
+    CARD32	mmWidth;
+    CARD32	mmHeight;
+    CARD8	connection;
+    CARD8	subpixelOrder;
+    CARD16	nCrtcs;
+    CARD16	nModes;
+    CARD16	nPreferred;
+    CARD16	nClones;
+    CARD16	nameLength;
+} xRRGetOutputInfoReply;
+#define sz_xRRGetOutputInfoReply	36
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RROutput	output;
+} xRRListOutputPropertiesReq;
+#define sz_xRRListOutputPropertiesReq	8
+
+typedef struct {
+    BYTE	type;
+    CARD8	pad0;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	nAtoms;
+    CARD16	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xRRListOutputPropertiesReply;
+#define sz_xRRListOutputPropertiesReply	32
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RROutput	output;
+    Atom	property;
+} xRRQueryOutputPropertyReq;
+#define sz_xRRQueryOutputPropertyReq	12
+
+typedef struct {
+    BYTE	type;
+    BYTE	pad0;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    BOOL	pending;
+    BOOL	range;
+    BOOL	immutable;
+    BYTE	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xRRQueryOutputPropertyReply;
+#define sz_xRRQueryOutputPropertyReply	32
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RROutput	output;
+    Atom	property;
+    BOOL	pending;
+    BOOL	range;
+    CARD16	pad;
+} xRRConfigureOutputPropertyReq;
+#define sz_xRRConfigureOutputPropertyReq	16
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RROutput	output;
+    Atom	property;
+    Atom	type;
+    CARD8	format;
+    CARD8	mode;
+    CARD16	pad;
+    CARD32	nUnits;
+} xRRChangeOutputPropertyReq;
+#define sz_xRRChangeOutputPropertyReq	24
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RROutput	output;
+    Atom	property;
+} xRRDeleteOutputPropertyReq;
+#define sz_xRRDeleteOutputPropertyReq	12
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RROutput	output;
+    Atom	property;
+    Atom	type;
+    CARD32	longOffset;
+    CARD32	longLength;
+#ifdef __cplusplus
+    BOOL	_delete;
+#else
+    BOOL	delete;
+#endif
+    BOOL	pending;
+    CARD16	pad1;
+} xRRGetOutputPropertyReq;
+#define sz_xRRGetOutputPropertyReq	28
+
+typedef struct {
+    BYTE	type;
+    CARD8	format;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    Atom	propertyType;
+    CARD32	bytesAfter;
+    CARD32	nItems;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+} xRRGetOutputPropertyReply;
+#define sz_xRRGetOutputPropertyReply	32
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    Window	window;
+    xRRModeInfo	modeInfo;
+} xRRCreateModeReq;
+#define sz_xRRCreateModeReq		40
+
+typedef struct {
+    BYTE	type;
+    CARD8	pad0;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    RRMode	mode;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xRRCreateModeReply;
+#define sz_xRRCreateModeReply		32
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RRMode	mode;
+} xRRDestroyModeReq;
+#define sz_xRRDestroyModeReq		8
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RROutput	output;
+    RRMode	mode;
+} xRRAddOutputModeReq;
+#define sz_xRRAddOutputModeReq		12
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RROutput	output;
+    RRMode	mode;
+} xRRDeleteOutputModeReq;
+#define sz_xRRDeleteOutputModeReq	12
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RRCrtc	crtc;
+    Time	configTimestamp;
+} xRRGetCrtcInfoReq;
+#define sz_xRRGetCrtcInfoReq		12
+
+typedef struct {
+    BYTE	type;
+    CARD8	status;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    Time	timestamp;
+    INT16	x;
+    INT16	y;
+    CARD16	width;
+    CARD16	height;
+    RRMode	mode;
+    Rotation	rotation;
+    Rotation	rotations;
+    CARD16	nOutput;
+    CARD16	nPossibleOutput;
+} xRRGetCrtcInfoReply;
+#define sz_xRRGetCrtcInfoReply		32
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RRCrtc	crtc;
+    Time	timestamp;
+    Time    	configTimestamp;
+    INT16	x;
+    INT16	y;
+    RRMode	mode;
+    Rotation	rotation;
+    CARD16	pad;
+} xRRSetCrtcConfigReq;
+#define sz_xRRSetCrtcConfigReq		28
+
+typedef struct {
+    BYTE	type;
+    CARD8	status;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    Time	newTimestamp;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xRRSetCrtcConfigReply;
+#define sz_xRRSetCrtcConfigReply	32
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RRCrtc	crtc;
+} xRRGetCrtcGammaSizeReq;
+#define sz_xRRGetCrtcGammaSizeReq	8
+
+typedef struct {
+    BYTE	type;
+    CARD8	status;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	size;
+    CARD16	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xRRGetCrtcGammaSizeReply;
+#define sz_xRRGetCrtcGammaSizeReply	32
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RRCrtc	crtc;
+} xRRGetCrtcGammaReq;
+#define sz_xRRGetCrtcGammaReq		8
+
+typedef struct {
+    BYTE	type;
+    CARD8	status;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	size;
+    CARD16	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xRRGetCrtcGammaReply;
+#define sz_xRRGetCrtcGammaReply		32
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RRCrtc	crtc;
+    CARD16	size;
+    CARD16	pad1;
+} xRRSetCrtcGammaReq;
+#define sz_xRRSetCrtcGammaReq		12
+
+/*
+ * Additions for V1.3
+ */
+
+typedef xRRGetScreenResourcesReq xRRGetScreenResourcesCurrentReq;
+
+#define sz_xRRGetScreenResourcesCurrentReq sz_xRRGetScreenResourcesReq
+
+typedef xRRGetScreenResourcesReply xRRGetScreenResourcesCurrentReply;
+#define sz_xRRGetScreenResourcesCurrentReply	sz_xRRGetScreenResourcesReply
+
+typedef struct {
+    CARD8		reqType;
+    CARD8		randrReqType;
+    CARD16		length;
+    RRCrtc		crtc;
+    xRenderTransform	transform;
+    CARD16		nbytesFilter;	/* number of bytes in filter name */
+    CARD16		pad;
+} xRRSetCrtcTransformReq;
+
+#define sz_xRRSetCrtcTransformReq	48
+
+typedef struct {
+    CARD8		reqType;
+    CARD8		randrReqType;
+    CARD16		length;
+    RRCrtc		crtc;
+} xRRGetCrtcTransformReq;
+
+#define sz_xRRGetCrtcTransformReq	8
+
+typedef struct {
+    BYTE		type;
+    CARD8		status;
+    CARD16		sequenceNumber;
+    CARD32		length;
+    xRenderTransform	pendingTransform;
+    BYTE		hasTransforms;
+    CARD8		pad0;
+    CARD16		pad1;
+    xRenderTransform	currentTransform;
+    CARD32		pad2;
+    CARD16		pendingNbytesFilter;    /* number of bytes in filter name */
+    CARD16		pendingNparamsFilter;   /* number of filter params */
+    CARD16		currentNbytesFilter;    /* number of bytes in filter name */
+    CARD16		currentNparamsFilter;   /* number of filter params */
+} xRRGetCrtcTransformReply;
+
+#define sz_xRRGetCrtcTransformReply	96
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    Window	window;
+    RROutput	output;
+} xRRSetOutputPrimaryReq;
+#define sz_xRRSetOutputPrimaryReq	12
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    Window	window;
+} xRRGetOutputPrimaryReq;
+#define sz_xRRGetOutputPrimaryReq	8
+
+typedef struct {
+    BYTE	type;
+    CARD8	pad;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    RROutput	output;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xRRGetOutputPrimaryReply;
+#define sz_xRRGetOutputPrimaryReply	32
+
+/*
+ * Additions for V1.4
+ */
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    Window	window;
+} xRRGetProvidersReq;
+#define sz_xRRGetProvidersReq 8
+
+typedef struct {
+    BYTE	type;
+    CARD8	pad;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    Time	timestamp;
+    CARD16	nProviders;
+    CARD16	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xRRGetProvidersReply;
+#define sz_xRRGetProvidersReply 32
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RRProvider	provider;
+    Time	configTimestamp;
+} xRRGetProviderInfoReq;
+#define sz_xRRGetProviderInfoReq 12
+
+typedef struct {
+    BYTE	type;
+    CARD8	status;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    Time	timestamp;
+    CARD32	capabilities;
+    CARD16	nCrtcs;
+    CARD16	nOutputs;
+    CARD16	nAssociatedProviders;
+    CARD16	nameLength;
+    CARD32	pad1;
+    CARD32	pad2;
+} xRRGetProviderInfoReply;
+#define sz_xRRGetProviderInfoReply 32
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RRProvider  provider;
+    RRProvider  source_provider;
+    Time	configTimestamp;
+} xRRSetProviderOutputSourceReq;
+#define sz_xRRSetProviderOutputSourceReq 16
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RRProvider  provider;
+    RRProvider  sink_provider;
+    Time	configTimestamp;
+} xRRSetProviderOffloadSinkReq;
+#define sz_xRRSetProviderOffloadSinkReq 16
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RRProvider	provider;
+} xRRListProviderPropertiesReq;
+#define sz_xRRListProviderPropertiesReq	8
+
+typedef struct {
+    BYTE	type;
+    CARD8	pad0;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	nAtoms;
+    CARD16	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xRRListProviderPropertiesReply;
+#define sz_xRRListProviderPropertiesReply	32
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RRProvider	provider;
+    Atom	property;
+} xRRQueryProviderPropertyReq;
+#define sz_xRRQueryProviderPropertyReq	12
+
+typedef struct {
+    BYTE	type;
+    BYTE	pad0;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    BOOL	pending;
+    BOOL	range;
+    BOOL	immutable;
+    BYTE	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xRRQueryProviderPropertyReply;
+#define sz_xRRQueryProviderPropertyReply	32
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RRProvider	provider;
+    Atom	property;
+    BOOL	pending;
+    BOOL	range;
+    CARD16	pad;
+} xRRConfigureProviderPropertyReq;
+#define sz_xRRConfigureProviderPropertyReq	16
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RRProvider	provider;
+    Atom	property;
+    Atom	type;
+    CARD8	format;
+    CARD8	mode;
+    CARD16	pad;
+    CARD32	nUnits;
+} xRRChangeProviderPropertyReq;
+#define sz_xRRChangeProviderPropertyReq	24
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RRProvider	provider;
+    Atom	property;
+} xRRDeleteProviderPropertyReq;
+#define sz_xRRDeleteProviderPropertyReq	12
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RRProvider	provider;
+    Atom	property;
+    Atom	type;
+    CARD32	longOffset;
+    CARD32	longLength;
+#ifdef __cplusplus
+    BOOL	_delete;
+#else
+    BOOL	delete;
+#endif
+    BOOL	pending;
+    CARD16	pad1;
+} xRRGetProviderPropertyReq;
+#define sz_xRRGetProviderPropertyReq	28
+
+typedef struct {
+    BYTE	type;
+    CARD8	format;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    Atom	propertyType;
+    CARD32	bytesAfter;
+    CARD32	nItems;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+} xRRGetProviderPropertyReply;
+#define sz_xRRGetProviderPropertyReply	32
+
+/*
+ * Additions for V1.6
+ */
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    Window	window;
+    RRLease	lid;
+    CARD16	nCrtcs;
+    CARD16	nOutputs;
+} xRRCreateLeaseReq;
+#define sz_xRRCreateLeaseReq	16
+
+typedef struct {
+    BYTE	type;
+    CARD8	nfd;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+    CARD32	pad7;
+} xRRCreateLeaseReply;
+#define sz_xRRCreateLeaseReply		32
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RRLease	lid;
+    BYTE	terminate;
+    CARD8	pad1;
+    CARD16	pad2;
+} xRRFreeLeaseReq;
+#define sz_xRRFreeLeaseReq		12
+
+/*
+ * event
+ */
+typedef struct {
+    CARD8 type;				/* always evBase + ScreenChangeNotify */
+    CARD8 rotation;			/* new rotation */
+    CARD16 sequenceNumber;
+    Time timestamp;			/* time screen was changed */
+    Time configTimestamp;		/* time config data was changed */
+    Window root;			/* root window */
+    Window window;			/* window requesting notification */
+    SizeID sizeID;			/* new size ID */
+    CARD16 subpixelOrder;		/* subpixel order */
+    CARD16 widthInPixels;		/* new size */
+    CARD16 heightInPixels;
+    CARD16 widthInMillimeters;
+    CARD16 heightInMillimeters;
+} xRRScreenChangeNotifyEvent;
+#define sz_xRRScreenChangeNotifyEvent	32
+
+typedef struct {
+    CARD8 type;				/* always evBase + RRNotify */
+    CARD8 subCode;			/* RRNotify_CrtcChange */
+    CARD16 sequenceNumber;
+    Time timestamp;			/* time crtc was changed */
+    Window window;			/* window requesting notification */
+    RRCrtc crtc;			/* affected CRTC */
+    RRMode mode;			/* current mode */
+    CARD16 rotation;			/* rotation and reflection */
+    CARD16 pad1;			/* unused */
+    INT16 x;				/* new location */
+    INT16 y;
+    CARD16 width;			/* new size */
+    CARD16 height;
+} xRRCrtcChangeNotifyEvent;
+#define sz_xRRCrtcChangeNotifyEvent	32
+
+typedef struct {
+    CARD8 type;				/* always evBase + RRNotify */
+    CARD8 subCode;			/* RRNotify_OutputChange */
+    CARD16 sequenceNumber;
+    Time timestamp;			/* time output was changed */
+    Time configTimestamp;		/* time config was changed */
+    Window window;			/* window requesting notification */
+    RROutput output;			/* affected output */
+    RRCrtc crtc;			/* current crtc */
+    RRMode mode;			/* current mode */
+    CARD16 rotation;			/* rotation and reflection */
+    CARD8 connection;			/* connection status */
+    CARD8 subpixelOrder;		/* subpixel order */
+} xRROutputChangeNotifyEvent;
+#define sz_xRROutputChangeNotifyEvent	32
+
+typedef struct {
+    CARD8 type;				/* always evBase + RRNotify */
+    CARD8 subCode;			/* RRNotify_OutputProperty */
+    CARD16 sequenceNumber;
+    Window window;			/* window requesting notification */
+    RROutput output;			/* affected output */
+    Atom atom;				/* property name */
+    Time timestamp;			/* time crtc was changed */
+    CARD8 state;			/* NewValue or Deleted */
+    CARD8 pad1;
+    CARD16 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+} xRROutputPropertyNotifyEvent;
+#define sz_xRROutputPropertyNotifyEvent	32
+
+typedef struct {
+    CARD8 type;				/* always evBase + RRNotify */
+    CARD8 subCode;			/* RRNotify_ProviderChange */
+    CARD16 sequenceNumber;
+    Time timestamp;			/* time provider was changed */
+    Window window;			/* window requesting notification */
+    RRProvider provider;		/* affected provider */
+    CARD32 pad1;
+    CARD32 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+} xRRProviderChangeNotifyEvent;
+#define sz_xRRProviderChangeNotifyEvent	32
+
+typedef struct {
+    CARD8 type;				/* always evBase + RRNotify */
+    CARD8 subCode;			/* RRNotify_ProviderProperty */
+    CARD16 sequenceNumber;
+    Window window;			/* window requesting notification */
+    RRProvider provider;		/* affected provider */
+    Atom atom;				/* property name */
+    Time timestamp;			/* time provider was changed */
+    CARD8 state;			/* NewValue or Deleted */
+    CARD8 pad1;
+    CARD16 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+} xRRProviderPropertyNotifyEvent;
+#define sz_xRRProviderPropertyNotifyEvent	32
+
+typedef struct {
+    CARD8 type;				/* always evBase + RRNotify */
+    CARD8 subCode;			/* RRNotify_ResourceChange */
+    CARD16 sequenceNumber;
+    Time timestamp;			/* time resource was changed */
+    Window window;			/* window requesting notification */
+    CARD32 pad1;
+    CARD32 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+} xRRResourceChangeNotifyEvent;
+#define sz_xRRResourceChangeNotifyEvent	32
+
+typedef struct {
+    CARD8 type;				/* always evBase + RRNotify */
+    CARD8 subCode;			/* RRNotify_Lease */
+    CARD16 sequenceNumber;
+    Time timestamp;			/* time resource was changed */
+    Window window;			/* window requesting notification */
+    RRLease lease;
+    CARD8 created;			/* created/deleted */
+    CARD8 pad0;
+    CARD16 pad1;
+    CARD32 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+} xRRLeaseNotifyEvent;
+#define sz_xRRLeaseNotifyEvent		32
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RRCrtc	crtc;
+} xRRGetPanningReq;
+#define sz_xRRGetPanningReq		8
+
+typedef struct {
+    BYTE	type;
+    CARD8	status;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    Time	timestamp;
+    CARD16	left;
+    CARD16	top;
+    CARD16	width;
+    CARD16	height;
+    CARD16	track_left;
+    CARD16	track_top;
+    CARD16	track_width;
+    CARD16	track_height;
+    INT16	border_left;
+    INT16	border_top;
+    INT16	border_right;
+    INT16	border_bottom;
+} xRRGetPanningReply;
+#define sz_xRRGetPanningReply		36
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    RRCrtc	crtc;
+    Time	timestamp;
+    CARD16	left;
+    CARD16	top;
+    CARD16	width;
+    CARD16	height;
+    CARD16	track_left;
+    CARD16	track_top;
+    CARD16	track_width;
+    CARD16	track_height;
+    INT16	border_left;
+    INT16	border_top;
+    INT16	border_right;
+    INT16	border_bottom;
+} xRRSetPanningReq;
+#define sz_xRRSetPanningReq		36
+
+typedef struct {
+    BYTE	type;
+    CARD8	status;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    Time	newTimestamp;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xRRSetPanningReply;
+#define sz_xRRSetPanningReply	32
+
+typedef struct {
+    Atom	name;
+    BOOL	primary;
+    BOOL	automatic;
+    CARD16	noutput;
+    INT16	x;
+    INT16	y;
+    CARD16	width;
+    CARD16	height;
+    CARD32	widthInMillimeters;
+    CARD32	heightInMillimeters;
+} xRRMonitorInfo;
+#define sz_xRRMonitorInfo	24
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    Window	window;
+    BOOL	get_active;
+    CARD8	pad;
+    CARD16	pad2;
+} xRRGetMonitorsReq;
+#define sz_xRRGetMonitorsReq	12
+
+typedef struct {
+    BYTE	type;
+    CARD8	status;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    Time	timestamp;
+    CARD32	nmonitors;
+    CARD32	noutputs;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+} xRRGetMonitorsReply;
+#define sz_xRRGetMonitorsReply	32
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    Window	window;
+    xRRMonitorInfo	monitor;
+} xRRSetMonitorReq;
+#define sz_xRRSetMonitorReq	32
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	randrReqType;
+    CARD16	length;
+    Window	window;
+    Atom	name;
+} xRRDeleteMonitorReq;
+#define sz_xRRDeleteMonitorReq	12
+
+#undef RRLease
+#undef RRModeFlags
+#undef RRCrtc
+#undef RRMode
+#undef RROutput
+#undef RRMode
+#undef RRCrtc
+#undef RRProvider
+#undef Drawable
+#undef Window
+#undef Font
+#undef Pixmap
+#undef Cursor
+#undef Colormap
+#undef GContext
+#undef Atom
+#undef Time
+#undef KeyCode
+#undef KeySym
+#undef Rotation
+#undef SizeID
+#undef SubpixelOrder
+
+#endif /* _XRANDRP_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/recordconst.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/recordconst.h
new file mode 100644
index 0000000..ecdd81b
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/recordconst.h
@@ -0,0 +1,54 @@
+/***************************************************************************
+ * Copyright 1995 Network Computing Devices
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and
+ * its documentation for any purpose is hereby granted without fee, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Network Computing Devices
+ * not be used in advertising or publicity pertaining to distribution
+ * of the software without specific, written prior permission.
+ *
+ * NETWORK COMPUTING DEVICES DISCLAIMs ALL WARRANTIES WITH REGARD TO
+ * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES BE LIABLE
+ * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+ * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ **************************************************************************/
+
+#ifndef _RECORDCONST_H_
+#define _RECORDCONST_H_
+
+#define RECORD_NAME			"RECORD"
+#define RECORD_MAJOR_VERSION		1
+#define RECORD_MINOR_VERSION		13
+#define RECORD_LOWEST_MAJOR_VERSION	1
+#define RECORD_LOWEST_MINOR_VERSION	12
+
+#define XRecordBadContext       0	/* Not a valid RC */
+
+#define RecordNumErrors         (XRecordBadContext + 1)
+#define RecordNumEvents		0L
+
+/*
+ * Constants for arguments of various requests
+ */
+#define	XRecordFromServerTime		0x01
+#define	XRecordFromClientTime		0x02
+#define	XRecordFromClientSequence	0x04
+
+#define XRecordCurrentClients		1
+#define XRecordFutureClients		2
+#define XRecordAllClients		3
+
+#define XRecordFromServer           	0
+#define XRecordFromClient               1
+#define XRecordClientStarted           	2
+#define XRecordClientDied               3
+#define XRecordStartOfData		4
+#define XRecordEndOfData		5
+
+
+#endif /* _RECORD_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/recordproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/recordproto.h
new file mode 100644
index 0000000..d2016eb
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/recordproto.h
@@ -0,0 +1,306 @@
+/***************************************************************************
+ * Copyright 1995 Network Computing Devices
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and
+ * its documentation for any purpose is hereby granted without fee, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Network Computing Devices
+ * not be used in advertising or publicity pertaining to distribution
+ * of the software without specific, written prior permission.
+ *
+ * NETWORK COMPUTING DEVICES DISCLAIMs ALL WARRANTIES WITH REGARD TO
+ * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES BE LIABLE
+ * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+ * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ **************************************************************************/
+
+#ifndef _RECORDPROTO_H_
+#define _RECORDPROTO_H_
+
+#include <X11/extensions/recordconst.h>
+
+/* only difference between 1.12 and 1.13 is byte order of device events,
+   which the library doesn't deal with. */
+
+/*********************************************************
+ *
+ * Protocol request constants
+ *
+ */
+#define X_RecordQueryVersion    0     /* First request from client */
+#define X_RecordCreateContext   1     /* Create client RC */
+#define X_RecordRegisterClients 2     /* Add to client RC */
+#define X_RecordUnregisterClients 3   /* Delete from client RC */
+#define X_RecordGetContext      4     /* Query client RC */
+#define X_RecordEnableContext   5     /* Enable interception and reporting */
+#define X_RecordDisableContext  6     /* Disable interception and reporting */
+#define X_RecordFreeContext     7     /* Free client RC */
+
+#define sz_XRecordRange		32
+#define sz_XRecordClientInfo 	12
+#define sz_XRecordState 	16
+#define sz_XRecordDatum 	32
+
+
+#define XRecordGlobaldef
+#define XRecordGlobalref extern
+
+#define RecordMaxEvent     	(128L-1L)
+#define RecordMinDeviceEvent	(2L)
+#define RecordMaxDeviceEvent	(6L)
+#define RecordMaxError          (256L-1L)
+#define RecordMaxCoreRequest    (128L-1L)
+#define RecordMaxExtRequest     (256L-1L)
+#define RecordMinExtRequest     (129L-1L)
+
+#define RECORD_RC 		CARD32
+#define RECORD_XIDBASE		CARD32
+#define RECORD_CLIENTSPEC	CARD32
+#define RECORD_ELEMENT_HEADER	CARD8
+
+typedef RECORD_CLIENTSPEC RecordClientSpec, *RecordClientSpecPtr;
+
+typedef struct
+{
+    CARD8	first;
+    CARD8	last;
+} RECORD_RANGE8;
+
+typedef struct
+{
+    CARD16	first;
+    CARD16	last;
+} RECORD_RANGE16;
+
+typedef struct
+{
+    RECORD_RANGE8	majorCode;
+    RECORD_RANGE16	minorCode;
+} RECORD_EXTRANGE;
+
+typedef struct
+{
+    RECORD_RANGE8	coreRequests;
+    RECORD_RANGE8	coreReplies;
+    RECORD_EXTRANGE	extRequests;
+    RECORD_EXTRANGE	extReplies;
+    RECORD_RANGE8	deliveredEvents;
+    RECORD_RANGE8	deviceEvents;
+    RECORD_RANGE8	errors;
+    BOOL		clientStarted;
+    BOOL		clientDied;
+} RECORDRANGE;
+#define sz_RECORDRANGE 	24
+
+/* typedef RECORDRANGE xRecordRange, *xRecordRangePtr;
+#define sz_xRecordRange 24 */
+
+/* Cannot have structures within structures going over the wire */
+typedef struct
+{
+    CARD8       	coreRequestsFirst;
+    CARD8       	coreRequestsLast;
+    CARD8       	coreRepliesFirst;
+    CARD8       	coreRepliesLast;
+    CARD8  		extRequestsMajorFirst;
+    CARD8		extRequestsMajorLast;
+    CARD16  		extRequestsMinorFirst;
+    CARD16  		extRequestsMinorLast;
+    CARD8  		extRepliesMajorFirst;
+    CARD8		extRepliesMajorLast;
+    CARD16  		extRepliesMinorFirst;
+    CARD16  		extRepliesMinorLast;
+    CARD8       	deliveredEventsFirst;
+    CARD8       	deliveredEventsLast;
+    CARD8		deviceEventsFirst;
+    CARD8		deviceEventsLast;
+    CARD8       	errorsFirst;
+    CARD8       	errorsLast;
+    BOOL                clientStarted;
+    BOOL		clientDied;
+} xRecordRange;
+#define sz_xRecordRange 24
+
+typedef struct
+{
+    RECORD_CLIENTSPEC	clientResource;
+    CARD32		nRanges;
+/* LISTofRECORDRANGE */
+} RECORD_CLIENT_INFO;
+
+typedef RECORD_CLIENT_INFO xRecordClientInfo;
+
+/*
+ * Initialize
+ */
+typedef struct {
+    CARD8       reqType;
+    CARD8       recordReqType;
+    CARD16      length;
+    CARD16      majorVersion;
+    CARD16      minorVersion;
+} xRecordQueryVersionReq;
+#define sz_xRecordQueryVersionReq 	8
+
+typedef struct
+{
+    CARD8   type;
+    CARD8   pad0;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD16  majorVersion;
+    CARD16  minorVersion;
+    CARD32  pad1;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+ } xRecordQueryVersionReply;
+#define sz_xRecordQueryVersionReply  	32
+
+/*
+ * Create RC
+ */
+typedef struct
+{
+    CARD8     		reqType;
+    CARD8     		recordReqType;
+    CARD16    		length;
+    RECORD_RC		context;
+    RECORD_ELEMENT_HEADER elementHeader;
+    CARD8		pad;
+    CARD16		pad0;
+    CARD32		nClients;
+    CARD32		nRanges;
+/* LISTofRECORD_CLIENTSPEC */
+/* LISTofRECORDRANGE */
+} xRecordCreateContextReq;
+#define sz_xRecordCreateContextReq 	20
+
+/*
+ * Add to  RC
+ */
+typedef struct
+{
+    CARD8     		reqType;
+    CARD8     		recordReqType;
+    CARD16    		length;
+    RECORD_RC		context;
+    RECORD_ELEMENT_HEADER elementHeader;
+    CARD8		pad;
+    CARD16		pad0;
+    CARD32		nClients;
+    CARD32		nRanges;
+/* LISTofRECORD_CLIENTSPEC */
+/* LISTofRECORDRANGE */
+} xRecordRegisterClientsReq;
+#define sz_xRecordRegisterClientsReq 	20
+
+/*
+ * Delete from RC
+ */
+typedef struct
+{
+    CARD8     		reqType;
+    CARD8     		recordReqType;
+    CARD16    		length;
+    RECORD_RC		context;
+    CARD32		nClients;
+/* LISTofRECORD_CLIENTSPEC */
+} xRecordUnregisterClientsReq;
+#define sz_xRecordUnregisterClientsReq 	12
+
+/*
+ * Query RC
+ */
+typedef struct
+{
+    CARD8     	reqType;
+    CARD8     	recordReqType;
+    CARD16    	length;
+    RECORD_RC	context;
+} xRecordGetContextReq;
+#define sz_xRecordGetContextReq 		8
+
+typedef struct
+{
+    CARD8   	type;
+    BOOL    	enabled;
+    CARD16  	sequenceNumber;
+    CARD32  	length;
+    RECORD_ELEMENT_HEADER  elementHeader;
+    CARD8	pad;
+    CARD16	pad0;
+    CARD32  	nClients;
+    CARD32  	pad1;
+    CARD32  	pad2;
+    CARD32  	pad3;
+    CARD32  	pad4;
+/* LISTofCLIENT_INFO */ 		/* intercepted-clients */
+} xRecordGetContextReply;
+#define sz_xRecordGetContextReply  	32
+
+/*
+ * Enable data interception
+ */
+typedef struct
+{
+    CARD8     	reqType;
+    CARD8     	recordReqType;
+    CARD16    	length;
+    RECORD_RC	context;
+} xRecordEnableContextReq;
+#define sz_xRecordEnableContextReq 	8
+
+typedef struct
+{
+    CARD8		type;
+    CARD8		category;
+    CARD16		sequenceNumber;
+    CARD32		length;
+    RECORD_ELEMENT_HEADER  elementHeader;
+    BOOL		clientSwapped;
+    CARD16		pad1;
+    RECORD_XIDBASE 	idBase;
+    CARD32		serverTime;
+    CARD32		recordedSequenceNumber;
+    CARD32		pad3;
+    CARD32		pad4;
+    /* BYTE		data; */
+} xRecordEnableContextReply;
+#define sz_xRecordEnableContextReply 	32
+
+/*
+ * Disable data interception
+ */
+typedef struct
+{
+    CARD8     	reqType;
+    CARD8     	recordReqType;
+    CARD16    	length;
+    RECORD_RC 	context;
+} xRecordDisableContextReq;
+#define sz_xRecordDisableContextReq	8
+
+/*
+ * Free RC
+ */
+typedef struct
+{
+    CARD8     	reqType;
+    CARD8     	recordReqType;
+    CARD16    	length;
+    RECORD_RC 	context;
+} xRecordFreeContextReq;
+#define sz_xRecordFreeContextReq 	8
+
+#undef RECORD_RC
+#undef RECORD_XIDBASE
+#undef RECORD_ELEMENT_HEADER
+#undef RECORD_CLIENTSPEC
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/recordstr.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/recordstr.h
new file mode 100644
index 0000000..7f269b7
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/recordstr.h
@@ -0,0 +1,4 @@
+#warning "recordstr.h is obsolete and may be removed in the future."
+#warning "include <X11/extensions/record.h> for the library interfaces."
+#warning "include <X11/extensions/recordproto.h> for the protocol defines."
+#include <X11/extensions/recordproto.h>
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/render.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/render.h
new file mode 100644
index 0000000..7ecde3f
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/render.h
@@ -0,0 +1,210 @@
+/*
+ * Copyright © 2000 SuSE, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of SuSE not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  SuSE makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE
+ * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Author:  Keith Packard, SuSE, Inc.
+ */
+
+#ifndef _RENDER_H_
+#define _RENDER_H_
+
+#include <X11/Xdefs.h>
+
+typedef XID		Glyph;
+typedef XID		GlyphSet;
+typedef XID		Picture;
+typedef XID		PictFormat;
+
+#define RENDER_NAME	"RENDER"
+#define RENDER_MAJOR	0
+#define RENDER_MINOR	11
+
+#define X_RenderQueryVersion		    0
+#define X_RenderQueryPictFormats	    1
+#define X_RenderQueryPictIndexValues	    2	/* 0.7 */
+#define X_RenderQueryDithers		    3
+#define X_RenderCreatePicture		    4
+#define X_RenderChangePicture		    5
+#define X_RenderSetPictureClipRectangles    6
+#define X_RenderFreePicture		    7
+#define X_RenderComposite		    8
+#define X_RenderScale			    9
+#define X_RenderTrapezoids		    10
+#define X_RenderTriangles		    11
+#define X_RenderTriStrip		    12
+#define X_RenderTriFan			    13
+#define X_RenderColorTrapezoids		    14
+#define X_RenderColorTriangles		    15
+/* #define X_RenderTransform		    16 */
+#define X_RenderCreateGlyphSet		    17
+#define X_RenderReferenceGlyphSet	    18
+#define X_RenderFreeGlyphSet		    19
+#define X_RenderAddGlyphs		    20
+#define X_RenderAddGlyphsFromPicture	    21
+#define X_RenderFreeGlyphs		    22
+#define X_RenderCompositeGlyphs8	    23
+#define X_RenderCompositeGlyphs16	    24
+#define X_RenderCompositeGlyphs32	    25
+#define X_RenderFillRectangles		    26
+/* 0.5 */
+#define X_RenderCreateCursor		    27
+/* 0.6 */
+#define X_RenderSetPictureTransform	    28
+#define X_RenderQueryFilters		    29
+#define X_RenderSetPictureFilter	    30
+/* 0.8 */
+#define X_RenderCreateAnimCursor	    31
+/* 0.9 */
+#define X_RenderAddTraps		    32
+/* 0.10 */
+#define X_RenderCreateSolidFill             33
+#define X_RenderCreateLinearGradient        34
+#define X_RenderCreateRadialGradient        35
+#define X_RenderCreateConicalGradient       36
+#define RenderNumberRequests		    (X_RenderCreateConicalGradient+1)
+
+#define BadPictFormat			    0
+#define BadPicture			    1
+#define BadPictOp			    2
+#define BadGlyphSet			    3
+#define BadGlyph			    4
+#define RenderNumberErrors		    (BadGlyph+1)
+
+#define PictTypeIndexed			    0
+#define PictTypeDirect			    1
+
+#define PictOpMinimum			    0
+#define PictOpClear			    0
+#define PictOpSrc			    1
+#define PictOpDst			    2
+#define PictOpOver			    3
+#define PictOpOverReverse		    4
+#define PictOpIn			    5
+#define PictOpInReverse			    6
+#define PictOpOut			    7
+#define PictOpOutReverse		    8
+#define PictOpAtop			    9
+#define PictOpAtopReverse		    10
+#define PictOpXor			    11
+#define PictOpAdd			    12
+#define PictOpSaturate			    13
+#define PictOpMaximum			    13
+
+/*
+ * Operators only available in version 0.2
+ */
+#define PictOpDisjointMinimum			    0x10
+#define PictOpDisjointClear			    0x10
+#define PictOpDisjointSrc			    0x11
+#define PictOpDisjointDst			    0x12
+#define PictOpDisjointOver			    0x13
+#define PictOpDisjointOverReverse		    0x14
+#define PictOpDisjointIn			    0x15
+#define PictOpDisjointInReverse			    0x16
+#define PictOpDisjointOut			    0x17
+#define PictOpDisjointOutReverse		    0x18
+#define PictOpDisjointAtop			    0x19
+#define PictOpDisjointAtopReverse		    0x1a
+#define PictOpDisjointXor			    0x1b
+#define PictOpDisjointMaximum			    0x1b
+
+#define PictOpConjointMinimum			    0x20
+#define PictOpConjointClear			    0x20
+#define PictOpConjointSrc			    0x21
+#define PictOpConjointDst			    0x22
+#define PictOpConjointOver			    0x23
+#define PictOpConjointOverReverse		    0x24
+#define PictOpConjointIn			    0x25
+#define PictOpConjointInReverse			    0x26
+#define PictOpConjointOut			    0x27
+#define PictOpConjointOutReverse		    0x28
+#define PictOpConjointAtop			    0x29
+#define PictOpConjointAtopReverse		    0x2a
+#define PictOpConjointXor			    0x2b
+#define PictOpConjointMaximum			    0x2b
+
+/*
+ * Operators only available in version 0.11
+ */
+#define PictOpBlendMinimum			    0x30
+#define PictOpMultiply				    0x30
+#define PictOpScreen				    0x31
+#define PictOpOverlay				    0x32
+#define PictOpDarken				    0x33
+#define PictOpLighten				    0x34
+#define PictOpColorDodge			    0x35
+#define PictOpColorBurn				    0x36
+#define PictOpHardLight				    0x37
+#define PictOpSoftLight				    0x38
+#define PictOpDifference			    0x39
+#define PictOpExclusion				    0x3a
+#define PictOpHSLHue				    0x3b
+#define PictOpHSLSaturation			    0x3c
+#define PictOpHSLColor				    0x3d
+#define PictOpHSLLuminosity			    0x3e
+#define PictOpBlendMaximum			    0x3e
+
+#define PolyEdgeSharp			    0
+#define PolyEdgeSmooth			    1
+
+#define PolyModePrecise			    0
+#define PolyModeImprecise		    1
+
+#define CPRepeat			    (1 << 0)
+#define CPAlphaMap			    (1 << 1)
+#define CPAlphaXOrigin			    (1 << 2)
+#define CPAlphaYOrigin			    (1 << 3)
+#define CPClipXOrigin			    (1 << 4)
+#define CPClipYOrigin			    (1 << 5)
+#define CPClipMask			    (1 << 6)
+#define CPGraphicsExposure		    (1 << 7)
+#define CPSubwindowMode			    (1 << 8)
+#define CPPolyEdge			    (1 << 9)
+#define CPPolyMode			    (1 << 10)
+#define CPDither			    (1 << 11)
+#define CPComponentAlpha		    (1 << 12)
+#define CPLastBit			    12
+
+/* Filters included in 0.6 */
+#define FilterNearest			    "nearest"
+#define FilterBilinear			    "bilinear"
+/* Filters included in 0.10 */
+#define FilterConvolution		    "convolution"
+
+#define FilterFast			    "fast"
+#define FilterGood			    "good"
+#define FilterBest			    "best"
+
+#define FilterAliasNone			    -1
+
+/* Subpixel orders included in 0.6 */
+#define SubPixelUnknown			    0
+#define SubPixelHorizontalRGB		    1
+#define SubPixelHorizontalBGR		    2
+#define SubPixelVerticalRGB		    3
+#define SubPixelVerticalBGR		    4
+#define SubPixelNone			    5
+
+/* Extended repeat attributes included in 0.10 */
+#define RepeatNone                          0
+#define RepeatNormal                        1
+#define RepeatPad                           2
+#define RepeatReflect                       3
+
+#endif	/* _RENDER_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/renderproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/renderproto.h
new file mode 100644
index 0000000..2cd06af
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/renderproto.h
@@ -0,0 +1,661 @@
+/*
+ * Copyright © 2000 SuSE, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of SuSE not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  SuSE makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE
+ * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Author:  Keith Packard, SuSE, Inc.
+ */
+
+#ifndef _XRENDERP_H_
+#define _XRENDERP_H_
+
+#include <X11/Xmd.h>
+#include <X11/extensions/render.h>
+
+#define Window CARD32
+#define Drawable CARD32
+#define Font CARD32
+#define Pixmap CARD32
+#define Cursor CARD32
+#define Colormap CARD32
+#define GContext CARD32
+#define Atom CARD32
+#define VisualID CARD32
+#define Time CARD32
+#define KeyCode CARD8
+#define KeySym CARD32
+
+#define Picture	    CARD32
+#define PictFormat  CARD32
+#define Fixed	    INT32
+#define Glyphset    CARD32
+
+/*
+ * data structures
+ */
+
+typedef struct {
+    CARD16  red;
+    CARD16  redMask;
+    CARD16  green;
+    CARD16  greenMask;
+    CARD16  blue;
+    CARD16  blueMask;
+    CARD16  alpha;
+    CARD16  alphaMask;
+} xDirectFormat;
+
+#define sz_xDirectFormat    16
+
+typedef struct {
+    PictFormat	id;
+    CARD8	type;
+    CARD8	depth;
+    CARD16	pad1;
+    xDirectFormat   direct;
+    Colormap	colormap;
+} xPictFormInfo;
+
+#define sz_xPictFormInfo    28
+
+typedef struct {
+    VisualID	visual;
+    PictFormat	format;
+} xPictVisual;
+
+#define sz_xPictVisual	    8
+
+typedef struct {
+    CARD8	depth;
+    CARD8	pad1;
+    CARD16	nPictVisuals;
+    CARD32	pad2;
+} xPictDepth;
+
+#define sz_xPictDepth	8
+
+typedef struct {
+    CARD32	nDepth;
+    PictFormat	fallback;
+} xPictScreen;
+
+#define sz_xPictScreen	8
+
+typedef struct {
+    CARD32	pixel;
+    CARD16	red;
+    CARD16	green;
+    CARD16	blue;
+    CARD16	alpha;
+} xIndexValue;
+
+#define sz_xIndexValue	12
+
+typedef struct {
+    CARD16	red;
+    CARD16	green;
+    CARD16	blue;
+    CARD16	alpha;
+} xRenderColor;
+
+#define sz_xRenderColor	8
+
+typedef struct {
+    Fixed	x;
+    Fixed	y;
+} xPointFixed;
+
+#define sz_xPointFixed	8
+
+typedef struct {
+    xPointFixed	p1;
+    xPointFixed p2;
+} xLineFixed;
+
+#define sz_xLineFixed	16
+
+typedef struct {
+    xPointFixed	p1, p2, p3;
+} xTriangle;
+
+#define sz_xTriangle	24
+
+typedef struct {
+    Fixed	top;
+    Fixed	bottom;
+    xLineFixed	left;
+    xLineFixed	right;
+} xTrapezoid;
+
+#define sz_xTrapezoid	40
+
+typedef struct {
+    CARD16  width;
+    CARD16  height;
+    INT16   x;
+    INT16   y;
+    INT16   xOff;
+    INT16   yOff;
+} xGlyphInfo;
+
+#define sz_xGlyphInfo	12
+
+typedef struct {
+    CARD8   len;
+    CARD8   pad1;
+    CARD16  pad2;
+    INT16   deltax;
+    INT16   deltay;
+} xGlyphElt;
+
+#define sz_xGlyphElt	8
+
+typedef struct {
+    Fixed   l, r, y;
+} xSpanFix;
+
+#define sz_xSpanFix	12
+
+typedef struct {
+    xSpanFix	top, bot;
+} xTrap;
+
+#define sz_xTrap	24
+
+/*
+ * requests and replies
+ */
+typedef struct {
+    CARD8   reqType;
+    CARD8   renderReqType;
+    CARD16  length;
+    CARD32  majorVersion;
+    CARD32  minorVersion;
+} xRenderQueryVersionReq;
+
+#define sz_xRenderQueryVersionReq   12
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  majorVersion;
+    CARD32  minorVersion;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+} xRenderQueryVersionReply;
+
+#define sz_xRenderQueryVersionReply	32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   renderReqType;
+    CARD16  length;
+} xRenderQueryPictFormatsReq;
+
+#define sz_xRenderQueryPictFormatsReq	4
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  numFormats;
+    CARD32  numScreens;
+    CARD32  numDepths;
+    CARD32  numVisuals;
+    CARD32  numSubpixel;	    /* Version 0.6 */
+    CARD32  pad5;
+} xRenderQueryPictFormatsReply;
+
+#define sz_xRenderQueryPictFormatsReply	32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   renderReqType;
+    CARD16  length;
+    PictFormat	format;
+} xRenderQueryPictIndexValuesReq;
+
+#define sz_xRenderQueryPictIndexValuesReq   8
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  numIndexValues;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+    CARD32  pad6;
+} xRenderQueryPictIndexValuesReply;
+
+#define sz_xRenderQueryPictIndexValuesReply 32
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	renderReqType;
+    CARD16	length;
+    Picture	pid;
+    Drawable	drawable;
+    PictFormat	format;
+    CARD32	mask;
+} xRenderCreatePictureReq;
+
+#define sz_xRenderCreatePictureReq	    20
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	renderReqType;
+    CARD16	length;
+    Picture	picture;
+    CARD32	mask;
+} xRenderChangePictureReq;
+
+#define sz_xRenderChangePictureReq	    12
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       renderReqType;
+    CARD16      length;
+    Picture     picture;
+    INT16       xOrigin;
+    INT16       yOrigin;
+} xRenderSetPictureClipRectanglesReq;
+
+#define sz_xRenderSetPictureClipRectanglesReq	    12
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       renderReqType;
+    CARD16      length;
+    Picture     picture;
+} xRenderFreePictureReq;
+
+#define sz_xRenderFreePictureReq	    8
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       renderReqType;
+    CARD16      length;
+    CARD8	op;
+    CARD8	pad1;
+    CARD16	pad2;
+    Picture	src;
+    Picture	mask;
+    Picture	dst;
+    INT16	xSrc;
+    INT16	ySrc;
+    INT16	xMask;
+    INT16	yMask;
+    INT16	xDst;
+    INT16	yDst;
+    CARD16	width;
+    CARD16	height;
+} xRenderCompositeReq;
+
+#define sz_xRenderCompositeReq		    36
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       renderReqType;
+    CARD16      length;
+    Picture	src;
+    Picture	dst;
+    CARD32	colorScale;
+    CARD32	alphaScale;
+    INT16	xSrc;
+    INT16	ySrc;
+    INT16	xDst;
+    INT16	yDst;
+    CARD16	width;
+    CARD16	height;
+} xRenderScaleReq;
+
+#define sz_xRenderScaleReq			    32
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       renderReqType;
+    CARD16      length;
+    CARD8	op;
+    CARD8	pad1;
+    CARD16	pad2;
+    Picture	src;
+    Picture	dst;
+    PictFormat	maskFormat;
+    INT16	xSrc;
+    INT16	ySrc;
+} xRenderTrapezoidsReq;
+
+#define sz_xRenderTrapezoidsReq			    24
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       renderReqType;
+    CARD16      length;
+    CARD8	op;
+    CARD8	pad1;
+    CARD16	pad2;
+    Picture	src;
+    Picture	dst;
+    PictFormat	maskFormat;
+    INT16	xSrc;
+    INT16	ySrc;
+} xRenderTrianglesReq;
+
+#define sz_xRenderTrianglesReq			    24
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       renderReqType;
+    CARD16      length;
+    CARD8	op;
+    CARD8	pad1;
+    CARD16	pad2;
+    Picture	src;
+    Picture	dst;
+    PictFormat	maskFormat;
+    INT16	xSrc;
+    INT16	ySrc;
+} xRenderTriStripReq;
+
+#define sz_xRenderTriStripReq			    24
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       renderReqType;
+    CARD16      length;
+    CARD8	op;
+    CARD8	pad1;
+    CARD16	pad2;
+    Picture	src;
+    Picture	dst;
+    PictFormat	maskFormat;
+    INT16	xSrc;
+    INT16	ySrc;
+} xRenderTriFanReq;
+
+#define sz_xRenderTriFanReq			    24
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       renderReqType;
+    CARD16      length;
+    Glyphset    gsid;
+    PictFormat  format;
+} xRenderCreateGlyphSetReq;
+
+#define sz_xRenderCreateGlyphSetReq		    12
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       renderReqType;
+    CARD16      length;
+    Glyphset    gsid;
+    Glyphset    existing;
+} xRenderReferenceGlyphSetReq;
+
+#define sz_xRenderReferenceGlyphSetReq		    24
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       renderReqType;
+    CARD16      length;
+    Glyphset    glyphset;
+} xRenderFreeGlyphSetReq;
+
+#define sz_xRenderFreeGlyphSetReq		    8
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       renderReqType;
+    CARD16      length;
+    Glyphset    glyphset;
+    CARD32	nglyphs;
+} xRenderAddGlyphsReq;
+
+#define sz_xRenderAddGlyphsReq			    12
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       renderReqType;
+    CARD16      length;
+    Glyphset    glyphset;
+} xRenderFreeGlyphsReq;
+
+#define sz_xRenderFreeGlyphsReq			    8
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       renderReqType;
+    CARD16      length;
+    CARD8	op;
+    CARD8	pad1;
+    CARD16	pad2;
+    Picture	src;
+    Picture	dst;
+    PictFormat	maskFormat;
+    Glyphset	glyphset;
+    INT16	xSrc;
+    INT16	ySrc;
+} xRenderCompositeGlyphsReq, xRenderCompositeGlyphs8Req,
+xRenderCompositeGlyphs16Req, xRenderCompositeGlyphs32Req;
+
+#define sz_xRenderCompositeGlyphs8Req		    28
+#define sz_xRenderCompositeGlyphs16Req		    28
+#define sz_xRenderCompositeGlyphs32Req		    28
+
+/* 0.1 and higher */
+
+typedef struct {
+    CARD8	reqType;
+    CARD8       renderReqType;
+    CARD16      length;
+    CARD8	op;
+    CARD8	pad1;
+    CARD16	pad2;
+    Picture	dst;
+    xRenderColor    color;
+} xRenderFillRectanglesReq;
+
+#define sz_xRenderFillRectanglesReq		    20
+
+/* 0.5 and higher */
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	renderReqType;
+    CARD16	length;
+    Cursor	cid;
+    Picture	src;
+    CARD16	x;
+    CARD16	y;
+} xRenderCreateCursorReq;
+
+#define sz_xRenderCreateCursorReq		    16
+
+/* 0.6 and higher */
+
+/*
+ * This can't use an array because 32-bit values may be in bitfields
+ */
+typedef struct {
+    Fixed	matrix11;
+    Fixed	matrix12;
+    Fixed	matrix13;
+    Fixed	matrix21;
+    Fixed	matrix22;
+    Fixed	matrix23;
+    Fixed	matrix31;
+    Fixed	matrix32;
+    Fixed	matrix33;
+} xRenderTransform;
+
+#define sz_xRenderTransform 36
+
+typedef struct {
+    CARD8		reqType;
+    CARD8		renderReqType;
+    CARD16		length;
+    Picture		picture;
+    xRenderTransform	transform;
+} xRenderSetPictureTransformReq;
+
+#define sz_xRenderSetPictureTransformReq	    44
+
+typedef struct {
+    CARD8		reqType;
+    CARD8		renderReqType;
+    CARD16		length;
+    Drawable		drawable;
+} xRenderQueryFiltersReq;
+
+#define sz_xRenderQueryFiltersReq		    8
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  numAliases;	/* LISTofCARD16 */
+    CARD32  numFilters;	/* LISTofSTRING8 */
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+} xRenderQueryFiltersReply;
+
+#define sz_xRenderQueryFiltersReply		    32
+
+typedef struct {
+    CARD8		reqType;
+    CARD8		renderReqType;
+    CARD16		length;
+    Picture		picture;
+    CARD16		nbytes; /* number of bytes in name */
+    CARD16		pad;
+} xRenderSetPictureFilterReq;
+
+#define sz_xRenderSetPictureFilterReq		    12
+
+/* 0.8 and higher */
+
+typedef struct {
+    Cursor		cursor;
+    CARD32		delay;
+} xAnimCursorElt;
+
+#define sz_xAnimCursorElt			    8
+
+typedef struct {
+    CARD8		reqType;
+    CARD8		renderReqType;
+    CARD16		length;
+    Cursor		cid;
+} xRenderCreateAnimCursorReq;
+
+#define sz_xRenderCreateAnimCursorReq		    8
+
+/* 0.9 and higher */
+
+typedef struct {
+    CARD8		reqType;
+    CARD8		renderReqType;
+    CARD16		length;
+    Picture		picture;
+    INT16		xOff;
+    INT16		yOff;
+} xRenderAddTrapsReq;
+
+#define sz_xRenderAddTrapsReq			    12
+
+/* 0.10 and higher */
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	renderReqType;
+    CARD16	length;
+    Picture	pid;
+    xRenderColor color;
+} xRenderCreateSolidFillReq;
+
+#define sz_xRenderCreateSolidFillReq                 16
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	renderReqType;
+    CARD16	length;
+    Picture	pid;
+    xPointFixed p1;
+    xPointFixed p2;
+    CARD32      nStops;
+} xRenderCreateLinearGradientReq;
+
+#define sz_xRenderCreateLinearGradientReq                 28
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	renderReqType;
+    CARD16	length;
+    Picture	pid;
+    xPointFixed inner;
+    xPointFixed outer;
+    Fixed       inner_radius;
+    Fixed       outer_radius;
+    CARD32      nStops;
+} xRenderCreateRadialGradientReq;
+
+#define sz_xRenderCreateRadialGradientReq                 36
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	renderReqType;
+    CARD16	length;
+    Picture	pid;
+    xPointFixed center;
+    Fixed       angle; /* in degrees */
+    CARD32      nStops;
+} xRenderCreateConicalGradientReq;
+
+#define sz_xRenderCreateConicalGradientReq                 24
+
+#undef Window
+#undef Drawable
+#undef Font
+#undef Pixmap
+#undef Cursor
+#undef Colormap
+#undef GContext
+#undef Atom
+#undef VisualID
+#undef Time
+#undef KeyCode
+#undef KeySym
+
+#undef Picture
+#undef PictFormat
+#undef Fixed
+#undef Glyphset
+
+#endif /* _XRENDERP_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/saver.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/saver.h
new file mode 100644
index 0000000..e8da625
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/saver.h
@@ -0,0 +1,52 @@
+/*
+Copyright (c) 1992  X Consortium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of the X Consortium shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from the X Consortium.
+ *
+ * Author:  Keith Packard, MIT X Consortium
+ */
+
+#ifndef _SAVER_H_
+#define _SAVER_H_
+
+#define ScreenSaverName	"MIT-SCREEN-SAVER"
+#define ScreenSaverPropertyName "_MIT_SCREEN_SAVER_ID"
+
+#define ScreenSaverNotifyMask	0x00000001
+#define ScreenSaverCycleMask	0x00000002
+
+#define ScreenSaverMajorVersion	1
+#define ScreenSaverMinorVersion	1
+
+#define ScreenSaverOff		0
+#define ScreenSaverOn		1
+#define ScreenSaverCycle	2
+#define ScreenSaverDisabled	3
+
+#define ScreenSaverBlanked	0
+#define ScreenSaverInternal	1
+#define ScreenSaverExternal	2
+
+#define ScreenSaverNotify	0
+#define ScreenSaverNumberEvents	1
+
+#endif /* _SAVER_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/saverproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/saverproto.h
new file mode 100644
index 0000000..0b8e34e
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/saverproto.h
@@ -0,0 +1,175 @@
+/*
+Copyright (c) 1992  X Consortium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of the X Consortium shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from the X Consortium.
+ *
+ * Author:  Keith Packard, MIT X Consortium
+ */
+
+#ifndef _SAVERPROTO_H_
+#define _SAVERPROTO_H_
+
+#include <X11/extensions/saver.h>
+
+#define Window CARD32
+#define Drawable CARD32
+#define Font CARD32
+#define Pixmap CARD32
+#define Cursor CARD32
+#define Colormap CARD32
+#define GContext CARD32
+#define Atom CARD32
+#define VisualID CARD32
+#define Time CARD32
+#define KeyCode CARD8
+#define KeySym CARD32
+
+#define X_ScreenSaverQueryVersion   0
+
+typedef struct _ScreenSaverQueryVersion {
+    CARD8 reqType;		/* always ScreenSaverReqCode */
+    CARD8 saverReqType;		/* always X_ScreenSaverQueryVersion */
+    CARD16 length;
+    CARD8 clientMajor;
+    CARD8 clientMinor;
+    CARD16 unused;
+} xScreenSaverQueryVersionReq;
+#define sz_xScreenSaverQueryVersionReq	8
+
+typedef struct {
+    CARD8 type;			/* X_Reply */
+    CARD8 unused;			/* not used */
+    CARD16 sequenceNumber;
+    CARD32 length;
+    CARD16 majorVersion;	/* major version of protocol */
+    CARD16 minorVersion;	/* minor version of protocol */
+    CARD32 pad0;
+    CARD32 pad1;
+    CARD32 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+} xScreenSaverQueryVersionReply;
+#define sz_xScreenSaverQueryVersionReply	32
+
+#define X_ScreenSaverQueryInfo   1
+
+typedef struct _ScreenSaverQueryInfo {
+    CARD8 reqType;		/* always ScreenSaverReqCode */
+    CARD8 saverReqType;		/* always X_ScreenSaverQueryInfo */
+    CARD16 length;
+    Drawable drawable;
+} xScreenSaverQueryInfoReq;
+#define sz_xScreenSaverQueryInfoReq	8
+
+typedef struct {
+    CARD8 type;			/* X_Reply */
+    BYTE state;			/* Off, On */
+    CARD16 sequenceNumber;
+    CARD32 length;
+    Window window;
+    CARD32 tilOrSince;
+    CARD32 idle;
+    CARD32 eventMask;
+    BYTE kind;			/* Blanked, Internal, External */
+    CARD8 pad0;
+    CARD16 pad1;
+    CARD32 pad2;
+} xScreenSaverQueryInfoReply;
+#define sz_xScreenSaverQueryInfoReply	32
+
+#define X_ScreenSaverSelectInput   2
+
+typedef struct _ScreenSaverSelectInput {
+    CARD8 reqType;		/* always ScreenSaverReqCode */
+    CARD8 saverReqType;		/* always X_ScreenSaverSelectInput */
+    CARD16 length;
+    Drawable drawable;
+    CARD32 eventMask;
+} xScreenSaverSelectInputReq;
+#define sz_xScreenSaverSelectInputReq	12
+
+#define X_ScreenSaverSetAttributes   3
+
+typedef struct _ScreenSaverSetAttributes {
+    CARD8 reqType;		/* always ScreenSaverReqCode */
+    CARD8 saverReqType;		/* always X_ScreenSaverSetAttributes */
+    CARD16 length;
+    Drawable drawable;
+    INT16 x, y;
+    CARD16 width, height, borderWidth;
+    BYTE c_class;
+    CARD8 depth;
+    VisualID visualID;
+    CARD32 mask;
+} xScreenSaverSetAttributesReq;
+#define sz_xScreenSaverSetAttributesReq	28
+
+#define X_ScreenSaverUnsetAttributes   4
+
+typedef struct _ScreenSaverUnsetAttributes {
+    CARD8 reqType;		/* always ScreenSaverReqCode */
+    CARD8 saverReqType;		/* always X_ScreenSaverUnsetAttributes */
+    CARD16 length;
+    Drawable drawable;
+} xScreenSaverUnsetAttributesReq;
+#define sz_xScreenSaverUnsetAttributesReq	8
+
+#define X_ScreenSaverSuspend   5
+
+typedef struct _ScreenSaverSuspend {
+    CARD8 reqType;
+    CARD8 saverReqType;
+    CARD16 length;
+    CARD32 suspend;		/* a boolean, but using the wrong encoding */
+} xScreenSaverSuspendReq;
+#define sz_xScreenSaverSuspendReq	8
+
+typedef struct _ScreenSaverNotify {
+    CARD8 type;			/* always eventBase + ScreenSaverNotify */
+    BYTE state;			/* off, on, cycle */
+    CARD16 sequenceNumber;
+    Time timestamp;
+    Window root;
+    Window window;		/* screen saver window */
+    BYTE kind;			/* blanked, internal, external */
+    BYTE forced;
+    CARD16 pad0;
+    CARD32 pad1;
+    CARD32 pad2;
+    CARD32 pad3;
+} xScreenSaverNotifyEvent;
+#define sz_xScreenSaverNotifyEvent	32
+
+#undef Window
+#undef Drawable
+#undef Font
+#undef Pixmap
+#undef Cursor
+#undef Colormap
+#undef GContext
+#undef Atom
+#undef VisualID
+#undef Time
+#undef KeyCode
+#undef KeySym
+
+#endif /* _SAVERPROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/secur.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/secur.h
new file mode 100644
index 0000000..ca27b29
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/secur.h
@@ -0,0 +1,61 @@
+/*
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+*/
+
+#ifndef _SECUR_H
+#define _SECUR_H
+
+#define SECURITY_EXTENSION_NAME		"SECURITY"
+#define SECURITY_MAJOR_VERSION		1
+#define SECURITY_MINOR_VERSION		0
+
+#define XSecurityNumberEvents		1
+#define XSecurityNumberErrors		2
+#define XSecurityBadAuthorization	0
+#define XSecurityBadAuthorizationProtocol 1
+
+/* trust levels */
+#define XSecurityClientTrusted		0
+#define XSecurityClientUntrusted	1
+
+/* authorization attribute masks */
+#define XSecurityTimeout		(1<<0)
+#define XSecurityTrustLevel		(1<<1)
+#define XSecurityGroup  		(1<<2)
+#define XSecurityEventMask		(1<<3)
+#define XSecurityAllAuthorizationAttributes \
+ (XSecurityTimeout | XSecurityTrustLevel | XSecurityGroup | XSecurityEventMask)
+
+/* event masks */
+#define XSecurityAuthorizationRevokedMask (1<<0)
+#define XSecurityAllEventMasks XSecurityAuthorizationRevokedMask
+
+/* event offsets */
+#define XSecurityAuthorizationRevoked 0
+
+#define XSecurityAuthorizationName	"XC-QUERY-SECURITY-1"
+#define XSecurityAuthorizationNameLen	19
+
+#endif /* _SECUR_H */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/securproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/securproto.h
new file mode 100644
index 0000000..d9e120c
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/securproto.h
@@ -0,0 +1,110 @@
+/*
+Copyright 1996, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+*/
+
+#ifndef _SECURPROTO_H
+#define _SECURPROTO_H
+
+#include <X11/extensions/secur.h>
+
+#define X_SecurityQueryVersion		0
+#define X_SecurityGenerateAuthorization 1
+#define X_SecurityRevokeAuthorization   2
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       securityReqType;
+    CARD16      length;
+    CARD16      majorVersion;
+    CARD16      minorVersion;
+} xSecurityQueryVersionReq;
+#define sz_xSecurityQueryVersionReq 	8
+
+typedef struct {
+    CARD8   type;
+    CARD8   pad0;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD16  majorVersion;
+    CARD16  minorVersion;
+    CARD32  pad1;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+ } xSecurityQueryVersionReply;
+#define sz_xSecurityQueryVersionReply  	32
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       securityReqType;
+    CARD16      length;
+    CARD16      nbytesAuthProto;
+    CARD16      nbytesAuthData;
+    CARD32      valueMask;
+    /* auth protocol name padded to 4 bytes */
+    /* auth protocol data padded to 4 bytes */
+    /* list of CARD32 values, if any */
+} xSecurityGenerateAuthorizationReq;
+#define sz_xSecurityGenerateAuthorizationReq 12
+
+typedef struct {
+    CARD8   type;
+    CARD8   pad0;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  authId;
+    CARD16  dataLength;
+    CARD16  pad1;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+ } xSecurityGenerateAuthorizationReply;
+#define sz_xSecurityGenerateAuthorizationReply  	32
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       securityReqType;
+    CARD16      length;
+    CARD32      authId;
+} xSecurityRevokeAuthorizationReq;
+#define sz_xSecurityRevokeAuthorizationReq 8
+
+typedef struct _xSecurityAuthorizationRevokedEvent {
+    BYTE	type;
+    BYTE	detail;
+    CARD16	sequenceNumber;
+    CARD32	authId;
+    CARD32	pad0;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xSecurityAuthorizationRevokedEvent;
+#define sz_xSecurityAuthorizationRevokedEvent 32
+
+#endif /* _SECURPROTO_H */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/shapeconst.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/shapeconst.h
new file mode 100644
index 0000000..9088956
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/shapeconst.h
@@ -0,0 +1,55 @@
+/************************************************************
+
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+********************************************************/
+
+#ifndef _SHAPECONST_H_
+#define _SHAPECONST_H_
+
+/*
+ * Protocol requests constants and alignment values
+ * These would really be in SHAPE's X.h and Xproto.h equivalents
+ */
+
+#define SHAPENAME "SHAPE"
+
+#define SHAPE_MAJOR_VERSION	1	/* current version numbers */
+#define SHAPE_MINOR_VERSION	1
+
+#define ShapeSet			0
+#define ShapeUnion			1
+#define ShapeIntersect			2
+#define ShapeSubtract			3
+#define ShapeInvert			4
+
+#define ShapeBounding			0
+#define ShapeClip			1
+#define ShapeInput			2
+
+#define ShapeNotifyMask			(1L << 0)
+#define ShapeNotify			0
+
+#define ShapeNumberEvents		(ShapeNotify + 1)
+
+#endif /* _SHAPECONST_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/shapeproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/shapeproto.h
new file mode 100644
index 0000000..e5c1838
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/shapeproto.h
@@ -0,0 +1,237 @@
+/************************************************************
+
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+********************************************************/
+
+#ifndef _SHAPEPROTO_H_
+#define _SHAPEPROTO_H_
+
+#include <X11/extensions/shapeconst.h>
+
+/*
+ * Protocol requests constants and alignment values
+ * These would really be in SHAPE's X.h and Xproto.h equivalents
+ */
+
+#define Window CARD32
+#define Time CARD32
+
+#define X_ShapeQueryVersion		0
+#define X_ShapeRectangles		1
+#define X_ShapeMask			2
+#define X_ShapeCombine			3
+#define X_ShapeOffset			4
+#define X_ShapeQueryExtents		5
+#define X_ShapeSelectInput		6
+#define X_ShapeInputSelected		7
+#define X_ShapeGetRectangles		8
+
+typedef struct _ShapeQueryVersion {
+	CARD8	reqType;		/* always ShapeReqCode */
+	CARD8	shapeReqType;		/* always X_ShapeQueryVersion */
+	CARD16	length;
+} xShapeQueryVersionReq;
+#define sz_xShapeQueryVersionReq	4
+
+typedef struct {
+	BYTE	type;			/* X_Reply */
+	CARD8	unused;			/* not used */
+	CARD16	sequenceNumber;
+	CARD32	length;
+	CARD16	majorVersion;		/* major version of SHAPE protocol */
+	CARD16	minorVersion;		/* minor version of SHAPE protocol */
+	CARD32	pad0;
+	CARD32	pad1;
+	CARD32	pad2;
+	CARD32	pad3;
+	CARD32	pad4;
+} xShapeQueryVersionReply;
+#define sz_xShapeQueryVersionReply	32
+
+typedef struct _ShapeRectangles {
+	CARD8	reqType;	/* always ShapeReqCode */
+	CARD8	shapeReqType;	/* always X_ShapeRectangles */
+	CARD16	length;
+	CARD8	op;		/* Set, ... */
+	CARD8	destKind;	/* ShapeBounding or ShapeClip */
+	CARD8	ordering;	/* UnSorted, YSorted, YXSorted, YXBanded */
+	CARD8	pad0;		/* not used */
+	Window	dest;
+	INT16	xOff;
+	INT16	yOff;
+} xShapeRectanglesReq;		/* followed by xRects */
+#define sz_xShapeRectanglesReq	16
+
+typedef struct _ShapeMask {
+	CARD8	reqType;	/* always ShapeReqCode */
+	CARD8	shapeReqType;	/* always X_ShapeMask */
+	CARD16	length;
+
+	CARD8	op;		/* Set, ... */
+	CARD8	destKind;	/* ShapeBounding or ShapeClip */
+	CARD16	junk;		/* not used */
+
+	Window	dest;
+	INT16	xOff;
+	INT16	yOff;
+	CARD32	src;		/* 1 bit pixmap */
+} xShapeMaskReq;
+#define sz_xShapeMaskReq	20
+
+typedef struct _ShapeCombine {
+	CARD8	reqType;	/* always ShapeReqCode */
+	CARD8	shapeReqType;	/* always X_ShapeCombine */
+	CARD16	length;
+	CARD8	op;		/* Set, ... */
+	CARD8	destKind;	/* ShapeBounding or ShapeClip */
+	CARD8	srcKind;	/* ShapeBounding or ShapeClip */
+	CARD8	junk;		/* not used */
+	Window	dest;
+	INT16	xOff;
+	INT16	yOff;
+	Window	src;
+} xShapeCombineReq;
+#define sz_xShapeCombineReq	20
+
+typedef struct _ShapeOffset {
+	CARD8	reqType;	/* always ShapeReqCode */
+	CARD8	shapeReqType;	/* always X_ShapeOffset */
+	CARD16	length;
+	CARD8	destKind;	/* ShapeBounding or ShapeClip */
+	CARD8	junk1;		/* not used */
+	CARD16	junk2;		/* not used */
+	Window	dest;
+	INT16	xOff;
+	INT16	yOff;
+} xShapeOffsetReq;
+#define sz_xShapeOffsetReq	16
+
+typedef struct _ShapeQueryExtents {
+	CARD8	reqType;	/* always ShapeReqCode */
+	CARD8	shapeReqType;	/* always X_ShapeQueryExtents */
+	CARD16	length;
+	Window	window;
+} xShapeQueryExtentsReq;
+#define sz_xShapeQueryExtentsReq	8
+
+typedef struct {
+	BYTE	type;			/* X_Reply */
+	CARD8	unused;			/* not used */
+	CARD16	sequenceNumber;
+	CARD32	length;			/* 0 */
+	CARD8	boundingShaped;		/* window has bounding shape */
+	CARD8	clipShaped;		/* window has clip shape */
+	CARD16	unused1;
+	INT16	xBoundingShape;		/* extents of bounding shape */
+	INT16	yBoundingShape;
+	CARD16	widthBoundingShape;
+	CARD16	heightBoundingShape;
+	INT16	xClipShape;		/* extents of clip shape */
+	INT16	yClipShape;
+	CARD16	widthClipShape;
+	CARD16	heightClipShape;
+	CARD32	pad1;
+} xShapeQueryExtentsReply;
+#define sz_xShapeQueryExtentsReply	32
+
+typedef struct _ShapeSelectInput {
+	CARD8	reqType;	/* always ShapeReqCode */
+	CARD8	shapeReqType;	/* always X_ShapeSelectInput */
+	CARD16	length;
+	Window	window;
+	BYTE	enable;		/* xTrue -> send events */
+	BYTE	pad1;
+	CARD16	pad2;
+} xShapeSelectInputReq;
+#define sz_xShapeSelectInputReq	12
+
+typedef struct _ShapeNotify {
+	BYTE	type;		/* always eventBase + ShapeNotify */
+	BYTE	kind;		/* either ShapeBounding or ShapeClip */
+	CARD16	sequenceNumber;
+	Window	window;
+	INT16	x;
+	INT16	y;		/* extents of new shape */
+	CARD16	width;
+	CARD16	height;
+	Time	time;		/* time of change */
+	BYTE	shaped;		/* set when a shape actual exists */
+	BYTE	pad0;
+	CARD16	pad1;
+	CARD32	pad2;
+	CARD32	pad3;
+} xShapeNotifyEvent;
+#define sz_xShapeNotifyEvent	32
+
+typedef struct _ShapeInputSelected {
+	CARD8	reqType;	/* always ShapeReqCode */
+	CARD8	shapeReqType;	/* always X_ShapeInputSelected */
+	CARD16	length;
+	Window	window;
+} xShapeInputSelectedReq;
+#define sz_xShapeInputSelectedReq 8
+
+typedef struct {
+	BYTE	type;			/* X_Reply */
+	CARD8	enabled;		/* current status */
+	CARD16	sequenceNumber;
+	CARD32	length;		/* 0 */
+	CARD32	pad1;		/* unused */
+	CARD32	pad2;
+	CARD32	pad3;
+	CARD32	pad4;
+	CARD32	pad5;
+	CARD32	pad6;
+} xShapeInputSelectedReply;
+#define sz_xShapeInputSelectedReply	32
+
+typedef struct _ShapeGetRectangles {
+    CARD8   reqType;		/* always ShapeReqCode */
+    CARD8   shapeReqType;	/* always X_ShapeGetRectangles */
+    CARD16  length;
+    Window  window;
+    CARD8   kind;		/* ShapeBounding or ShapeClip */
+    CARD8   junk1;
+    CARD16  junk2;
+} xShapeGetRectanglesReq;
+#define sz_xShapeGetRectanglesReq	12
+
+typedef struct {
+	BYTE	type;			/* X_Reply */
+	CARD8	ordering;	/* UnSorted, YSorted, YXSorted, YXBanded */
+	CARD16	sequenceNumber;
+	CARD32	length;		/* not zero */
+	CARD32	nrects;		/* number of rectangles */
+	CARD32	pad1;
+	CARD32	pad2;
+	CARD32	pad3;
+	CARD32	pad4;
+	CARD32	pad5;
+} xShapeGetRectanglesReply;		/* followed by xRectangles */
+#define sz_xShapeGetRectanglesReply 32
+
+#undef Window
+#undef Time
+
+#endif /* _SHAPEPROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/shapestr.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/shapestr.h
new file mode 100644
index 0000000..20fde1d
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/shapestr.h
@@ -0,0 +1,8 @@
+#ifndef _SHAPESTR_H_
+#define _SHAPESTR_H_
+
+#warning "shapestr.h is obsolete and may be removed in the future."
+#warning "include <X11/extensions/shapeproto.h> for the protocol defines."
+#include <X11/extensions/shapeproto.h>
+
+#endif /* _SHAPESTR_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/shm.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/shm.h
new file mode 100644
index 0000000..be49f5e
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/shm.h
@@ -0,0 +1,44 @@
+/************************************************************
+
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+********************************************************/
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */
+
+#ifndef _SHM_H_
+#define _SHM_H_
+
+#define SHMNAME "MIT-SHM"
+
+#define SHM_MAJOR_VERSION	1	/* current version numbers */
+#define SHM_MINOR_VERSION	2
+
+#define ShmCompletion			0
+#define ShmNumberEvents			(ShmCompletion + 1)
+
+#define BadShmSeg			0
+#define ShmNumberErrors			(BadShmSeg + 1)
+
+
+#endif /* _SHM_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/shmproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/shmproto.h
new file mode 100644
index 0000000..6e32606
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/shmproto.h
@@ -0,0 +1,229 @@
+/************************************************************
+
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+********************************************************/
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */
+
+#ifndef _SHMPROTO_H_
+#define _SHMPROTO_H_
+
+#include <X11/extensions/shm.h>
+
+#define ShmSeg CARD32
+#define Drawable CARD32
+#define VisualID CARD32
+#define GContext CARD32
+#define Pixmap CARD32
+
+#define X_ShmQueryVersion		0
+#define X_ShmAttach			1
+#define X_ShmDetach			2
+#define X_ShmPutImage			3
+#define X_ShmGetImage			4
+#define X_ShmCreatePixmap		5
+#define X_ShmAttachFd                   6
+#define X_ShmCreateSegment              7
+
+typedef struct _ShmQueryVersion {
+    CARD8	reqType;		/* always ShmReqCode */
+    CARD8	shmReqType;		/* always X_ShmQueryVersion */
+    CARD16	length;
+} xShmQueryVersionReq;
+#define sz_xShmQueryVersionReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	sharedPixmaps;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	majorVersion;		/* major version of SHM protocol */
+    CARD16	minorVersion;		/* minor version of SHM protocol */
+    CARD16	uid;
+    CARD16	gid;
+    CARD8	pixmapFormat;
+    CARD8	pad0;
+    CARD16	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+} xShmQueryVersionReply;
+#define sz_xShmQueryVersionReply	32
+
+typedef struct _ShmAttach {
+    CARD8	reqType;	/* always ShmReqCode */
+    CARD8	shmReqType;	/* always X_ShmAttach */
+    CARD16	length;
+    ShmSeg	shmseg;
+    CARD32	shmid;
+    BOOL	readOnly;
+    BYTE	pad0;
+    CARD16	pad1;
+} xShmAttachReq;
+#define sz_xShmAttachReq	16
+
+typedef struct _ShmDetach {
+    CARD8	reqType;	/* always ShmReqCode */
+    CARD8	shmReqType;	/* always X_ShmDetach */
+    CARD16	length;
+    ShmSeg	shmseg;
+} xShmDetachReq;
+#define sz_xShmDetachReq	8
+
+typedef struct _ShmPutImage {
+    CARD8	reqType;	/* always ShmReqCode */
+    CARD8	shmReqType;	/* always X_ShmPutImage */
+    CARD16	length;
+    Drawable	drawable;
+    GContext	gc;
+    CARD16	totalWidth;
+    CARD16	totalHeight;
+    CARD16	srcX;
+    CARD16	srcY;
+    CARD16	srcWidth;
+    CARD16	srcHeight;
+    INT16	dstX;
+    INT16	dstY;
+    CARD8	depth;
+    CARD8	format;
+    CARD8	sendEvent;
+    CARD8	bpad;
+    ShmSeg	shmseg;
+    CARD32	offset;
+} xShmPutImageReq;
+#define sz_xShmPutImageReq	40
+
+typedef struct _ShmGetImage {
+    CARD8	reqType;	/* always ShmReqCode */
+    CARD8	shmReqType;	/* always X_ShmGetImage */
+    CARD16	length;
+    Drawable	drawable;
+    INT16	x;
+    INT16	y;
+    CARD16	width;
+    CARD16	height;
+    CARD32	planeMask;
+    CARD8	format;
+    CARD8	pad0;
+    CARD8	pad1;
+    CARD8	pad2;
+    ShmSeg	shmseg;
+    CARD32	offset;
+} xShmGetImageReq;
+#define sz_xShmGetImageReq	32
+
+typedef struct _ShmGetImageReply {
+    BYTE	type;  /* X_Reply */
+    CARD8	depth;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    VisualID	visual;
+    CARD32	size;
+    CARD32	pad0;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+} xShmGetImageReply;
+#define sz_xShmGetImageReply	32
+
+typedef struct _ShmCreatePixmap {
+    CARD8	reqType;	/* always ShmReqCode */
+    CARD8	shmReqType;	/* always X_ShmCreatePixmap */
+    CARD16	length;
+    Pixmap	pid;
+    Drawable	drawable;
+    CARD16	width;
+    CARD16	height;
+    CARD8	depth;
+    CARD8	pad0;
+    CARD8	pad1;
+    CARD8	pad2;
+    ShmSeg	shmseg;
+    CARD32	offset;
+} xShmCreatePixmapReq;
+#define sz_xShmCreatePixmapReq 28
+
+typedef struct _ShmCompletion {
+    BYTE	type;		/* always eventBase + ShmCompletion */
+    BYTE	bpad0;
+    CARD16	sequenceNumber;
+    Drawable	drawable;
+    CARD16	minorEvent;
+    BYTE	majorEvent;
+    BYTE	bpad1;
+    ShmSeg	shmseg;
+    CARD32	offset;
+    CARD32	pad0;
+    CARD32	pad1;
+    CARD32	pad2;
+} xShmCompletionEvent;
+#define sz_xShmCompletionEvent	32
+
+/* Version 1.2 additions */
+typedef struct _ShmAttachFd {
+    CARD8	reqType;	/* always ShmReqCode */
+    CARD8	shmReqType;	/* always X_ShmAttachFd */
+    CARD16	length;
+    ShmSeg	shmseg;
+    BOOL	readOnly;
+    BYTE	pad0;
+    CARD16	pad1;
+} xShmAttachFdReq;
+/* File descriptor is passed with this request */
+#define sz_xShmAttachFdReq	12
+
+typedef struct _ShmCreateSegment {
+    CARD8	reqType;	/* always ShmReqCode */
+    CARD8	shmReqType;	/* always X_ShmAttachFd */
+    CARD16	length;
+    ShmSeg	shmseg;
+    CARD32	size;
+    BOOL	readOnly;
+    BYTE	pad0;
+    CARD16	pad1;
+} xShmCreateSegmentReq;
+#define sz_xShmCreateSegmentReq 16
+
+typedef struct {
+    CARD8	type;			/* must be X_Reply */
+    CARD8	nfd;			/* must be 1	*/
+    CARD16	sequenceNumber;		/* last sequence number */
+    CARD32	length;			/* 0 */
+    CARD32	pad2;			/* unused */
+    CARD32	pad3;			/* unused */
+    CARD32	pad4;			/* unused */
+    CARD32	pad5;			/* unused */
+    CARD32	pad6;			/* unused */
+    CARD32	pad7;			/* unused */
+} xShmCreateSegmentReply;
+/* File descriptor is passed with this reply */
+#define sz_xShmCreateSegmentReply	32
+
+#undef ShmSeg
+#undef Drawable
+#undef VisualID
+#undef GContext
+#undef Pixmap
+
+#endif /* _SHMPROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/shmstr.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/shmstr.h
new file mode 100644
index 0000000..78f3759
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/shmstr.h
@@ -0,0 +1,63 @@
+/************************************************************
+
+Copyright 1989, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+********************************************************/
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */
+
+#ifndef _SHMSTR_H_
+#define _SHMSTR_H_
+
+#include <X11/extensions/shmproto.h>
+
+#ifdef _XSHM_SERVER_
+#define XSHM_PUT_IMAGE_ARGS \
+    DrawablePtr		/* dst */, \
+    GCPtr		/* pGC */, \
+    int			/* depth */, \
+    unsigned int	/* format */, \
+    int			/* w */, \
+    int			/* h */, \
+    int			/* sx */, \
+    int			/* sy */, \
+    int			/* sw */, \
+    int			/* sh */, \
+    int			/* dx */, \
+    int			/* dy */, \
+    char *		/* data */
+
+#define XSHM_CREATE_PIXMAP_ARGS \
+    ScreenPtr	/* pScreen */, \
+    int		/* width */, \
+    int		/* height */, \
+    int		/* depth */, \
+    char *	/* addr */
+
+typedef struct _ShmFuncs {
+    PixmapPtr	(* CreatePixmap)(XSHM_CREATE_PIXMAP_ARGS);
+    void	(* PutImage)(XSHM_PUT_IMAGE_ARGS);
+} ShmFuncs, *ShmFuncsPtr;
+#endif
+
+#endif /* _SHMSTR_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/syncconst.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/syncconst.h
new file mode 100644
index 0000000..0479816
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/syncconst.h
@@ -0,0 +1,181 @@
+/*
+
+Copyright 1991, 1993, 1994, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+/***********************************************************
+Copyright 1991,1993 by Digital Equipment Corporation, Maynard, Massachusetts,
+and Olivetti Research Limited, Cambridge, England.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Digital or Olivetti
+not be used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL AND OLIVETTI DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL THEY BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
+USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+#ifndef _SYNCCONST_H_
+#define _SYNCCONST_H_
+
+#define SYNC_NAME "SYNC"
+
+#define SYNC_MAJOR_VERSION	3
+#define SYNC_MINOR_VERSION	1
+
+
+#define XSyncCounterNotify              0
+#define XSyncAlarmNotify		1
+#define XSyncAlarmNotifyMask 		(1L << XSyncAlarmNotify)
+
+#define XSyncNumberEvents		2L
+
+#define XSyncBadCounter			0L
+#define XSyncBadAlarm			1L
+#define XSyncBadFence           2L
+#define XSyncNumberErrors		(XSyncBadFence + 1)
+
+/*
+ * Flags for Alarm Attributes
+ */
+#define XSyncCACounter			(1L<<0)
+#define XSyncCAValueType		(1L<<1)
+#define XSyncCAValue			(1L<<2)
+#define XSyncCATestType			(1L<<3)
+#define XSyncCADelta			(1L<<4)
+#define XSyncCAEvents			(1L<<5)
+
+/*  The _XSync macros below are for library internal use only.  They exist
+ *  so that if we have to make a fix, we can change it in this one place
+ *  and have both the macro and function variants inherit the fix.
+ */
+
+#define _XSyncIntToValue(pv, i)     ((pv)->hi=((i<0)?~0:0),(pv)->lo=(i))
+#define _XSyncIntsToValue(pv, l, h) ((pv)->lo = (l), (pv)->hi = (h))
+#define _XSyncValueGreaterThan(a, b)\
+    ((a).hi>(b).hi || ((a).hi==(b).hi && (a).lo>(b).lo))
+#define _XSyncValueLessThan(a, b)\
+    ((a).hi<(b).hi || ((a).hi==(b).hi && (a).lo<(b).lo))
+#define _XSyncValueGreaterOrEqual(a, b)\
+    ((a).hi>(b).hi || ((a).hi==(b).hi && (a).lo>=(b).lo))
+#define _XSyncValueLessOrEqual(a, b)\
+    ((a).hi<(b).hi || ((a).hi==(b).hi && (a).lo<=(b).lo))
+#define _XSyncValueEqual(a, b)	((a).lo==(b).lo && (a).hi==(b).hi)
+#define _XSyncValueIsNegative(v) (((v).hi & 0x80000000) ? 1 : 0)
+#define _XSyncValueIsZero(a)	((a).lo==0 && (a).hi==0)
+#define _XSyncValueIsPositive(v) (((v).hi & 0x80000000) ? 0 : 1)
+#define _XSyncValueLow32(v)	((v).lo)
+#define _XSyncValueHigh32(v)	((v).hi)
+#define _XSyncValueAdd(presult,a,b,poverflow) {\
+	int t = (a).lo;\
+	Bool signa = XSyncValueIsNegative(a);\
+	Bool signb = XSyncValueIsNegative(b);\
+	((presult)->lo = (a).lo + (b).lo);\
+	((presult)->hi = (a).hi + (b).hi);\
+	if (t>(presult)->lo) (presult)->hi++;\
+	*poverflow = ((signa == signb) && !(signa == XSyncValueIsNegative(*presult)));\
+     }
+#define _XSyncValueSubtract(presult,a,b,poverflow) {\
+	int t = (a).lo;\
+	Bool signa = XSyncValueIsNegative(a);\
+	Bool signb = XSyncValueIsNegative(b);\
+	((presult)->lo = (a).lo - (b).lo);\
+	((presult)->hi = (a).hi - (b).hi);\
+	if (t<(presult)->lo) (presult)->hi--;\
+	*poverflow = ((signa == signb) && !(signa == XSyncValueIsNegative(*presult)));\
+     }
+#define _XSyncMaxValue(pv) ((pv)->hi = 0x7fffffff, (pv)->lo = 0xffffffff)
+#define _XSyncMinValue(pv) ((pv)->hi = 0x80000000, (pv)->lo = 0)
+
+/*
+ *  These are the publicly usable macros.  If you want the function version
+ *  of one of these, just #undef the macro to uncover the function.
+ *  (This is the same convention that the ANSI C library uses.)
+ */
+
+#define XSyncIntToValue(pv, i) _XSyncIntToValue(pv, i)
+#define XSyncIntsToValue(pv, l, h) _XSyncIntsToValue(pv, l, h)
+#define XSyncValueGreaterThan(a, b) _XSyncValueGreaterThan(a, b)
+#define XSyncValueLessThan(a, b) _XSyncValueLessThan(a, b)
+#define XSyncValueGreaterOrEqual(a, b) _XSyncValueGreaterOrEqual(a, b)
+#define XSyncValueLessOrEqual(a, b) _XSyncValueLessOrEqual(a, b)
+#define XSyncValueEqual(a, b) _XSyncValueEqual(a, b)
+#define XSyncValueIsNegative(v) _XSyncValueIsNegative(v)
+#define XSyncValueIsZero(a) _XSyncValueIsZero(a)
+#define XSyncValueIsPositive(v) _XSyncValueIsPositive(v)
+#define XSyncValueLow32(v) _XSyncValueLow32(v)
+#define XSyncValueHigh32(v) _XSyncValueHigh32(v)
+#define XSyncValueAdd(presult,a,b,poverflow) _XSyncValueAdd(presult,a,b,poverflow)
+#define XSyncValueSubtract(presult,a,b,poverflow) _XSyncValueSubtract(presult,a,b,poverflow)
+#define XSyncMaxValue(pv) _XSyncMaxValue(pv)
+#define XSyncMinValue(pv) _XSyncMinValue(pv)
+
+/*
+ * Constants for the value_type argument of various requests
+ */
+typedef enum {
+    XSyncAbsolute,
+    XSyncRelative
+} XSyncValueType;
+
+/*
+ * Alarm Test types
+ */
+typedef enum {
+    XSyncPositiveTransition,
+    XSyncNegativeTransition,
+    XSyncPositiveComparison,
+    XSyncNegativeComparison
+} XSyncTestType;
+
+/*
+ * Alarm state constants
+ */
+typedef enum {
+    XSyncAlarmActive,
+    XSyncAlarmInactive,
+    XSyncAlarmDestroyed
+} XSyncAlarmState;
+
+
+typedef XID XSyncCounter;
+typedef XID XSyncAlarm;
+typedef XID XSyncFence;
+typedef struct _XSyncValue {
+    int hi;
+    unsigned int lo;
+} XSyncValue;
+#endif /* _SYNCCONST_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/syncproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/syncproto.h
new file mode 100644
index 0000000..0fa1db7
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/syncproto.h
@@ -0,0 +1,474 @@
+/*
+
+Copyright 1991, 1993, 1994, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+/***********************************************************
+Copyright 1991,1993 by Digital Equipment Corporation, Maynard, Massachusetts,
+and Olivetti Research Limited, Cambridge, England.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Digital or Olivetti
+not be used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL AND OLIVETTI DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL THEY BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
+USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+#ifndef _SYNCPROTO_H_
+#define _SYNCPROTO_H_
+
+#include <X11/extensions/syncconst.h>
+
+#define X_SyncInitialize		0
+#define X_SyncListSystemCounters	1
+#define X_SyncCreateCounter		2
+#define X_SyncSetCounter		3
+#define X_SyncChangeCounter		4
+#define X_SyncQueryCounter              5
+#define X_SyncDestroyCounter		6
+#define X_SyncAwait			7
+#define X_SyncCreateAlarm               8
+#define X_SyncChangeAlarm	        9
+#define X_SyncQueryAlarm	       10
+#define X_SyncDestroyAlarm	       11
+#define X_SyncSetPriority   	       12
+#define X_SyncGetPriority   	       13
+#define X_SyncCreateFence	       14
+#define X_SyncTriggerFence	       15
+#define X_SyncResetFence	       16
+#define X_SyncDestroyFence	       17
+#define X_SyncQueryFence	       18
+#define X_SyncAwaitFence	       19
+
+/* cover up types from sync.h to make sure they're the right size for
+ * protocol packaging.  These will be undef'ed after all the protocol
+ * structures are defined.
+ */
+#define XSyncCounter CARD32
+#define XSyncAlarm   CARD32
+#define XSyncFence   CARD32
+#define Drawable     CARD32
+
+/*
+ * Initialize
+ */
+typedef struct _xSyncInitialize {
+    CARD8	reqType;
+    CARD8	syncReqType;
+    CARD16	length;
+    CARD8	majorVersion;
+    CARD8	minorVersion;
+    CARD16	pad;
+} xSyncInitializeReq;
+#define sz_xSyncInitializeReq		8
+
+typedef struct {
+    BYTE	type;
+    CARD8	unused;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD8	majorVersion;
+    CARD8	minorVersion;
+    CARD16	pad;
+    CARD32	pad0;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+} xSyncInitializeReply;
+#define sz_xSyncInitializeReply	32
+
+/*
+ * ListSystemCounters
+ */
+typedef struct _xSyncListSystemCounters
+{
+    CARD8	reqType;
+    CARD8	syncReqType;
+    CARD16	length;
+} xSyncListSystemCountersReq;
+#define sz_xSyncListSystemCountersReq	4
+
+typedef struct {
+    BYTE	type;
+    CARD8	unused;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    INT32	nCounters;
+    CARD32	pad0;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+} xSyncListSystemCountersReply;
+#define sz_xSyncListSystemCountersReply	32
+
+typedef struct {
+    XSyncCounter counter;
+    INT32	resolution_hi;
+    CARD32	resolution_lo;
+    CARD16	name_length;
+} xSyncSystemCounter;
+#define sz_xSyncSystemCounter 14
+
+/*
+ * Create Counter
+ */
+typedef struct _xSyncCreateCounterReq {
+    CARD8	reqType;
+    CARD8	syncReqType;
+    CARD16	length;
+    XSyncCounter cid;
+    INT32	initial_value_hi;
+    CARD32	initial_value_lo;
+} xSyncCreateCounterReq;
+#define sz_xSyncCreateCounterReq	16
+
+/*
+ * Change Counter
+ */
+typedef struct _xSyncChangeCounterReq {
+    CARD8	reqType;
+    CARD8	syncReqType;
+    CARD16	length;
+    XSyncCounter cid;
+    INT32	value_hi;
+    CARD32	value_lo;
+} xSyncChangeCounterReq;
+#define sz_xSyncChangeCounterReq	16
+
+/*
+ * Set Counter
+ */
+typedef struct _xSyncSetCounterReq {
+    CARD8	reqType;
+    CARD8	syncReqType;
+    CARD16	length;
+    XSyncCounter cid;
+    INT32	value_hi;
+    CARD32	value_lo;
+} xSyncSetCounterReq;
+#define sz_xSyncSetCounterReq	16
+
+/*
+ * Destroy Counter
+ */
+typedef struct _xSyncDestroyCounterReq {
+    CARD8	reqType;
+    CARD8	syncReqType;
+    CARD16	length;
+    XSyncCounter counter;
+} xSyncDestroyCounterReq;
+#define sz_xSyncDestroyCounterReq	8
+
+/*
+ * Query Counter
+ */
+typedef struct _xSyncQueryCounterReq {
+    CARD8	reqType;
+    CARD8	syncReqType;
+    CARD16	length;
+    XSyncCounter counter;
+} xSyncQueryCounterReq;
+#define sz_xSyncQueryCounterReq		8
+
+
+typedef struct {
+    BYTE	type;
+    CARD8	unused;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    INT32	value_hi;
+    CARD32	value_lo;
+    CARD32	pad0;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+} xSyncQueryCounterReply;
+#define sz_xSyncQueryCounterReply	32
+
+/*
+ * Await
+ */
+typedef struct _xSyncAwaitReq {
+    CARD8	reqType;
+    CARD8	syncReqType;
+    CARD16	length;
+} xSyncAwaitReq;
+#define sz_xSyncAwaitReq		4
+
+typedef struct _xSyncWaitCondition {
+    XSyncCounter counter;
+    CARD32	value_type;
+    INT32	wait_value_hi;
+    CARD32	wait_value_lo;
+    CARD32	test_type;
+    INT32	event_threshold_hi;
+    CARD32	event_threshold_lo;
+} xSyncWaitCondition;
+#define sz_xSyncWaitCondition		28
+
+/*
+ * Create Alarm
+ */
+typedef struct _xSyncCreateAlarmReq {
+    CARD8	reqType;
+    CARD8	syncReqType;
+    CARD16	length;
+    XSyncAlarm	id;
+    CARD32	valueMask;
+} xSyncCreateAlarmReq;
+#define sz_xSyncCreateAlarmReq		12
+
+/*
+ * Destroy Alarm
+ */
+typedef struct _xSyncDestroyAlarmReq {
+    CARD8	reqType;
+    CARD8	syncReqType;
+    CARD16	length;
+    XSyncAlarm	alarm;
+} xSyncDestroyAlarmReq;
+#define sz_xSyncDestroyAlarmReq		8
+
+/*
+ * Query Alarm
+ */
+typedef struct _xSyncQueryAlarmReq {
+    CARD8	reqType;
+    CARD8	syncReqType;
+    CARD16	length;
+    XSyncAlarm	alarm;
+} xSyncQueryAlarmReq;
+#define sz_xSyncQueryAlarmReq		8
+
+typedef struct {
+    BYTE	type;
+    CARD8	unused;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    XSyncCounter counter;
+    CARD32	value_type;
+    INT32	wait_value_hi;
+    CARD32	wait_value_lo;
+    CARD32	test_type;
+    INT32	delta_hi;
+    CARD32	delta_lo;
+    BOOL        events;
+    BYTE        state;
+    BYTE	pad0;
+    BYTE	pad1;
+} xSyncQueryAlarmReply;
+#define sz_xSyncQueryAlarmReply		40
+
+/*
+ * Change Alarm
+ */
+typedef struct _xSyncChangeAlarmReq {
+    CARD8	reqType;
+    CARD8	syncReqType;
+    CARD16	length;
+    XSyncAlarm	alarm;
+    CARD32	valueMask;
+} xSyncChangeAlarmReq;
+#define sz_xSyncChangeAlarmReq		12
+
+/*
+ * SetPriority
+ */
+typedef struct _xSyncSetPriority{
+    CARD8   	reqType;
+    CARD8   	syncReqType;
+    CARD16  	length;
+    CARD32  	id;
+    INT32  	priority;
+} xSyncSetPriorityReq;
+#define sz_xSyncSetPriorityReq	    	12
+
+/*
+ * Get Priority
+ */
+typedef struct _xSyncGetPriority{
+    CARD8   	reqType;
+    CARD8   	syncReqType;
+    CARD16  	length;
+    CARD32  	id; /*XXX XID? */
+} xSyncGetPriorityReq;
+#define sz_xSyncGetPriorityReq	    	 8
+
+typedef struct {
+    BYTE	type;
+    CARD8	unused;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    INT32  	priority;
+    CARD32  	pad0;
+    CARD32  	pad1;
+    CARD32  	pad2;
+    CARD32  	pad3;
+    CARD32  	pad4;
+} xSyncGetPriorityReply;
+#define sz_xSyncGetPriorityReply	32
+
+/*
+ * Create Fence
+ */
+typedef struct _xSyncCreateFenceReq {
+    CARD8	reqType;
+    CARD8	syncReqType;
+    CARD16	length;
+    Drawable	d;
+    XSyncFence	fid;
+    BOOL	initially_triggered;
+    CARD8	pad0;
+    CARD16	pad1;
+} xSyncCreateFenceReq;
+#define sz_xSyncCreateFenceReq		16
+
+/*
+ * Put a fence object in the "triggered" state.
+ */
+typedef struct _xSyncTriggerFenceReq {
+    CARD8	reqType;
+    CARD8	syncReqType;
+    CARD16	length;
+    XSyncFence	fid;
+} xSyncTriggerFenceReq;
+#define sz_xSyncTriggerFenceReq		8
+
+/*
+ * Put a fence in the "untriggered" state.
+ */
+typedef struct _xSyncResetFenceReq {
+    CARD8	reqType;
+    CARD8	syncReqType;
+    CARD16	length;
+    XSyncFence	fid;
+} xSyncResetFenceReq;
+#define sz_xSyncResetFenceReq		8
+
+/*
+ * Destroy a fence object
+ */
+typedef struct _xSyncDestroyFenceReq {
+    CARD8	reqType;
+    CARD8	syncReqType;
+    CARD16	length;
+    XSyncFence	fid;
+} xSyncDestroyFenceReq;
+#define sz_xSyncDestroyFenceReq		8
+
+/*
+ * Query a fence object
+ */
+typedef struct _xSyncQueryFenceReq {
+    CARD8	reqType;
+    CARD8	syncReqType;
+    CARD16	length;
+    XSyncFence	fid;
+} xSyncQueryFenceReq;
+#define sz_xSyncQueryFenceReq		8
+
+/*
+ * Wait for any of a list of fence sync objects
+ * to reach the "triggered" state.
+ */
+typedef struct _xSyncAwaitFenceReq {
+    CARD8	reqType;
+    CARD8	syncReqType;
+    CARD16	length;
+} xSyncAwaitFenceReq;
+#define sz_xSyncAwaitFenceReq		4
+
+typedef struct {
+    BYTE	type;
+    CARD8	unused;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    BOOL	triggered;
+    BYTE	pad0;
+    CARD16	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xSyncQueryFenceReply;
+#define sz_xSyncQueryFenceReply		32
+
+/*
+ * Events
+ */
+
+typedef struct _xSyncCounterNotifyEvent {
+    BYTE	type;
+    BYTE	kind;
+    CARD16	sequenceNumber;
+    XSyncCounter counter;
+    INT32	wait_value_hi;
+    CARD32	wait_value_lo;
+    INT32	counter_value_hi;
+    CARD32	counter_value_lo;
+    CARD32	time;
+    CARD16	count;
+    BOOL	destroyed;
+    BYTE        pad0;
+} xSyncCounterNotifyEvent;
+
+typedef struct _xSyncAlarmNotifyEvent {
+    BYTE	type;
+    BYTE	kind;
+    CARD16	sequenceNumber;
+    XSyncAlarm	alarm;
+    INT32	counter_value_hi;
+    CARD32	counter_value_lo;
+    INT32	alarm_value_hi;
+    CARD32	alarm_value_lo;
+    CARD32	time;
+    CARD8       state;
+    BYTE        pad0;
+    BYTE        pad1;
+    BYTE        pad2;
+} xSyncAlarmNotifyEvent;
+
+#undef XSyncCounter
+#undef XSyncAlarm
+#undef XSyncFence
+#undef Drawable
+
+
+#endif /* _SYNCPROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/syncstr.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/syncstr.h
new file mode 100644
index 0000000..43cdcba
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/syncstr.h
@@ -0,0 +1,182 @@
+/*
+
+Copyright 1991, 1993, 1994, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+/***********************************************************
+Copyright 1991,1993 by Digital Equipment Corporation, Maynard, Massachusetts,
+and Olivetti Research Limited, Cambridge, England.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Digital or Olivetti
+not be used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL AND OLIVETTI DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL THEY BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
+USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+#ifndef _SYNCSTR_H_
+#define _SYNCSTR_H_
+
+#include <X11/extensions/syncproto.h>
+
+#ifdef _SYNC_SERVER
+
+#define CARD64 XSyncValue /* XXX temporary! need real 64 bit values for Alpha */
+
+typedef struct _SyncCounter {
+    ClientPtr		client;	/* Owning client. 0 for system counters */
+    XSyncCounter	id;		/* resource ID */
+    CARD64		value;		/* counter value */
+    struct _SyncTriggerList *pTriglist;	/* list of triggers */
+    Bool		beingDestroyed; /* in process of going away */
+    struct _SysCounterInfo *pSysCounterInfo; /* NULL if not a system counter */
+} SyncCounter;
+
+/*
+ * The System Counter interface
+ */
+
+typedef enum {
+    XSyncCounterNeverChanges,
+    XSyncCounterNeverIncreases,
+    XSyncCounterNeverDecreases,
+    XSyncCounterUnrestricted
+} SyncCounterType;
+
+typedef struct _SysCounterInfo {
+    char	*name;
+    CARD64	resolution;
+    CARD64	bracket_greater;
+    CARD64	bracket_less;
+    SyncCounterType counterType;  /* how can this counter change */
+    void        (*QueryValue)(
+			      pointer /*pCounter*/,
+			      CARD64 * /*freshvalue*/
+);
+    void	(*BracketValues)(
+				 pointer /*pCounter*/,
+				 CARD64 * /*lessthan*/,
+				 CARD64 * /*greaterthan*/
+);
+} SysCounterInfo;
+
+
+
+typedef struct _SyncTrigger {
+    SyncCounter *pCounter;
+    CARD64	wait_value;	/* wait value */
+    unsigned int value_type;     /* Absolute or Relative */
+    unsigned int test_type;	/* transition or Comparison type */
+    CARD64	test_value;	/* trigger event threshold value */
+    Bool	(*CheckTrigger)(
+				struct _SyncTrigger * /*pTrigger*/,
+				CARD64 /*newval*/
+				);
+    void	(*TriggerFired)(
+				struct _SyncTrigger * /*pTrigger*/
+				);
+    void	(*CounterDestroyed)(
+				struct _SyncTrigger * /*pTrigger*/
+				    );
+} SyncTrigger;
+
+typedef struct _SyncTriggerList {
+    SyncTrigger *pTrigger;
+    struct _SyncTriggerList *next;
+} SyncTriggerList;
+
+typedef struct _SyncAlarmClientList {
+    ClientPtr	client;
+    XID		delete_id;
+    struct _SyncAlarmClientList *next;
+} SyncAlarmClientList;
+
+typedef struct _SyncAlarm {
+    SyncTrigger trigger;
+    ClientPtr	client;
+    XSyncAlarm 	alarm_id;
+    CARD64	delta;
+    int		events;
+    int		state;
+    SyncAlarmClientList *pEventClients;
+} SyncAlarm;
+
+typedef struct {
+    ClientPtr	client;
+    CARD32 	delete_id;
+    int		num_waitconditions;
+} SyncAwaitHeader;
+
+typedef struct {
+    SyncTrigger trigger;
+    CARD64	event_threshold;
+    SyncAwaitHeader *pHeader;
+} SyncAwait;
+
+typedef union {
+    SyncAwaitHeader header;
+    SyncAwait	    await;
+} SyncAwaitUnion;
+
+
+extern pointer SyncCreateSystemCounter(
+    char *	/* name */,
+    CARD64  	/* initial_value */,
+    CARD64  	/* resolution */,
+    SyncCounterType /* change characterization */,
+    void        (* /*QueryValue*/ ) (
+        pointer /* pCounter */,
+        CARD64 * /* pValue_return */), /* XXX prototype */
+    void        (* /*BracketValues*/) (
+        pointer /* pCounter */,
+        CARD64 * /* pbracket_less */,
+        CARD64 * /* pbracket_greater */)
+);
+
+extern void SyncChangeCounter(
+    SyncCounter *	/* pCounter*/,
+    CARD64  		/* new_value */
+);
+
+extern void SyncDestroySystemCounter(
+    pointer pCounter
+);
+extern void InitServertime(void);
+
+#endif /* _SYNC_SERVER */
+
+#endif /* _SYNCSTR_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/vldXvMC.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/vldXvMC.h
new file mode 100644
index 0000000..fbd251e
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/vldXvMC.h
@@ -0,0 +1,174 @@
+/*****************************************************************************
+ * VLD XvMC Nonstandard extension API.
+ *
+ * Copyright (c) 2004 The Unichrome Project. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHOR(S) OR COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Author: Thomas Hellström, 2004.
+ */
+
+
+#ifndef _VLDXVMC_H
+#define _VLDXVMC_H
+
+#include <X11/Xlib.h>
+#include <X11/extensions/XvMC.h>
+
+/*
+ * New "Motion compensation type".
+ */
+
+#define XVMC_VLD 0x0020000
+
+/*
+ * Below Flags to be passed in the XvMCMpegControl structure 'flag' field.
+ */
+
+#define XVMC_PROGRESSIVE_SEQUENCE 0x00000010
+
+/*
+ * Zig-Zag Scan / Alternative Scan.
+ */
+
+#define XVMC_ZIG_ZAG_SCAN         0x00000000
+#define XVMC_ALTERNATE_SCAN       0x00000100
+
+/*
+ * Frame DCT and frame prediction are used. /
+ * Field prediction
+ */
+
+#define XVMC_PRED_DCT_FRAME       0x00000040
+#define XVMC_PRED_DCT_FIELD       0x00000000
+
+/*
+ * Top / Bottom field first
+ */
+
+#define XVMC_TOP_FIELD_FIRST      0x00000080
+#define XVMC_BOTTOM_FIELD_FIRST   0x00000000
+
+/*
+ * Motion vectors coded in intra macroblocks
+ */
+
+#define XVMC_CONCEALMENT_MOTION_VECTORS 0x00000200
+
+/*
+ * Which of two mappings between quantiser_scale_code
+ * and quantiser_scale shall apply.
+ */
+
+#define XVMC_Q_SCALE_TYPE         0x00000400
+
+/*
+ * Intra VLC Format: Bit = 0,  Bit = 1
+ * Intra blocks      B-14      B-15
+ * Non-intra blocks  B-14      B-14
+ */
+#define XVMC_INTRA_VLC_FORMAT     0x00000800
+
+/*
+ * Also XVMC_SECOND_FIELD should be set in flags if active.
+ */
+
+#define XVMC_I_PICTURE 1
+#define XVMC_P_PICTURE 2
+#define XVMC_B_PICTURE 3
+
+typedef struct _XvMCMpegControl{
+    unsigned
+        BVMV_range,        /* Backward vertical motion vector range */
+	BHMV_range,        /* Backward horizontal motion vector range */
+	FVMV_range,        /* Forward vertical motion vector range */
+	FHMV_range,        /* Forward horizontal motion vector range */
+	picture_structure, /* XVMC_TOP_FIELD, XVMC_BOTTOM_FIELD,
+			    *  XVMC_FRAME_PICTURE
+			    */
+	intra_dc_precision, /* 0x00 - 0x03 corresponds to 8 to 11 bits prec. */
+	picture_coding_type,/* XVMC_X_PICTURE */
+	mpeg_coding,        /* XVMC_MPEG_2 */
+	flags;              /* See above */
+}XvMCMpegControl;
+
+
+/*
+ * The following function is called BEFORE starting sending slices to the
+ * lib. It grabs the decoder hardware and prepares it for coming slices.
+ * The function XvMCSyncSurface will release the hardware for other contexts
+ * in addition to it's current functionality.
+ */
+
+extern Status XvMCBeginSurface(Display *display,
+			       XvMCContext *context,
+			       XvMCSurface *target_surface,
+			       XvMCSurface *past_surface,
+			       XvMCSurface *future_surface,
+			       const XvMCMpegControl *control);
+
+
+/*
+ * The quantizer matrix structure. This should be filled in by the user and
+ * uploaded whenever a change is needed. The lib initializes with
+ * default matrices and will automatically load the hardware with new matrices
+ * on decoder context switches. To load data, set the corresponding load flag
+ * to true and fill in the values. The VIA MPEG2 engine only uses the
+ * intra_quantiser_matrix and the non_intra_quantiser_matrix.
+ */
+
+typedef struct _XvMCQMatrix {
+    int load_intra_quantiser_matrix;
+    int load_non_intra_quantiser_matrix;
+    int load_chroma_intra_quantiser_matrix;
+    int load_chroma_non_intra_quantiser_matrix;
+    unsigned char intra_quantiser_matrix[64];
+    unsigned char non_intra_quantiser_matrix[64];
+    unsigned char chroma_intra_quantiser_matrix[64];
+    unsigned char chroma_non_intra_quantiser_matrix[64];
+} XvMCQMatrix;
+
+/*
+ * Upload a XvMCQMatrix structure to the clientlib.
+ * The hardware will start using it the next XvMCBeginSurface.
+ */
+
+extern Status XvMCLoadQMatrix(Display *display, XvMCContext *context,
+			      const XvMCQMatrix *qmx);
+
+
+/*
+ * Put a slice to the decoder. The hardware will start processing it
+ * immediately.
+ */
+
+extern Status XvMCPutSlice(Display *display,XvMCContext *context,
+			   char *slice, int nBytes);
+/*
+ * Put a slice without the slice start code to the decoder.
+ * The hardware will start processing it
+ * immediately. This function is for client optimization.
+ * XvMCPutSlice(display,context,slice,nBytes) is equivalent to
+ * XvMCPutSlice2(display,context,slice+4,nBytes-4,slice[3]);
+ */
+
+extern Status XvMCPutSlice2(Display *display,XvMCContext *context,
+			   char *slice, int nBytes, int sliceCode);
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/windowswm.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/windowswm.h
new file mode 100644
index 0000000..9938900
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/windowswm.h
@@ -0,0 +1,195 @@
+/*
+ * WindowsWM extension is based on AppleWM extension
+ * Authors:	Kensuke Matsuzaki
+ */
+/**************************************************************************
+
+Copyright (c) 2002 Apple Computer, Inc.
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sub license, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice (including the
+next paragraph) shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+**************************************************************************/
+
+#ifndef _WINDOWSWM_H_
+#define _WINDOWSWM_H_
+
+#include <X11/Xfuncproto.h>
+
+#define X_WindowsWMQueryVersion		0
+#define X_WindowsWMFrameGetRect		1
+#define X_WindowsWMFrameDraw		2
+#define X_WindowsWMFrameSetTitle	3
+#define X_WindowsWMDisableUpdate	4
+#define X_WindowsWMReenableUpdate	5
+#define X_WindowsWMSelectInput		6
+#define X_WindowsWMSetFrontProcess	7
+
+/* Events */
+#define WindowsWMControllerNotify	0
+#define WindowsWMActivationNotify	1
+#define WindowsWMNumberEvents		2
+
+#define WindowsWMControllerNotifyMask	(1L << 0)
+#define WindowsWMActivationNotifyMask	(1L << 1)
+
+/* "Kinds" of ControllerNotify events */
+#define WindowsWMMinimizeWindow		0
+#define WindowsWMMaximizeWindow		1
+#define WindowsWMRestoreWindow		2
+#define WindowsWMCloseWindow		3
+#define WindowsWMBringAllToFront	4
+#define WindowsWMHideWindow		5
+#define WindowsWMMoveWindow		6
+#define WindowsWMResizeWindow		7
+#define WindowsWMActivateWindow		8
+
+/* "Kinds" of ActivationNotify events */
+#define WindowsWMIsActive		0
+#define WindowsWMIsInactive		1
+
+/* Errors */
+#define WindowsWMClientNotLocal		0
+#define WindowsWMOperationNotSupported	1
+#define WindowsWMNumberErrors		(WindowsWMOperationNotSupported + 1)
+
+/* Possible value for frame_rect argument to XWindowsWMFrameGetRect() */
+#define WindowsWMFrameRectTitleBar	1
+#define WindowsWMFrameRectTracking	2
+#define WindowsWMFrameRectGrowBox	3
+
+/* Window frame styles */
+#define WindowsWMFrameStyleBorder		0x800000
+#define WindowsWMFrameStyleCaption		0xc00000
+#define WindowsWMFrameStyleChild		0x40000000
+#define WindowsWMFrameStyleChildWindow		0x40000000
+#define WindowsWMFrameStyleClipChildren		0x2000000
+#define WindowsWMFrameStyleClipSiblings		0x4000000
+#define WindowsWMFrameStyleDisabled		0x8000000
+#define WindowsWMFrameStyleDlgFrame		0x400000
+#define WindowsWMFrameStyleGroup		0x20000
+#define WindowsWMFrameStyleHScroll		0x100000
+#define WindowsWMFrameStyleIconic		0x20000000
+#define WindowsWMFrameStyleMaximize		0x1000000
+#define WindowsWMFrameStyleMaximizeBox		0x10000
+#define WindowsWMFrameStyleMinimize		0x20000000
+#define WindowsWMFrameStyleMinimizeBox		0x20000
+#define WindowsWMFrameStyleOverlapped		0
+#define WindowsWMFrameStyleOverlappedWindow	0xcf0000
+#define WindowsWMFrameStylePopup		0x80000000
+#define WindowsWMFrameStylePopupWindow		0x80880000
+#define WindowsWMFrameStyleSizeBox		0x40000
+#define WindowsWMFrameStyleSysMenu		0x80000
+#define WindowsWMFrameStyleTabStop		0x10000
+#define WindowsWMFrameStyleThickFrame		0x40000
+#define WindowsWMFrameStyleTiled		0
+#define WindowsWMFrameStyleTiledWindow		0xcf0000
+#define WindowsWMFrameStyleVisible		0x10000000
+#define WindowsWMFrameStyleVScroll		0x200000
+
+/* Window frame Ex-styles */
+#define WindowsWMFrameStyleExAcceptFiles	16
+#define WindowsWMFrameStyleExAppWindow		0x40000
+#define WindowsWMFrameStyleExClientEdge		512
+#define WindowsWMFrameStyleExComposited		0x2000000
+#define WindowsWMFrameStyleExContextHelp	0x400
+#define WindowsWMFrameStyleExControlParent	0x10000
+#define WindowsWMFrameStyleExDlgModalFrame	1
+#define WindowsWMFrameStyleExLayered		0x80000
+#define WindowsWMFrameStyleExLayoutRtl		0x400000
+#define WindowsWMFrameStyleExLeft		0
+#define WindowsWMFrameStyleExLeftScrollBar	0x4000
+#define WindowsWMFrameStyleExLtrReading		0
+#define WindowsWMFrameStyleExMDIChild		64
+#define WindowsWMFrameStyleExNoActivate		0x8000000
+#define WindowsWMFrameStyleExNoInheritLayout	0x100000
+#define WindowsWMFrameStyleExNoParentNotify	4
+#define WindowsWMFrameStyleExOverlappedWindow	0x300
+#define WindowsWMFrameStyleExPaletteWindow	0x188
+#define WindowsWMFrameStyleExRight		0x1000
+#define WindowsWMFrameStyleExRightScrollBar	0
+#define WindowsWMFrameStyleExRtlReading		0x2000
+#define WindowsWMFrameStyleExStaticEdge		0x20000
+#define WindowsWMFrameStyleExToolWindow		128
+#define WindowsWMFrameStyleExTopMost		8
+#define WindowsWMFrameStyleExTransparent	32
+#define WindowsWMFrameStyleExWindowEdge		256
+
+#define WINDOWSWM_RAISE_ON_CLICK	"_WINDOWSWM_RAISE_ON_CLICK"
+#define WINDOWSWM_MOUSE_ACTIVATE	"_WINDOWSWM_MOUSE_ACTIVATE"
+#define WINDOWSWM_CLIENT_WINDOW		"_WINDOWSWM_CLIENT_WINDOW"
+#define WINDOWSWM_NATIVE_HWND		"_WINDOWSWM_NATIVE_HWND"
+
+#ifndef _WINDOWSWM_SERVER_
+
+typedef struct {
+    int	type;		    /* of event */
+    unsigned long serial;   /* # of last request processed by server */
+    Bool send_event;	    /* true if this came from a SendEvent request */
+    Display *display;	    /* Display the event was read from */
+    Window window;	    /* window of event */
+    Time time;		    /* server timestamp when event happened */
+    int kind;		    /* subtype of event */
+    int arg;
+    int x;
+    int y;
+    int w;
+    int h;
+} XWindowsWMNotifyEvent;
+
+_XFUNCPROTOBEGIN
+
+Bool XWindowsWMQueryExtension (Display *dpy, int *event_base, int *error_base);
+
+Bool XWindowsWMQueryVersion (Display *dpy, int *majorVersion,
+			     int *minorVersion, int *patchVersion);
+
+Bool XWindowsWMDisableUpdate (Display *dpy, int screen);
+
+Bool XWindowsWMReenableUpdate (Display *dpy, int screen);
+
+Bool XWindowsWMSelectInput (Display *dpy, unsigned long mask);
+
+Bool XWindowsWMSetFrontProcess (Display *dpy);
+
+Bool XWindowsWMFrameGetRect (Display *dpy,
+			     unsigned int frame_style,
+			     unsigned int frame_style_ex,
+			     unsigned int frame_rect,
+			     short inner_x, short inner_y,
+			     short inner_w, short inner_h,
+			     short *ret_x, short *ret_y,
+			     short *ret_w, short *ret_h);
+
+Bool XWindowsWMFrameDraw (Display *dpy, int screen, Window window,
+			  unsigned int frame_style,
+			  unsigned int frame_style_ex,
+			  short inner_x, short inner_y,
+			  short inner_w, short inner_h);
+
+Bool XWindowsWMFrameSetTitle (Display *dpy, int screen, Window window,
+			      unsigned int title_length,
+			      const char * title_bytes);
+
+_XFUNCPROTOEND
+
+#endif /* _WINDOWSWM_SERVER_ */
+#endif /* _WINDOWSWM_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/windowswmstr.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/windowswmstr.h
new file mode 100644
index 0000000..b4e75aa
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/windowswmstr.h
@@ -0,0 +1,169 @@
+/*
+ * WindowsWM extension is based on AppleWM extension
+ * Authors:	Kensuke Matsuzaki
+ */
+/**************************************************************************
+
+Copyright (c) 2002 Apple Computer, Inc.
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sub license, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice (including the
+next paragraph) shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+**************************************************************************/
+
+#ifndef _WINDOWSWMSTR_H_
+#define _WINDOWSWMSTR_H_
+
+#include <X11/extensions/windowswm.h>
+#include <X11/X.h>
+#include <X11/Xmd.h>
+
+#define WINDOWSWMNAME "Windows-WM"
+
+#define WINDOWS_WM_MAJOR_VERSION	1	/* current version numbers */
+#define WINDOWS_WM_MINOR_VERSION	0
+#define WINDOWS_WM_PATCH_VERSION	0
+
+typedef struct _WindowsWMQueryVersion {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_WMQueryVersion */
+    CARD16	length;
+} xWindowsWMQueryVersionReq;
+#define sz_xWindowsWMQueryVersionReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	majorVersion;		/* major version of WM protocol */
+    CARD16	minorVersion;		/* minor version of WM protocol */
+    CARD32	patchVersion;		/* patch version of WM protocol */
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xWindowsWMQueryVersionReply;
+#define sz_xWindowsWMQueryVersionReply	32
+
+typedef struct _WindowsWMDisableUpdate {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_WMDisableUpdate */
+    CARD16	length;
+    CARD32	screen;
+} xWindowsWMDisableUpdateReq;
+#define sz_xWindowsWMDisableUpdateReq	8
+
+typedef struct _WindowsWMReenableUpdate {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_WMReenableUpdate */
+    CARD16	length;
+    CARD32	screen;
+} xWindowsWMReenableUpdateReq;
+#define sz_xWindowsWMReenableUpdateReq	8
+
+typedef struct _WindowsWMSelectInput {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_WMSelectInput */
+    CARD16	length;
+    CARD32	mask;
+} xWindowsWMSelectInputReq;
+#define sz_xWindowsWMSelectInputReq	8
+
+typedef struct _WindowsWMNotify {
+	BYTE	type;		/* always eventBase + event type */
+	BYTE	kind;
+	CARD16	sequenceNumber;
+	Window	window;
+	Time	time;		/* time of change */
+	CARD16	pad1;
+	CARD32	arg;
+	INT16	x;
+	INT16	y;
+	CARD16	w;
+	CARD16	h;
+} xWindowsWMNotifyEvent;
+#define sz_xWindowsWMNotifyEvent	28
+
+typedef struct _WindowsWMSetFrontProcess {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_WMSetFrontProcess */
+    CARD16	length;
+} xWindowsWMSetFrontProcessReq;
+#define sz_xWindowsWMSetFrontProcessReq 4
+
+typedef struct _WindowsWMFrameGetRect {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_WMFrameGetRect */
+    CARD16	length;
+    CARD32	frame_style;
+    CARD32	frame_style_ex;
+    CARD16	frame_rect;
+    INT16	ix;
+    INT16	iy;
+    CARD16	iw;
+    CARD16	ih;
+    CARD16	pad1;
+} xWindowsWMFrameGetRectReq;
+#define sz_xWindowsWMFrameGetRectReq	24
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    INT16	x;
+    INT16	y;
+    CARD16	w;
+    CARD16	h;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xWindowsWMFrameGetRectReply;
+#define sz_xWindowsWMFrameGetRectReply	32
+
+typedef struct _WindowsWMFrameDraw {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_WMFrameDraw */
+    CARD16	length;
+    CARD32	screen;
+    CARD32	window;
+    CARD32	frame_style;
+    CARD32	frame_style_ex;
+    INT16	ix;
+    INT16	iy;
+    CARD16	iw;
+    CARD16	ih;
+} xWindowsWMFrameDrawReq;
+#define sz_xWindowsWMFrameDrawReq	28
+
+typedef struct _WindowsWMFrameSetTitle {
+    CARD8	reqType;		/* always WMReqCode */
+    CARD8	wmReqType;		/* always X_WMFrameSetTitle */
+    CARD16	length;
+    CARD32	screen;
+    CARD32	window;
+    CARD32	title_length;
+} xWindowsWMFrameSetTitleReq;
+#define sz_xWindowsWMFrameSetTitleReq	16
+
+#endif /* _WINDOWSWMSTR_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xcalibrateproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xcalibrateproto.h
new file mode 100644
index 0000000..f9b9425
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xcalibrateproto.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright © 2003 Philip Blundell
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Philip Blundell not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Philip Blundell makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * PHILIP BLUNDELL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL PHILIP BLUNDELL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef XCALIBRATEPROTO_H
+#define XCALIBRATEPROTO_H
+
+/*
+ * requests and replies
+ */
+typedef struct {
+    CARD8   reqType;
+    CARD8   xCalibrateReqType;
+    CARD16  length;
+    CARD32  majorVersion;
+    CARD32  minorVersion;
+} xXCalibrateQueryVersionReq;
+
+#define sz_xXCalibrateQueryVersionReq   12
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  majorVersion;
+    CARD32  minorVersion;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+} xXCalibrateQueryVersionReply;
+
+#define sz_xXCalibrateQueryVersionReply	32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xCalibrateReqType;
+    CARD16  length;
+    CARD16  on;
+    CARD16  pad;
+} xXCalibrateRawModeReq;
+
+#define sz_xXCalibrateRawModeReq	8
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  status;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+    CARD32  pad6;
+    CARD32  pad7;
+} xXCalibrateRawModeReply;
+
+#define sz_xXCalibrateRawModeReply	32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xCalibrateReqType;
+    CARD16  length;
+    CARD32  x;
+    CARD32  y;
+} xXCalibrateScreenToCoordReq;
+
+#define sz_xXCalibrateScreenToCoordReq	12
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  x;
+    CARD32  y;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+    CARD32  pad6;
+} xXCalibrateScreenToCoordReply;
+
+#define sz_xXCalibrateScreenToCoordReply	32
+
+/* Events */
+
+typedef struct {
+    CARD8	type;
+    CARD8	pad1;
+    CARD16	sequenceNumber;
+    CARD16	x;
+    CARD16	y;
+    CARD16	pressure;
+    CARD16      pad2;
+} xXCalibrateRawTouchscreenEvent;
+
+#define sz_xXCalibrateRawTouchscreenEvent 12
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xcalibratewire.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xcalibratewire.h
new file mode 100644
index 0000000..d1d2edf
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xcalibratewire.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright © 2003 Philip Blundell
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Philip Blundell not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Philip Blundell makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * PHILIP BLUNDELL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL PHILIP BLUNDELL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef XCALIBRATEWIRE_H
+#define XCALIBRATEWIRE_H
+
+#define XCALIBRATE_MAJOR_VERSION 0
+#define XCALIBRATE_MINOR_VERSION 1
+#define XCALIBRATE_NAME "XCALIBRATE"
+
+#define X_XCalibrateQueryVersion		0
+#define X_XCalibrateRawMode			1
+#define X_XCalibrateScreenToCoord		2
+
+#define XCalibrateNumberRequests		(X_XCalibrateScreenToCoord + 1)
+
+#define X_XCalibrateRawTouchscreen		0
+
+#define XCalibrateNumberEvents			(X_XCalibrateRawTouchscreen + 1)
+
+#define XCalibrateNumberErrors			0
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xcmiscproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xcmiscproto.h
new file mode 100644
index 0000000..616cec3
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xcmiscproto.h
@@ -0,0 +1,110 @@
+/*
+
+Copyright 1993, 1994, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+#ifndef _XCMISCPROTO_H_
+#define _XCMISCPROTO_H_
+
+#define X_XCMiscGetVersion	0
+#define X_XCMiscGetXIDRange	1
+#define X_XCMiscGetXIDList	2
+
+#define XCMiscNumberEvents	0
+
+#define XCMiscNumberErrors	0
+
+#define XCMiscMajorVersion	1
+#define XCMiscMinorVersion	1
+
+#define XCMiscExtensionName	"XC-MISC"
+
+typedef struct {
+    CARD8	reqType;	/* always XCMiscCode */
+    CARD8	miscReqType;	/* always X_XCMiscGetVersion */
+    CARD16	length;
+    CARD16	majorVersion;
+    CARD16	minorVersion;
+} xXCMiscGetVersionReq;
+#define sz_xXCMiscGetVersionReq 8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	pad0;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	majorVersion;
+    CARD16	minorVersion;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xXCMiscGetVersionReply;
+#define sz_xXCMiscGetVersionReply 32
+
+typedef struct {
+    CARD8	reqType;	/* always XCMiscCode */
+    CARD8	miscReqType;	/* always X_XCMiscGetXIDRange */
+    CARD16	length;
+} xXCMiscGetXIDRangeReq;
+#define sz_xXCMiscGetXIDRangeReq 4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	pad0;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	start_id;
+    CARD32	count;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+} xXCMiscGetXIDRangeReply;
+#define sz_xXCMiscGetXIDRangeReply 32
+
+typedef struct {
+    CARD8	reqType;	/* always XCMiscCode */
+    CARD8	miscReqType;	/* always X_XCMiscGetXIDList */
+    CARD16	length;
+    CARD32	count;		/* number of IDs requested */
+} xXCMiscGetXIDListReq;
+#define sz_xXCMiscGetXIDListReq 8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	pad0;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	count;		/* number of IDs requested */
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xXCMiscGetXIDListReply;
+#define sz_xXCMiscGetXIDListReply 32
+
+#endif /* _XCMISCPROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xcmiscstr.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xcmiscstr.h
new file mode 100644
index 0000000..c2b6433
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xcmiscstr.h
@@ -0,0 +1,3 @@
+#warning "xcmiscstr.h is obsolete and may be removed in the future."
+#warning "include <X11/extensions/xcmiscproto.h> for the protocol defines."
+#include <X11/extensions/xcmiscproto.h>
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86bigfont.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86bigfont.h
new file mode 100644
index 0000000..1bf47e9
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86bigfont.h
@@ -0,0 +1,20 @@
+/*
+ * Declarations for the BIGFONT extension.
+ *
+ * Copyright (c) 1999-2000  Bruno Haible
+ * Copyright (c) 1999-2000  The XFree86 Project, Inc.
+ */
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD */
+
+#ifndef _XF86BIGFONT_H_
+#define _XF86BIGFONT_H_
+
+#define X_XF86BigfontQueryVersion	0
+#define X_XF86BigfontQueryFont		1
+
+#define XF86BigfontNumberEvents		0
+
+#define XF86BigfontNumberErrors		0
+
+#endif /* _XF86BIGFONT_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86bigfproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86bigfproto.h
new file mode 100644
index 0000000..a0710dd
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86bigfproto.h
@@ -0,0 +1,92 @@
+/*
+ * Declarations of request structures for the BIGFONT extension.
+ *
+ * Copyright (c) 1999-2000  Bruno Haible
+ * Copyright (c) 1999-2000  The XFree86 Project, Inc.
+ */
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD */
+
+#ifndef _XF86BIGFPROTO_H_
+#define _XF86BIGFPROTO_H_
+
+#include <X11/extensions/xf86bigfont.h>
+
+#define XF86BIGFONTNAME			"XFree86-Bigfont"
+
+#define XF86BIGFONT_MAJOR_VERSION	1	/* current version numbers */
+#define XF86BIGFONT_MINOR_VERSION	1
+
+typedef struct _XF86BigfontQueryVersion {
+    CARD8	reqType;		/* always XF86BigfontReqCode */
+    CARD8	xf86bigfontReqType;	/* always X_XF86BigfontQueryVersion */
+    CARD16	length;
+} xXF86BigfontQueryVersionReq;
+#define sz_xXF86BigfontQueryVersionReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	capabilities;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	majorVersion;		/* major version of XFree86-Bigfont */
+    CARD16	minorVersion;		/* minor version of XFree86-Bigfont */
+    CARD32	uid;
+    CARD32	gid;
+    CARD32	signature;
+    CARD32	pad1;
+    CARD32	pad2;
+} xXF86BigfontQueryVersionReply;
+#define sz_xXF86BigfontQueryVersionReply 32
+
+/* Bit masks that can be set in the capabilities */
+#define XF86Bigfont_CAP_LocalShm 1
+
+typedef struct _XF86BigfontQueryFont {
+    CARD8	reqType;		/* always XF86BigfontReqCode */
+    CARD8	xf86bigfontReqType;	/* always X_XF86BigfontQueryFont */
+    CARD16	length;
+    CARD32	id;
+    CARD32	flags;
+} xXF86BigfontQueryFontReq;
+#define sz_xXF86BigfontQueryFontReq	12
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    xCharInfo	minBounds;
+#ifndef WORD64
+    CARD32	walign1;
+#endif
+    xCharInfo	maxBounds;
+#ifndef WORD64
+    CARD32	walign2;
+#endif
+    CARD16	minCharOrByte2;
+    CARD16	maxCharOrByte2;
+    CARD16	defaultChar;
+    CARD16	nFontProps;
+    CARD8	drawDirection;
+    CARD8	minByte1;
+    CARD8	maxByte1;
+    BOOL	allCharsExist;
+    INT16	fontAscent;
+    INT16	fontDescent;
+    CARD32	nCharInfos;
+    CARD32	nUniqCharInfos;
+    CARD32	shmid;
+    CARD32	shmsegoffset;
+    /* followed by nFontProps xFontProp structures */
+    /* and if nCharInfos > 0 && shmid == -1,
+       followed by nUniqCharInfos xCharInfo structures
+       and then by nCharInfos CARD16 indices (each >= 0, < nUniqCharInfos)
+       and then, if nCharInfos is odd, one more CARD16 for padding. */
+} xXF86BigfontQueryFontReply;
+#define sz_xXF86BigfontQueryFontReply	72
+
+/* Bit masks that can be set in the flags */
+#define XF86Bigfont_FLAGS_Shm 1
+
+#endif /* _XF86BIGFPROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86bigfstr.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86bigfstr.h
new file mode 100644
index 0000000..cf6735d
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86bigfstr.h
@@ -0,0 +1,3 @@
+#warning "xf86bigfstr.h is obsolete and may be removed in the future."
+#warning "include <X11/extensions/xf86bigfproto.h> for the protocol defines."
+#include <X11/extensions/xf86bigfproto.h>
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dga.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dga.h
new file mode 100644
index 0000000..7b5d635
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dga.h
@@ -0,0 +1,13 @@
+#ifdef _XF86DGA_SERVER_
+
+#warning "xf86dga.h is obsolete and may be removed in the future."
+#warning "include <X11/extensions/xf86dgaconst.h> instead."
+#include <X11/extensions/xf86dgaconst.h>
+
+#else
+
+#warning "xf86dga.h is obsolete and may be removed in the future."
+#warning "include <X11/extensions/Xxf86dga.h> instead."
+#include <X11/extensions/Xxf86dga.h>
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dga1const.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dga1const.h
new file mode 100644
index 0000000..eca06f6
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dga1const.h
@@ -0,0 +1,36 @@
+/*
+
+Copyright (c) 1995  Jon Tombs
+Copyright (c) 1995  XFree86 Inc
+
+*/
+
+/************************************************************************
+
+   THIS IS THE OLD DGA API AND IS OBSOLETE.  PLEASE DO NOT USE IT ANYMORE
+
+************************************************************************/
+
+#ifndef _XF86DGA1CONST_H_
+#define _XF86DGA1CONST_H_
+
+#define X_XF86DGAQueryVersion		0
+#define X_XF86DGAGetVideoLL		1
+#define X_XF86DGADirectVideo		2
+#define X_XF86DGAGetViewPortSize	3
+#define X_XF86DGASetViewPort		4
+#define X_XF86DGAGetVidPage		5
+#define X_XF86DGASetVidPage		6
+#define X_XF86DGAInstallColormap	7
+#define X_XF86DGAQueryDirectVideo	8
+#define X_XF86DGAViewPortChanged	9
+
+#define XF86DGADirectPresent		0x0001
+#define XF86DGADirectGraphics		0x0002
+#define XF86DGADirectMouse		0x0004
+#define XF86DGADirectKeyb		0x0008
+#define XF86DGAHasColormap		0x0100
+#define XF86DGADirectColormap		0x0200
+
+
+#endif /* _XF86DGA1CONST_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dga1proto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dga1proto.h
new file mode 100644
index 0000000..61d95b3
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dga1proto.h
@@ -0,0 +1,195 @@
+/*
+
+Copyright (c) 1995  Jon Tombs
+Copyright (c) 1995  XFree86 Inc.
+
+*/
+
+#ifndef _XF86DGAPROTO1_H_
+#define _XF86DGAPROTO1_H_
+
+#include <X11/extensions/xf86dga1const.h>
+
+typedef struct _XF86DGAQueryVersion {
+    CARD8	reqType;		/* always DGAReqCode */
+    CARD8	dgaReqType;		/* always X_DGAQueryVersion */
+    CARD16	length;
+} xXF86DGAQueryVersionReq;
+#define sz_xXF86DGAQueryVersionReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	majorVersion;		/* major version of DGA protocol */
+    CARD16	minorVersion;		/* minor version of DGA protocol */
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXF86DGAQueryVersionReply;
+#define sz_xXF86DGAQueryVersionReply	32
+
+typedef struct _XF86DGAGetVideoLL {
+    CARD8	reqType;		/* always DGAReqCode */
+    CARD8	dgaReqType;		/* always X_XF86DGAGetVideoLL */
+    CARD16	length;
+    CARD16	screen;
+    CARD16	pad;
+} xXF86DGAGetVideoLLReq;
+#define sz_xXF86DGAGetVideoLLReq	8
+
+typedef struct _XF86DGAInstallColormap{
+    CARD8	reqType;
+    CARD8	dgaReqType;
+    CARD16	length;
+    CARD16	screen;
+    CARD16	pad2;
+    CARD32	id;  /* colormap. */
+} xXF86DGAInstallColormapReq;
+#define sz_xXF86DGAInstallColormapReq        12
+
+
+typedef struct {
+    BYTE	type;
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	offset;
+    CARD32	width;
+    CARD32	bank_size;
+    CARD32	ram_size;
+    CARD32	pad4;
+    CARD32	pad5;
+} xXF86DGAGetVideoLLReply;
+#define sz_xXF86DGAGetVideoLLReply	32
+
+typedef struct _XF86DGADirectVideo {
+    CARD8	reqType;		/* always DGAReqCode */
+    CARD8	dgaReqType;		/* always X_XF86DGADirectVideo */
+    CARD16	length;
+    CARD16	screen;
+    CARD16	enable;
+} xXF86DGADirectVideoReq;
+#define sz_xXF86DGADirectVideoReq	8
+
+
+typedef struct _XF86DGAGetViewPortSize {
+    CARD8	reqType;		/* always DGAReqCode */
+    CARD8	dgaReqType;		/* always X_XF86DGAGetViewPort */
+    CARD16	length;
+    CARD16	screen;
+    CARD16	pad;
+} xXF86DGAGetViewPortSizeReq;
+#define sz_xXF86DGAGetViewPortSizeReq	8
+
+typedef struct {
+    BYTE	type;
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	width;
+    CARD32	height;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xXF86DGAGetViewPortSizeReply;
+#define sz_xXF86DGAGetViewPortSizeReply	32
+
+typedef struct _XF86DGASetViewPort {
+    CARD8	reqType;		/* always DGAReqCode */
+    CARD8	dgaReqType;		/* always X_XF86DGASetViewPort */
+    CARD16	length;
+    CARD16	screen;
+    CARD16	pad;
+    CARD32	x;
+    CARD32	y;
+} xXF86DGASetViewPortReq;
+#define sz_xXF86DGASetViewPortReq	16
+
+typedef struct _XF86DGAGetVidPage {
+    CARD8	reqType;		/* always DGAReqCode */
+    CARD8	dgaReqType;		/* always X_XF86DGAGetVidPage */
+    CARD16	length;
+    CARD16	screen;
+    CARD16	pad;
+} xXF86DGAGetVidPageReq;
+#define sz_xXF86DGAGetVidPageReq	8
+
+typedef struct {
+    BYTE	type;
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	vpage;
+    CARD32	pad;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xXF86DGAGetVidPageReply;
+#define sz_xXF86DGAGetVidPageReply	32
+
+
+typedef struct _XF86DGASetVidPage {
+    CARD8	reqType;		/* always DGAReqCode */
+    CARD8	dgaReqType;		/* always X_XF86DGASetVidPage */
+    CARD16	length;
+    CARD16	screen;
+    CARD16	vpage;
+} xXF86DGASetVidPageReq;
+#define sz_xXF86DGASetVidPageReq	8
+
+
+typedef struct _XF86DGAQueryDirectVideo {
+    CARD8	reqType;		/* always DGAReqCode */
+    CARD8	dgaReqType;		/* always X_DGAQueryVersion */
+    CARD16	length;
+    CARD16	screen;
+    CARD16	pad;
+} xXF86DGAQueryDirectVideoReq;
+#define sz_xXF86DGAQueryDirectVideoReq	8
+
+typedef struct {
+    BYTE	type;
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	flags;
+    CARD32	pad;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xXF86DGAQueryDirectVideoReply;
+#define sz_xXF86DGAQueryDirectVideoReply 32
+
+
+typedef struct _XF86DGAViewPortChanged {
+    CARD8	reqType;		/* always DGAReqCode */
+    CARD8	dgaReqType;		/* always X_DGAQueryVersion */
+    CARD16	length;
+    CARD16	screen;
+    CARD16	n;
+} xXF86DGAViewPortChangedReq;
+#define sz_xXF86DGAViewPortChangedReq	8
+
+typedef struct {
+    BYTE	type;
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	result;
+    CARD32	pad;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xXF86DGAViewPortChangedReply;
+#define sz_xXF86DGAViewPortChangedReply 32
+
+#endif /* _XF86DGAPROTO1_H_ */
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dga1str.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dga1str.h
new file mode 100644
index 0000000..d8e73e8
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dga1str.h
@@ -0,0 +1,3 @@
+#warning "xf86dga1str.h is obsolete and may be removed in the future."
+#warning "include <X11/extensions/xf86dga1proto.h> for the protocol defines."
+#include <X11/extensions/xf86dga1proto.h>
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dgaconst.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dgaconst.h
new file mode 100644
index 0000000..b21e84f
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dgaconst.h
@@ -0,0 +1,96 @@
+/*
+   Copyright (c) 1999  XFree86 Inc
+*/
+
+#ifndef _XF86DGACONST_H_
+#define _XF86DGACONST_H_
+
+#include <X11/extensions/xf86dga1const.h>
+
+#define X_XDGAQueryVersion		0
+
+/* 1 through 9 are in xf86dga1.h */
+
+/* 10 and 11 are reserved to avoid conflicts with rogue DGA extensions */
+
+#define X_XDGAQueryModes		12
+#define X_XDGASetMode			13
+#define X_XDGASetViewport		14
+#define X_XDGAInstallColormap		15
+#define X_XDGASelectInput		16
+#define X_XDGAFillRectangle		17
+#define X_XDGACopyArea			18
+#define X_XDGACopyTransparentArea	19
+#define X_XDGAGetViewportStatus		20
+#define X_XDGASync			21
+#define X_XDGAOpenFramebuffer		22
+#define X_XDGACloseFramebuffer		23
+#define X_XDGASetClientVersion		24
+#define X_XDGAChangePixmapMode		25
+#define X_XDGACreateColormap		26
+
+
+#define XDGAConcurrentAccess	0x00000001
+#define XDGASolidFillRect	0x00000002
+#define XDGABlitRect		0x00000004
+#define XDGABlitTransRect	0x00000008
+#define XDGAPixmap    		0x00000010
+
+#define XDGAInterlaced          0x00010000
+#define XDGADoublescan          0x00020000
+
+#define XDGAFlipImmediate	0x00000001
+#define XDGAFlipRetrace		0x00000002
+
+#define XDGANeedRoot		0x00000001
+
+#define XF86DGANumberEvents		7
+
+#define XDGAPixmapModeLarge		0
+#define XDGAPixmapModeSmall		1
+
+#define XF86DGAClientNotLocal		0
+#define XF86DGANoDirectVideoMode	1
+#define XF86DGAScreenNotActive		2
+#define XF86DGADirectNotActivated	3
+#define XF86DGAOperationNotSupported	4
+#define XF86DGANumberErrors		(XF86DGAOperationNotSupported + 1)
+
+
+typedef struct {
+   int num;		/* A unique identifier for the mode (num > 0) */
+   char *name;		/* name of mode given in the XF86Config */
+   float verticalRefresh;
+   int flags;		/* DGA_CONCURRENT_ACCESS, etc... */
+   int imageWidth;	/* linear accessible portion (pixels) */
+   int imageHeight;
+   int pixmapWidth;	/* Xlib accessible portion (pixels) */
+   int pixmapHeight;	/* both fields ignored if no concurrent access */
+   int bytesPerScanline;
+   int byteOrder;	/* MSBFirst, LSBFirst */
+   int depth;
+   int bitsPerPixel;
+   unsigned long redMask;
+   unsigned long greenMask;
+   unsigned long blueMask;
+   short visualClass;
+   int viewportWidth;
+   int viewportHeight;
+   int xViewportStep;	/* viewport position granularity */
+   int yViewportStep;
+   int maxViewportX;	/* max viewport origin */
+   int maxViewportY;
+   int viewportFlags;	/* types of page flipping possible */
+   int reserved1;
+   int reserved2;
+} XDGAMode;
+
+
+typedef struct {
+   XDGAMode mode;
+   unsigned char *data;
+   Pixmap pixmap;
+} XDGADevice;
+
+
+#endif /* _XF86DGACONST_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dgaproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dgaproto.h
new file mode 100644
index 0000000..2e8a712
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dgaproto.h
@@ -0,0 +1,344 @@
+/*
+
+Copyright (c) 1995  Jon Tombs
+Copyright (c) 1995  XFree86 Inc.
+
+*/
+
+#ifndef _XF86DGAPROTO_H_
+#define _XF86DGAPROTO_H_
+
+#include <X11/extensions/xf86dga1proto.h>
+#include <X11/extensions/xf86dgaconst.h>
+
+#define XF86DGANAME "XFree86-DGA"
+
+#define XDGA_MAJOR_VERSION	2	/* current version numbers */
+#define XDGA_MINOR_VERSION	0
+
+
+typedef struct _XDGAQueryVersion {
+    CARD8	reqType;		/* always DGAReqCode */
+    CARD8	dgaReqType;		/* always X_DGAQueryVersion */
+    CARD16	length;
+} xXDGAQueryVersionReq;
+#define sz_xXDGAQueryVersionReq		4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	majorVersion;		/* major version of DGA protocol */
+    CARD16	minorVersion;		/* minor version of DGA protocol */
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXDGAQueryVersionReply;
+#define sz_xXDGAQueryVersionReply	32
+
+typedef struct _XDGAQueryModes {
+    CARD8	reqType;
+    CARD8	dgaReqType;
+    CARD16	length;
+    CARD32	screen;
+} xXDGAQueryModesReq;
+#define sz_xXDGAQueryModesReq		8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	number;			/* number of modes available */
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXDGAQueryModesReply;
+#define sz_xXDGAQueryModesReply	32
+
+
+typedef struct _XDGASetMode {
+    CARD8	reqType;
+    CARD8	dgaReqType;
+    CARD16	length;
+    CARD32	screen;
+    CARD32	mode;			/* mode number to init */
+    CARD32	pid;			/* Pixmap descriptor */
+} xXDGASetModeReq;
+#define sz_xXDGASetModeReq		16
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	offset;			/* offset into framebuffer map */
+    CARD32	flags;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xXDGASetModeReply;
+#define sz_xXDGASetModeReply	32
+
+typedef struct {
+   CARD8	byte_order;
+   CARD8	depth;
+   CARD16 	num;
+   CARD16	bpp;
+   CARD16	name_size;
+   CARD32	vsync_num;
+   CARD32	vsync_den;
+   CARD32	flags;
+   CARD16	image_width;
+   CARD16	image_height;
+   CARD16	pixmap_width;
+   CARD16	pixmap_height;
+   CARD32	bytes_per_scanline;
+   CARD32	red_mask;
+   CARD32	green_mask;
+   CARD32	blue_mask;
+   CARD16	visual_class;
+   CARD16	pad1;
+   CARD16	viewport_width;
+   CARD16	viewport_height;
+   CARD16	viewport_xstep;
+   CARD16	viewport_ystep;
+   CARD16	viewport_xmax;
+   CARD16	viewport_ymax;
+   CARD32	viewport_flags;
+   CARD32	reserved1;
+   CARD32	reserved2;
+} xXDGAModeInfo;
+#define sz_xXDGAModeInfo 72
+
+typedef struct _XDGAOpenFramebuffer {
+    CARD8	reqType;
+    CARD8	dgaReqType;
+    CARD16	length;
+    CARD32	screen;
+} xXDGAOpenFramebufferReq;
+#define sz_xXDGAOpenFramebufferReq	8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;			/* device name size if there is one */
+    CARD32	mem1;			/* physical memory */
+    CARD32	mem2;			/* spillover for _alpha_ */
+    CARD32	size;			/* size of map in bytes */
+    CARD32	offset;			/* optional offset into device */
+    CARD32	extra;			/* extra info associated with the map */
+    CARD32	pad2;
+} xXDGAOpenFramebufferReply;
+#define sz_xXDGAOpenFramebufferReply	32
+
+
+typedef struct _XDGACloseFramebuffer {
+    CARD8	reqType;
+    CARD8	dgaReqType;
+    CARD16	length;
+    CARD32	screen;
+} xXDGACloseFramebufferReq;
+#define sz_xXDGACloseFramebufferReq	8
+
+
+typedef struct _XDGASetViewport {
+    CARD8	reqType;
+    CARD8	dgaReqType;
+    CARD16	length;
+    CARD32	screen;
+    CARD16	x;
+    CARD16	y;
+    CARD32	flags;
+} xXDGASetViewportReq;
+#define sz_xXDGASetViewportReq	16
+
+
+typedef struct _XDGAInstallColormap {
+    CARD8	reqType;
+    CARD8	dgaReqType;
+    CARD16	length;
+    CARD32	screen;
+    CARD32	cmap;
+} xXDGAInstallColormapReq;
+#define sz_xXDGAInstallColormapReq	12
+
+typedef struct _XDGASelectInput {
+    CARD8	reqType;
+    CARD8	dgaReqType;
+    CARD16	length;
+    CARD32	screen;
+    CARD32	mask;
+} xXDGASelectInputReq;
+#define sz_xXDGASelectInputReq	12
+
+typedef struct _XDGAFillRectangle {
+    CARD8	reqType;
+    CARD8	dgaReqType;
+    CARD16	length;
+    CARD32	screen;
+    CARD16	x;
+    CARD16	y;
+    CARD16	width;
+    CARD16	height;
+    CARD32	color;
+} xXDGAFillRectangleReq;
+#define sz_xXDGAFillRectangleReq	20
+
+
+typedef struct _XDGACopyArea {
+    CARD8	reqType;
+    CARD8	dgaReqType;
+    CARD16	length;
+    CARD32	screen;
+    CARD16	srcx;
+    CARD16	srcy;
+    CARD16	width;
+    CARD16	height;
+    CARD16	dstx;
+    CARD16	dsty;
+} xXDGACopyAreaReq;
+#define sz_xXDGACopyAreaReq	20
+
+typedef struct _XDGACopyTransparentArea {
+    CARD8	reqType;
+    CARD8	dgaReqType;
+    CARD16	length;
+    CARD32	screen;
+    CARD16	srcx;
+    CARD16	srcy;
+    CARD16	width;
+    CARD16	height;
+    CARD16	dstx;
+    CARD16	dsty;
+    CARD32	key;
+} xXDGACopyTransparentAreaReq;
+#define sz_xXDGACopyTransparentAreaReq	24
+
+
+typedef struct _XDGAGetViewportStatus {
+    CARD8	reqType;
+    CARD8	dgaReqType;
+    CARD16	length;
+    CARD32	screen;
+} xXDGAGetViewportStatusReq;
+#define sz_xXDGAGetViewportStatusReq	8
+
+typedef struct {
+    BYTE	type;
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	status;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXDGAGetViewportStatusReply;
+#define sz_xXDGAGetViewportStatusReply	32
+
+typedef struct _XDGASync {
+    CARD8	reqType;
+    CARD8	dgaReqType;
+    CARD16	length;
+    CARD32	screen;
+} xXDGASyncReq;
+#define sz_xXDGASyncReq	8
+
+typedef struct {
+    BYTE	type;
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+    CARD32	pad7;
+} xXDGASyncReply;
+#define sz_xXDGASyncReply	32
+
+typedef struct _XDGASetClientVersion {
+    CARD8	reqType;
+    CARD8	dgaReqType;
+    CARD16	length;
+    CARD16	major;
+    CARD16	minor;
+} xXDGASetClientVersionReq;
+#define sz_xXDGASetClientVersionReq	8
+
+
+typedef struct {
+    CARD8	reqType;
+    CARD8	dgaReqType;
+    CARD16	length;
+    CARD32	screen;
+    CARD16	x;
+    CARD16	y;
+    CARD32	flags;
+} xXDGAChangePixmapModeReq;
+#define sz_xXDGAChangePixmapModeReq	16
+
+typedef struct {
+    BYTE	type;
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	x;
+    CARD16	y;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+    CARD32	pad7;
+} xXDGAChangePixmapModeReply;
+#define sz_xXDGAChangePixmapModeReply	32
+
+typedef struct _XDGACreateColormap {
+    CARD8	reqType;
+    CARD8	dgaReqType;
+    CARD16	length;
+    CARD32	screen;
+    CARD32	id;
+    CARD32	mode;
+    CARD8	alloc;
+    CARD8	pad1;
+    CARD16	pad2;
+} xXDGACreateColormapReq;
+#define sz_xXDGACreateColormapReq	20
+
+
+typedef struct {
+  union {
+    struct {
+      BYTE type;
+      BYTE detail;
+      CARD16 sequenceNumber;
+    } u;
+    struct {
+      CARD32 pad0;
+      CARD32 time;
+      INT16 dx;
+      INT16 dy;
+      INT16 screen;
+      CARD16 state;
+      CARD32 pad1;
+      CARD32 pad2;
+      CARD32 pad3;
+      CARD32 pad4;
+    } event;
+  } u;
+} dgaEvent;
+
+
+#endif /* _XF86DGAPROTO_H_ */
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dgastr.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dgastr.h
new file mode 100644
index 0000000..f4809d1
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86dgastr.h
@@ -0,0 +1,3 @@
+#warning "xf86dgastr.h is obsolete and may be removed in the future."
+#warning "include <X11/extensions/xf86dgaproto.h> for the protocol defines."
+#include <X11/extensions/xf86dgaproto.h>
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86misc.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86misc.h
new file mode 100644
index 0000000..611871d
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86misc.h
@@ -0,0 +1,172 @@
+/* $XFree86: xc/include/extensions/xf86misc.h,v 3.16 2002/11/20 04:04:56 dawes Exp $ */
+
+/*
+ * Copyright (c) 1995, 1996  The XFree86 Project, Inc
+ */
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD */
+
+#ifndef _XF86MISC_H_
+#define _XF86MISC_H_
+
+#include <X11/Xfuncproto.h>
+
+#define X_XF86MiscQueryVersion		0
+#ifdef _XF86MISC_SAVER_COMPAT_
+#define X_XF86MiscGetSaver		1
+#define X_XF86MiscSetSaver		2
+#endif
+#define X_XF86MiscGetMouseSettings	3
+#define X_XF86MiscGetKbdSettings	4
+#define X_XF86MiscSetMouseSettings	5
+#define X_XF86MiscSetKbdSettings	6
+#define X_XF86MiscSetGrabKeysState	7
+#define X_XF86MiscSetClientVersion      8
+#define X_XF86MiscGetFilePaths		9
+#define X_XF86MiscPassMessage		10
+
+#define XF86MiscNumberEvents		0
+
+#define XF86MiscBadMouseProtocol	0
+#define XF86MiscBadMouseBaudRate	1
+#define XF86MiscBadMouseFlags		2
+#define XF86MiscBadMouseCombo		3
+#define XF86MiscBadKbdType		4
+#define XF86MiscModInDevDisabled	5
+#define XF86MiscModInDevClientNotLocal	6
+#define XF86MiscNoModule                7
+#define XF86MiscNumberErrors		(XF86MiscNoModule + 1)
+
+/* Never renumber these */
+#define MTYPE_MICROSOFT		0
+#define MTYPE_MOUSESYS		1
+#define MTYPE_MMSERIES		2
+#define MTYPE_LOGITECH		3
+#define MTYPE_BUSMOUSE		4
+#define MTYPE_LOGIMAN		5
+#define MTYPE_PS_2		6
+#define MTYPE_MMHIT		7
+#define MTYPE_GLIDEPOINT	8
+#define MTYPE_IMSERIAL		9
+#define MTYPE_THINKING		10
+#define MTYPE_IMPS2		11
+#define MTYPE_THINKINGPS2	12
+#define MTYPE_MMANPLUSPS2	13
+#define MTYPE_GLIDEPOINTPS2	14
+#define MTYPE_NETPS2		15
+#define MTYPE_NETSCROLLPS2	16
+#define MTYPE_SYSMOUSE		17
+#define MTYPE_AUTOMOUSE		18
+#define MTYPE_ACECAD		19
+#define MTYPE_EXPPS2            20
+
+#define MTYPE_XQUEUE		127
+#define MTYPE_OSMOUSE		126
+#define MTYPE_UNKNOWN		125
+
+#define KTYPE_UNKNOWN		0
+#define KTYPE_84KEY		1
+#define KTYPE_101KEY		2
+#define KTYPE_OTHER		3
+#define KTYPE_XQUEUE		4
+
+#define MF_CLEAR_DTR		1
+#define MF_CLEAR_RTS		2
+#define MF_REOPEN		128
+
+#ifndef _XF86MISC_SERVER_
+
+/* return values for XF86MiscSetGrabKeysState */
+#define MiscExtGrabStateSuccess	0	/* No errors */
+#define MiscExtGrabStateLocked	1	/* A client already requested that
+					 * grabs cannot be removed/killed */
+#define MiscExtGrabStateAlready	2	/* Request for enabling/disabling
+					 * grab removal/kill already done */
+
+_XFUNCPROTOBEGIN
+
+typedef struct {
+    char*	device;
+    int		type;
+    int		baudrate;
+    int		samplerate;
+    int		resolution;
+    int		buttons;
+    Bool	emulate3buttons;
+    int		emulate3timeout;
+    Bool	chordmiddle;
+    int		flags;
+} XF86MiscMouseSettings;
+
+typedef struct {
+    int		type;
+    int		rate;
+    int		delay;
+    Bool	servnumlock;
+} XF86MiscKbdSettings;
+
+typedef struct {
+    char*	configfile;
+    char*	modulepath;
+    char*	logfile;
+} XF86MiscFilePaths;
+
+Bool XF86MiscQueryVersion(
+    Display*		/* dpy */,
+    int*		/* majorVersion */,
+    int*		/* minorVersion */
+);
+
+Bool XF86MiscQueryExtension(
+    Display*		/* dpy */,
+    int*		/* event_base */,
+    int*		/* error_base */
+);
+
+Bool XF86MiscSetClientVersion(
+    Display *dpy	/* dpy */
+);
+
+Status XF86MiscGetMouseSettings(
+    Display*			/* dpy */,
+    XF86MiscMouseSettings*	/* mouse info */
+);
+
+Status XF86MiscGetKbdSettings(
+    Display*			/* dpy */,
+    XF86MiscKbdSettings*	/* keyboard info */
+);
+
+Status XF86MiscSetMouseSettings(
+    Display*			/* dpy */,
+    XF86MiscMouseSettings*	/* mouse info */
+);
+
+Status XF86MiscSetKbdSettings(
+    Display*			/* dpy */,
+    XF86MiscKbdSettings*	/* keyboard info */
+);
+
+int XF86MiscSetGrabKeysState(
+    Display*			/* dpy */,
+    Bool			/* enabled */
+);
+
+Status XF86MiscGetFilePaths(
+    Display*			/* dpy */,
+    XF86MiscFilePaths*		/* file paths/locations */
+);
+
+Status XF86MiscPassMessage(
+    Display*			/* dpy */,
+    int				/* screen */,
+    const char*			/* message name/type */,
+    const char*			/* message contents/value */,
+    char **			/* returned message */
+);
+
+_XFUNCPROTOEND
+
+#endif
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86mscstr.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86mscstr.h
new file mode 100644
index 0000000..cc0f0cf
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86mscstr.h
@@ -0,0 +1,238 @@
+/* $XFree86: xc/include/extensions/xf86mscstr.h,v 3.12 2002/11/20 04:04:56 dawes Exp $ */
+
+/*
+ * Copyright (c) 1995, 1996  The XFree86 Project, Inc
+ */
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD */
+
+#ifndef _XF86MISCSTR_H_
+#define _XF86MISCSTR_H_
+
+#include <X11/extensions/xf86misc.h>
+
+#define XF86MISCNAME		"XFree86-Misc"
+
+#define XF86MISC_MAJOR_VERSION	0	/* current version numbers */
+#define XF86MISC_MINOR_VERSION	9
+
+typedef struct _XF86MiscQueryVersion {
+    CARD8	reqType;		/* always XF86MiscReqCode */
+    CARD8	xf86miscReqType;	/* always X_XF86MiscQueryVersion */
+    CARD16	length;
+} xXF86MiscQueryVersionReq;
+#define sz_xXF86MiscQueryVersionReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	majorVersion;		/* major version of XFree86-Misc */
+    CARD16	minorVersion;		/* minor version of XFree86-Misc */
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXF86MiscQueryVersionReply;
+#define sz_xXF86MiscQueryVersionReply	32
+
+#ifdef _XF86MISC_SAVER_COMPAT_
+typedef struct _XF86MiscGetSaver {
+    CARD8       reqType;                /* always XF86MiscReqCode */
+    CARD8       xf86miscReqType;     /* always X_XF86MiscGetSaver */
+    CARD16      length;
+    CARD16      screen;
+    CARD16      pad;
+} xXF86MiscGetSaverReq;
+#define sz_xXF86MiscGetSaverReq	8
+
+typedef struct _XF86MiscSetSaver {
+    CARD8	reqType;		/* always XF86MiscReqCode */
+    CARD8	xf86miscReqType;	/* always X_XF86MiscSetSaver */
+    CARD16	length;
+    CARD16	screen;
+    CARD16	pad;
+    CARD32	suspendTime;
+    CARD32	offTime;
+} xXF86MiscSetSaverReq;
+#define sz_xXF86MiscSetSaverReq	16
+
+typedef struct {
+    BYTE	type;
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	suspendTime;
+    CARD32	offTime;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xXF86MiscGetSaverReply;
+#define sz_xXF86MiscGetSaverReply	32
+#endif
+
+typedef struct _XF86MiscGetMouseSettings {
+    CARD8	reqType;		/* always XF86MiscReqCode */
+    CARD8	xf86miscReqType;	/* always X_XF86MiscGetMouseSettings */
+    CARD16	length;
+} xXF86MiscGetMouseSettingsReq;
+#define sz_xXF86MiscGetMouseSettingsReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	mousetype;
+    CARD32	baudrate;
+    CARD32	samplerate;
+    CARD32	resolution;
+    CARD32	buttons;
+    BOOL	emulate3buttons;
+    BOOL	chordmiddle;
+    CARD16	pad2;
+    CARD32	emulate3timeout;
+    CARD32	flags;
+    CARD32	devnamelen;		/* strlen(device)+1 */
+} xXF86MiscGetMouseSettingsReply;
+#define sz_xXF86MiscGetMouseSettingsReply	44
+
+typedef struct _XF86MiscGetKbdSettings {
+    CARD8	reqType;		/* always XF86MiscReqCode */
+    CARD8	xf86miscReqType;	/* always X_XF86MiscGetKbdSettings */
+    CARD16	length;
+} xXF86MiscGetKbdSettingsReq;
+#define sz_xXF86MiscGetKbdSettingsReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	kbdtype;
+    CARD32	rate;
+    CARD32	delay;
+    BOOL	servnumlock;
+    BOOL	pad2;
+    CARD16	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xXF86MiscGetKbdSettingsReply;
+#define sz_xXF86MiscGetKbdSettingsReply	32
+
+typedef struct _XF86MiscSetMouseSettings {
+    CARD8	reqType;		/* always XF86MiscReqCode */
+    CARD8	xf86miscReqType;	/* always X_XF86MiscSetMouseSettings */
+    CARD16	length;
+    CARD32	mousetype;
+    CARD32	baudrate;
+    CARD32	samplerate;
+    CARD32	resolution;
+    CARD32	buttons;
+    BOOL	emulate3buttons;
+    BOOL	chordmiddle;
+    CARD16	devnamelen;
+    CARD32	emulate3timeout;
+    CARD32	flags;
+} xXF86MiscSetMouseSettingsReq;
+#define sz_xXF86MiscSetMouseSettingsReq	36
+
+typedef struct _XF86MiscSetKbdSettings {
+    CARD8	reqType;		/* always XF86MiscReqCode */
+    CARD8	xf86miscReqType;	/* always X_XF86MiscSetKbdSettings */
+    CARD16	length;
+    CARD32	kbdtype;
+    CARD32	rate;
+    CARD32	delay;
+    BOOL	servnumlock;
+    BOOL	pad1;
+    CARD16	pad2;
+} xXF86MiscSetKbdSettingsReq;
+#define sz_xXF86MiscSetKbdSettingsReq	20
+
+typedef struct _XF86MiscSetGrabKeysState {
+    CARD8	reqType;		/* always XF86MiscReqCode */
+    CARD8	xf86miscReqType;	/* always X_XF86MiscSetKbdSettings */
+    CARD16	length;
+    BOOL	enable;
+    BOOL	pad1;
+    CARD16	pad2;
+} xXF86MiscSetGrabKeysStateReq;
+#define sz_xXF86MiscSetGrabKeysStateReq	8
+
+typedef struct {
+    BYTE	type;
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	status;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXF86MiscSetGrabKeysStateReply;
+#define sz_xXF86MiscSetGrabKeysStateReply	32
+
+typedef struct _XF86MiscSetClientVersion {
+    CARD8	reqType;		/* always XF86MiscReqCode */
+    CARD8	xf86miscReqType;
+    CARD16	length;
+    CARD16	major;
+    CARD16	minor;
+} xXF86MiscSetClientVersionReq;
+#define sz_xXF86MiscSetClientVersionReq	8
+
+typedef struct _XF86MiscGetFilePaths {
+    CARD8	reqType;		/* always XF86MiscReqCode */
+    CARD8	xf86miscReqType;	/* always X_XF86MiscGetFilePaths */
+    CARD16	length;
+} xXF86MiscGetFilePathsReq;
+#define sz_xXF86MiscGetFilePathsReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	configlen;
+    CARD16	modulelen;
+    CARD16	loglen;
+    CARD16	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXF86MiscGetFilePathsReply;
+#define sz_xXF86MiscGetFilePathsReply	32
+
+typedef struct _XF86MiscPassMessage {
+    CARD8	reqType;		/* always XF86MiscReqCode */
+    CARD8	xf86miscReqType;	/* always X_XF86MiscPassMessage */
+    CARD16	length;
+    CARD16	typelen;
+    CARD16	vallen;
+    CARD16	screen;
+    CARD16	pad;
+} xXF86MiscPassMessageReq;
+#define sz_xXF86MiscPassMessageReq	12
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BYTE	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	mesglen;
+    CARD16	pad2;
+    CARD32	status;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXF86MiscPassMessageReply;
+#define sz_xXF86MiscPassMessageReply	32
+
+#endif /* _XF86MISCSTR_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86rush.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86rush.h
new file mode 100644
index 0000000..5cf0c16
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86rush.h
@@ -0,0 +1,113 @@
+/* $XFree86: xc/include/extensions/xf86rush.h,v 1.4 2000/02/29 03:09:00 dawes Exp $ */
+/*
+
+Copyright (c) 1998  Daryll Strauss
+
+*/
+
+#ifndef _XF86RUSH_H_
+#define _XF86RUSH_H_
+
+#include <X11/extensions/Xv.h>
+#include <X11/Xfuncproto.h>
+
+#define X_XF86RushQueryVersion		0
+#define X_XF86RushLockPixmap		1
+#define X_XF86RushUnlockPixmap		2
+#define X_XF86RushUnlockAllPixmaps	3
+#define X_XF86RushGetCopyMode		4
+#define X_XF86RushSetCopyMode		5
+#define X_XF86RushGetPixelStride	6
+#define X_XF86RushSetPixelStride	7
+#define X_XF86RushOverlayPixmap		8
+#define X_XF86RushStatusRegOffset	9
+#define X_XF86RushAT3DEnableRegs	10
+#define X_XF86RushAT3DDisableRegs	11
+
+#define XF86RushNumberEvents		0
+
+#define XF86RushClientNotLocal		0
+#define XF86RushNumberErrors		(XF86RushClientNotLocal + 1)
+
+#ifndef _XF86RUSH_SERVER_
+
+_XFUNCPROTOBEGIN
+
+Bool XF86RushQueryVersion(
+    Display*		/* dpy */,
+    int*		/* majorVersion */,
+    int*		/* minorVersion */
+);
+
+Bool XF86RushQueryExtension(
+    Display*		/* dpy */,
+    int*		/* event_base */,
+    int*		/* error_base */
+);
+
+Bool XF86RushLockPixmap(
+    Display *		/* dpy */,
+    int			/* screen */,
+    Pixmap		/* Pixmap */,
+    void **		/* Return address */
+);
+
+Bool XF86RushUnlockPixmap(
+    Display *		/* dpy */,
+    int			/* screen */,
+    Pixmap		/* Pixmap */
+);
+
+Bool XF86RushUnlockAllPixmaps(
+    Display *		/* dpy */
+);
+
+Bool XF86RushSetCopyMode(
+    Display *		/* dpy */,
+    int			/* screen */,
+    int			/* copy mode */
+);
+
+Bool XF86RushSetPixelStride(
+    Display *		/* dpy */,
+    int			/* screen */,
+    int			/* pixel stride */
+);
+
+Bool XF86RushOverlayPixmap(
+    Display *		/* dpy */,
+    XvPortID		/* port */,
+    Drawable		/* d */,
+    GC			/* gc */,
+    Pixmap		/* pixmap */,
+    int			/* src_x */,
+    int			/* src_y */,
+    unsigned int	/* src_w */,
+    unsigned int	/* src_h */,
+    int			/* dest_x */,
+    int			/* dest_y */,
+    unsigned int	/* dest_w */,
+    unsigned int	/* dest_h */,
+    unsigned int	/* id */
+);
+
+int XF86RushStatusRegOffset(
+    Display *		/* dpy */,
+    int			/* screen */
+);
+
+Bool XF86RushAT3DEnableRegs(
+    Display *		/* dpy */,
+    int			/* screen */
+);
+
+Bool XF86RushAT3DDisableRegs(
+    Display *		/* dpy */,
+    int			/* screen */
+);
+
+_XFUNCPROTOEND
+
+#endif /* _XF86RUSH_SERVER_ */
+
+#endif /* _XF86RUSH_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86rushstr.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86rushstr.h
new file mode 100644
index 0000000..7c31a8a
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86rushstr.h
@@ -0,0 +1,163 @@
+/* $XFree86: xc/include/extensions/xf86rushstr.h,v 1.4 2000/02/29 03:09:02 dawes Exp $ */
+/*
+
+Copyright (c) 1998  Daryll Strauss
+
+*/
+
+#ifndef _XF86RUSHSTR_H_
+#define _XF86RUSHSTR_H_
+
+#include <X11/extensions/xf86rush.h>
+
+#define XF86RUSHNAME "XFree86-Rush"
+
+#define XF86RUSH_MAJOR_VERSION	1	/* current version numbers */
+#define XF86RUSH_MINOR_VERSION	1
+
+typedef struct _XF86RushQueryVersion {
+    CARD8	reqType;		/* always RushReqCode */
+    CARD8	rushReqType;		/* always X_RushQueryVersion */
+    CARD16	length;
+} xXF86RushQueryVersionReq;
+#define sz_xXF86RushQueryVersionReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	majorVersion;		/* major version of Rush protocol */
+    CARD16	minorVersion;		/* minor version of Rush protocol */
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXF86RushQueryVersionReply;
+#define sz_xXF86RushQueryVersionReply	32
+
+typedef struct _XF86RushLockPixmap {
+    CARD8	reqType;		/* always RushReqCode */
+    CARD8	rushReqType;		/* always X_RushLockPixmap */
+    CARD16	length;
+    CARD16	screen;
+    CARD16	pad;
+    CARD32	pixmap;
+} xXF86RushLockPixmapReq;
+#define sz_xXF86RushLockPixmapReq	12
+
+typedef struct {
+    BYTE	type;
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	addr;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXF86RushLockPixmapReply;
+#define sz_xXF86RushLockPixmapReply	32
+
+typedef struct _XF86RushUnlockPixmap {
+    CARD8	reqType;		/* always RushReqCode */
+    CARD8	rushReqType;		/* always X_RushUnlockPixmap */
+    CARD16	length;
+    CARD16	screen;
+    CARD16	pad;
+    CARD32	pixmap;
+} xXF86RushUnlockPixmapReq;
+#define sz_xXF86RushUnlockPixmapReq	12
+
+typedef struct _XF86RushUnlockAllPixmaps {
+    CARD8	reqType;		/* always RushReqCode */
+    CARD8	rushReqType;		/* always X_RushUnlockAllPixmaps */
+    CARD16      length;
+} xXF86RushUnlockAllPixmapsReq;
+#define sz_xXF86RushUnlockAllPixmapsReq   4
+
+typedef struct _XF86RushSetCopyMode {
+    CARD8       reqType;                /* always RushReqCode */
+    CARD8       rushReqType;            /* always X_RushSetCopyMode */
+    CARD16      length;
+    CARD16      screen;
+    CARD16      pad;
+    CARD32      CopyMode;
+} xXF86RushSetCopyModeReq;
+#define sz_xXF86RushSetCopyModeReq      12
+
+
+typedef struct _XF86RushSetPixelStride {
+    CARD8       reqType;                /* always RushReqCode */
+    CARD8       rushReqType;            /* always X_RushSetCopyMode */
+    CARD16      length;
+    CARD16      screen;
+    CARD16      pad;
+    CARD32      PixelStride;
+} xXF86RushSetPixelStrideReq;
+#define sz_xXF86RushSetPixelStrideReq      12
+
+typedef struct {
+    CARD8	reqType;               /* always RushReqCode */
+    CARD8	rushReqType;           /* always X_RushOverlayPixmap */
+    CARD16	length;
+    XvPortID	port;
+    Drawable	drawable;
+    GContext	gc;
+    Pixmap	pixmap;
+    CARD32	id;
+    INT16	src_x;
+    INT16	src_y;
+    CARD16	src_w;
+    CARD16	src_h;
+    INT16	drw_x;
+    INT16	drw_y;
+    CARD16	drw_w;
+    CARD16	drw_h;
+} xXF86RushOverlayPixmapReq;
+#define sz_xXF86RushOverlayPixmapReq 40
+
+typedef struct _XF86RushStatusRegOffset {
+    CARD8	reqType;		/* always RushReqCode */
+    CARD8	rushReqType;		/* always X_RushStatusRegOffset */
+    CARD16      length;
+    CARD16      screen;
+    CARD16      pad;
+} xXF86RushStatusRegOffsetReq;
+#define sz_xXF86RushStatusRegOffsetReq   8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	offset;			/* Offset of Rush status reg in mem */
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXF86RushStatusRegOffsetReply;
+#define sz_xXF86RushStatusRegOffsetReply	32
+
+typedef struct _XF86RushAT3DEnableRegs {
+    CARD8	reqType;		/* always RushReqCode */
+    CARD8	rushReqType;		/* always X_RushAT3DEnableRegs */
+    CARD16      length;
+    CARD16      screen;
+    CARD16      pad;
+} xXF86RushAT3DEnableRegsReq;
+#define sz_xXF86RushAT3DEnableRegsReq   8
+
+typedef struct _XF86RushAT3DDisableRegs {
+    CARD8	reqType;		/* always RushReqCode */
+    CARD8	rushReqType;		/* always X_RushAT3DDisableRegs */
+    CARD16      length;
+    CARD16      screen;
+    CARD16      pad;
+} xXF86RushAT3DDisableRegsReq;
+#define sz_xXF86RushAT3DDisableRegsReq   8
+
+#endif /* _XF86RUSHSTR_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86vm.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86vm.h
new file mode 100644
index 0000000..a874ab5
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86vm.h
@@ -0,0 +1,65 @@
+/*
+
+Copyright 1995  Kaleb S. KEITHLEY
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL Kaleb S. KEITHLEY BE LIABLE FOR ANY CLAIM, DAMAGES
+OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of Kaleb S. KEITHLEY
+shall not be used in advertising or otherwise to promote the sale, use
+or other dealings in this Software without prior written authorization
+from Kaleb S. KEITHLEY
+
+*/
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */
+
+#ifndef _XF86VM_H_
+#define _XF86VM_H_
+
+#include <X11/Xmd.h>
+
+
+#define CLKFLAG_PROGRAMABLE		1
+
+#ifdef XF86VIDMODE_EVENTS
+#define XF86VidModeNotify		0
+#define XF86VidModeNumberEvents		(XF86VidModeNotify + 1)
+
+#define XF86VidModeNotifyMask		0x00000001
+
+#define XF86VidModeNonEvent		0
+#define XF86VidModeModeChange		1
+#else
+#define XF86VidModeNumberEvents		0
+#endif
+
+#define XF86VidModeBadClock		0
+#define XF86VidModeBadHTimings		1
+#define XF86VidModeBadVTimings		2
+#define XF86VidModeModeUnsuitable	3
+#define XF86VidModeExtensionDisabled	4
+#define XF86VidModeClientNotLocal	5
+#define XF86VidModeZoomLocked		6
+#define XF86VidModeNumberErrors		(XF86VidModeZoomLocked + 1)
+
+#define XF86VM_READ_PERMISSION	1
+#define XF86VM_WRITE_PERMISSION	2
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86vmproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86vmproto.h
new file mode 100644
index 0000000..7307284
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86vmproto.h
@@ -0,0 +1,583 @@
+/*
+
+Copyright 1995  Kaleb S. KEITHLEY
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL Kaleb S. KEITHLEY BE LIABLE FOR ANY CLAIM, DAMAGES
+OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of Kaleb S. KEITHLEY
+shall not be used in advertising or otherwise to promote the sale, use
+or other dealings in this Software without prior written authorization
+from Kaleb S. KEITHLEY
+
+*/
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */
+
+#ifndef _XF86VIDMODEPROTO_H_
+#define _XF86VIDMODEPROTO_H_
+
+#include <X11/extensions/xf86vm.h>
+
+#define XF86VIDMODENAME "XFree86-VidModeExtension"
+
+#define XF86VIDMODE_MAJOR_VERSION	2	/* current version numbers */
+#define XF86VIDMODE_MINOR_VERSION	2
+
+#define X_XF86VidModeQueryVersion	0
+#define X_XF86VidModeGetModeLine	1
+#define X_XF86VidModeModModeLine	2
+#define X_XF86VidModeSwitchMode		3
+#define X_XF86VidModeGetMonitor		4
+#define X_XF86VidModeLockModeSwitch	5
+#define X_XF86VidModeGetAllModeLines	6
+#define X_XF86VidModeAddModeLine	7
+#define X_XF86VidModeDeleteModeLine	8
+#define X_XF86VidModeValidateModeLine	9
+#define X_XF86VidModeSwitchToMode	10
+#define X_XF86VidModeGetViewPort	11
+#define X_XF86VidModeSetViewPort	12
+/* new for version 2.x of this extension */
+#define X_XF86VidModeGetDotClocks	13
+#define X_XF86VidModeSetClientVersion	14
+#define X_XF86VidModeSetGamma		15
+#define X_XF86VidModeGetGamma		16
+#define X_XF86VidModeGetGammaRamp	17
+#define X_XF86VidModeSetGammaRamp	18
+#define X_XF86VidModeGetGammaRampSize	19
+#define X_XF86VidModeGetPermissions	20
+/*
+ * major version 0 == uses parameter-to-wire functions in XFree86 libXxf86vm.
+ * major version 1 == uses parameter-to-wire functions hard-coded in xvidtune
+ *                    client.
+ * major version 2 == uses new protocol version in XFree86 4.0.
+ */
+
+typedef struct _XF86VidModeQueryVersion {
+    CARD8	reqType;		/* always XF86VidModeReqCode */
+    CARD8	xf86vidmodeReqType;	/* always X_XF86VidModeQueryVersion */
+    CARD16	length;
+} xXF86VidModeQueryVersionReq;
+#define sz_xXF86VidModeQueryVersionReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	majorVersion;		/* major version of XF86VidMode */
+    CARD16	minorVersion;		/* minor version of XF86VidMode */
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXF86VidModeQueryVersionReply;
+#define sz_xXF86VidModeQueryVersionReply	32
+
+typedef struct _XF86VidModeGetModeLine {
+    CARD8	reqType;		/* always XF86VidModeReqCode */
+    CARD8	xf86vidmodeReqType;
+    CARD16	length;
+    CARD16	screen;
+    CARD16	pad;
+} xXF86VidModeGetModeLineReq,
+  xXF86VidModeGetAllModeLinesReq,
+  xXF86VidModeGetMonitorReq,
+  xXF86VidModeGetViewPortReq,
+  xXF86VidModeGetDotClocksReq,
+  xXF86VidModeGetPermissionsReq;
+#define sz_xXF86VidModeGetModeLineReq		8
+#define sz_xXF86VidModeGetAllModeLinesReq	8
+#define sz_xXF86VidModeGetMonitorReq		8
+#define sz_xXF86VidModeGetViewPortReq		8
+#define sz_xXF86VidModeGetDotClocksReq		8
+#define sz_xXF86VidModeGetPermissionsReq	8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	dotclock;
+    CARD16	hdisplay;
+    CARD16	hsyncstart;
+    CARD16	hsyncend;
+    CARD16	htotal;
+    CARD16	hskew;
+    CARD16	vdisplay;
+    CARD16	vsyncstart;
+    CARD16	vsyncend;
+    CARD16	vtotal;
+    CARD16	pad2;
+    CARD32	flags;
+    CARD32	reserved1;
+    CARD32	reserved2;
+    CARD32	reserved3;
+    CARD32	privsize;
+} xXF86VidModeGetModeLineReply;
+#define sz_xXF86VidModeGetModeLineReply	52
+
+/* 0.x version */
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	dotclock;
+    CARD16	hdisplay;
+    CARD16	hsyncstart;
+    CARD16	hsyncend;
+    CARD16	htotal;
+    CARD16	vdisplay;
+    CARD16	vsyncstart;
+    CARD16	vsyncend;
+    CARD16	vtotal;
+    CARD32	flags;
+    CARD32	privsize;
+} xXF86OldVidModeGetModeLineReply;
+#define sz_xXF86OldVidModeGetModeLineReply	36
+
+typedef struct {
+    CARD32	dotclock;
+    CARD16	hdisplay;
+    CARD16	hsyncstart;
+    CARD16	hsyncend;
+    CARD16	htotal;
+    CARD32	hskew;
+    CARD16	vdisplay;
+    CARD16	vsyncstart;
+    CARD16	vsyncend;
+    CARD16	vtotal;
+    CARD16	pad1;
+    CARD32	flags;
+    CARD32	reserved1;
+    CARD32	reserved2;
+    CARD32	reserved3;
+    CARD32	privsize;
+} xXF86VidModeModeInfo;
+
+/* 0.x version */
+typedef struct {
+    CARD32	dotclock;
+    CARD16	hdisplay;
+    CARD16	hsyncstart;
+    CARD16	hsyncend;
+    CARD16	htotal;
+    CARD16	vdisplay;
+    CARD16	vsyncstart;
+    CARD16	vsyncend;
+    CARD16	vtotal;
+    CARD32	flags;
+    CARD32	privsize;
+} xXF86OldVidModeModeInfo;
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	modecount;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXF86VidModeGetAllModeLinesReply;
+#define sz_xXF86VidModeGetAllModeLinesReply	32
+
+typedef struct _XF86VidModeAddModeLine {
+    CARD8	reqType;		/* always XF86VidModeReqCode */
+    CARD8	xf86vidmodeReqType;	/* always X_XF86VidModeAddMode */
+    CARD16	length;
+    CARD32	screen;			/* could be CARD16 but need the pad */
+    CARD32	dotclock;
+    CARD16	hdisplay;
+    CARD16	hsyncstart;
+    CARD16	hsyncend;
+    CARD16	htotal;
+    CARD16	hskew;
+    CARD16	vdisplay;
+    CARD16	vsyncstart;
+    CARD16	vsyncend;
+    CARD16	vtotal;
+    CARD16	pad1;
+    CARD32	flags;
+    CARD32	reserved1;
+    CARD32	reserved2;
+    CARD32	reserved3;
+    CARD32	privsize;
+    CARD32	after_dotclock;
+    CARD16	after_hdisplay;
+    CARD16	after_hsyncstart;
+    CARD16	after_hsyncend;
+    CARD16	after_htotal;
+    CARD16	after_hskew;
+    CARD16	after_vdisplay;
+    CARD16	after_vsyncstart;
+    CARD16	after_vsyncend;
+    CARD16	after_vtotal;
+    CARD16	pad2;
+    CARD32	after_flags;
+    CARD32	reserved4;
+    CARD32	reserved5;
+    CARD32	reserved6;
+} xXF86VidModeAddModeLineReq;
+#define sz_xXF86VidModeAddModeLineReq	92
+
+/* 0.x version */
+typedef struct _XF86OldVidModeAddModeLine {
+    CARD8	reqType;		/* always XF86VidModeReqCode */
+    CARD8	xf86vidmodeReqType;	/* always X_XF86VidModeAddMode */
+    CARD16	length;
+    CARD32	screen;			/* could be CARD16 but need the pad */
+    CARD32	dotclock;
+    CARD16	hdisplay;
+    CARD16	hsyncstart;
+    CARD16	hsyncend;
+    CARD16	htotal;
+    CARD16	vdisplay;
+    CARD16	vsyncstart;
+    CARD16	vsyncend;
+    CARD16	vtotal;
+    CARD32	flags;
+    CARD32	privsize;
+    CARD32	after_dotclock;
+    CARD16	after_hdisplay;
+    CARD16	after_hsyncstart;
+    CARD16	after_hsyncend;
+    CARD16	after_htotal;
+    CARD16	after_vdisplay;
+    CARD16	after_vsyncstart;
+    CARD16	after_vsyncend;
+    CARD16	after_vtotal;
+    CARD32	after_flags;
+} xXF86OldVidModeAddModeLineReq;
+#define sz_xXF86OldVidModeAddModeLineReq	60
+
+typedef struct _XF86VidModeModModeLine {
+    CARD8	reqType;		/* always XF86VidModeReqCode */
+    CARD8	xf86vidmodeReqType;	/* always X_XF86VidModeModModeLine */
+    CARD16	length;
+    CARD32	screen;			/* could be CARD16 but need the pad */
+    CARD16	hdisplay;
+    CARD16	hsyncstart;
+    CARD16	hsyncend;
+    CARD16	htotal;
+    CARD16	hskew;
+    CARD16	vdisplay;
+    CARD16	vsyncstart;
+    CARD16	vsyncend;
+    CARD16	vtotal;
+    CARD16	pad1;
+    CARD32	flags;
+    CARD32	reserved1;
+    CARD32	reserved2;
+    CARD32	reserved3;
+    CARD32	privsize;
+} xXF86VidModeModModeLineReq;
+#define sz_xXF86VidModeModModeLineReq	48
+
+/* 0.x version */
+typedef struct _XF86OldVidModeModModeLine {
+    CARD8	reqType;		/* always XF86OldVidModeReqCode */
+    CARD8	xf86vidmodeReqType;	/* always X_XF86OldVidModeModModeLine */
+    CARD16	length;
+    CARD32	screen;			/* could be CARD16 but need the pad */
+    CARD16	hdisplay;
+    CARD16	hsyncstart;
+    CARD16	hsyncend;
+    CARD16	htotal;
+    CARD16	vdisplay;
+    CARD16	vsyncstart;
+    CARD16	vsyncend;
+    CARD16	vtotal;
+    CARD32	flags;
+    CARD32	privsize;
+} xXF86OldVidModeModModeLineReq;
+#define sz_xXF86OldVidModeModModeLineReq	32
+
+typedef struct _XF86VidModeValidateModeLine {
+    CARD8	reqType;		/* always XF86VidModeReqCode */
+    CARD8	xf86vidmodeReqType;
+    CARD16	length;
+    CARD32	screen;			/* could be CARD16 but need the pad */
+    CARD32	dotclock;
+    CARD16	hdisplay;
+    CARD16	hsyncstart;
+    CARD16	hsyncend;
+    CARD16	htotal;
+    CARD16	hskew;
+    CARD16	vdisplay;
+    CARD16	vsyncstart;
+    CARD16	vsyncend;
+    CARD16	vtotal;
+    CARD16	pad1;
+    CARD32	flags;
+    CARD32	reserved1;
+    CARD32	reserved2;
+    CARD32	reserved3;
+    CARD32	privsize;
+} xXF86VidModeDeleteModeLineReq,
+  xXF86VidModeValidateModeLineReq,
+  xXF86VidModeSwitchToModeReq;
+#define sz_xXF86VidModeDeleteModeLineReq	52
+#define sz_xXF86VidModeValidateModeLineReq	52
+#define sz_xXF86VidModeSwitchToModeReq		52
+
+/* 0.x version */
+typedef struct _XF86OldVidModeValidateModeLine {
+    CARD8	reqType;		/* always XF86OldVidModeReqCode */
+    CARD8	xf86vidmodeReqType;
+    CARD16	length;
+    CARD32	screen;			/* could be CARD16 but need the pad */
+    CARD32	dotclock;
+    CARD16	hdisplay;
+    CARD16	hsyncstart;
+    CARD16	hsyncend;
+    CARD16	htotal;
+    CARD16	vdisplay;
+    CARD16	vsyncstart;
+    CARD16	vsyncend;
+    CARD16	vtotal;
+    CARD32	flags;
+    CARD32	privsize;
+} xXF86OldVidModeDeleteModeLineReq,
+  xXF86OldVidModeValidateModeLineReq,
+  xXF86OldVidModeSwitchToModeReq;
+#define sz_xXF86OldVidModeDeleteModeLineReq	36
+#define sz_xXF86OldVidModeValidateModeLineReq	36
+#define sz_xXF86OldVidModeSwitchToModeReq	36
+
+typedef struct _XF86VidModeSwitchMode {
+    CARD8	reqType;		/* always XF86VidModeReqCode */
+    CARD8	xf86vidmodeReqType;	/* always X_XF86VidModeSwitchMode */
+    CARD16	length;
+    CARD16	screen;
+    CARD16	zoom;
+} xXF86VidModeSwitchModeReq;
+#define sz_xXF86VidModeSwitchModeReq	8
+
+typedef struct _XF86VidModeLockModeSwitch {
+    CARD8	reqType;		/* always XF86VidModeReqCode */
+    CARD8	xf86vidmodeReqType;	/* always X_XF86VidModeLockModeSwitch */
+    CARD16	length;
+    CARD16	screen;
+    CARD16	lock;
+} xXF86VidModeLockModeSwitchReq;
+#define sz_xXF86VidModeLockModeSwitchReq	8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	status;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXF86VidModeValidateModeLineReply;
+#define sz_xXF86VidModeValidateModeLineReply	32
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD8	vendorLength;
+    CARD8	modelLength;
+    CARD8	nhsync;
+    CARD8	nvsync;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXF86VidModeGetMonitorReply;
+#define sz_xXF86VidModeGetMonitorReply	32
+
+typedef struct {
+    BYTE	type;
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	x;
+    CARD32	y;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xXF86VidModeGetViewPortReply;
+#define sz_xXF86VidModeGetViewPortReply	32
+
+typedef struct _XF86VidModeSetViewPort {
+    CARD8	reqType;		/* always VidModeReqCode */
+    CARD8	xf86vidmodeReqType;	/* always X_XF86VidModeSetViewPort */
+    CARD16	length;
+    CARD16	screen;
+    CARD16	pad;
+    CARD32	x;
+    CARD32	y;
+} xXF86VidModeSetViewPortReq;
+#define sz_xXF86VidModeSetViewPortReq	16
+
+typedef struct {
+    BYTE	type;
+    BOOL	pad1;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	flags;
+    CARD32	clocks;
+    CARD32	maxclocks;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+} xXF86VidModeGetDotClocksReply;
+#define sz_xXF86VidModeGetDotClocksReply	32
+
+typedef struct _XF86VidModeSetClientVersion {
+    CARD8	reqType;		/* always XF86VidModeReqCode */
+    CARD8	xf86vidmodeReqType;
+    CARD16	length;
+    CARD16	major;
+    CARD16	minor;
+} xXF86VidModeSetClientVersionReq;
+#define sz_xXF86VidModeSetClientVersionReq	8
+
+typedef struct _XF86VidModeGetGamma {
+    CARD8	reqType;		/* always XF86VidModeReqCode */
+    CARD8	xf86vidmodeReqType;
+    CARD16	length;
+    CARD16	screen;
+    CARD16	pad;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+    CARD32	pad6;
+} xXF86VidModeGetGammaReq;
+#define sz_xXF86VidModeGetGammaReq		32
+
+typedef struct {
+    BYTE	type;
+    BOOL	pad;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	red;
+    CARD32	green;
+    CARD32	blue;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+} xXF86VidModeGetGammaReply;
+#define sz_xXF86VidModeGetGammaReply		32
+
+typedef struct _XF86VidModeSetGamma {
+    CARD8	reqType;		/* always XF86VidModeReqCode */
+    CARD8	xf86vidmodeReqType;
+    CARD16	length;
+    CARD16	screen;
+    CARD16	pad;
+    CARD32	red;
+    CARD32	green;
+    CARD32	blue;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+} xXF86VidModeSetGammaReq;
+#define sz_xXF86VidModeSetGammaReq		32
+
+
+typedef struct _XF86VidModeSetGammaRamp {
+    CARD8       reqType;                /* always XF86VidModeReqCode */
+    CARD8       xf86vidmodeReqType;
+    CARD16      length;
+    CARD16      screen;
+    CARD16      size;
+} xXF86VidModeSetGammaRampReq;
+#define sz_xXF86VidModeSetGammaRampReq             8
+
+typedef struct _XF86VidModeGetGammaRamp {
+    CARD8       reqType;                /* always XF86VidModeReqCode */
+    CARD8       xf86vidmodeReqType;
+    CARD16      length;
+    CARD16      screen;
+    CARD16      size;
+} xXF86VidModeGetGammaRampReq;
+#define sz_xXF86VidModeGetGammaRampReq             8
+
+typedef struct {
+    BYTE        type;
+    BOOL        pad;
+    CARD16      sequenceNumber;
+    CARD32      length;
+    CARD16      size;
+    CARD16      pad0;
+    CARD32      pad1;
+    CARD32      pad2;
+    CARD32      pad3;
+    CARD32      pad4;
+    CARD32      pad5;
+} xXF86VidModeGetGammaRampReply;
+#define sz_xXF86VidModeGetGammaRampReply            32
+
+typedef struct _XF86VidModeGetGammaRampSize {
+    CARD8       reqType;                /* always XF86VidModeReqCode */
+    CARD8       xf86vidmodeReqType;
+    CARD16      length;
+    CARD16      screen;
+    CARD16      pad;
+} xXF86VidModeGetGammaRampSizeReq;
+#define sz_xXF86VidModeGetGammaRampSizeReq             8
+
+typedef struct {
+    BYTE        type;
+    BOOL        pad;
+    CARD16      sequenceNumber;
+    CARD32      length;
+    CARD16      size;
+    CARD16      pad0;
+    CARD32      pad1;
+    CARD32      pad2;
+    CARD32      pad3;
+    CARD32      pad4;
+    CARD32      pad5;
+} xXF86VidModeGetGammaRampSizeReply;
+#define sz_xXF86VidModeGetGammaRampSizeReply            32
+
+typedef struct {
+    BYTE        type;
+    BOOL        pad;
+    CARD16      sequenceNumber;
+    CARD32      length;
+    CARD32      permissions;
+    CARD32      pad1;
+    CARD32      pad2;
+    CARD32      pad3;
+    CARD32      pad4;
+    CARD32      pad5;
+} xXF86VidModeGetPermissionsReply;
+#define sz_xXF86VidModeGetPermissionsReply            32
+
+
+#endif /* _XF86VIDMODEPROTO_H_ */
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86vmstr.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86vmstr.h
new file mode 100644
index 0000000..f521335
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xf86vmstr.h
@@ -0,0 +1,3 @@
+#warning "xf86vmstr.h is obsolete and may be removed in the future."
+#warning "include <X11/extensions/xf86vmproto.h> for the protocol defines."
+#include <X11/extensions/xf86vmproto.h>
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xfixesproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xfixesproto.h
new file mode 100644
index 0000000..916535a
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xfixesproto.h
@@ -0,0 +1,585 @@
+/*
+ * Copyright (c) 2006, Oracle and/or its affiliates.
+ * Copyright 2010 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+/*
+ * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _XFIXESPROTO_H_
+#define _XFIXESPROTO_H_
+
+#include <X11/Xmd.h>
+#include <X11/extensions/xfixeswire.h>
+#include <X11/extensions/shapeconst.h>
+
+#define Window CARD32
+#define Drawable CARD32
+#define Font CARD32
+#define Pixmap CARD32
+#define Cursor CARD32
+#define Colormap CARD32
+#define GContext CARD32
+#define Atom CARD32
+#define VisualID CARD32
+#define Time CARD32
+#define KeyCode CARD8
+#define KeySym CARD32
+#define Picture CARD32
+
+/*************** Version 1 ******************/
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+} xXFixesReq;
+
+/*
+ * requests and replies
+ */
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    CARD32  majorVersion;
+    CARD32  minorVersion;
+} xXFixesQueryVersionReq;
+
+#define sz_xXFixesQueryVersionReq   12
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD32  majorVersion;
+    CARD32  minorVersion;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+} xXFixesQueryVersionReply;
+
+#define sz_xXFixesQueryVersionReply	32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    BYTE    mode;	    /* SetModeInsert/SetModeDelete*/
+    BYTE    target;	    /* SaveSetNearest/SaveSetRoot*/
+    BYTE    map;	    /* SaveSetMap/SaveSetUnmap */
+    BYTE    pad1;
+    Window  window;
+} xXFixesChangeSaveSetReq;
+
+#define sz_xXFixesChangeSaveSetReq	12
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Window  window;
+    Atom    selection;
+    CARD32  eventMask;
+} xXFixesSelectSelectionInputReq;
+
+#define sz_xXFixesSelectSelectionInputReq   16
+
+typedef struct {
+    CARD8   type;
+    CARD8   subtype;
+    CARD16  sequenceNumber;
+    Window  window;
+    Window  owner;
+    Atom    selection;
+    Time    timestamp;
+    Time    selectionTimestamp;
+    CARD32  pad2;
+    CARD32  pad3;
+} xXFixesSelectionNotifyEvent;
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Window  window;
+    CARD32  eventMask;
+} xXFixesSelectCursorInputReq;
+
+#define sz_xXFixesSelectCursorInputReq	12
+
+typedef struct {
+    CARD8   type;
+    CARD8   subtype;
+    CARD16  sequenceNumber;
+    Window  window;
+    CARD32  cursorSerial;
+    Time    timestamp;
+    Atom    name;	    /* Version 2 */
+    CARD32  pad1;
+    CARD32  pad2;
+    CARD32  pad3;
+} xXFixesCursorNotifyEvent;
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+} xXFixesGetCursorImageReq;
+
+#define sz_xXFixesGetCursorImageReq 4
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    INT16   x;
+    INT16   y;
+    CARD16  width;
+    CARD16  height;
+    CARD16  xhot;
+    CARD16  yhot;
+    CARD32  cursorSerial;
+    CARD32  pad2;
+    CARD32  pad3;
+} xXFixesGetCursorImageReply;
+
+#define sz_xXFixesGetCursorImageReply	32
+
+/*************** Version 2 ******************/
+
+#define Region CARD32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Region  region;
+    /* LISTofRECTANGLE */
+} xXFixesCreateRegionReq;
+
+#define sz_xXFixesCreateRegionReq	8
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Region  region;
+    Pixmap  bitmap;
+} xXFixesCreateRegionFromBitmapReq;
+
+#define sz_xXFixesCreateRegionFromBitmapReq	12
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Region  region;
+    Window  window;
+    CARD8   kind;
+    CARD8   pad1;
+    CARD16  pad2;
+} xXFixesCreateRegionFromWindowReq;
+
+#define sz_xXFixesCreateRegionFromWindowReq	16
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Region  region;
+    GContext gc;
+} xXFixesCreateRegionFromGCReq;
+
+#define sz_xXFixesCreateRegionFromGCReq	12
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Region  region;
+    Picture picture;
+} xXFixesCreateRegionFromPictureReq;
+
+#define sz_xXFixesCreateRegionFromPictureReq	12
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Region  region;
+} xXFixesDestroyRegionReq;
+
+#define sz_xXFixesDestroyRegionReq	8
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Region  region;
+    /* LISTofRECTANGLE */
+} xXFixesSetRegionReq;
+
+#define sz_xXFixesSetRegionReq		8
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Region  source;
+    Region  destination;
+} xXFixesCopyRegionReq;
+
+#define sz_xXFixesCopyRegionReq		12
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Region  source1;
+    Region  source2;
+    Region  destination;
+} xXFixesCombineRegionReq,
+  xXFixesUnionRegionReq,
+  xXFixesIntersectRegionReq,
+  xXFixesSubtractRegionReq;
+
+#define sz_xXFixesCombineRegionReq	16
+#define sz_xXFixesUnionRegionReq	sz_xXFixesCombineRegionReq
+#define sz_xXFixesIntersectRegionReq	sz_xXFixesCombineRegionReq
+#define sz_xXFixesSubtractRegionReq	sz_xXFixesCombineRegionReq
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Region  source;
+    INT16   x, y;
+    CARD16  width, height;
+    Region  destination;
+} xXFixesInvertRegionReq;
+
+#define sz_xXFixesInvertRegionReq	20
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Region  region;
+    INT16   dx, dy;
+} xXFixesTranslateRegionReq;
+
+#define sz_xXFixesTranslateRegionReq	12
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Region  source;
+    Region  destination;
+} xXFixesRegionExtentsReq;
+
+#define sz_xXFixesRegionExtentsReq	12
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Region  region;
+} xXFixesFetchRegionReq;
+
+#define sz_xXFixesFetchRegionReq	8
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    INT16   x, y;
+    CARD16  width, height;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+} xXFixesFetchRegionReply;
+
+#define sz_xXFixesFetchRegionReply	32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    GContext	gc;
+    Region  region;
+    INT16   xOrigin, yOrigin;
+} xXFixesSetGCClipRegionReq;
+
+#define sz_xXFixesSetGCClipRegionReq	16
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Window  dest;
+    BYTE    destKind;
+    CARD8   pad1;
+    CARD16  pad2;
+    INT16   xOff, yOff;
+    Region  region;
+} xXFixesSetWindowShapeRegionReq;
+
+#define sz_xXFixesSetWindowShapeRegionReq	20
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Picture picture;
+    Region  region;
+    INT16   xOrigin, yOrigin;
+} xXFixesSetPictureClipRegionReq;
+
+#define sz_xXFixesSetPictureClipRegionReq   16
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Cursor  cursor;
+    CARD16  nbytes;
+    CARD16  pad;
+} xXFixesSetCursorNameReq;
+
+#define sz_xXFixesSetCursorNameReq	    12
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Cursor  cursor;
+} xXFixesGetCursorNameReq;
+
+#define sz_xXFixesGetCursorNameReq	    8
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    Atom    atom;
+    CARD16  nbytes;
+    CARD16  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+    CARD32  pad6;
+} xXFixesGetCursorNameReply;
+
+#define sz_xXFixesGetCursorNameReply	    32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+} xXFixesGetCursorImageAndNameReq;
+
+#define sz_xXFixesGetCursorImageAndNameReq  4
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    INT16   x;
+    INT16   y;
+    CARD16  width;
+    CARD16  height;
+    CARD16  xhot;
+    CARD16  yhot;
+    CARD32  cursorSerial;
+    Atom    cursorName;
+    CARD16  nbytes;
+    CARD16  pad;
+} xXFixesGetCursorImageAndNameReply;
+
+#define sz_xXFixesGetCursorImageAndNameReply	32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Cursor  source;
+    Cursor  destination;
+} xXFixesChangeCursorReq;
+
+#define sz_xXFixesChangeCursorReq	12
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Cursor  source;
+    CARD16  nbytes;
+    CARD16  pad;
+} xXFixesChangeCursorByNameReq;
+
+#define sz_xXFixesChangeCursorByNameReq	12
+
+/*************** Version 3 ******************/
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Region  source;
+    Region  destination;
+    CARD16  left;
+    CARD16  right;
+    CARD16  top;
+    CARD16  bottom;
+} xXFixesExpandRegionReq;
+
+#define sz_xXFixesExpandRegionReq	20
+
+/*************** Version 4.0 ******************/
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Window  window;
+} xXFixesHideCursorReq;
+
+#define sz_xXFixesHideCursorReq	sizeof(xXFixesHideCursorReq)
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Window  window;
+} xXFixesShowCursorReq;
+
+#define sz_xXFixesShowCursorReq	sizeof(xXFixesShowCursorReq)
+
+/*************** Version 5.0 ******************/
+
+#define Barrier CARD32
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Barrier barrier;
+    Window  window;
+    INT16   x1;
+    INT16   y1;
+    INT16   x2;
+    INT16   y2;
+    CARD32  directions;
+    CARD16  pad;
+    CARD16  num_devices;
+    /* array of CARD16 devices */
+} xXFixesCreatePointerBarrierReq;
+
+#define sz_xXFixesCreatePointerBarrierReq 28
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    Barrier barrier;
+} xXFixesDestroyPointerBarrierReq;
+
+#define sz_xXFixesDestroyPointerBarrierReq 8
+
+/*************** Version 6.0 ******************/
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+    CARD32  disconnect_mode;
+} xXFixesSetClientDisconnectModeReq;
+
+#define sz_xXFixesSetClientDisconnectModeReq    8
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xfixesReqType;
+    CARD16  length;
+} xXFixesGetClientDisconnectModeReq;
+
+#define sz_xXFixesGetClientDisconnectModeReq    4
+
+typedef struct {
+    BYTE        type;                   /* X_Reply */
+    CARD8       pad0;
+    CARD16      sequenceNumber;
+    CARD32      length;
+    CARD32      disconnect_mode;
+    CARD32      pad1;
+    CARD32      pad2;
+    CARD32      pad3;
+    CARD32      pad4;
+    CARD32      pad5;
+} xXFixesGetClientDisconnectModeReply;
+
+#define sz_xXFixesGetClientDisconnectModeReply	32
+
+#undef Barrier
+#undef Region
+#undef Picture
+#undef Window
+#undef Drawable
+#undef Font
+#undef Pixmap
+#undef Cursor
+#undef Colormap
+#undef GContext
+#undef Atom
+#undef VisualID
+#undef Time
+#undef KeyCode
+#undef KeySym
+
+#endif /* _XFIXESPROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xfixeswire.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xfixeswire.h
new file mode 100644
index 0000000..83251cf
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xfixeswire.h
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2006, Oracle and/or its affiliates.
+ * Copyright 2010 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+/*
+ * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Keith Packard not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Keith Packard makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+
+#ifndef _XFIXESWIRE_H_
+#define _XFIXESWIRE_H_
+
+#define XFIXES_NAME	"XFIXES"
+#define XFIXES_MAJOR	6
+#define XFIXES_MINOR	0
+
+/*************** Version 1 ******************/
+#define X_XFixesQueryVersion		    0
+#define X_XFixesChangeSaveSet		    1
+#define X_XFixesSelectSelectionInput	    2
+#define X_XFixesSelectCursorInput	    3
+#define X_XFixesGetCursorImage		    4
+/*************** Version 2 ******************/
+#define X_XFixesCreateRegion		    5
+#define X_XFixesCreateRegionFromBitmap	    6
+#define X_XFixesCreateRegionFromWindow	    7
+#define X_XFixesCreateRegionFromGC	    8
+#define X_XFixesCreateRegionFromPicture	    9
+#define X_XFixesDestroyRegion		    10
+#define X_XFixesSetRegion		    11
+#define X_XFixesCopyRegion		    12
+#define X_XFixesUnionRegion		    13
+#define X_XFixesIntersectRegion		    14
+#define X_XFixesSubtractRegion		    15
+#define X_XFixesInvertRegion		    16
+#define X_XFixesTranslateRegion		    17
+#define X_XFixesRegionExtents		    18
+#define X_XFixesFetchRegion		    19
+#define X_XFixesSetGCClipRegion		    20
+#define X_XFixesSetWindowShapeRegion	    21
+#define X_XFixesSetPictureClipRegion	    22
+#define X_XFixesSetCursorName		    23
+#define X_XFixesGetCursorName		    24
+#define X_XFixesGetCursorImageAndName	    25
+#define X_XFixesChangeCursor		    26
+#define X_XFixesChangeCursorByName	    27
+/*************** Version 3 ******************/
+#define X_XFixesExpandRegion		    28
+/*************** Version 4 ******************/
+#define X_XFixesHideCursor		    29
+#define X_XFixesShowCursor		    30
+/*************** Version 5 ******************/
+#define X_XFixesCreatePointerBarrier	    31
+#define X_XFixesDestroyPointerBarrier	    32
+/*************** Version 6 ******************/
+#define X_XFixesSetClientDisconnectMode	    33
+#define X_XFixesGetClientDisconnectMode	    34
+
+#define XFixesNumberRequests		    (X_XFixesGetClientDisconnectMode+1)
+
+/* Selection events share one event number */
+#define XFixesSelectionNotify		    0
+
+/* Within the selection, the 'subtype' field distinguishes */
+#define XFixesSetSelectionOwnerNotify	    0
+#define XFixesSelectionWindowDestroyNotify  1
+#define XFixesSelectionClientCloseNotify    2
+
+#define XFixesSetSelectionOwnerNotifyMask	(1L << 0)
+#define XFixesSelectionWindowDestroyNotifyMask	(1L << 1)
+#define XFixesSelectionClientCloseNotifyMask	(1L << 2)
+
+/* There's only one cursor event so far */
+#define XFixesCursorNotify		    1
+
+#define XFixesDisplayCursorNotify	    0
+
+#define XFixesDisplayCursorNotifyMask	    (1L << 0)
+
+#define XFixesNumberEvents		    (2)
+
+/* errors */
+#define BadRegion			    0
+#define BadBarrier			    1
+#define XFixesNumberErrors		    (BadBarrier+1)
+
+#define SaveSetNearest			    0
+#define SaveSetRoot			    1
+
+#define SaveSetMap			    0
+#define SaveSetUnmap			    1
+
+/*************** Version 2 ******************/
+
+#define WindowRegionBounding		    0
+#define WindowRegionClip		    1
+
+/*************** Version 5 ******************/
+
+#define BarrierPositiveX		    (1L << 0)
+#define BarrierPositiveY		    (1L << 1)
+#define BarrierNegativeX		    (1L << 2)
+#define BarrierNegativeY		    (1L << 3)
+
+/*************** Version 6 ******************/
+
+/* The default server behaviour */
+#define XFixesClientDisconnectFlagDefault   0
+/* The server may disconnect this client to shut down */
+#define XFixesClientDisconnectFlagTerminate  (1L << 0)
+
+/*************** Version 6.1 ******************/
+
+/* The server must terminate if this client exits */
+#define XFixesClientDisconnectFlagForceTerminate  (1L << 1)
+
+#endif	/* _XFIXESWIRE_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xtestconst.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtestconst.h
new file mode 100644
index 0000000..e74b904
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtestconst.h
@@ -0,0 +1,41 @@
+/*
+
+Copyright 1992, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+#ifndef _XTEST_CONST_H_
+#define _XTEST_CONST_H_
+
+#define XTestNumberEvents	0
+
+#define XTestNumberErrors	0
+
+#define XTestCurrentCursor ((Cursor)1)
+
+#define XTestMajorVersion	2
+#define XTestMinorVersion	2
+
+#define XTestExtensionName	"XTEST"
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xtestext1const.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtestext1const.h
new file mode 100644
index 0000000..656edc6
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtestext1const.h
@@ -0,0 +1,160 @@
+/*
+ * xtestext1.h
+ *
+ * X11 Input Synthesis Extension include file
+ */
+
+/*
+
+
+Copyright 1986, 1987, 1988, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1986, 1987, 1988 by Hewlett-Packard Corporation
+
+Permission to use, copy, modify, and distribute this
+software and its documentation for any purpose and without
+fee is hereby granted, provided that the above copyright
+notice appear in all copies and that both that copyright
+notice and this permission notice appear in supporting
+documentation, and that the name of Hewlett-Packard not be used in
+advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+Hewlett-Packard makes no representations about the
+suitability of this software for any purpose.  It is provided
+"as is" without express or implied warranty.
+
+This software is not subject to any license of the American
+Telephone and Telegraph Company or of the Regents of the
+University of California.
+
+*/
+
+#ifndef _XTESTEXT1CONST_H
+#define _XTESTEXT1CONST_H 1
+
+#define XTestMAX_ACTION_LIST_SIZE       64
+#define XTestACTIONS_SIZE	28
+
+
+/*
+ * used in the XTestPressButton and XTestPressKey functions
+ */
+#define XTestPRESS                      1 << 0
+#define XTestRELEASE                    1 << 1
+#define XTestSTROKE                     1 << 2
+
+/*
+ * When doing a key or button stroke, the number of milliseconds
+ * to delay between the press and the release of a key or button
+ * in the XTestPressButton and XTestPressKey functions.
+ */
+
+#define XTestSTROKE_DELAY_TIME		10
+
+/*
+ * used in the XTestGetInput function
+ */
+#define XTestEXCLUSIVE                  1 << 0
+#define XTestPACKED_ACTIONS             1 << 1
+#define XTestPACKED_MOTION              1 << 2
+
+/*
+ * used in the XTestFakeInput function
+ */
+#define XTestFAKE_ACK_NOT_NEEDED        0
+#define XTestFAKE_ACK_REQUEST           1
+
+/*
+ * used in the XTest extension initialization routine
+ */
+#define XTestEXTENSION_NAME             "XTestExtension1"
+#define XTestEVENT_COUNT                2
+
+/*
+ * This is the definition for the format of the header byte
+ * in the input action structures.
+ */
+#define XTestACTION_TYPE_MASK   0x03    /* bits 0 and 1          */
+#define XTestKEY_STATE_MASK     0x04    /* bit 2 (key action)    */
+#define XTestX_SIGN_BIT_MASK    0x04    /* bit 2 (motion action) */
+#define XTestY_SIGN_BIT_MASK    0x08    /* bit 3 (motion action) */
+#define XTestDEVICE_ID_MASK     0xf0    /* bits 4 through 7      */
+
+#define XTestMAX_DEVICE_ID	0x0f
+#define XTestPackDeviceID(x)	(((x) & XTestMAX_DEVICE_ID) << 4)
+#define XTestUnpackDeviceID(x)	(((x) & XTestDEVICE_ID_MASK) >> 4)
+
+/*
+ * These are the possible action types.
+ */
+#define XTestDELAY_ACTION       0
+#define XTestKEY_ACTION         1
+#define XTestMOTION_ACTION      2
+#define XTestJUMP_ACTION        3
+
+/*
+ * These are the definitions for key/button motion input actions.
+ */
+#define XTestKEY_UP             0x04
+#define XTestKEY_DOWN           0x00
+
+/*
+ * These are the definitions for pointer relative motion input
+ * actions.
+ *
+ * The sign bits for the x and y relative motions are contained
+ * in the header byte.  The x and y relative motions are packed
+ * into one byte to make things fit in 32 bits.  If the relative
+ * motion range is larger than +/-15, use the pointer jump action.
+ */
+#define XTestMOTION_MAX            15
+#define XTestMOTION_MIN            -15
+
+#define XTestX_NEGATIVE            0x04
+#define XTestY_NEGATIVE            0x08
+
+#define XTestX_MOTION_MASK         0x0f
+#define XTestY_MOTION_MASK         0xf0
+
+#define XTestPackXMotionValue(x)   ((x) & XTestX_MOTION_MASK)
+#define XTestPackYMotionValue(x)   (((x) << 4) & XTestY_MOTION_MASK)
+
+#define XTestUnpackXMotionValue(x) ((x) & XTestX_MOTION_MASK)
+#define XTestUnpackYMotionValue(x) (((x) & XTestY_MOTION_MASK) >> 4)
+/*
+ * These are the definitions for a long delay input action.  It is
+ * used when more than XTestSHORT_DELAY_TIME milliseconds of delay
+ * (approximately one minute) is needed.
+ *
+ * The device ID for a delay is always set to XTestDELAY_DEVICE_ID.
+ * This guarantees that a header byte with a value of 0 is not
+ * a valid header, so it can be used as a flag to indicate that
+ * there are no more input actions in an XTestInputAction event.
+ */
+
+#define XTestSHORT_DELAY_TIME	0xffff
+#define XTestDELAY_DEVICE_ID    0x0f
+
+#endif /* _XTESTEXT1CONST_H */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xtestext1proto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtestext1proto.h
new file mode 100644
index 0000000..d14ace1
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtestext1proto.h
@@ -0,0 +1,221 @@
+/*
+ * xtestext1.h
+ *
+ * X11 Input Synthesis Extension include file
+ */
+
+/*
+Copyright 1986, 1987, 1988, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1986, 1987, 1988 by Hewlett-Packard Corporation
+
+Permission to use, copy, modify, and distribute this
+software and its documentation for any purpose and without
+fee is hereby granted, provided that the above copyright
+notice appear in all copies and that both that copyright
+notice and this permission notice appear in supporting
+documentation, and that the name of Hewlett-Packard not be used in
+advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+Hewlett-Packard makes no representations about the
+suitability of this software for any purpose.  It is provided
+"as is" without express or implied warranty.
+
+This software is not subject to any license of the American
+Telephone and Telegraph Company or of the Regents of the
+University of California.
+
+*/
+
+#ifndef _XTESTEXT1PROTO_H
+#define _XTESTEXT1PROTO_H 1
+
+#include <X11/extensions/xtestext1const.h>
+
+/*
+ * the typedefs for CARD8, CARD16, and CARD32 are defined in Xmd.h
+ */
+
+/*
+ * XTest request type values
+ *
+ * used in the XTest extension protocol requests
+ */
+#define X_TestFakeInput                  1
+#define X_TestGetInput                   2
+#define X_TestStopInput                  3
+#define X_TestReset                      4
+#define X_TestQueryInputSize             5
+
+/*
+ * This defines the maximum size of a list of input actions
+ * to be sent to the server.  It should always be a multiple of
+ * 4 so that the entire xTestFakeInputReq structure size is a
+ * multiple of 4.
+ */
+
+typedef struct {
+        CARD8   reqType;        /* always XTestReqCode             */
+        CARD8   XTestReqType;   /* always X_TestFakeInput           */
+        CARD16  length;         /* 2 + XTestMAX_ACTION_LIST_SIZE/4 */
+        CARD32  ack;
+        CARD8   action_list[XTestMAX_ACTION_LIST_SIZE];
+} xTestFakeInputReq;
+#define sz_xTestFakeInputReq (XTestMAX_ACTION_LIST_SIZE + 8)
+
+typedef struct {
+        CARD8   reqType;        /* always XTestReqCode  */
+        CARD8   XTestReqType;   /* always X_TestGetInput */
+        CARD16  length;         /* 2                    */
+        CARD32  mode;
+} xTestGetInputReq;
+#define sz_xTestGetInputReq 8
+
+typedef struct {
+        CARD8   reqType;        /* always XTestReqCode   */
+        CARD8   XTestReqType;   /* always X_TestStopInput */
+        CARD16  length;         /* 1                     */
+} xTestStopInputReq;
+#define sz_xTestStopInputReq 4
+
+typedef struct {
+        CARD8   reqType;        /* always XTestReqCode */
+        CARD8   XTestReqType;   /* always X_TestReset   */
+        CARD16  length;         /* 1                   */
+} xTestResetReq;
+#define sz_xTestResetReq 4
+
+typedef struct {
+        CARD8   reqType;        /* always XTestReqCode        */
+        CARD8   XTestReqType;   /* always X_TestQueryInputSize */
+        CARD16  length;         /* 1                          */
+} xTestQueryInputSizeReq;
+#define sz_xTestQueryInputSizeReq 4
+
+/*
+ * This is the definition of the reply for the xTestQueryInputSize
+ * request.  It should remain the same minimum size as other replies
+ * (32 bytes).
+ */
+typedef struct {
+        CARD8   type;           /* always X_Reply  */
+        CARD8   pad1;
+        CARD16  sequenceNumber;
+        CARD32  length;         /* always 0 */
+        CARD32  size_return;
+        CARD32  pad2;
+        CARD32  pad3;
+        CARD32  pad4;
+        CARD32  pad5;
+        CARD32  pad6;
+} xTestQueryInputSizeReply;
+
+/*
+ * This is the definition for the input action wire event structure.
+ * This event is sent to the client when the server has one or
+ * more user input actions to report to the client.  It must
+ * remain the same size as all other wire events (32 bytes).
+ */
+typedef struct {
+        CARD8   type;           /* always XTestInputActionType */
+        CARD8   pad00;
+        CARD16  sequenceNumber;
+        CARD8   actions[XTestACTIONS_SIZE];
+} xTestInputActionEvent;
+
+/*
+ * This is the definition for the xTestFakeAck wire event structure.
+ * This event is sent to the client when the server has completely
+ * processed its input action buffer, and is ready for more.
+ * It must remain the same size as all other wire events (32 bytes).
+ */
+typedef struct {
+        CARD8   type;           /* always XTestFakeAckType */
+        CARD8   pad00;
+        CARD16  sequenceNumber;
+        CARD32  pad02;
+        CARD32  pad03;
+        CARD32  pad04;
+        CARD32  pad05;
+        CARD32  pad06;
+        CARD32  pad07;
+        CARD32  pad08;
+} xTestFakeAckEvent;
+
+/*
+ * These are the definitions for key/button motion input actions.
+ */
+typedef struct {
+        CARD8   header;         /* which device, key up/down */
+        CARD8   keycode;        /* which key/button to move  */
+        CARD16  delay_time;     /* how long to delay (in ms) */
+} XTestKeyInfo;
+
+/*
+ * This is the definition for pointer jump input actions.
+ */
+typedef struct {
+        CARD8   header;         /* which pointer             */
+        CARD8   pad1;           /* unused padding byte       */
+        CARD16  jumpx;          /* x coord to jump to        */
+        CARD16  jumpy;          /* y coord to jump to        */
+        CARD16  delay_time;     /* how long to delay (in ms) */
+} XTestJumpInfo;
+
+/*
+ * These are the definitions for pointer relative motion input
+ * actions.
+ *
+ * The sign bits for the x and y relative motions are contained
+ * in the header byte.  The x and y relative motions are packed
+ * into one byte to make things fit in 32 bits.  If the relative
+ * motion range is larger than +/-15, use the pointer jump action.
+ */
+
+typedef struct {
+        CARD8   header;         /* which pointer             */
+        CARD8   motion_data;    /* x,y relative motion       */
+        CARD16  delay_time;     /* how long to delay (in ms) */
+} XTestMotionInfo;
+
+/*
+ * These are the definitions for a long delay input action.  It is
+ * used when more than XTestSHORT_DELAY_TIME milliseconds of delay
+ * (approximately one minute) is needed.
+ *
+ * The device ID for a delay is always set to XTestDELAY_DEVICE_ID.
+ * This guarantees that a header byte with a value of 0 is not
+ * a valid header, so it can be used as a flag to indicate that
+ * there are no more input actions in an XTestInputAction event.
+ */
+
+typedef struct {
+        CARD8   header;         /* always XTestDELAY_DEVICE_ID */
+        CARD8   pad1;           /* unused padding byte         */
+        CARD16  pad2;           /* unused padding word         */
+        CARD32  delay_time;     /* how long to delay (in ms)   */
+} XTestDelayInfo;
+
+#endif /* _XTESTEXT1PROTO_H */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xtestproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtestproto.h
new file mode 100644
index 0000000..9595ac1
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtestproto.h
@@ -0,0 +1,124 @@
+/*
+
+Copyright 1992, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+#ifndef _XTESTPROTO_H_
+#define _XTESTPROTO_H_
+
+#include <X11/extensions/xtestconst.h>
+
+#define Window CARD32
+#define Time CARD32
+#define Cursor CARD32
+
+#define X_XTestGetVersion	0
+#define X_XTestCompareCursor	1
+#define X_XTestFakeInput	2
+#define X_XTestGrabControl	3
+
+typedef struct {
+    CARD8	reqType;	/* always XTestReqCode */
+    CARD8	xtReqType;	/* always X_XTestGetVersion */
+    CARD16	length;
+    CARD8	majorVersion;
+    CARD8	pad;
+    CARD16	minorVersion;
+} xXTestGetVersionReq;
+#define sz_xXTestGetVersionReq 8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    CARD8	majorVersion;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	minorVersion;
+    CARD16	pad0;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xXTestGetVersionReply;
+#define sz_xXTestGetVersionReply 32
+
+typedef struct {
+    CARD8	reqType;	/* always XTestReqCode */
+    CARD8	xtReqType;	/* always X_XTestCompareCursor */
+    CARD16	length;
+    Window	window;
+    Cursor	cursor;
+} xXTestCompareCursorReq;
+#define sz_xXTestCompareCursorReq 12
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	same;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD32	pad0;
+    CARD32	pad1;
+    CARD32	pad2;
+    CARD32	pad3;
+    CARD32	pad4;
+    CARD32	pad5;
+} xXTestCompareCursorReply;
+#define sz_xXTestCompareCursorReply 32
+
+/* used only on the client side */
+typedef struct {
+    CARD8	reqType;	/* always XTestReqCode */
+    CARD8	xtReqType;	/* always X_XTestFakeInput */
+    CARD16	length;
+    BYTE	type;
+    BYTE	detail;
+    CARD16	pad0;
+    Time	time;
+    Window	root;
+    CARD32	pad1;
+    CARD32	pad2;
+    INT16	rootX, rootY;
+    CARD32	pad3;
+    CARD16	pad4;
+    CARD8	pad5;
+    CARD8	deviceid;
+} xXTestFakeInputReq;
+#define sz_xXTestFakeInputReq 36
+
+typedef struct {
+    CARD8	reqType;	/* always XTestReqCode */
+    CARD8	xtReqType;	/* always X_XTestGrabControl */
+    CARD16	length;
+    BOOL	impervious;
+    CARD8	pad0;
+    CARD8	pad1;
+    CARD8	pad2;
+} xXTestGrabControlReq;
+#define sz_xXTestGrabControlReq 8
+
+#undef Window
+#undef Time
+#undef Cursor
+
+#endif /* _XTESTPROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xtrapbits.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtrapbits.h
new file mode 100644
index 0000000..794cc9e
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtrapbits.h
@@ -0,0 +1,83 @@
+/* $XFree86$ */
+/*
+ * This include file is designed to be a portable way for systems to define
+ * bit field manipulation of arrays of bits.
+ */
+#ifndef __XTRAPBITS__
+#define __XTRAPBITS__ "@(#)xtrapbits.h	1.6 - 90/09/18  "
+
+/*****************************************************************************
+Copyright 1987, 1988, 1989, 1990, 1994 by Digital Equipment Corporation,
+Maynard, MA
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+*****************************************************************************/
+/*
+ *
+ *  CONTRIBUTORS:
+ *
+ *      Dick Annicchiarico
+ *      Robert Chesler
+ *      Dan Coutu
+ *      Gene Durso
+ *      Marc Evans
+ *      Alan Jamison
+ *      Mark Henry
+ *      Ken Miller
+ *
+ */
+typedef unsigned char *UByteP;  /* Pointer to an unsigned byte array */
+#define BitsInByte    8L        /* The number of bits in a byte */
+
+#define BitInByte(bit)	        /* Returns the bit mask of a byte */ \
+    (1L << (((bit) % BitsInByte)))
+
+#define BitInWord(bit)	        /* Returns the bit mask of a word */ \
+    (1L << (((bit) % (BitsInByte * 2L))))
+
+#define BitInLong(bit)	        /* Returns the bit mask of a long */ \
+    (1L << (((bit) % (BitsInByte * 4L))))
+
+#define ByteInArray(array,bit)	/* Returns the byte offset to get to a bit */ \
+    (((UByteP)(array))[(bit) / BitsInByte])
+
+#define BitIsTrue(array,bit)    /* Test to see if a specific bit is True */ \
+    (ByteInArray(array,bit) & BitInByte(bit))
+
+#define BitIsFalse(array,bit)   /* Test to see if a specific bit is False */ \
+    (!(BitIsTrue(array,bit)))
+
+#define BitTrue(array,bit)      /* Set a specific bit to be True */ \
+    (ByteInArray(array,bit) |= BitInByte(bit))
+
+#define BitFalse(array,bit)     /* Set a specific bit to be False */ \
+    (ByteInArray(array,bit) &= ~BitInByte(bit))
+
+#define BitToggle(array,bit)    /* Toggle a specific bit */ \
+    (ByteInArray(array,bit) ^= BitInByte(bit))
+
+#define BitCopy(dest,src,bit)   /* Copy a specific bit */ \
+    BitIsTrue((src),(bit)) ? BitTrue((dest),(bit)) : BitFalse((dest),(bit))
+
+#define BitValue(array,bit)     /* Return True or False depending on bit */ \
+    (BitIsTrue((array),(bit)) ? True : False)
+
+#define BitSet(array,bit,value) /* Set bit to given value in array */ \
+    (value) ? BitTrue((array),(bit)) : BitFalse((array),(bit))
+
+#endif /* __XTRAPBITS__ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xtrapddmi.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtrapddmi.h
new file mode 100644
index 0000000..4515ca6
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtrapddmi.h
@@ -0,0 +1,115 @@
+/* $XFree86$ */
+
+#ifndef __XTRAPDDMI__
+#define __XTRAPDDMI__
+
+/*****************************************************************************
+Copyright 1987, 1988, 1989, 1990, 1991 by Digital Equipment Corp., Maynard, MA
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+*****************************************************************************/
+/*
+ *
+ *  CONTRIBUTORS:
+ *
+ *      Dick Annicchiarico
+ *      Robert Chesler
+ *      Dan Coutu
+ *      Gene Durso
+ *      Marc Evans
+ *      Alan Jamison
+ *      Mark Henry
+ *      Ken Miller
+ *
+ *  DESCRIPTION:
+ *      This header file is used by the XTrap server extension only
+ *      (not used by clients or the XTrap Toolkit).  Information
+ *      contained herein should *not* be visible to clients (xtrapdi.h
+ *      is used for this).  The name is historical.
+ */
+#include <X11/X.h>
+#include <X11/extensions/xtrapbits.h>
+#include "dix.h"
+
+#ifndef MIN
+# define MIN(a,b) ((a) < (b) ? (a) : (b))
+#endif
+#ifndef MAX
+# define MAX(a,b) ((a) > (b) ? (a) : (b))
+#endif
+
+#define XETrapNumEvents    1L  /* constants used for AddExtension */
+
+/* Other constants used within the extension code */
+#define XETrapMinRepSize        32L        /* Minimum number of longs */
+
+/* This structure will be globally declared to provide storage to hold
+ * the various extension wide configuration information.  Allocated on
+ * a per-client basis.
+ */
+typedef struct
+{
+    ClientPtr            client;  /* Multi-client support and error handling */
+    xXTrapGetCurReply    cur;    /* Struct of Miscellaneous state info */
+    xXTrapGetStatsReply  *stats; /* Pointer to stat's, malloc'd if requested */
+    CARD32 last_input_time;      /* last timestamp from input event */
+    CARD16 protocol;             /* current communication protocol */
+} XETrapEnv;
+
+#define XETrapSetHeaderEvent(phdr)      ((phdr)->type = 0x1L)
+#define XETrapSetHeaderRequest(phdr)    ((phdr)->type = 0x2L)
+#define XETrapSetHeaderSpecial(phdr)    ((phdr)->type = 0x3L)
+#define XETrapSetHeaderCursor(phdr)     ((phdr)->type = 0x4L)
+#define XETrapSetHeaderReply(phdr)      ((phdr)->type = 0x5L)
+
+#ifndef vaxc
+#define globaldef
+#define globalref extern
+#endif
+
+/* Extension platform identifier (conditionally defined) */
+#if ( defined (__osf__) && defined(__alpha) )
+# define XETrapPlatform    PF_DECOSF1
+#endif
+#ifdef ultrix
+# define XETrapPlatform    PF_DECUltrix
+#endif
+#ifdef vms
+#ifdef VAXELN
+# define XETrapPlatform    PF_DECELN
+#else
+# define XETrapPlatform    PF_DECVMS
+#endif
+#endif
+#ifdef VT1000
+# define XETrapPlatform    PF_DECVT1000
+#endif
+#ifdef VXT
+# define XETrapPlatform    PF_DECXTerm
+#endif
+#ifdef PC
+# define XETrapPlatform    PF_IBMAT
+#endif
+#ifdef sun
+# define XETrapPlatform    PF_SunSparc
+#endif
+#ifndef XETrapPlatform
+# define XETrapPlatform    PF_Other
+#endif  /* XETrapPlatform */
+
+#endif /* __XTRAPDDMI__ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xtrapdi.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtrapdi.h
new file mode 100644
index 0000000..e26cb9c
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtrapdi.h
@@ -0,0 +1,501 @@
+/* $XFree86$ */
+#ifndef __XTRAPDI__
+#define __XTRAPDI__
+
+/*****************************************************************************
+Copyright 1987, 1988, 1989, 1990, 1991, 1992, 1994 by Digital Equipment Corp.,
+Maynard, MA
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+*****************************************************************************/
+/*
+ *
+ *  CONTRIBUTORS:
+ *
+ *      Dick Annicchiarico
+ *      Robert Chesler
+ *      Dan Coutu
+ *      Gene Durso
+ *      Marc Evans
+ *      Alan Jamison
+ *      Mark Henry
+ *      Ken Miller
+ *
+ *  DESCRIPTION:
+ *      This header file defines the common structures/constants
+ *      between the XTrap extension and clients.  All protocol
+ *      definitions between XTrap extension/clients can be found
+ *      here.
+ */
+
+#define NEED_REPLIES
+#define NEED_EVENTS
+#include <X11/X.h>
+#include <X11/Xmd.h>
+#ifdef SMT
+#define NEED_EVENTS
+#define NEED_REPLIES
+#endif
+#include <X11/Xproto.h>
+#include <X11/extensions/xtrapbits.h>
+#define XTrapExtName "DEC-XTRAP"
+/* Current Release, Version, and Revision of the XTrap Extension */
+#define XETrapRelease      3L
+#define XETrapVersion      4L
+#ifndef XETrapRevision        /* Changed from the Makefile by users */
+# define XETrapRevision    0L
+#endif /* XETrapRevision */
+#define XETrapProtocol     32L
+
+#ifndef SIZEOF
+# ifdef __STDC__
+#  define SIZEOF(x) sz_##x
+# else
+#  define SIZEOF(x) sz_/**/x
+# endif /* if ANSI C compiler else not */
+#endif
+#ifndef sz_CARD32
+#define sz_CARD32   4L
+#endif
+#ifndef sz_CARD8
+#define sz_CARD8    1L
+#endif
+#ifndef True
+# define True  1L
+# define False 0L
+#endif
+
+/* This is used as flags to indicate desired request traps
+ * Note:  This has been padded to a CARD32 to keep structure aligned
+ */
+#define XETrapMaxRequest (((SIZEOF(CARD32)+((256L-1L) / \
+    (BitsInByte*SIZEOF(CARD8))))/SIZEOF(CARD32))*SIZEOF(CARD32))
+typedef CARD8 ReqFlags[XETrapMaxRequest];
+
+/* This is used as flags to indicate desired event traps
+ * Until events become *fully vectored*, we'll have to fake it
+ * by defining an array of 5 events (KeyPress, KeyRelease,
+ * ButtonPress, ButtonRelease, and MotionNotify.  The extra 2
+ * are required as the event types start with "2" (errors and
+ * replies are 0 & 1).  The event type is the index into the
+ * bits.
+ * Note:  This has been padded to a longword to keep structure aligned
+ */
+#ifndef VECTORED_EVENTS
+#define XETrapCoreEvents    (2L+5L)
+#else
+#define XETrapCoreEvents    128L
+#endif
+#define XETrapMaxEvent (((SIZEOF(CARD32)+((XETrapCoreEvents-1L) / \
+    (BitsInByte*SIZEOF(CARD8))))/SIZEOF(CARD32))*SIZEOF(CARD32))
+typedef CARD8 EventFlags[XETrapMaxEvent];
+
+/* This structure is used in a request to specify the types of
+ * configuration information that should be changed or updated.
+ */
+typedef struct
+{
+    CARD8      valid[4L];  /* Bits TRUE indicates data field is used */
+    CARD8      data[4L];   /* Bits looked at if corresponding valid bit set */
+    ReqFlags   req;        /* Bits correspond to core requests */
+    EventFlags event;      /* Bits correspond to core events */
+} XETrapFlags;
+
+/* Bit definitions for the above XETrapFlags structure. */
+#define  XETrapTimestamp      0L          /* hdr timestamps desired */
+#define  XETrapCmd            1L          /* command key specified */
+#define  XETrapCmdKeyMod      2L          /* cmd key is a modifier  */
+#define  XETrapRequest        3L          /* output requests array */
+#define  XETrapEvent          4L          /*  future  output events array */
+#define  XETrapMaxPacket      5L          /* Maximum packet length set */
+#define  XETrapTransOut       6L          /* obsolete */
+#define  XETrapStatistics     7L          /* collect counts on requests */
+#define  XETrapWinXY          8L          /* Fill in Window (X,Y) in hdr */
+#define  XETrapTransIn        9L          /* obsolete */
+#define  XETrapCursor         10L         /* Trap cursor state changes */
+#define  XETrapXInput         11L         /* Use XInput extension */
+#define  XETrapVectorEvents   12L         /* Use Vectored Events (128) */
+#define  XETrapColorReplies   13L         /* Return replies with Color Req's */
+#define  XETrapGrabServer     14L         /* Disables client GrabServers */
+
+typedef struct /* used by XEConfigRequest */
+{
+    XETrapFlags flags;            /* Flags to specify what should be chg'd */
+    CARD16      max_pkt_size;     /* Maximum number of bytes in a packet */
+    CARD8       cmd_key;       /* Keyboard command_key (KeyCode) */
+/*
+ * cmd_key is intentionally *not* defined KeyCode since it's definition is
+ * ambiguous (int in Intrinsic.h and unsigned char in X.h.
+ */
+    CARD8      pad[1L];           /* pad out to a quadword */
+} XETrapCfg;
+
+/* These structures are used within the Xtrap request structure for
+ * the various types of xtrap request
+ */
+#ifndef _XINPUT
+/* (see the definition of XEvent as a reference) */
+typedef struct /* used by XESimulateXEventRequest for synthesizing core evts */
+{
+    CARD8    type;                 /* (must be first) as in XEvent */
+    CARD8    detail;               /* Detail keycode/button as in XEvent */
+    CARD8    screen;               /* screen number (0 to n) */
+    CARD8    pad;                  /* pad to longword */
+    INT16    x;                    /* X & Y coord as in XEvent */
+    INT16    y;
+} XETrapInputReq;
+#endif
+
+/* These are constants that refer to the extension request vector table.
+ * A request will use these values as minor opcodes.
+ */
+#define XETrap_Reset          0L     /* set to steady state */
+#define XETrap_GetAvailable   1L     /* get available funct from ext */
+#define XETrap_Config         2L     /* configure extension */
+#define XETrap_StartTrap      3L     /* use Trapping  */
+#define XETrap_StopTrap       4L     /* stop using Trapping */
+#define XETrap_GetCurrent     5L     /* get current info from ext */
+#define XETrap_GetStatistics  6L     /* get count statistics from ext */
+#ifndef _XINPUT
+#define XETrap_SimulateXEvent 7L     /* async input simulation */
+#endif
+#define XETrap_GetVersion     8L     /* Get (Just) Version */
+#define XETrap_GetLastInpTime 9L     /* Get Timestamp of last client input */
+
+/* The following are formats of a request to the XTRAP
+ * extension.  The data-less XTrap requests all use xXTrapReq
+ */
+typedef struct
+{
+    CARD8  reqType;
+    CARD8  minor_opcode;
+    CARD16 length;
+    CARD32 pad;             /* Maintain quadword alignment */
+} xXTrapReq;
+/* the following works because all fields are defined as bit (Bnn) fields */
+#define sz_xXTrapReq (sizeof(xXTrapReq))
+/* For retrieving version/available info (passes lib-side protocol number) */
+typedef struct
+{
+    CARD8  reqType;
+    CARD8  minor_opcode;
+    CARD16 length;
+    CARD16 protocol;        /* The xtrap extension protocol number */
+    CARD16 pad;             /* Maintain quadword alignment */
+} xXTrapGetReq;
+/* the following works because all fields are defined as bit (Bnn) fields */
+#define sz_xXTrapGetReq (sizeof(xXTrapGetReq))
+
+typedef struct
+{
+    CARD8     reqType;
+    CARD8     minor_opcode;
+    CARD16    length;
+    /*
+     * The following is done so that structure padding wont be
+     * a problem.  The request structure contains a shadow for
+     * the XETrapCfg structure. Since the XETrapCfg also has a
+     * substructure (XETrapFlags) this structure is also shadowed.
+     *
+     * The following are a shadow of the XETrapFlags
+     * structure.
+     */
+    CARD8       config_flags_valid[4L];
+    CARD8       config_flags_data[4L];
+    ReqFlags    config_flags_req;
+    EventFlags  config_flags_event;
+    /* End Shadow (XETrapFlags)*/
+    CARD16      config_max_pkt_size;  /* Max number of bytes in a packet */
+    CARD8       config_cmd_key;       /* Keyboard command_key (KeyCode) */
+/*
+ * cmd_key is intentionally *not* defined KeyCode since it's definition is
+ * ambiguous (int in Intrinsic.h and unsigned char in X.h.
+ */
+    CARD8      config_pad[1L];           /* pad out to a quadword */
+    /* End Shadow (XETrapCfg) */
+    CARD32    pad;      /* Maintain quadword alignment */
+} xXTrapConfigReq;
+/* the following works because all fields are defined as bit (Bnn) fields */
+#define sz_xXTrapConfigReq (sizeof(xXTrapConfigReq))
+
+#ifndef _XINPUT
+typedef struct
+{
+    CARD8            reqType;
+    CARD8            minor_opcode;
+    CARD16           length;
+    CARD32           pad;       /* Maintain quadword alignment */
+    XETrapInputReq   input;
+} xXTrapInputReq;
+/* the following works because all fields are defined as bit (Bnn) fields */
+#define sz_xXTrapInputReq (sizeof(xXTrapInputReq))
+#endif
+
+
+/* The following structures are used by the server extension to send
+ * information and replies to the client.
+ */
+
+/* header for all X replies */
+typedef struct
+{
+    CARD8  type;
+    CARD8  detail;
+    CARD16 sequenceNumber;
+    CARD32 length;
+} XETrapRepHdr;
+
+/* Structure of Get Available Functionality reply */
+typedef struct
+{
+    CARD32  pf_ident;         /* Contains constant identifying the platform */
+    CARD16  xtrap_release;    /* The xtrap extension release number */
+    CARD16  xtrap_version;    /* The xtrap extension version number */
+    CARD16  xtrap_revision;   /* The xtrap extension revision number */
+    CARD16  max_pkt_size;     /* Maximum number of bytes in a packet */
+    CARD8   valid[4];         /* What specific configuration flags are valid */
+    CARD32  major_opcode;     /* The major opcode identifying xtrap */
+    CARD32  event_base;       /* The event value we start at */
+    CARD32  pad0;             /* obsolete field */
+    CARD16  pad1, pad2, pad3; /* obsolete field */
+    CARD16  xtrap_protocol;   /* The xtrap extension protocol number */
+    INT16   cur_x;            /* Current X & Y coord for relative motion */
+    INT16   cur_y;
+} XETrapGetAvailRep;
+
+typedef struct
+{
+    CARD16  xtrap_release;    /* The xtrap extension release number */
+    CARD16  xtrap_version;    /* The xtrap extension version number */
+    CARD16  xtrap_revision;   /* The xtrap extension revision number */
+    CARD16  xtrap_protocol;   /* The xtrap extension protocol number */
+} XETrapGetVersRep;
+
+typedef struct
+{
+    CARD32 last_time;         /* Timestamp of last input time */
+} XETrapGetLastInpTimeRep;
+
+/* Structure of Get Current Configuration Information reply */
+typedef struct
+{
+    CARD8       state_flags[2]; /* Miscellaneous flags, see below #define's */
+    CARD16      pad0;           /* Assure quadword alignment */
+    XETrapCfg   config;         /* Current Config information */
+    CARD32      pad1;
+} XETrapGetCurRep;
+
+/* Mask definitions for the above flags. */
+#define XETrapTrapActive     0L    /* If sending/receiving between client/ext */
+
+/* Structure of Get Statistics Information reply */
+typedef struct
+{
+    CARD32   requests[256L]; /* Array containing request counts if trapped */
+    CARD32   events[XETrapCoreEvents];  /* Array containing event stats */
+#ifndef VECTORED_EVENTS
+    CARD32   pad;            /* Pad out to a quadword */
+#endif
+} XETrapGetStatsRep;
+
+#define PF_Other         0L       /* server not one of the below */
+#define PF_Apollo        10L      /* server on Apollo system */
+#define PF_ATT           20L      /* server on AT&T system */
+#define PF_Cray1         30L      /* server on Cray 1 system */
+#define PF_Cray2         31L      /* server on Cray 2 system */
+#define PF_DECUltrix     40L      /* server on DEC ULTRIX system */
+#define PF_DECVMS        41L      /* server on DEC VMS system */
+#define PF_DECVT1000     42L      /* server on DEC-VT1000-terminal */
+#define PF_DECXTerm      43L      /* server on DEC-X-terminal */
+#define PF_DECELN	 44L      /* server on DEC VAXELN X terminal */
+#define PF_DECOSF1       45L      /* server on DEC's OSF/1 system */
+#define PF_HP9000s800    50L      /* server on HP 9000/800 system */
+#define PF_HP9000s300    51L      /* server on HP 9000/300 system */
+#define PF_IBMAT         60L      /* server on IBM/AT system */
+#define PF_IBMRT         61L      /* server on IBM/RT system */
+#define PF_IBMPS2        62L      /* server on IBM/PS2 system */
+#define PF_IBMRS         63L      /* server on IBM/RS system */
+#define PF_MacII         70L      /* server on Mac II system */
+#define PF_Pegasus       80L      /* server on Tektronix Pegasus system */
+#define PF_SGI           90L      /* server on Silicon Graphcis system */
+#define PF_Sony          100L     /* server on Sony system */
+#define PF_Sun3          110L     /* server on Sun 3 system */
+#define PF_Sun386i       111L     /* server on Sun 386i system */
+#define PF_SunSparc      112L     /* server on Sun Sparc system */
+
+/* reply sent back by XETrapGetAvailable request */
+typedef struct
+{
+    XETrapRepHdr       hdr;
+    XETrapGetAvailRep  data;
+} xXTrapGetAvailReply;
+/* the following works because all fields are defined as bit (Bnn) fields */
+#define sz_xXTrapGetAvailReply  sizeof(xXTrapGetAvailReply)
+
+/* reply sent back by XETrapGetVersion request */
+typedef struct
+{
+    XETrapRepHdr       hdr;
+    XETrapGetVersRep  data;
+    CARD32 pad0;        /* pad out to 32 bytes */
+    CARD32 pad1;
+    CARD32 pad2;
+    CARD32 pad3;
+} xXTrapGetVersReply;
+/* the following works because all fields are defined as bit (Bnn) fields */
+#define sz_xXTrapGetVersReply  sizeof(xXTrapGetVersReply)
+
+/* reply sent back by XETrapGetLastInpTime request */
+typedef struct
+{
+    XETrapRepHdr            hdr;
+    /*
+     * The following is a shadow of the XETrapGetLastInpTimeRep
+     * structure.  This is done to avoid structure padding.
+     */
+    CARD32 data_last_time;    /* Timestamp of last input time */
+    CARD32 pad0;              /* pad out to 32 bytes */
+    CARD32 pad1;
+    CARD32 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+} xXTrapGetLITimReply;
+/* the following works because all fields are defined as bit (Bnn) fields */
+#define sz_xXTrapGetLITimReply  sizeof(xXTrapGetLITimReply)
+
+/* reply sent back by XETrapGetCurrent request */
+typedef struct
+{
+    XETrapRepHdr     hdr;
+    /*
+     * The following is a shadow of the XETrapGetCurRep
+     * structure.  This is done to avoid structure padding.
+     * Since the XETrapGetCurRep structure contains a sub-structure
+     * (XETrapCfg) there is a shadow for that as well.*/
+    CARD8       data_state_flags[2]; /* Misc flags, see below #define's */
+    CARD16      data_pad0;           /* Assure quadword alignment */
+    /* XETrapCfg Shadow Starts */
+    CARD8       data_config_flags_valid[4L];
+    CARD8       data_config_flags_data[4L];
+    ReqFlags    data_config_flags_req;
+    EventFlags  data_config_flags_event;
+    CARD16      data_config_max_pkt_size;  /* Max num of bytes in a pkt */
+    CARD8       data_config_cmd_key;       /* Keyboard cmd_key (KeyCode) */
+/*
+ * cmd_key is intentionally *not* defined KeyCode since it's definition is
+ * ambiguous (int in Intrinsic.h and unsigned char in X.h.
+ */
+    CARD8      data_config_pad[1L];           /* pad out to a quadword */
+    /* End Shadow (XETrapCfg) */
+    CARD32      pad1;
+} xXTrapGetCurReply;
+/* the following works because all fields are defined as bit (Bnn) fields */
+#define sz_xXTrapGetCurReply  sizeof(xXTrapGetCurReply)
+
+/* reply sent back by XETrapGetStatistics request */
+/* Note:
+ * The following does *not* use the standard XETrapRepHdr, but instead
+ * one which is padded out to 32-bytes.  This is because Cray's have a problem
+ * reading arrays of CARD32s without using the _Read32 macro (see XERqsts.c).
+ * This requires that none of the data be in the _Reply area.
+ */
+typedef struct
+{
+    CARD8  type;
+    CARD8  detail;
+    CARD16 sequenceNumber;
+    CARD32 length;
+    CARD32 pad0;
+    CARD32 pad1;
+    CARD32 pad2;
+    CARD32 pad3;
+    CARD32 pad4;
+    CARD32 pad5;
+    XETrapGetStatsRep  data;
+} xXTrapGetStatsReply;
+#define sz_xXTrapGetStatsReply  1088
+
+typedef struct /* the XTrap Output header (for output from ext to client) */
+{   /* this must be quadword aligned for portability */
+    CARD32   count;               /* Length including this header */
+    CARD32   timestamp;           /* timestamp if desired */
+    CARD8    type;                /* event id, request id, special id */
+    CARD8    screen;              /* screen number (0 to n) */
+    INT16    win_x;               /* X coord of drawable, if any */
+    INT16    win_y;               /* X coord of drawable, if any */
+    CARD16   client;              /* to distinguish requests */
+} XETrapHeader;
+/* the following works because all fields are defined as bit (Bnn) fields */
+#define sz_XETrapHeader   sizeof(XETrapHeader)
+
+#define XETrapHeaderIsEvent(phdr)       (XETrapGetHeaderType(phdr) == 0x1L)
+#define XETrapHeaderIsRequest(phdr)     (XETrapGetHeaderType(phdr) == 0x2L)
+#define XETrapHeaderIsSpecial(phdr)     (XETrapGetHeaderType(phdr) == 0x3L)
+#define XETrapHeaderIsCursor(phdr)      (XETrapGetHeaderType(phdr) == 0x4L)
+#define XETrapHeaderIsReply(phdr)       (XETrapGetHeaderType(phdr) == 0x5L)
+
+/* Define a structure used for reading/writing datum of type XTrap */
+typedef struct
+{
+    XETrapHeader hdr;
+    union
+    {
+        xEvent          event;
+        xResourceReq    req;
+        xGenericReply   reply;
+        /* special? */
+    } u;
+} XETrapDatum;
+
+/* this doesn't get picked up for VMS server builds (different Xproto.h) */
+#ifndef sz_xEvent
+#define sz_xEvent 32
+#endif
+/* Minimum size of a packet from the server extension */
+#define XETrapMinPktSize    (SIZEOF(XETrapHeader) + SIZEOF(xEvent))
+
+/* Constants used with the XLIB transport */
+#define XETrapDataStart      0L    /* Used in the detail field */
+#define XETrapDataContinued  1L    /* Used in the detail field */
+#define XETrapDataLast       2L    /* Used in the detail field */
+#define XETrapData           0L    /* Used in the type field */
+#define XETrapNumberEvents   1L
+/* This is the representation on the wire(see also XLib.h) */
+#define sz_EventData         24L   /* 32 bytes - type, detail, seq, index */
+typedef struct {
+    CARD8  type;
+    CARD8  detail;
+    CARD16 sequenceNumber;
+    CARD32 idx;
+    CARD8  data[sz_EventData];
+} xETrapDataEvent;
+
+/* Error message indexes added to X for extension */
+#define BadIO               2L      /* Can't read/write */
+#define BadStatistics       4L      /* Stat's not avail. */
+#define BadDevices          5L      /* Devices not vectored */
+#define BadScreen           7L      /* Can't send event to given screen */
+#define BadSwapReq          8L      /* Can't send swapped extension requests */
+#define XETrapNumErrors     (BadSwapReq + 1)
+
+
+#define XEKeyIsClear       0
+#define XEKeyIsEcho        1
+#define XEKeyIsOther       2
+
+#endif /* __XTRAPDI__ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xtrapemacros.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtrapemacros.h
new file mode 100644
index 0000000..89c8f63
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtrapemacros.h
@@ -0,0 +1,387 @@
+/* $XFree86: xc/include/extensions/xtrapemacros.h,v 1.1 2001/11/02 23:29:26 dawes Exp $ */
+#ifndef __XTRAPEMACROS__
+#define __XTRAPEMACROS__ "@(#)xtrapemacros.h	1.9 - 90/09/18  "
+
+/*****************************************************************************
+Copyright 1987, 1988, 1989, 1990, 1991, 1994 by Digital Equipment Corp.,
+Maynard, MA
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+*****************************************************************************/
+/*
+ *
+ *  CONTRIBUTORS:
+ *
+ *      Dick Annicchiarico
+ *      Robert Chesler
+ *      Dan Coutu
+ *      Gene Durso
+ *      Marc Evans
+ *      Alan Jamison
+ *      Mark Henry
+ *      Ken Miller
+ *
+ *  DESCRIPTION:
+ *      This include file is designed to provide the *visible*
+ *      interface to XTrap data structures.  Fields can be set
+ *      using these macros by client programs unless otherwise
+ *      specified; however, use of Trap Context convenience
+ *      routines is strongly encouraged (XETrapContext.c)
+ */
+#include <X11/extensions/xtrapbits.h>
+#include <signal.h>
+
+/* msleep macro to replace msleep() for portability reasons */
+#define msleep(m)   usleep((m)*1000)
+
+/* Copying TC's assumes that the new TC must be created */
+#define XECopyTC(src,mask,dest) \
+    (dest = XECreateTC(((src)->dpy), (mask), (&((src)->values))))
+
+/* Expands to SET each element of the TCValues structure
+ * Returns the TCValues Mask so that the Set can be entered
+ * as an argument to the XEChangeTC() routine call
+ */
+/* Note: req_cb & evt_cb would only be used if you wanted to
+ *       *share* callbacks between Trap Contexts.  Normally,
+ *       XEAddRequestCB() and XEAddEventCB() would be used.
+ */
+#define XETrapSetCfgReqCB(tcv,x)      ((tcv)->req_cb = (x))
+#define XETrapSetCfgEvtCB(tcv,x)      ((tcv)->evt_cb = (x))
+#define XETrapSetCfgMaxPktSize(tcv,x) ((tcv)->v.max_pkt_size = (x))
+#define XETrapSetCfgCmdKey(tcv,x)     ((tcv)->v.cmd_key = (x))
+/* Note: e is only pertinent for "valid" or "data" */
+#define XETrapSetCfgFlags(tcv,e,a)    \
+    memcpy((tcv)->v.flags.e, (a), sizeof((tcv)->v.flags.e))
+#define XETrapSetCfgFlagTimestamp(tcv,e,x) \
+    BitSet((tcv)->v.flags.e, XETrapTimestamp, (x))
+#define XETrapSetCfgFlagCmd(tcv,e,x) \
+    BitSet((tcv)->v.flags.e, XETrapCmd, (x))
+#define XETrapSetCfgFlagCmdKeyMod(tcv,e,x) \
+    BitSet((tcv)->v.flags.e, XETrapCmdKeyMod, (x))
+#define XETrapSetCfgFlagRequest(tcv,e,x) \
+    BitSet((tcv)->v.flags.e, XETrapRequest, (x))
+#define XETrapSetCfgFlagEvent(tcv,e,x) \
+    BitSet((tcv)->v.flags.e, XETrapEvent, (x))
+#define XETrapSetCfgFlagMaxPacket(tcv,e,x) \
+    BitSet((tcv)->v.flags.e, XETrapMaxPacket, (x))
+#define XETrapSetCfgFlagStatistics(tcv,e,x) \
+    BitSet((tcv)->v.flags.e, XETrapStatistics, (x))
+#define XETrapSetCfgFlagWinXY(tcv,e,x) \
+    BitSet((tcv)->v.flags.e, XETrapWinXY, (x))
+#define XETrapSetCfgFlagCursor(tcv,e,x) \
+    BitSet((tcv)->v.flags.e, XETrapCursor, (x))
+#define XETrapSetCfgFlagReq(tcv,request,x) \
+    BitSet((tcv)->v.flags.req, (request), (x))
+#define XETrapSetCfgFlagXInput(tcv,e,x) \
+    BitSet((tcv)->v.flags.e, XETrapXInput, (x))
+#define XETrapSetCfgFlagColorReplies(tcv,e,x) \
+    BitSet((tcv)->v.flags.e, XETrapColorReplies, (x))
+#define XETrapSetCfgFlagGrabServer(tcv,e,x) \
+    BitSet((tcv)->v.flags.e, XETrapGrabServer, (x))
+#define XETrapSetCfgFlagEvt(tcv,evt,x) \
+    BitSet((tcv)->v.flags.event, (evt), (x))
+
+#define XETrapSetValFlagDeltaTimes(tcv,x) \
+    BitSet((tcv)->tc_flags, XETCDeltaTimes, (x))
+
+/* Fields returned in the "GetAvailable" request */
+#define XETrapGetAvailPFIdent(avail)      ((avail)->pf_ident)
+#define XETrapGetAvailRelease(avail)      ((avail)->xtrap_release)
+#define XETrapGetAvailVersion(avail)      ((avail)->xtrap_version)
+#define XETrapGetAvailRevision(avail)     ((avail)->xtrap_revision)
+#define XETrapGetAvailMaxPktSize(avail)   ((avail)->max_pkt_size)
+#define XETrapGetAvailFlags(avail,a)  \
+    memcpy((a), (avail)->valid, sizeof((avail)->valid))
+#define XETrapGetAvailFlagTimestamp(avail) \
+    (BitValue((avail)->valid, XETrapTimestamp))
+#define XETrapGetAvailFlagCmd(avail) \
+    (BitValue((avail)->valid, XETrapCmd))
+#define XETrapGetAvailFlagCmdKeyMod(avail) \
+    (BitValue((avail)->valid, XETrapCmdKeyMod))
+#define XETrapGetAvailFlagRequest(avail) \
+    (BitValue((avail)->valid, XETrapRequest))
+#define XETrapGetAvailFlagEvent(avail) \
+    (BitValue((avail)->valid, XETrapEvent))
+#define XETrapGetAvailFlagMaxPacket(avail) \
+    (BitValue((avail)->valid, XETrapMaxPacket))
+#define XETrapGetAvailFlagStatistics(avail) \
+    (BitValue((avail)->valid, XETrapStatistics))
+#define XETrapGetAvailFlagWinXY(avail) \
+    (BitValue((avail)->valid, XETrapWinXY))
+#define XETrapGetAvailFlagCursor(avail) \
+    (BitValue((avail)->valid, XETrapCursor))
+#define XETrapGetAvailFlagXInput(avail) \
+    (BitValue((avail)->valid, XETrapXInput))
+#define XETrapGetAvailFlagVecEvt(avail) \
+    (BitValue((avail)->valid, XETrapVectorEvents))
+#define XETrapGetAvailFlagColorReplies(avail) \
+    (BitValue((avail)->valid, XETrapColorReplies))
+#define XETrapGetAvailFlagGrabServer(avail) \
+    (BitValue((avail)->valid, XETrapGrabServer))
+#define XETrapGetAvailOpCode(avail)         ((avail)->major_opcode)
+/* Macro's for creating current request and trap context macros */
+#define XETrapGetCfgMaxPktSize(cfg) ((cfg)->max_pkt_size)
+#define XETrapGetCfgCmdKey(cfg)     ((cfg)->cmd_key)
+#define XETrapGetCfgFlags(cfg,e,a)  \
+    memcpy((a), (cfg)->flags.e, sizeof((cfg)->flags.e))
+#define XETrapGetCfgFlagTimestamp(cfg,e) \
+    (BitValue((cfg)->flags.e, XETrapTimestamp))
+#define XETrapGetCfgFlagCmd(cfg,e) \
+    (BitValue((cfg)->flags.e, XETrapCmd))
+#define XETrapGetCfgFlagCmdKeyMod(cfg,e) \
+    (BitValue((cfg)->flags.e, XETrapCmdKeyMod))
+#define XETrapGetCfgFlagRequest(cfg,e) \
+    (BitValue((cfg)->flags.e, XETrapRequest))
+#define XETrapGetCfgFlagEvent(cfg,e) \
+    (BitValue((cfg)->flags.e, XETrapEvent))
+#define XETrapGetCfgFlagMaxPacket(cfg,e) \
+    (BitValue((cfg)->flags.e, XETrapMaxPacket))
+#define XETrapGetCfgFlagStatistics(cfg,e) \
+    (BitValue((cfg)->flags.e, XETrapStatistics))
+#define XETrapGetCfgFlagWinXY(cfg,e) \
+    (BitValue((cfg)->flags.e, XETrapWinXY))
+#define XETrapGetCfgFlagCursor(cfg,e) \
+    (BitValue((cfg)->flags.e, XETrapCursor))
+#define XETrapGetCfgFlagXInput(cfg,e) \
+    (BitValue((cfg)->flags.e, XETrapXInput))
+#define XETrapGetCfgFlagColorReplies(cfg,e) \
+    (BitValue((cfg)->flags.e, XETrapColorReplies))
+#define XETrapGetCfgFlagGrabServer(cfg,e) \
+    (BitValue((cfg)->flags.e, XETrapGrabServer))
+/* Request values are in "Xproto.h" of the flavor X_RequestType */
+#define XETrapGetCfgFlagReq(cfg,request) \
+    (BitValue((cfg)->flags.req, (request)))
+/* Event types are in "X.h" of the flavor EventType (e.g. KeyPress) */
+#define XETrapGetCfgFlagEvt(cfg,evt) \
+    (BitValue((cfg)->flags.event, (evt)))
+
+/* Fields returned int the "GetCurrent" Request */
+#define XETrapGetCurX(avail)              ((avail)->cur_x)
+#define XETrapGetCurY(avail)              ((avail)->cur_y)
+#define XETrapGetCurSFlags(cur,a) \
+    memcpy((a), (cur)->state_flags, sizeof((cur)->state_flags))
+#define XETrapGetCurMaxPktSize(cur) (XETrapGetCfgMaxPktSize(&((cur)->config)))
+#define XETrapGetCurCmdKey(cur)     (XETrapGetCfgCmdKey(&((cur)->config)))
+/* Note: e is only pertinent for "valid" or "data" */
+#define XETrapGetCurCFlags(cur,e,a) (XETrapGetCfgFlags(&((cur)->config),e,a))
+#define XETrapGetCurFlagTimestamp(cur,e) \
+    (XETrapGetCfgFlagTimestamp(&((cur)->config),e))
+#define XETrapGetCurFlagCmd(cur,e)  (XETrapGetCfgFlagCmd(&((cur)->config),e))
+#define XETrapGetCurFlagCmdKeyMod(cur,e) \
+    (XETrapGetCfgFlagCmdKeyMod(&((cur)->config),e))
+#define XETrapGetCurFlagRequest(cur,r) \
+    (XETrapGetCfgFlagRequest(&((cur)->config),r))
+#define XETrapGetCurFlagEvent(cur,e) \
+    (XETrapGetCfgFlagEvent(&((cur)->config),e))
+#define XETrapGetCurFlagMaxPacket(cur,e) \
+    (XETrapGetCfgFlagMaxPacket(&((cur)->config),e))
+#define XETrapGetCurFlagStatistics(cur,e) \
+    (XETrapGetCfgFlagStatistics(&((cur)->config),e))
+#define XETrapGetCurFlagWinXY(cur,e) \
+    (XETrapGetCfgFlagWinXY(&((cur)->config),e))
+#define XETrapGetCurFlagCursor(cur,e) \
+    (XETrapGetCfgFlagCursor(&((cur)->config),e))
+#define XETrapGetCurFlagXInput(cur,e) \
+    (XETrapGetCfgFlagXInput(&((cur)->config),e))
+#define XETrapGetCurFlagColorReplies(cur,e) \
+    (XETrapGetCfgFlagColorReplies(&((cur)->config),e))
+#define XETrapGetCurFlagGrabServer(cur,e) \
+    (XETrapGetCfgFlagGrabServer(&((cur)->config),e))
+/* Request values are in "Xproto.h" of the flavor X_RequestType */
+#define XETrapGetCurFlagReq(cur,r)  (XETrapGetCfgFlagReq(&((cur)->config),r))
+/* Event types are in "X.h" of the flavor EventType (e.g. KeyPress) */
+#define XETrapGetCurFlagEvt(cur,e)  (XETrapGetCfgFlagEvt(&((cur)->config),e))
+
+/* Fields returned int the "GetStatistics" Request */
+#define XETrapGetStatsReq(stat,e)   ((stat)->requests[(e)])
+#define XETrapGetStatsEvt(stat,e)   ((stat)->events[(e)])
+
+/* Fields returned in the "GetVersion" request */
+#define XETrapGetVersRelease(vers)      ((vers)->xtrap_release)
+#define XETrapGetVersVersion(vers)      ((vers)->xtrap_version)
+#define XETrapGetVersRevision(vers)     ((vers)->xtrap_revision)
+
+/* Fields returned in the "GetLastInpTime" request */
+#define XETrapGetLastInpTime(time_rep)      ((time_rep)->last_time)
+
+/* Expands to GET each element of the TCValues structure */
+#define XETrapGetTCReqCB(tc)      ((tc)->values.req_cb)
+#define XETrapGetTCEvtCB(tc)      ((tc)->values.evt_cb)
+#define XETrapGetTCTime(tc)       ((tc)->values.last_time)
+/* TC specific flags */
+#define XETrapGetTCLFlags(tc,a)  \
+    memcpy((a), (tc)->values.tc_flags, sizeof((tc)->values.tc_flags))
+#define XETrapGetTCFlagDeltaTimes(tc) \
+    (BitValue((tc)->values.tc_flags, XETCDeltaTimes))
+#define XETrapGetTCFlagTrapActive(tc) \
+    (BitValue((tc)->values.tc_flags, XETCTrapActive))
+#define XETrapGetTCMaxPktSize(tc) (XETrapGetCfgMaxPktSize(&((tc)->values.v)))
+#define XETrapGetTCCmdKey(tc)     (XETrapGetCfgCmdKey(&((tc)->values.v)))
+/* Note: e is only pertinent for "valid" or "data" */
+#define XETrapGetTCFlags(tc,e,a)  (XETrapGetCfgFlags(&((tc)->values.v),e,a))
+#define XETrapGetTCFlagTimestamp(tc,e) \
+    (XETrapGetCfgFlagTimestamp(&((tc)->values.v),e))
+#define XETrapGetTCFlagCmd(tc,e) \
+    (XETrapGetCfgFlagCmd(&((tc)->values.v),e))
+#define XETrapGetTCFlagCmdKeyMod(tc,e) \
+    (XETrapGetCfgFlagCmdKeyMod(&((tc)->values.v),e))
+#define XETrapGetTCFlagRequest(tc,r) \
+    (XETrapGetCfgFlagRequest(&((tc)->values.v),r))
+#define XETrapGetTCFlagEvent(tc,e) \
+    (XETrapGetCfgFlagEvent(&((tc)->values.v),e))
+#define XETrapGetTCFlagMaxPacket(tc,e) \
+    (XETrapGetCfgFlagMaxPacket(&((tc)->values.v),e))
+#define XETrapGetTCFlagStatistics(tc,e) \
+    (XETrapGetCfgFlagStatistics(&((tc)->values.v),e))
+#define XETrapGetTCFlagWinXY(tc,e) \
+    (XETrapGetCfgFlagWinXY(&((tc)->values.v),e))
+#define XETrapGetTCFlagCursor(tc,e) \
+    (XETrapGetCfgFlagCursor(&((tc)->values.v),e))
+#define XETrapGetTCFlagXInput(tc,e) \
+    (XETrapGetCfgFlagXInput(&((tc)->values.v),e))
+#define XETrapGetTCFlagColorReplies(tc,e) \
+    (XETrapGetCfgFlagColorReplies(&((tc)->values.v),e))
+#define XETrapGetTCFlagGrabServer(tc,e) \
+    (XETrapGetCfgFlagGrabServer(&((tc)->values.v),e))
+/* Request values are in "Xproto.h" of the flavor X_RequestType */
+#define XETrapGetTCFlagReq(tc,r) \
+    (XETrapGetCfgFlagReq(&((tc)->values.v),r))
+/* Event types are in "X.h" of the flavor EventType (e.g. KeyPress) */
+#define XETrapGetTCFlagEvt(tc,e) \
+    (XETrapGetCfgFlagEvt(&((tc)->values.v),e))
+/* The following can/should *not* be set directly! */
+#define XETrapGetNext(tc)        ((tc)->next)
+#define XETrapGetDpy(tc)         ((tc)->dpy)
+#define XETrapGetEventBase(tc)   ((tc)->eventBase)
+#define XETrapGetErrorBase(tc)   ((tc)->errorBase)
+#define XETrapGetExtOpcode(tc)   ((tc)->extOpcode)
+#define XETrapGetXBuff(tc)       ((tc)->xbuff)
+#define XETrapGetXMaxSize(tc)    ((tc)->xmax_size)
+#define XETrapGetExt(tc)         ((tc)->ext_data)
+#define XETrapGetDirty(tc)       ((tc)->dirty)
+#define XETrapGetValues(tc)      memcpy((x),(tc)->values,sizeof((tc)->values))
+#define XETrapGetEventFunc(tc)   ((tc)->eventFunc)
+
+#define XETrapGetHeaderCount(phdr)      ((phdr)->count)
+#define XETrapGetHeaderTimestamp(phdr)  ((phdr)->timestamp)
+#define XETrapGetHeaderType(phdr)       ((phdr)->type)
+#define XETrapGetHeaderScreen(phdr)     ((phdr)->screen)
+#define XETrapGetHeaderWindowX(phdr)    ((phdr)->win_x)
+#define XETrapGetHeaderWindowY(phdr)    ((phdr)->win_y)
+#define XETrapGetHeaderClient(phdr)     ((phdr)->client)
+
+#define XEGetRelease(tc)        ((tc)->release)
+#define XEGetVersion(tc)        ((tc)->version)
+#define XEGetRevision(tc)       ((tc)->revision)
+
+/*  Condition handling macros */
+#if !defined(vms) && \
+    (!defined(_InitExceptionHandling) || !defined(_ClearExceptionHandling))
+# ifndef _SetSIGBUSHandling
+#  ifdef SIGBUS
+#   define _SetSIGBUSHandling(rtn)  (void)signal(SIGBUS, rtn)
+#  else
+#   define _SetSIGBUSHandling(rtn)  /* */
+#  endif
+# endif
+# ifndef _SetSIGSEGVHandling
+#  ifdef SIGSEGV
+#   define _SetSIGSEGVHandling(rtn) (void)signal(SIGSEGV, rtn)
+#  else
+#   define _SetSIGSEGVHandling(rtn) /* */
+#  endif
+# endif
+# ifndef _SetSIGFPEHandling
+#  ifdef SIGFPE
+#   define _SetSIGFPEHandling(rtn)  (void)signal(SIGFPE, rtn)
+#  else
+#   define _SetSIGFPEHandling(rtn)  /* */
+#  endif
+# endif
+# ifndef _SetSIGILLHandling
+#  ifdef SIGILL
+#   define _SetSIGILLHandling(rtn)  (void)signal(SIGILL, rtn)
+#  else
+#   define _SetSIGILLHandling(rtn)  /* */
+#  endif
+# endif
+# ifndef _SetSIGSYSHandling
+#  ifdef SIGSYS
+#   define _SetSIGSYSHandling(rtn)  (void)signal(SIGSYS, rtn)
+#  else
+#   define _SetSIGSYSHandling(rtn)  /* */
+#  endif
+# endif
+# ifndef _SetSIGHUPHandling
+#  ifdef SIGHUP
+#   define _SetSIGHUPHandling(rtn)  (void)signal(SIGHUP, rtn)
+#  else
+#   define _SetSIGHUPHandling(rtn)  /* */
+#  endif
+# endif
+# ifndef _SetSIGPIPEHandling
+#  ifdef SIGPIPE
+#   define _SetSIGPIPEHandling(rtn) (void)signal(SIGPIPE, rtn)
+#  else
+#   define _SetSIGPIPEHandling(rtn) /* */
+#  endif
+# endif
+# ifndef _SetSIGTERMHandling
+#  ifdef SIGTERM
+#   define _SetSIGTERMHandling(rtn) (void)signal(SIGTERM, rtn)
+#  else
+#   define _SetSIGTERMHandling(rtn) /* */
+#  endif
+# endif
+#endif
+#ifndef _InitExceptionHandling
+#ifdef vms
+#define _InitExceptionHandling(rtn)                        \
+    VAXC$ESTABLISH(rtn)   /* VMS exception handler */
+#else /* vms */
+#define _InitExceptionHandling(rtn)                           \
+    _SetSIGBUSHandling(rtn);  /* Bus error */                 \
+    _SetSIGSEGVHandling(rtn); /* Accvio/Segment error */      \
+    _SetSIGFPEHandling(rtn);  /* Floating point exception */  \
+    _SetSIGILLHandling(rtn);  /* Illegal instruction */       \
+    _SetSIGSYSHandling(rtn);  /* Param error in sys call */   \
+    _SetSIGHUPHandling(rtn);                                  \
+    _SetSIGPIPEHandling(rtn);                                 \
+    _SetSIGTERMHandling(rtn)
+#endif /* vms */
+#endif /* _InitExceptionHandling */
+
+#ifndef _ClearExceptionHandling
+#ifdef vms
+#define _ClearExceptionHandling() \
+    LIB$REVERT()
+#else
+#define _ClearExceptionHandling() \
+    _SetSIGBUSHandling(SIG_DFL);   /* Bus error */                 \
+    _SetSIGSEGVHandling(SIG_DFL);  /* Accvio/Segment error */      \
+    _SetSIGFPEHandling(SIG_DFL);   /* Floating point exception */  \
+    _SetSIGILLHandling(SIG_DFL);   /* Illegal instruction */       \
+    _SetSIGSYSHandling(SIG_DFL);   /* Param error in sys call */   \
+    _SetSIGHUPHandling(SIG_DFL);                                   \
+    _SetSIGPIPEHandling(SIG_DFL);                                  \
+    _SetSIGTERMHandling(SIG_DFL)
+#endif /* vms */
+#endif /* _ClearExceptionHandling */
+
+#endif /* __XTRAPEMACROS__ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xtraplib.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtraplib.h
new file mode 100644
index 0000000..2694ae2
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtraplib.h
@@ -0,0 +1,133 @@
+/* $XFree86$ */
+#ifndef __XTRAPLIB__
+#define __XTRAPLIB__
+
+
+/*****************************************************************************
+Copyright 1987, 1988, 1989, 1990, 1991, 1994 by Digital Equipment Corp.,
+Maynard, MA
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+*****************************************************************************/
+/*
+ *
+ *  CONTRIBUTORS:
+ *
+ *      Dick Annicchiarico
+ *      Robert Chesler
+ *      Dan Coutu
+ *      Gene Durso
+ *      Marc Evans
+ *      Alan Jamison
+ *      Mark Henry
+ *      Ken Miller
+ *
+ *  DESCRIPTION:
+ *      This header file describes all the structures/constants required
+ *      for interfacing with the client toolkit *except* the common
+ *      client/extension definitions in xtrapdi.h.  Namely, *no* extension-
+ *      only information or client/extension information can be found here.
+ */
+#ifdef SMT
+#define NEED_EVENTS
+#define NEED_REPLIES
+#endif
+#include <X11/Xlib.h>
+#include <X11/Intrinsic.h>
+#include <X11/extensions/xtrapdi.h>
+#include <X11/extensions/xtrapemacros.h>
+
+typedef struct _XETC XETC;
+
+typedef int  (*int_function)(XETC *tc, XETrapDatum *pdatum, BYTE *userp);
+typedef void (*void_function)(XETC *tc, XETrapDatum *pdatum, BYTE *userp);
+
+typedef struct  /* Callback structure */
+{
+    void_function func;
+    BYTE          *data;
+} XETrapCB;
+
+/* Data structure for setting trap context */
+typedef struct
+{
+    CARD8       tc_flags[2L];  /* Toolkit-side specific flags */
+    XETrapCfg   v;             /* XTrap configuration values */
+    XETrapCB    *req_cb;       /* Pointer to Request Callbacks */
+    XETrapCB    *evt_cb;       /* Pointer to Event Callbacks (starting at 2) */
+    CARD32      last_time;     /* Last (delta) timestamp */
+} XETCValues;
+
+    /* bits 0 thru 6 are formerly "families" (now obsolete) */
+#define XETCDeltaTimes             7
+#define XETCTrapActive             8
+    /* bits 9 thru 15 are reserved for future expansion */
+
+/* Values bit masks (used when determining what's dirty */
+#define TCStatistics               (1L<<0L)
+#define TCRequests                 (1L<<1L)
+#define TCEvents                   (1L<<2L)
+#define TCMaxPacket                (1L<<3L)
+#define TCCmdKey                   (1L<<4L)
+#define TCTimeStamps               (1L<<5L)
+#define TCWinXY                    (1L<<6L)
+#define TCXInput                   (1L<<7L)
+#define TCReqCBs                   (1L<<8L)
+#define TCEvtCBs                   (1L<<9L)
+#define TCCursor                   (1L<<10L)
+#define TCColorReplies             (1L<<11L)
+#define TCGrabServer               (1L<<12L)
+
+/* This is the representation we use in the library code for XLib transport */
+typedef struct {
+    int type;
+    unsigned long serial;
+    Bool synthetic;
+    Display *display;
+    int detail;
+    unsigned long idx;
+    unsigned char data[sz_EventData];
+} XETrapDataEvent;
+
+/* Trap Context structure for maintaining XTrap State for client */
+struct _XETC
+{
+    struct _XETC *next;         /* Ptr to next linked-listed TC */
+    Display      *dpy;          /* Display ptr of current TC */
+    INT32        eventBase /*B32*/; /* First event value */
+    INT32        errorBase /*B32*/; /* First error value */
+    INT32        extOpcode /*B32*/; /* Major opcode of the extension */
+    BYTE         *xbuff;        /* Pointer to buffer for XLib Communications */
+    CARD16       xmax_size /*B16*/; /* Max Size of a request */
+    XExtData     *ext_data;     /* hook for extension to hang data */
+    /*
+     *  The following are initialized with the client-side version number
+     *  However, when either a GetAvailable or GetVersion reply is received,
+     *  these values are updated with the *oldest* version numbers.
+     */
+    CARD16       release /*B16*/;   /* The extension release number */
+    CARD16       version /*B16*/;   /* The xtrap extension version number */
+    CARD16       revision /*B16*/;  /* The xtrap extension revision number */
+    CARD16       protocol /*B16*/;  /* The xtrap extension protocol number */
+    unsigned     dirty /*B32*/;     /* cache dirty bits */
+    XETCValues   values;        /* shadow structure of values */
+    Boolean      (*eventFunc[XETrapNumberEvents])(XETrapDataEvent *event, struct _XETC *tc);
+};
+
+
+#endif /* __XTRAPLIB__ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xtraplibp.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtraplibp.h
new file mode 100644
index 0000000..aeb6b31
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtraplibp.h
@@ -0,0 +1,151 @@
+/* $XFree86$ */
+#ifndef __XTRAPLIBP__
+#define __XTRAPLIBP__
+
+
+/*****************************************************************************
+Copyright 1987, 1988, 1989, 1990, 1991, 1994 by Digital Equipment Corp.,
+Maynard, MA
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+*****************************************************************************/
+/*
+ *
+ *  CONTRIBUTORS:
+ *
+ *      Dick Annicchiarico
+ *      Robert Chesler
+ *      Dan Coutu
+ *      Gene Durso
+ *      Marc Evans
+ *      Alan Jamison
+ *      Mark Henry
+ *      Ken Miller
+ *
+ *  DESCRIPTION:
+ *      This header file contains the function prototypes for client/toolkit
+ *      routines sorted by module (globally defined routines *only*).
+ */
+
+#include <X11/Xfuncproto.h>
+
+#include <stdio.h>
+
+_XFUNCPROTOBEGIN
+
+/* XEConTxt.c */
+XETC *XECreateTC (Display *dpy , CARD32 valuemask , XETCValues *value );
+int XEChangeTC (XETC *tc , CARD32 mask , XETCValues *values );
+void XEFreeTC (XETC *tc );
+int XETrapSetMaxPacket (XETC *tc , Bool set_flag , CARD16 size );
+int XETrapSetCommandKey (XETC *tc , Bool set_flag , KeySym cmd_key ,
+    Bool mod_flag );
+int XETrapSetTimestamps (XETC *tc , Bool set_flag , Bool delta_flag );
+int XETrapSetWinXY (XETC *tc , Bool set_flag );
+int XETrapSetCursor (XETC *tc , Bool set_flag );
+int XETrapSetXInput (XETC *tc , Bool set_flag );
+int XETrapSetColorReplies (XETC *tc , Bool set_flag );
+int XETrapSetGrabServer (XETC *tc , Bool set_flag );
+int XETrapSetStatistics (XETC *tc , Bool set_flag );
+int XETrapSetRequests (XETC *tc , Bool set_flag , ReqFlags requests );
+int XETrapSetEvents (XETC *tc , Bool set_flag , EventFlags events );
+Bool XESetCmdGateState (XETC *tc , CARD8 type, Bool *gate_closed ,
+    CARD8 *next_key , Bool *key_ignore );
+
+/* XERqsts.c */
+int XEFlushConfig (XETC *tc );
+int XEResetRequest (XETC *tc );
+int XEGetVersionRequest (XETC *tc , XETrapGetVersRep *ret );
+int XEGetLastInpTimeRequest (XETC *tc , XETrapGetLastInpTimeRep *ret );
+int XEGetAvailableRequest (XETC *tc , XETrapGetAvailRep *ret );
+int XEStartTrapRequest (XETC *tc );
+int XEStopTrapRequest (XETC *tc );
+int XESimulateXEventRequest (XETC *tc , CARD8 type , CARD8 detail ,
+    CARD16 x , CARD16 y , CARD8 screen );
+int XEGetCurrentRequest (XETC *tc , XETrapGetCurRep *ret );
+int XEGetStatisticsRequest (XETC *tc , XETrapGetStatsRep *ret );
+
+/* XECallBcks.c */
+int XEAddRequestCB (XETC *tc , CARD8 req , void_function func , BYTE *data );
+int XEAddRequestCBs (XETC *tc , ReqFlags req_flags , void_function func ,
+    BYTE *data );
+int XEAddEventCB (XETC *tc , CARD8 evt , void_function func , BYTE *data );
+int XEAddEventCBs (XETC *tc , EventFlags evt_flags , void_function func ,
+    BYTE *data );
+
+/* The following seem to never be used.  Perhaps they should be removed */
+void XERemoveRequestCB (XETC *tc, CARD8 req);
+void XERemoveRequestCBs (XETC *tc, ReqFlags req_flags);
+void XERemoveAllRequestCBs (XETC *tc);
+void XERemoveEventCB (XETC *tc, CARD8 evt);
+void XERemoveEventCBs (XETC *tc, EventFlags evt_flags);
+void XERemoveAllEventCBs (XETC *tc);
+
+
+/* XEDsptch.c */
+Boolean XETrapDispatchXLib (XETrapDataEvent *event , XETC *tc);
+
+/* XEWrappers.c */
+Boolean XETrapDispatchEvent (XEvent *pevent , XETC *tc );
+XtInputMask XETrapAppPending (XtAppContext app);
+void XETrapAppMainLoop (XtAppContext app , XETC *tc );
+int XETrapAppWhileLoop (XtAppContext app , XETC *tc , Bool *done );
+int XETrapWaitForSomething (XtAppContext app );
+Boolean (*XETrapGetEventHandler(XETC *tc, CARD32 id))(XETrapDataEvent *event, XETC *tc);
+Boolean (*XETrapSetEventHandler(XETC *tc, CARD32 id, Boolean (*pfunc)(XETrapDataEvent *event, XETC *tc))) (XETrapDataEvent *event, XETC *tc);
+
+/* XEPrInfo.c */
+void XEPrintRelease (FILE *ofp , XETrapGetAvailRep *pavail );
+void XEPrintTkRelease ( FILE *ofp, XETC *tc);
+void XEPrintPlatform (FILE *ofp , XETrapGetAvailRep *pavail );
+void XEPrintAvailFlags (FILE *ofp , XETrapGetAvailRep *pavail );
+void XEPrintAvailPktSz (FILE *ofp , XETrapGetAvailRep *pavail );
+void XEPrintStateFlags (FILE *ofp , XETrapGetCurRep *pcur );
+void XEPrintMajOpcode (FILE *ofp , XETrapGetAvailRep *pavail );
+void XEPrintCurXY (FILE *ofp , XETrapGetAvailRep *pavail );
+void XEPrintTkFlags (FILE *ofp , XETC *tc );
+void XEPrintLastTime (FILE *ofp , XETC *tc );
+void XEPrintCfgFlags (FILE *ofp , XETrapGetCurRep *pcur );
+void XEPrintRequests (FILE *ofp , XETrapGetCurRep *pcur );
+void XEPrintEvents (FILE *ofp , XETrapGetCurRep *pcur );
+void XEPrintCurPktSz (FILE *ofp , XETrapGetCurRep *pcur );
+void XEPrintCmdKey (FILE *ofp , XETrapGetCurRep *pcur );
+void XEPrintEvtStats (FILE *ofp , XETrapGetStatsRep *pstats , XETC *tc);
+void XEPrintReqStats (FILE *ofp , XETrapGetStatsRep *pstats , XETC *tc);
+void XEPrintAvail (FILE *ofp , XETrapGetAvailRep *pavail );
+void XEPrintTkState (FILE *ofp , XETC *tc );
+void XEPrintCurrent (FILE *ofp , XETrapGetCurRep *pcur );
+void XEPrintStatistics (FILE *ofp , XETrapGetStatsRep *pstats, XETC *tc );
+
+/* XEStrMap.c */
+INT16 XEEventStringToID (char *string );
+INT16 XERequestStringToID (char *string );
+CARD32 XEPlatformStringToID (char *string );
+char *XEEventIDToString (CARD8 id , XETC *tc);
+char *XERequestIDToExtString (register CARD8 id , XETC *tc);
+char *XERequestIDToString (CARD8 id , XETC *tc);
+char *XEPlatformIDToString (CARD32 id );
+
+/* XETrapInit.c */
+Bool XETrapQueryExtension (Display *dpy,INT32 *event_base_return,
+			  INT32 *error_base_return, INT32 *opcode_return);
+
+
+_XFUNCPROTOEND
+
+#endif /* __XTRAPLIBP__ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xtrapproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtrapproto.h
new file mode 100644
index 0000000..49614fd
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xtrapproto.h
@@ -0,0 +1,168 @@
+/* $XFree86: xc/include/extensions/xtrapproto.h,v 1.1 2001/11/02 23:29:26 dawes Exp $ */
+
+#ifndef __XTRAPPROTO__
+#define __XTRAPPROTO__
+
+/*****************************************************************************
+Copyright 1987, 1988, 1989, 1990, 1991 by Digital Equipment Corp., Maynard, MA
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+*****************************************************************************/
+/*
+ *
+ *  CONTRIBUTORS:
+ *
+ *      Dick Annicchiarico
+ *      Robert Chesler
+ *      Dan Coutu
+ *      Gene Durso
+ *      Marc Evans
+ *      Alan Jamison
+ *      Mark Henry
+ *      Ken Miller
+ *
+ *  DESCRIPTION:
+ *      This header file contains the function prototypes for extension
+ *      routines sorted by module (globally defined routines *only*).
+ */
+#ifndef Bool
+# define Bool int
+#endif
+/* xtrapdi.c */
+int XETrapDestroyEnv (pointer value , XID id );
+void XETrapCloseDown ( ExtensionEntry *extEntry );
+Bool XETrapRedirectDevices (void );
+void DEC_XTRAPInit (void );
+int XETrapCreateEnv (ClientPtr client );
+int XETrapDispatch (ClientPtr client );
+int sXETrapDispatch (ClientPtr client );
+int XETrapReset (xXTrapReq *request , ClientPtr client );
+int XETrapGetAvailable (xXTrapGetReq *request , ClientPtr client );
+int XETrapGetCurrent (xXTrapReq *request , ClientPtr client );
+int XETrapGetStatistics (xXTrapReq *request , ClientPtr client );
+int XETrapConfig (xXTrapConfigReq *request , ClientPtr client );
+int XETrapStartTrap (xXTrapReq *request , ClientPtr client );
+int XETrapStopTrap (xXTrapReq *request , ClientPtr client );
+int XETrapGetVersion (xXTrapGetReq *request , ClientPtr client );
+int XETrapGetLastInpTime (xXTrapReq *request , ClientPtr client );
+int XETrapRequestVector (ClientPtr client );
+int XETrapKeyboard (xEvent *x_event , DevicePtr keybd , int count );
+#ifndef VECTORED_EVENTS
+int XETrapPointer (xEvent *x_event , DevicePtr ptrdev , int count );
+#else
+int XETrapEventVector (ClientPtr client , xEvent *x_event );
+#endif
+void XETrapStampAndMail (xEvent *x_event );
+void sReplyXTrapDispatch (ClientPtr client , int size , char *reply );
+int XETrapWriteXLib (XETrapEnv *penv , BYTE *data , CARD32 nbytes );
+
+/* xtrapddmi.c */
+void XETrapPlatformSetup (void );
+int XETrapSimulateXEvent (xXTrapInputReq *request , ClientPtr client );
+
+/* xtrapdiswap.c */
+int sXETrapReset (xXTrapReq *request , ClientPtr client );
+int sXETrapGetAvailable (xXTrapGetReq *request , ClientPtr client );
+int sXETrapConfig (xXTrapConfigReq *request , ClientPtr client );
+int sXETrapStartTrap (xXTrapReq *request , ClientPtr client );
+int sXETrapStopTrap (xXTrapReq *request , ClientPtr client );
+int sXETrapGetCurrent (xXTrapReq *request , ClientPtr client );
+int sXETrapGetStatistics (xXTrapReq *request , ClientPtr client );
+int sXETrapSimulateXEvent (xXTrapInputReq *request , ClientPtr client );
+int sXETrapGetVersion (xXTrapGetReq *request , ClientPtr client );
+int sXETrapGetLastInpTime (xXTrapReq *request , ClientPtr client );
+void sReplyXETrapGetAvail (ClientPtr client , int size , char *reply );
+void sReplyXETrapGetVers (ClientPtr client , int size , char *reply );
+void sReplyXETrapGetLITim (ClientPtr client , int size , char *reply );
+void sReplyXETrapGetCur (ClientPtr client , int size , char *reply );
+void sReplyXETrapGetStats (ClientPtr client , int size , char *reply );
+void sXETrapHeader (XETrapHeader *hdr );
+void XETSwSimpleReq (xReq *data );
+void XETSwResourceReq (xResourceReq *data );
+void XETSwCreateWindow (xCreateWindowReq *data , ClientPtr client );
+void XETSwChangeWindowAttributes (xChangeWindowAttributesReq *data , ClientPtr client );
+void XETSwReparentWindow (xReparentWindowReq *data );
+void XETSwConfigureWindow (xConfigureWindowReq *data  , ClientPtr client );
+void XETSwInternAtom (xInternAtomReq *data );
+void XETSwChangeProperty (xChangePropertyReq *data );
+void XETSwDeleteProperty (xDeletePropertyReq *data );
+void XETSwGetProperty (xGetPropertyReq *data );
+void XETSwSetSelectionOwner (xSetSelectionOwnerReq *data );
+void XETSwConvertSelection (xConvertSelectionReq *data );
+void XETSwSendEvent (xSendEventReq *data );
+void XETSwGrabPointer (xGrabPointerReq *data );
+void XETSwGrabButton (xGrabButtonReq *data );
+void XETSwUngrabButton (xUngrabButtonReq *data );
+void XETSwChangeActivePointerGrab (xChangeActivePointerGrabReq *data );
+void XETSwGrabKeyboard (xGrabKeyboardReq *data );
+void XETSwGrabKey (xGrabKeyReq *data );
+void XETSwUngrabKey (xUngrabKeyReq *data );
+void XETSwGetMotionEvents (xGetMotionEventsReq *data );
+void XETSwTranslateCoords (xTranslateCoordsReq *data );
+void XETSwWarpPointer (xWarpPointerReq *data );
+void XETSwSetInputFocus (xSetInputFocusReq *data );
+void XETSwOpenFont (xOpenFontReq *data );
+void XETSwListFonts (xListFontsReq *data );
+void XETSwListFontsWithInfo (xListFontsWithInfoReq *data );
+void XETSwSetFontPath (xSetFontPathReq *data );
+void XETSwCreatePixmap (xCreatePixmapReq *data );
+void XETSwCreateGC (xCreateGCReq *data , ClientPtr client );
+void XETSwChangeGC (xChangeGCReq *data , ClientPtr client );
+void XETSwCopyGC (xCopyGCReq *data );
+void XETSwSetDashes (xSetDashesReq *data );
+void XETSwSetClipRectangles (xSetClipRectanglesReq *data , ClientPtr client );
+void XETSwClearToBackground (xClearAreaReq *data );
+void XETSwCopyArea (xCopyAreaReq *data );
+void XETSwCopyPlane (xCopyPlaneReq *data );
+void XETSwPoly (xPolyPointReq *data , ClientPtr client );
+void XETSwFillPoly (xFillPolyReq *data , ClientPtr client );
+void XETSwPutImage (xPutImageReq *data );
+void XETSwGetImage (xGetImageReq *data );
+void XETSwPolyText (xPolyTextReq *data );
+void XETSwImageText (xImageTextReq *data );
+void XETSwCreateColormap (xCreateColormapReq *data );
+void XETSwCopyColormapAndFree (xCopyColormapAndFreeReq *data );
+void XETSwAllocColor (xAllocColorReq *data );
+void XETSwAllocNamedColor (xAllocNamedColorReq *data );
+void XETSwAllocColorCells (xAllocColorCellsReq *data );
+void XETSwAllocColorPlanes (xAllocColorPlanesReq *data );
+void XETSwFreeColors (xFreeColorsReq *data , ClientPtr client );
+void XETSwStoreColors (xStoreColorsReq *data , ClientPtr client );
+void XETSwStoreNamedColor (xStoreNamedColorReq *data );
+void XETSwQueryColors (xQueryColorsReq *data , ClientPtr client );
+void XETSwLookupColor (xLookupColorReq *data );
+void XETSwCreateCursor (xCreateCursorReq *data );
+void XETSwCreateGlyphCursor (xCreateGlyphCursorReq *data );
+void XETSwRecolorCursor (xRecolorCursorReq *data );
+void XETSwQueryBestSize (xQueryBestSizeReq *data );
+void XETSwQueryExtension (xQueryExtensionReq *data );
+void XETSwChangeKeyboardMapping (xChangeKeyboardMappingReq *data );
+void XETSwChangeKeyboardControl (xChangeKeyboardControlReq *data , ClientPtr client );
+void XETSwChangePointerControl (xChangePointerControlReq *data );
+void XETSwSetScreenSaver (xSetScreenSaverReq *data );
+void XETSwChangeHosts (xChangeHostsReq *data );
+void XETSwRotateProperties (xRotatePropertiesReq *data , ClientPtr client );
+void XETSwNoOperation (xReq *data );
+#ifdef vms
+void SwapLongs (long *list , unsigned long count );
+void SwapShorts (short *list , unsigned long count );
+int SwapColorItem (xColorItem *pItem );
+#endif /* vms */
+
+
+#endif /* __XTRAPPROTO__ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/extensions/xwaylandproto.h b/depends/libxcb/depends/xorgproto/include/X11/extensions/xwaylandproto.h
new file mode 100644
index 0000000..49f048d
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/extensions/xwaylandproto.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright © 2022 Red Hat, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no representations
+ * about the suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#ifndef _XWAYLAND_PROTO_H_
+#define _XWAYLAND_PROTO_H_
+
+#include <X11/Xproto.h>
+
+#define XWAYLAND_EXTENSION_NAME		"XWAYLAND"
+#define XWAYLAND_EXTENSION_MAJOR	1
+#define XWAYLAND_EXTENSION_MINOR	0
+
+/* Request opcodes */
+#define X_XwlQueryVersion		0
+
+#define XwlNumberRequests		1
+#define XwlNumberErrors			0
+#define XwlNumberEvents			0
+
+typedef struct {
+    CARD8   reqType;
+    CARD8   xwlReqType;
+    CARD16  length;
+    CARD16  majorVersion;
+    CARD16  minorVersion;
+} xXwlQueryVersionReq;
+#define sz_xXwlQueryVersionReq		8
+
+typedef struct {
+    BYTE    type;   /* X_Reply */
+    BYTE    pad1;
+    CARD16  sequenceNumber;
+    CARD32  length;
+    CARD16  majorVersion;
+    CARD16  minorVersion;
+    CARD32  pad2;
+    CARD32  pad3;
+    CARD32  pad4;
+    CARD32  pad5;
+    CARD32  pad6;
+} xXwlQueryVersionReply;
+#define sz_xXwlQueryVersionReply	32
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/fonts/FS.h b/depends/libxcb/depends/xorgproto/include/X11/fonts/FS.h
new file mode 100644
index 0000000..fa4ff80
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/fonts/FS.h
@@ -0,0 +1,129 @@
+/*
+ * Copyright 1990, 1991 Network Computing Devices;
+ * Portions Copyright 1987 by Digital Equipment Corporation
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and
+ * its documentation for any purpose is hereby granted without fee, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the names of Network Computing Devices or Digital
+ * not be used in advertising or publicity pertaining to distribution
+ * of the software without specific, written prior permission.
+ * Network Computing Devices and Digital make no representations
+ * about the suitability of this software for any purpose.  It is provided
+ * "as is" without express or implied warranty.
+ *
+ * NETWORK COMPUTING DEVICES AND DIGITAL DISCLAIM ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES
+ * OR DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+ * THIS SOFTWARE.
+ */
+
+/*
+
+Portions Copyright 1987, 1994, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+#ifndef _FS_H_
+#define	_FS_H_
+
+#include <X11/Xdefs.h>
+#include <X11/fonts/fsmasks.h>
+
+#define	FS_PROTOCOL		2
+#define	FS_PROTOCOL_MINOR	0
+
+#ifndef X_PROTOCOL
+/* protocol families */
+#define FamilyInternet          0
+#define FamilyDECnet            1
+#define FamilyChaos             2
+#define FamilyInternet6         6
+
+
+typedef unsigned int    FSDrawDirection;
+#endif
+
+#ifndef None
+#define	None		0L
+#endif
+
+#define	LeftToRightDrawDirection	0
+#define	RightToLeftDrawDirection	1
+
+/* font info flags */
+#define	FontInfoAllCharsExist		(1L << 0)
+#define	FontInfoInkInside		(1L << 1)
+#define	FontInfoHorizontalOverlap	(1L << 2)
+
+/* auth status flags */
+#define	AuthSuccess	0
+#define	AuthContinue	1
+#define	AuthBusy	2
+#define	AuthDenied	3
+
+/* property types */
+#define	PropTypeString		0
+#define	PropTypeUnsigned	1
+#define	PropTypeSigned		2
+
+#ifndef LSBFirst
+/* byte order */
+#define LSBFirst                0
+#define MSBFirst                1
+#endif
+
+/* event masks */
+#define	CatalogueChangeNotifyMask	(1L << 0)
+#define	FontChangeNotifyMask		(1L << 1)
+
+/* errors */
+#define	FSSuccess		-1
+#define	FSBadRequest		0
+#define	FSBadFormat		1
+#define	FSBadFont		2
+#define	FSBadRange		3
+#define	FSBadEventMask		4
+#define	FSBadAccessContext	5
+#define	FSBadIDChoice		6
+#define	FSBadName		7
+#define	FSBadResolution		8
+#define	FSBadAlloc		9
+#define	FSBadLength		10
+#define	FSBadImplementation	11
+
+#define	FirstExtensionError	128
+#define	LastExtensionError	255
+
+/* events */
+#define	KeepAlive		0
+#define	CatalogueChangeNotify	1
+#define	FontChangeNotify	2
+#define FSLASTEvent		3
+
+#endif				/* _FS_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/fonts/FSproto.h b/depends/libxcb/depends/xorgproto/include/X11/fonts/FSproto.h
new file mode 100644
index 0000000..3cdb834
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/fonts/FSproto.h
@@ -0,0 +1,814 @@
+/*
+
+Copyright 1990, 1991, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+ * Copyright 1990, 1991 Network Computing Devices;
+ * Portions Copyright 1987 by Digital Equipment Corporation
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and
+ * its documentation for any purpose is hereby granted without fee, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the names of Network Computing Devices, or Digital
+ * not be used in advertising or publicity pertaining to distribution
+ * of the software without specific, written prior permission.
+ *
+ * NETWORK COMPUTING DEVICES, AND DIGITAL DISCLAIM ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES,
+ * OR DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+ * THIS SOFTWARE.
+ */
+
+#ifndef _FS_PROTO_H_
+#define _FS_PROTO_H_
+
+#include <X11/fonts/FS.h>
+
+#define sz_fsPropOffset 20
+#define sz_fsPropInfo 8
+#define sz_fsResolution 6
+
+#define sz_fsChar2b 2
+#define sz_fsChar2b_version1 2
+#define sz_fsOffset32 8
+#define sz_fsRange		4
+
+#define	sz_fsXCharInfo		12
+#define	sz_fsXFontInfoHeader		40
+
+#define	sz_fsConnClientPrefix	8
+#define	sz_fsConnSetup		12
+#define	sz_fsConnSetupExtra	8
+#define	sz_fsConnSetupAccept	12
+
+/* request sizes */
+#define	sz_fsReq		4
+#define	sz_fsListExtensionsReq	4
+#define	sz_fsResourceReq	8
+
+#define	sz_fsNoopReq			4
+#define	sz_fsListExtensionReq		4
+#define	sz_fsQueryExtensionReq		4
+#define	sz_fsListCataloguesReq		12
+#define	sz_fsSetCataloguesReq		4
+#define	sz_fsGetCataloguesReq		4
+#define	sz_fsSetEventMaskReq		8
+#define	sz_fsGetEventMaskReq		4
+#define	sz_fsCreateACReq		8
+#define	sz_fsFreeACReq			8
+#define	sz_fsSetAuthorizationReq	8
+#define	sz_fsSetResolutionReq		4
+#define	sz_fsGetResolutionReq		4
+#define	sz_fsListFontsReq		12
+#define	sz_fsListFontsWithXInfoReq	12
+#define	sz_fsOpenBitmapFontReq		16
+#define	sz_fsQueryXInfoReq		8
+#define	sz_fsQueryXExtents8Req		12
+#define	sz_fsQueryXExtents16Req		12
+#define	sz_fsQueryXBitmaps8Req		16
+#define	sz_fsQueryXBitmaps16Req		16
+#define	sz_fsCloseReq			8
+
+/* reply sizes */
+#define	sz_fsReply			8
+#define	sz_fsGenericReply		8
+
+#define	sz_fsListExtensionsReply	8
+#define	sz_fsQueryExtensionReply	20
+#define	sz_fsListCataloguesReply	16
+#define	sz_fsGetCataloguesReply		8
+#define	sz_fsGetEventMaskReply		12
+#define	sz_fsCreateACReply		12
+#define	sz_fsGetResolutionReply		8
+#define	sz_fsListFontsReply		16
+#define	sz_fsListFontsWithXInfoReply	(12 + sz_fsXFontInfoHeader)
+#define	sz_fsOpenBitmapFontReply	16
+#define	sz_fsQueryXInfoReply		(8 + sz_fsXFontInfoHeader)
+#define	sz_fsQueryXExtents8Reply	12
+#define	sz_fsQueryXExtents16Reply	12
+#define	sz_fsQueryXBitmaps8Reply	20
+#define	sz_fsQueryXBitmaps16Reply	20
+
+#define	sz_fsError		16
+#define	sz_fsEvent		12
+#define sz_fsKeepAliveEvent 	12
+
+#define	fsTrue	1
+#define	fsFalse	0
+
+/* temp decls */
+#define	Mask		CARD32
+#define	Font		CARD32
+#define	AccContext	CARD32
+
+typedef CARD32	fsTimestamp;
+
+#ifdef NOTDEF /* in fsmasks.h */
+typedef CARD32	fsBitmapFormat;
+typedef CARD32	fsBitmapFormatMask;
+#endif
+
+#define sz_fsBitmapFormat	4
+
+typedef struct {
+    INT16	left,
+		right;
+    INT16	width;
+    INT16	ascent,
+		descent;
+    CARD16	attributes;
+}           fsXCharInfo;
+
+typedef struct {
+    CARD8       high;
+    CARD8       low;
+}           fsChar2b;
+
+typedef struct {
+    CARD8       low;
+    CARD8       high;
+}           fsChar2b_version1;
+
+typedef struct {
+    CARD8	min_char_high;
+    CARD8	min_char_low;
+    CARD8	max_char_high;
+    CARD8	max_char_low;
+}           fsRange;
+
+typedef struct	{
+    CARD32	position;
+    CARD32	length;
+}	    fsOffset32;
+
+typedef struct {
+    fsOffset32	name;
+    fsOffset32	value;
+    CARD8 	type;
+    BYTE        pad0;
+    CARD16	pad1;
+}           fsPropOffset;
+
+typedef struct {
+    CARD32	num_offsets;
+    CARD32	data_len;
+    /* offsets */
+    /* data */
+}	    fsPropInfo;
+
+typedef struct {
+    CARD16	x_resolution;
+    CARD16	y_resolution;
+    CARD16	point_size;
+}	    fsResolution;
+
+
+typedef struct {
+    CARD32	flags;
+    CARD8	char_range_min_char_high;
+    CARD8	char_range_min_char_low;
+    CARD8	char_range_max_char_high;
+    CARD8	char_range_max_char_low;
+
+    CARD8	draw_direction;
+    CARD8	pad;
+    CARD8	default_char_high;
+    CARD8	default_char_low;
+    INT16	min_bounds_left;
+    INT16	min_bounds_right;
+
+    INT16	min_bounds_width;
+    INT16	min_bounds_ascent;
+    INT16	min_bounds_descent;
+    CARD16	min_bounds_attributes;
+
+    INT16	max_bounds_left;
+    INT16	max_bounds_right;
+    INT16	max_bounds_width;
+    INT16	max_bounds_ascent;
+
+    INT16	max_bounds_descent;
+    CARD16	max_bounds_attributes;
+    INT16	font_ascent;
+    INT16	font_descent;
+    /* propinfo */
+}           fsXFontInfoHeader;
+
+
+/* requests */
+
+typedef struct {
+    BYTE        byteOrder;
+    CARD8       num_auths;
+    CARD16      major_version;
+    CARD16      minor_version;
+    CARD16      auth_len;
+    /* auth data */
+}           fsConnClientPrefix;
+
+typedef struct {
+    CARD16	status;
+    CARD16 	major_version;
+    CARD16 	minor_version;
+    CARD8	num_alternates;
+    CARD8	auth_index;
+    CARD16	alternate_len;
+    CARD16	auth_len;
+    /* alternates */
+    /* auth data */
+}           fsConnSetup;
+
+typedef struct {
+    CARD32	length;
+    CARD16	status;
+    CARD16	pad;
+    /* more auth data */
+}           fsConnSetupExtra;
+
+typedef struct {
+    CARD32	length;
+    CARD16	max_request_len;
+    CARD16	vendor_len;
+    CARD32	release_number;
+    /* vendor string */
+}	    fsConnSetupAccept;
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       data;
+    CARD16      length;
+}           fsReq;
+
+/*
+ * The fsFakeReq structure is never used in the protocol; it is prepended
+ * to incoming packets when setting up a connection so we can index
+ * through InitialVector.  To avoid alignment problems, it is padded
+ * to the size of a word on the largest machine this code runs on.
+ * Hence no sz_fsFakeReq constant is necessary.
+ */
+typedef struct {
+    CARD8       reqType;
+    CARD8       data;
+    CARD16      length;
+    CARD32      pad;		/* to fill out to multiple of 64 bits */
+}           fsFakeReq;
+
+typedef struct {
+    CARD8       reqType;
+    BYTE        pad;
+    CARD16      length;
+    Font        id;
+}           fsResourceReq;
+
+typedef fsReq	fsNoopReq;
+typedef fsReq	fsListExtensionsReq;
+
+typedef struct {
+    CARD8       reqType;
+    BYTE        nbytes;
+    CARD16      length;
+    /* name */
+}           fsQueryExtensionReq;
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       data;
+    CARD16      length;
+    CARD32      maxNames;
+    CARD16      nbytes;
+    CARD16      pad2;
+    /* pattern */
+}	    fsListCataloguesReq;
+
+typedef struct {
+    CARD8       reqType;
+    BYTE        num_catalogues;
+    CARD16      length;
+    /* catalogues */
+}           fsSetCataloguesReq;
+
+typedef fsReq	fsGetCataloguesReq;
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       ext_opcode;
+    CARD16      length;
+    Mask	event_mask;
+}           fsSetEventMaskReq;
+
+typedef struct {
+    CARD8       reqType;
+    CARD8       ext_opcode;
+    CARD16      length;
+}           fsGetEventMaskReq;
+
+typedef struct {
+    CARD8       reqType;
+    BYTE        num_auths;
+    CARD16      length;
+    AccContext  acid;
+    /* auth protocols */
+}           fsCreateACReq;
+
+typedef fsResourceReq	fsFreeACReq;
+typedef fsResourceReq	fsSetAuthorizationReq;
+
+typedef struct {
+    CARD8	reqType;
+    BYTE	num_resolutions;
+    CARD16	length;
+    /* resolutions */
+}	    fsSetResolutionReq;
+
+typedef fsReq	fsGetResolutionReq;
+
+typedef struct {
+    CARD8       reqType;
+    BYTE        pad;
+    CARD16      length;
+    CARD32      maxNames;
+    CARD16      nbytes;
+    CARD16      pad2;
+    /* pattern */
+}           fsListFontsReq;
+
+typedef fsListFontsReq fsListFontsWithXInfoReq;
+
+typedef struct {
+    CARD8       reqType;
+    BYTE        pad;
+    CARD16      length;
+    Font        fid;
+    fsBitmapFormatMask format_mask;
+    fsBitmapFormat format_hint;
+    /* pattern */
+}           fsOpenBitmapFontReq;
+
+typedef fsResourceReq fsQueryXInfoReq;
+
+typedef struct {
+    CARD8       reqType;
+    BOOL        range;
+    CARD16      length;
+    Font        fid;
+    CARD32      num_ranges;
+    /* list of chars */
+}           fsQueryXExtents8Req;
+
+typedef fsQueryXExtents8Req	fsQueryXExtents16Req;
+
+typedef struct {
+    CARD8       reqType;
+    BOOL	range;
+    CARD16      length;
+    Font        fid;
+    fsBitmapFormat format;
+    CARD32      num_ranges;
+    /* list of chars */
+}           fsQueryXBitmaps8Req;
+
+typedef fsQueryXBitmaps8Req	fsQueryXBitmaps16Req;
+
+typedef fsResourceReq fsCloseReq;
+
+
+/* replies */
+typedef struct {
+    BYTE        type;
+    BYTE        data1;
+    CARD16      sequenceNumber;
+    CARD32      length;
+}           fsGenericReply;
+
+typedef struct {
+    BYTE        type;
+    CARD8       nExtensions;
+    CARD16      sequenceNumber;
+    CARD32      length;
+    /* extension names */
+}           fsListExtensionsReply;
+
+typedef struct {
+    BYTE        type;
+    CARD8       present;
+    CARD16      sequenceNumber;
+    CARD32      length;
+    CARD16      major_version;
+    CARD16      minor_version;
+    CARD8       major_opcode;
+    CARD8       first_event;
+    CARD8       num_events;
+    CARD8       first_error;
+    CARD8       num_errors;
+    CARD8	pad1;
+    CARD16	pad2;
+}           fsQueryExtensionReply;
+
+typedef struct {
+    BYTE        type;
+    BYTE        pad;
+    CARD16      sequenceNumber;
+    CARD32      length;
+    CARD32      num_replies;
+    CARD32      num_catalogues;
+    /* catalog names */
+}	    fsListCataloguesReply;
+
+typedef struct {
+    BYTE        type;
+    CARD8       num_catalogues;
+    CARD16      sequenceNumber;
+    CARD32      length;
+    /* catalogue names */
+}           fsGetCataloguesReply;
+
+typedef struct {
+    BYTE        type;
+    BYTE        pad1;
+    CARD16      sequenceNumber;
+    CARD32      length;
+    CARD32      event_mask;
+}	    fsGetEventMaskReply;
+
+typedef struct {
+    BYTE	type;
+    CARD8	auth_index;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    CARD16	status;
+    CARD16	pad;
+    /* auth data */
+}	    fsCreateACReply;
+
+typedef struct {
+    CARD32	length;
+    CARD16	status;
+    CARD16	pad;
+    /* auth data */
+}	    fsCreateACExtraReply;
+
+typedef struct {
+    BYTE	type;
+    CARD8	num_resolutions;
+    CARD16	sequenceNumber;
+    CARD32	length;
+    /* resolutions */
+}	    fsGetResolutionReply;
+
+typedef struct {
+    BYTE        type;
+    BYTE        pad1;
+    CARD16      sequenceNumber;
+    CARD32      length;
+    CARD32      following;
+    CARD32      nFonts;
+    /* font names */
+}           fsListFontsReply;
+
+/*
+ * this one is messy.  the reply itself is variable length (unknown
+ * number of replies) and the contents of each is variable (unknown
+ * number of properties)
+ *
+ */
+
+typedef struct {
+    BYTE        type;
+    CARD8       nameLength;	/* 0 is end-of-reply */
+    CARD16 	sequenceNumber;
+    CARD32 	length;
+    CARD32 	nReplies;
+    CARD32	font_header_flags;
+    CARD8	font_hdr_char_range_min_char_high;
+    CARD8	font_hdr_char_range_min_char_low;
+    CARD8	font_hdr_char_range_max_char_high;
+    CARD8	font_hdr_char_range_max_char_low;
+    CARD8	font_header_draw_direction;
+    CARD8	font_header_pad;
+    CARD8	font_header_default_char_high;
+    CARD8	font_header_default_char_low;
+    INT16	font_header_min_bounds_left;
+    INT16	font_header_min_bounds_right;
+    INT16	font_header_min_bounds_width;
+    INT16	font_header_min_bounds_ascent;
+    INT16	font_header_min_bounds_descent;
+    CARD16	font_header_min_bounds_attributes;
+    INT16	font_header_max_bounds_left;
+    INT16	font_header_max_bounds_right;
+    INT16	font_header_max_bounds_width;
+    INT16	font_header_max_bounds_ascent;
+    INT16	font_header_max_bounds_descent;
+    CARD16	font_header_max_bounds_attributes;
+    INT16	font_header_font_ascent;
+    INT16	font_header_font_descent;
+    /* propinfo */
+    /* name */
+}           fsListFontsWithXInfoReply;
+
+typedef struct {
+    BYTE        type;
+    CARD8       otherid_valid;
+    CARD16 	sequenceNumber;
+    CARD32 	length;
+    CARD32	otherid;
+    BYTE	cachable;
+    BYTE	pad1;
+    CARD16	pad2;
+}           fsOpenBitmapFontReply;
+
+typedef struct {
+    BYTE        type;
+    CARD8       pad0;
+    CARD16 	sequenceNumber;
+    CARD32 	length;
+    CARD32	font_header_flags;
+    CARD8	font_hdr_char_range_min_char_high;
+    CARD8	font_hdr_char_range_min_char_low;
+    CARD8	font_hdr_char_range_max_char_high;
+    CARD8	font_hdr_char_range_max_char_low;
+    CARD8	font_header_draw_direction;
+    CARD8	font_header_pad;
+    CARD8	font_header_default_char_high;
+    CARD8	font_header_default_char_low;
+    INT16	font_header_min_bounds_left;
+    INT16	font_header_min_bounds_right;
+    INT16	font_header_min_bounds_width;
+    INT16	font_header_min_bounds_ascent;
+    INT16	font_header_min_bounds_descent;
+    CARD16	font_header_min_bounds_attributes;
+    INT16	font_header_max_bounds_left;
+    INT16	font_header_max_bounds_right;
+    INT16	font_header_max_bounds_width;
+    INT16	font_header_max_bounds_ascent;
+    INT16	font_header_max_bounds_descent;
+    CARD16	font_header_max_bounds_attributes;
+    INT16	font_header_font_ascent;
+    INT16	font_header_font_descent;
+    /* propinfo */
+}           fsQueryXInfoReply;
+
+typedef struct {
+    BYTE        type;
+    CARD8       pad0;
+    CARD16      sequenceNumber;
+    CARD32      length;
+    CARD32      num_extents;
+    /* extents */
+}           fsQueryXExtents8Reply;
+
+typedef fsQueryXExtents8Reply	fsQueryXExtents16Reply;
+
+typedef struct {
+    BYTE        type;
+    CARD8       pad0;
+    CARD16      sequenceNumber;
+    CARD32      length;
+    CARD32      replies_hint;
+    CARD32      num_chars;
+    CARD32      nbytes;
+    /* offsets */
+    /* glyphs */
+}           fsQueryXBitmaps8Reply;
+
+typedef fsQueryXBitmaps8Reply	fsQueryXBitmaps16Reply;
+
+typedef union {
+    fsGenericReply generic;
+    fsListExtensionsReply extensions;
+    fsGetResolutionReply getres;
+}           fsReply;
+
+/* errors */
+typedef struct {
+    BYTE        type;
+    BYTE        request;
+    CARD16 	sequenceNumber;
+    CARD32 	length;
+    fsTimestamp	timestamp;
+    CARD8	major_opcode;
+    CARD8	minor_opcode;
+    CARD16	pad;
+}	    fsError;
+
+typedef struct {
+    BYTE        type;
+    BYTE        request;
+    CARD16 	sequenceNumber;
+    CARD32 	length;
+    fsTimestamp	timestamp;
+    CARD8	major_opcode;
+    CARD8	minor_opcode;
+    CARD16	pad;
+}	    fsRequestError;
+
+typedef struct {
+    BYTE        type;
+    BYTE        request;
+    CARD16 	sequenceNumber;
+    CARD32 	length;
+    fsTimestamp	timestamp;
+    CARD8	major_opcode;
+    CARD8	minor_opcode;
+    CARD16	pad;
+    fsBitmapFormat	format;
+}	    fsFormatError;
+
+typedef struct {
+    BYTE        type;
+    BYTE        request;
+    CARD16 	sequenceNumber;
+    CARD32 	length;
+    fsTimestamp	timestamp;
+    CARD8	major_opcode;
+    CARD8	minor_opcode;
+    CARD16	pad;
+    Font	fontid;
+}	    fsFontError;
+
+typedef struct {
+    BYTE        type;
+    BYTE        request;
+    CARD16 	sequenceNumber;
+    CARD32 	length;
+    fsTimestamp	timestamp;
+    CARD8	major_opcode;
+    CARD8	minor_opcode;
+    CARD16	pad;
+    fsRange	range;
+}	    fsRangeError;
+
+typedef struct {
+    BYTE        type;
+    BYTE        request;
+    CARD16 	sequenceNumber;
+    CARD32 	length;
+    fsTimestamp	timestamp;
+    CARD8	major_opcode;
+    CARD8	minor_opcode;
+    CARD16	pad;
+    Mask	event_mask;
+}	    fsEventMaskError;
+
+typedef struct {
+    BYTE        type;
+    BYTE        request;
+    CARD16 	sequenceNumber;
+    CARD32 	length;
+    fsTimestamp	timestamp;
+    CARD8	major_opcode;
+    CARD8	minor_opcode;
+    CARD16	pad;
+    AccContext	acid;
+}	    fsAccessContextError;
+
+typedef struct {
+    BYTE        type;
+    BYTE        request;
+    CARD16 	sequenceNumber;
+    CARD32 	length;
+    fsTimestamp	timestamp;
+    CARD8	major_opcode;
+    CARD8	minor_opcode;
+    CARD16	pad;
+    Font	fontid;
+}	    fsIDChoiceError;
+
+typedef struct {
+    BYTE        type;
+    BYTE        request;
+    CARD16 	sequenceNumber;
+    CARD32 	length;
+    fsTimestamp	timestamp;
+    CARD8	major_opcode;
+    CARD8	minor_opcode;
+    CARD16	pad;
+}	    fsNameError;
+
+typedef struct {
+    BYTE        type;
+    BYTE        request;
+    CARD16 	sequenceNumber;
+    CARD32 	length;
+    fsTimestamp	timestamp;
+    CARD8	major_opcode;
+    CARD8	minor_opcode;
+    fsResolution resolution;
+}	    fsResolutionError;
+
+typedef struct {
+    BYTE        type;
+    BYTE        request;
+    CARD16 	sequenceNumber;
+    CARD32 	length;
+    fsTimestamp	timestamp;
+    CARD8	major_opcode;
+    CARD8	minor_opcode;
+    CARD16	pad;
+}	    fsAllocError;
+
+typedef struct {
+    BYTE        type;
+    BYTE        request;
+    CARD16 	sequenceNumber;
+    CARD32 	length;
+    fsTimestamp	timestamp;
+    CARD8	major_opcode;
+    CARD8	minor_opcode;
+    CARD16	pad;
+    CARD32	bad_length;
+}	    fsLengthError;
+
+typedef struct {
+    BYTE        type;
+    BYTE        request;
+    CARD16 	sequenceNumber;
+    CARD32 	length;
+    fsTimestamp	timestamp;
+    CARD8	major_opcode;
+    CARD8	minor_opcode;
+    CARD16	pad;
+}	    fsImplementationError;
+
+/* events */
+typedef struct {
+    BYTE        type;
+    BYTE        event_code;
+    CARD16 	sequenceNumber;
+    CARD32 	length;
+    fsTimestamp	timestamp;
+}	    fsKeepAliveEvent;
+
+typedef struct {
+    BYTE        type;
+    BYTE        event_code;
+    CARD16 	sequenceNumber;
+    CARD32 	length;
+    fsTimestamp	timestamp;
+    BOOL	added;
+    BOOL	deleted;
+    CARD16	pad;
+}	    fsCatalogueChangeNotifyEvent;
+
+typedef fsCatalogueChangeNotifyEvent	fsFontChangeNotifyEvent;
+
+typedef fsCatalogueChangeNotifyEvent	fsEvent;
+
+/* reply codes */
+#define	FS_Reply		0	/* normal reply */
+#define	FS_Error		1	/* error */
+#define	FS_Event		2
+
+/* request codes */
+#define		FS_Noop			0
+#define		FS_ListExtensions	1
+#define		FS_QueryExtension	2
+#define		FS_ListCatalogues	3
+#define		FS_SetCatalogues	4
+#define		FS_GetCatalogues	5
+#define		FS_SetEventMask		6
+#define		FS_GetEventMask		7
+#define		FS_CreateAC		8
+#define		FS_FreeAC		9
+#define		FS_SetAuthorization	10
+#define		FS_SetResolution	11
+#define		FS_GetResolution	12
+#define		FS_ListFonts		13
+#define		FS_ListFontsWithXInfo	14
+#define		FS_OpenBitmapFont	15
+#define		FS_QueryXInfo		16
+#define		FS_QueryXExtents8	17
+#define		FS_QueryXExtents16	18
+#define		FS_QueryXBitmaps8	19
+#define		FS_QueryXBitmaps16	20
+#define		FS_CloseFont		21
+
+/* restore decls */
+#undef	Mask
+#undef	Font
+#undef  AccContext
+
+#endif				/* _FS_PROTO_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/fonts/font.h b/depends/libxcb/depends/xorgproto/include/X11/fonts/font.h
new file mode 100644
index 0000000..b596ba2
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/fonts/font.h
@@ -0,0 +1,168 @@
+/***********************************************************
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+#ifndef FONT_H
+#define FONT_H
+
+#include <X11/Xfuncproto.h>
+
+#ifndef BitmapFormatByteOrderMask
+#include	"fsmasks.h"
+#endif
+
+/* data structures */
+#ifndef _XTYPEDEF_FONTPTR
+typedef struct _Font *FontPtr;
+#define _XTYPEDEF_FONTPTR
+#endif
+
+typedef struct _FontInfo *FontInfoPtr;
+typedef struct _FontProp *FontPropPtr;
+typedef struct _ExtentInfo *ExtentInfoPtr;
+typedef struct _FontPathElement *FontPathElementPtr;
+
+#ifndef _XTYPEDEF_CHARINFOPTR
+typedef struct _CharInfo *CharInfoPtr;
+#define _XTYPEDEF_CHARINFOPTR
+#endif
+
+typedef struct _FontNames *FontNamesPtr;
+typedef struct _FontResolution *FontResolutionPtr;
+
+#define NullCharInfo	((CharInfoPtr) 0)
+#define NullFont	((FontPtr) 0)
+#define NullFontInfo	((FontInfoPtr) 0)
+
+ /* draw direction */
+#define LeftToRight 0
+#define RightToLeft 1
+#define BottomToTop 2
+#define TopToBottom 3
+typedef int DrawDirection;
+
+#define NO_SUCH_CHAR	-1
+
+
+#define	FontAliasType	0x1000
+
+#define	AllocError	80
+#define	StillWorking	81
+#define	FontNameAlias	82
+#define	BadFontName	83
+#define	Suspended	84
+#define	Successful	85
+#define	BadFontPath	86
+#define	BadCharRange	87
+#define	BadFontFormat	88
+#define	FPEResetFailed	89	/* for when an FPE reset won't work */
+
+/* OpenFont flags */
+#define FontLoadInfo	0x0001
+#define FontLoadProps	0x0002
+#define FontLoadMetrics	0x0004
+#define FontLoadBitmaps	0x0008
+#define FontLoadAll	0x000f
+#define	FontOpenSync	0x0010
+#define FontReopen	0x0020
+
+/* Query flags */
+#define	LoadAll		0x1
+#define	FinishRamge	0x2
+#define       EightBitFont    0x4
+#define       SixteenBitFont  0x8
+
+/* Glyph Caching Modes */
+#define CACHING_OFF 0
+#define CACHE_16_BIT_GLYPHS 1
+#define CACHE_ALL_GLYPHS 2
+#define DEFAULT_GLYPH_CACHING_MODE CACHE_16_BIT_GLYPHS
+extern int glyphCachingMode;
+
+struct _Client;
+
+extern int StartListFontsWithInfo(
+    struct _Client * /*client*/,
+    int /*length*/,
+    unsigned char * /*pattern*/,
+    int /*max_names*/
+);
+
+extern FontNamesPtr MakeFontNamesRecord(
+    unsigned /* size */
+);
+
+extern void FreeFontNames(
+    FontNamesPtr /* pFN*/
+);
+
+extern int  AddFontNamesName(
+    FontNamesPtr /* names */,
+    char * /* name */,
+    int /* length */
+);
+
+#if 0 /* unused */
+extern int  FontToFSError();
+extern FontResolutionPtr GetClientResolution();
+#endif
+
+typedef struct _FontPatternCache    *FontPatternCachePtr;
+
+extern FontPatternCachePtr  MakeFontPatternCache (
+    void
+);
+
+extern void		    FreeFontPatternCache (
+    FontPatternCachePtr /* cache */
+);
+
+extern void		    EmptyFontPatternCache (
+    FontPatternCachePtr /* cache */
+);
+
+extern void		    CacheFontPattern (
+    FontPatternCachePtr /* cache */,
+    const char * /* pattern */,
+    int /* patlen */,
+    FontPtr /* pFont */
+);
+extern _X_EXPORT FontResolutionPtr GetClientResolutions(
+    int * /* num */
+);
+
+extern FontPtr		    FindCachedFontPattern (
+    FontPatternCachePtr /* cache */,
+    const char * /* pattern */,
+    int /* patlen */
+);
+
+extern void		    RemoveCachedFontPattern (
+    FontPatternCachePtr /* cache */,
+    FontPtr /* pFont */
+);
+
+typedef enum {
+    Linear8Bit, TwoD8Bit, Linear16Bit, TwoD16Bit
+}           FontEncoding;
+
+#endif				/* FONT_H */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/fonts/fontproto.h b/depends/libxcb/depends/xorgproto/include/X11/fonts/fontproto.h
new file mode 100644
index 0000000..23b8df6
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/fonts/fontproto.h
@@ -0,0 +1,94 @@
+/***********************************************************
+
+Copyright (c) 1999  The XFree86 Project Inc.
+
+All Rights Reserved.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The XFree86 Project
+Inc. shall not be used in advertising or otherwise to promote the
+sale, use or other dealings in this Software without prior written
+authorization from The XFree86 Project Inc..
+
+*/
+#ifndef _FONTPROTO_H
+#define _FONTPROTO_H
+
+#include <X11/Xfuncproto.h>
+
+/* Externally provided functions required by libXfont */
+
+extern _X_EXPORT int RegisterFPEFunctions (
+				  NameCheckFunc name_func,
+				  InitFpeFunc init_func,
+				  FreeFpeFunc free_func,
+				  ResetFpeFunc reset_func,
+				  OpenFontFunc open_func,
+				  CloseFontFunc close_func,
+				  ListFontsFunc list_func,
+				  StartLfwiFunc start_lfwi_func,
+				  NextLfwiFunc next_lfwi_func,
+				  WakeupFpeFunc wakeup_func,
+				  ClientDiedFunc client_died,
+				  LoadGlyphsFunc load_glyphs,
+				  StartLaFunc start_list_alias_func,
+				  NextLaFunc next_list_alias_func,
+				  SetPathFunc set_path_func);
+
+extern _X_EXPORT int GetDefaultPointSize ( void );
+
+extern _X_EXPORT int init_fs_handlers ( FontPathElementPtr fpe,
+                                        BlockHandlerProcPtr block_handler);
+extern _X_EXPORT void remove_fs_handlers ( FontPathElementPtr fpe,
+                                           BlockHandlerProcPtr block_handler,
+                                           Bool all );
+
+extern _X_EXPORT int client_auth_generation ( ClientPtr client );
+
+#ifndef ___CLIENTSIGNAL_DEFINED___
+#define ___CLIENTSIGNAL_DEFINED___
+extern Bool ClientSignal ( ClientPtr client );
+#endif /* ___CLIENTSIGNAL_DEFINED___ */
+
+extern _X_EXPORT void DeleteFontClientID ( Font id );
+extern _X_EXPORT Font GetNewFontClientID ( void );
+extern _X_EXPORT int StoreFontClientFont ( FontPtr pfont, Font id );
+extern _X_EXPORT void FontFileRegisterFpeFunctions ( void );
+extern _X_EXPORT void FontFileCheckRegisterFpeFunctions ( void );
+
+extern Bool XpClientIsBitmapClient ( ClientPtr client );
+extern Bool XpClientIsPrintClient( ClientPtr client, FontPathElementPtr fpe );
+extern void PrinterFontRegisterFpeFunctions ( void );
+
+extern void fs_register_fpe_functions ( void );
+extern void check_fs_register_fpe_functions ( void );
+
+/* util/private.c */
+extern FontPtr  CreateFontRec (void);
+extern void  DestroyFontRec (FontPtr font);
+extern Bool     _FontSetNewPrivate (FontPtr        /* pFont */,
+				    int            /* n */,
+				    void *         /* ptr */);
+extern int      AllocateFontPrivateIndex (void);
+extern void ResetFontPrivateIndex (void);
+
+/* Type1/t1funcs.c */
+extern void Type1RegisterFontFileFunctions(void);
+extern void CIDRegisterFontFileFunctions(void);
+
+/* Speedo/spfuncs.c */
+extern void SpeedoRegisterFontFileFunctions(void);
+
+/* FreeType/ftfuncs.c */
+extern void FreeTypeRegisterFontFileFunctions(void);
+
+#endif
diff --git a/depends/libxcb/depends/xorgproto/include/X11/fonts/fontstruct.h b/depends/libxcb/depends/xorgproto/include/X11/fonts/fontstruct.h
new file mode 100644
index 0000000..a327ef9
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/fonts/fontstruct.h
@@ -0,0 +1,297 @@
+/***********************************************************
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+#ifndef FONTSTR_H
+#define FONTSTR_H
+
+#include <X11/Xproto.h>
+#include "font.h"
+#include <X11/Xfuncproto.h>
+#include <X11/Xdefs.h>
+
+/*
+ * This version of the server font data structure is only for describing
+ * the in memory data structure. The file structure is not necessarily a
+ * copy of this. That is up to the compiler and the OS layer font loading
+ * machinery.
+ */
+
+#define GLYPHPADOPTIONS 4	/* 1, 2, 4, or 8 */
+
+typedef struct _FontProp {
+    long        name;
+    long        value;		/* assumes ATOM is not larger than INT32 */
+}           FontPropRec;
+
+typedef struct _FontResolution {
+    unsigned short x_resolution;
+    unsigned short y_resolution;
+    unsigned short point_size;
+}           FontResolutionRec;
+
+typedef struct _ExtentInfo {
+    DrawDirection drawDirection;
+    int         fontAscent;
+    int         fontDescent;
+    int         overallAscent;
+    int         overallDescent;
+    int         overallWidth;
+    int         overallLeft;
+    int         overallRight;
+}           ExtentInfoRec;
+
+typedef struct _CharInfo {
+    xCharInfo   metrics;	/* info preformatted for Queries */
+    char       *bits;		/* pointer to glyph image */
+}           CharInfoRec;
+
+/*
+ * Font is created at font load time. It is specific to a single encoding.
+ * e.g. not all of the glyphs in a font may be part of a single encoding.
+ */
+
+typedef struct _FontInfo {
+    unsigned short firstCol;
+    unsigned short lastCol;
+    unsigned short firstRow;
+    unsigned short lastRow;
+    unsigned short defaultCh;
+    unsigned int noOverlap:1;
+    unsigned int terminalFont:1;
+    unsigned int constantMetrics:1;
+    unsigned int constantWidth:1;
+    unsigned int inkInside:1;
+    unsigned int inkMetrics:1;
+    unsigned int allExist:1;
+    unsigned int drawDirection:2;
+    unsigned int cachable:1;
+    unsigned int anamorphic:1;
+    short       maxOverlap;
+    short       pad;
+    xCharInfo   maxbounds;
+    xCharInfo   minbounds;
+    xCharInfo   ink_maxbounds;
+    xCharInfo   ink_minbounds;
+    short       fontAscent;
+    short       fontDescent;
+    int         nprops;
+    FontPropPtr props;
+    char       *isStringProp;
+}           FontInfoRec;
+
+typedef struct _Font {
+    int         refcnt;
+    FontInfoRec info;
+    char        bit;
+    char        byte;
+    char        glyph;
+    char        scan;
+    fsBitmapFormat format;
+    int         (*get_glyphs) (FontPtr         /* font */,
+			       unsigned long   /* count */,
+			       unsigned char * /* chars */,
+			       FontEncoding    /* encoding */,
+			       unsigned long * /* count */,
+			       CharInfoPtr *   /* glyphs */);
+    int         (*get_metrics) (FontPtr         /* font */,
+				unsigned long   /* count */,
+				unsigned char * /* chars */,
+				FontEncoding    /* encoding */,
+				unsigned long * /* count */,
+				xCharInfo **    /* glyphs */);
+    void        (*unload_font) (FontPtr         /* font */);
+    void        (*unload_glyphs) (FontPtr         /* font */);
+    FontPathElementPtr fpe;
+    void        *svrPrivate;
+    void        *fontPrivate;
+    void        *fpePrivate;
+    int		maxPrivate;
+    void        **devPrivates;
+}           FontRec;
+
+#define FontGetPrivate(pFont,n) ((n) > (pFont)->maxPrivate ? (void *) 0 : \
+			     (pFont)->devPrivates[n])
+
+#define FontSetPrivate(pFont,n,ptr) ((n) > (pFont)->maxPrivate ? \
+			_FontSetNewPrivate (pFont, n, ptr) : \
+			((((pFont)->devPrivates[n] = (ptr)) != 0) || TRUE))
+
+typedef struct _FontNames {
+    int         nnames;
+    int         size;
+    int        *length;
+    char      **names;
+}           FontNamesRec;
+
+
+/* External view of font paths */
+typedef struct _FontPathElement {
+    int         name_length;
+#if FONT_PATH_ELEMENT_NAME_CONST
+    const
+#endif
+    char        *name;
+    int         type;
+    int         refcount;
+    void        *private;
+}           FontPathElementRec;
+
+typedef Bool (*NameCheckFunc) (const char *name);
+typedef int (*InitFpeFunc) (FontPathElementPtr fpe);
+typedef int (*FreeFpeFunc) (FontPathElementPtr fpe);
+typedef int (*ResetFpeFunc) (FontPathElementPtr fpe);
+typedef int (*OpenFontFunc) ( void *client,
+			      FontPathElementPtr fpe,
+			      Mask flags,
+			      const char* name,
+			      int namelen,
+			      fsBitmapFormat format,
+			      fsBitmapFormatMask fmask,
+			      XID id,
+			      FontPtr* pFont,
+			      char** aliasName,
+			      FontPtr non_cachable_font);
+typedef void (*CloseFontFunc) (FontPathElementPtr fpe, FontPtr pFont);
+typedef int (*ListFontsFunc) (void *client,
+			      FontPathElementPtr fpe,
+			      const char* pat,
+			      int len,
+			      int max,
+			      FontNamesPtr names);
+
+typedef int (*StartLfwiFunc) (void *client,
+			      FontPathElementPtr fpe,
+			      const char* pat,
+			      int len,
+			      int max,
+			      void ** privatep);
+
+typedef int (*NextLfwiFunc) (void *client,
+			     FontPathElementPtr fpe,
+			     char** name,
+			     int* namelen,
+			     FontInfoPtr* info,
+			     int* numFonts,
+			     void *private);
+
+typedef int (*WakeupFpeFunc) (FontPathElementPtr fpe,
+			      unsigned long* LastSelectMask);
+
+typedef void (*ClientDiedFunc) (void *client,
+			       FontPathElementPtr fpe);
+
+typedef int (*LoadGlyphsFunc) (void *client,
+			       FontPtr pfont,
+			       Bool range_flag,
+			       unsigned int nchars,
+			       int item_size,
+			       unsigned char* data);
+
+typedef int (*StartLaFunc) (void *client,
+			    FontPathElementPtr fpe,
+			    const char* pat,
+			    int len,
+			    int max,
+			    void ** privatep);
+
+typedef int (*NextLaFunc) (void *client,
+			   FontPathElementPtr fpe,
+			   char** namep,
+			   int* namelenp,
+			   char** resolvedp,
+			   int* resolvedlenp,
+			   void *private);
+
+typedef void (*SetPathFunc)(void);
+
+typedef struct _FPEFunctions {
+    NameCheckFunc       name_check;
+    InitFpeFunc 	init_fpe;
+    ResetFpeFunc	reset_fpe;
+    FreeFpeFunc         free_fpe;
+    OpenFontFunc        open_font;
+    CloseFontFunc       close_font;
+    ListFontsFunc       list_fonts;
+    StartLaFunc         start_list_fonts_and_aliases;
+    NextLaFunc          list_next_font_or_alias;
+    StartLfwiFunc       start_list_fonts_with_info;
+    NextLfwiFunc        list_next_font_with_info;
+    WakeupFpeFunc       wakeup_fpe;
+    ClientDiedFunc 	client_died;
+		/* for load_glyphs, range_flag = 0 ->
+			nchars = # of characters in data
+			item_size = bytes/char
+			data = list of characters
+		   range_flag = 1 ->
+			nchars = # of fsChar2b's in data
+			item_size is ignored
+			data = list of fsChar2b's */
+    LoadGlyphsFunc	load_glyphs;
+    SetPathFunc		set_path_hook;
+} FPEFunctionsRec, FPEFunctions;
+
+/*
+ * Various macros for computing values based on contents of
+ * the above structures
+ */
+
+#define	GLYPHWIDTHPIXELS(pci) \
+	((pci)->metrics.rightSideBearing - (pci)->metrics.leftSideBearing)
+
+#define	GLYPHHEIGHTPIXELS(pci) \
+ 	((pci)->metrics.ascent + (pci)->metrics.descent)
+
+#define	GLYPHWIDTHBYTES(pci)	(((GLYPHWIDTHPIXELS(pci))+7) >> 3)
+
+#define GLYPHWIDTHPADDED(bc)	(((bc)+7) & ~0x7)
+
+#define BYTES_PER_ROW(bits, nbytes) \
+	((nbytes) == 1 ? (((bits)+7)>>3)	/* pad to 1 byte */ \
+	:(nbytes) == 2 ? ((((bits)+15)>>3)&~1)	/* pad to 2 bytes */ \
+	:(nbytes) == 4 ? ((((bits)+31)>>3)&~3)	/* pad to 4 bytes */ \
+	:(nbytes) == 8 ? ((((bits)+63)>>3)&~7)	/* pad to 8 bytes */ \
+	: 0)
+
+#define BYTES_FOR_GLYPH(ci,pad)	(GLYPHHEIGHTPIXELS(ci) * \
+				 BYTES_PER_ROW(GLYPHWIDTHPIXELS(ci),pad))
+/*
+ * Macros for computing different bounding boxes for fonts; from
+ * the font protocol
+ */
+
+#define FONT_MAX_ASCENT(pi)	((pi)->fontAscent > (pi)->ink_maxbounds.ascent ? \
+			    (pi)->fontAscent : (pi)->ink_maxbounds.ascent)
+#define FONT_MAX_DESCENT(pi)	((pi)->fontDescent > (pi)->ink_maxbounds.descent ? \
+			    (pi)->fontDescent : (pi)->ink_maxbounds.descent)
+#define FONT_MAX_HEIGHT(pi)	(FONT_MAX_ASCENT(pi) + FONT_MAX_DESCENT(pi))
+#define FONT_MIN_LEFT(pi)	((pi)->ink_minbounds.leftSideBearing < 0 ? \
+			    (pi)->ink_minbounds.leftSideBearing : 0)
+#define FONT_MAX_RIGHT(pi)	((pi)->ink_maxbounds.rightSideBearing > \
+				(pi)->ink_maxbounds.characterWidth ? \
+			    (pi)->ink_maxbounds.rightSideBearing : \
+				(pi)->ink_maxbounds.characterWidth)
+#define FONT_MAX_WIDTH(pi)	(FONT_MAX_RIGHT(pi) - FONT_MIN_LEFT(pi))
+
+#include "fontproto.h"
+
+#endif				/* FONTSTR_H */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/fonts/fsmasks.h b/depends/libxcb/depends/xorgproto/include/X11/fonts/fsmasks.h
new file mode 100644
index 0000000..8617902
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/fonts/fsmasks.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright 1990, 1991 Network Computing Devices;
+ * Portions Copyright 1987 by Digital Equipment Corporation
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and
+ * its documentation for any purpose is hereby granted without fee, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the names of Network Computing Devices or Digital
+ * not be used in advertising or publicity pertaining to distribution
+ * of the software without specific, written prior permission.
+ * Network Computing Devices and Digital make no representations
+ * about the suitability of this software for any purpose.  It is provided
+ * "as is" without express or implied warranty.
+ *
+ * NETWORK COMPUTING DEVICES AND DIGITAL DISCLAIM ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES
+ * OR DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+ * THIS SOFTWARE.
+ */
+
+/*
+
+Portions Copyright 1987, 1994, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+*/
+
+
+/*
+ * masks & values used by the font lib and the font server
+ */
+
+#ifndef _FSMASKS_H_
+#define _FSMASKS_H_
+
+#include <X11/Xmd.h>
+
+/* font format macros */
+#define BitmapFormatByteOrderMask       (1L << 0)
+#define BitmapFormatBitOrderMask        (1L << 1)
+#define BitmapFormatImageRectMask       (3L << 2)
+#define BitmapFormatScanlinePadMask     (3L << 8)
+#define BitmapFormatScanlineUnitMask    (3L << 12)
+
+#define BitmapFormatByteOrderLSB        (0)
+#define BitmapFormatByteOrderMSB        (1L << 0)
+#define BitmapFormatBitOrderLSB         (0)
+#define BitmapFormatBitOrderMSB         (1L << 1)
+
+#define BitmapFormatImageRectMin        (0L << 2)
+#define BitmapFormatImageRectMaxWidth   (1L << 2)
+#define BitmapFormatImageRectMax        (2L << 2)
+
+#define BitmapFormatScanlinePad8        (0L << 8)
+#define BitmapFormatScanlinePad16       (1L << 8)
+#define BitmapFormatScanlinePad32       (2L << 8)
+#define BitmapFormatScanlinePad64       (3L << 8)
+
+#define BitmapFormatScanlineUnit8       (0L << 12)
+#define BitmapFormatScanlineUnit16      (1L << 12)
+#define BitmapFormatScanlineUnit32      (2L << 12)
+#define BitmapFormatScanlineUnit64      (3L << 12)
+
+#define BitmapFormatMaskByte            (1L << 0)
+#define BitmapFormatMaskBit             (1L << 1)
+#define BitmapFormatMaskImageRectangle  (1L << 2)
+#define BitmapFormatMaskScanLinePad     (1L << 3)
+#define BitmapFormatMaskScanLineUnit    (1L << 4)
+
+typedef CARD32 fsBitmapFormat;
+typedef CARD32 fsBitmapFormatMask;
+
+#endif	/* _FSMASKS_H_ */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/fonts/meson.build b/depends/libxcb/depends/xorgproto/include/X11/fonts/meson.build
new file mode 100644
index 0000000..5e49054
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/fonts/meson.build
@@ -0,0 +1,9 @@
+install_headers(
+    'font.h',
+    'fontproto.h',
+    'fontstruct.h',
+    'FS.h',
+    'fsmasks.h',
+    'FSproto.h',
+    subdir : 'X11/fonts'
+)
diff --git a/depends/libxcb/depends/xorgproto/include/X11/keysym.h b/depends/libxcb/depends/xorgproto/include/X11/keysym.h
new file mode 100644
index 0000000..0ffdde4
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/keysym.h
@@ -0,0 +1,74 @@
+/***********************************************************
+
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+/* default keysyms */
+#define XK_MISCELLANY
+#define XK_XKB_KEYS
+#define XK_LATIN1
+#define XK_LATIN2
+#define XK_LATIN3
+#define XK_LATIN4
+#define XK_LATIN8
+#define XK_LATIN9
+#define XK_CAUCASUS
+#define XK_GREEK
+#define XK_KATAKANA
+#define XK_ARABIC
+#define XK_CYRILLIC
+#define XK_HEBREW
+#define XK_THAI
+#define XK_KOREAN
+#define XK_ARMENIAN
+#define XK_GEORGIAN
+#define XK_VIETNAMESE
+#define XK_CURRENCY
+#define XK_MATHEMATICAL
+#define XK_BRAILLE
+#define XK_SINHALA
+
+#include <X11/keysymdef.h>
+
diff --git a/depends/libxcb/depends/xorgproto/include/X11/keysymdef.h b/depends/libxcb/depends/xorgproto/include/X11/keysymdef.h
new file mode 100644
index 0000000..625cc61
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/keysymdef.h
@@ -0,0 +1,2501 @@
+/***********************************************************
+Copyright 1987, 1994, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+
+/*
+ * The "X11 Window System Protocol" standard defines in Appendix A the
+ * keysym codes. These 29-bit integer values identify characters or
+ * functions associated with each key (e.g., via the visible
+ * engraving) of a keyboard layout. This file assigns mnemonic macro
+ * names for these keysyms.
+ *
+ * This file is also compiled (by src/util/makekeys.c in libX11) into
+ * hash tables that can be accessed with X11 library functions such as
+ * XStringToKeysym() and XKeysymToString().
+ *
+ * Where a keysym corresponds one-to-one to an ISO 10646 / Unicode
+ * character, this is noted in a comment that provides both the U+xxxx
+ * Unicode position, as well as the official Unicode name of the
+ * character.
+ *
+ * Where the correspondence is either not one-to-one or semantically
+ * unclear, the Unicode position and name are enclosed in
+ * parentheses. Such legacy keysyms should be considered deprecated
+ * and are not recommended for use in future keyboard mappings.
+ *
+ * For any future extension of the keysyms with characters already
+ * found in ISO 10646 / Unicode, the following algorithm shall be
+ * used. The new keysym code position will simply be the character's
+ * Unicode number plus 0x01000000. The keysym values in the range
+ * 0x01000100 to 0x0110ffff are reserved to represent Unicode
+ * characters in the range U+0100 to U+10FFFF.
+ *
+ * While most newer Unicode-based X11 clients do already accept
+ * Unicode-mapped keysyms in the range 0x01000100 to 0x0110ffff, it
+ * will remain necessary for clients -- in the interest of
+ * compatibility with existing servers -- to also understand the
+ * existing legacy keysym values in the range 0x0100 to 0x20ff.
+ *
+ * Where several mnemonic names are defined for the same keysym in this
+ * file, all but the first one listed should be considered deprecated.
+ *
+ * Mnemonic names for keysyms are defined in this file with lines
+ * that match one of these Perl regular expressions:
+ *
+ *    /^\#define XK_([a-zA-Z_0-9]+)\s+0x([0-9a-f]+)\s*\/\* U\+([0-9A-F]{4,6}) (.*) \*\/\s*$/
+ *    /^\#define XK_([a-zA-Z_0-9]+)\s+0x([0-9a-f]+)\s*\/\*\(U\+([0-9A-F]{4,6}) (.*)\)\*\/\s*$/
+ *    /^\#define XK_([a-zA-Z_0-9]+)\s+0x([0-9a-f]+)\s*(\/\*\s*(.*)\s*\*\/)?\s*$/
+ *
+ * Before adding new keysyms, please do consider the following: In
+ * addition to the keysym names defined in this file, the
+ * XStringToKeysym() and XKeysymToString() functions will also handle
+ * any keysym string of the form "U0020" to "U007E" and "U00A0" to
+ * "U10FFFF" for all possible Unicode characters. In other words,
+ * every possible Unicode character has already a keysym string
+ * defined algorithmically, even if it is not listed here. Therefore,
+ * defining an additional keysym macro is only necessary where a
+ * non-hexadecimal mnemonic name is needed, or where the new keysym
+ * does not represent any existing Unicode character.
+ *
+ * When adding new keysyms to this file, do not forget to also update the
+ * following as needed:
+ *
+ *   - the mappings in src/KeyBind.c in the libX11 repo
+ *     https://gitlab.freedesktop.org/xorg/lib/libx11
+ *
+ *   - the protocol specification in specs/keysyms.xml in this repo
+ *     https://gitlab.freedesktop.org/xorg/proto/xorgproto
+ *
+ */
+
+#define XK_VoidSymbol                  0xffffff  /* Void symbol */
+
+#ifdef XK_MISCELLANY
+/*
+ * TTY function keys, cleverly chosen to map to ASCII, for convenience of
+ * programming, but could have been arbitrary (at the cost of lookup
+ * tables in client code).
+ */
+
+#define XK_BackSpace                     0xff08  /* Back space, back char */
+#define XK_Tab                           0xff09
+#define XK_Linefeed                      0xff0a  /* Linefeed, LF */
+#define XK_Clear                         0xff0b
+#define XK_Return                        0xff0d  /* Return, enter */
+#define XK_Pause                         0xff13  /* Pause, hold */
+#define XK_Scroll_Lock                   0xff14
+#define XK_Sys_Req                       0xff15
+#define XK_Escape                        0xff1b
+#define XK_Delete                        0xffff  /* Delete, rubout */
+
+
+
+/* International & multi-key character composition */
+
+#define XK_Multi_key                     0xff20  /* Multi-key character compose */
+#define XK_Codeinput                     0xff37
+#define XK_SingleCandidate               0xff3c
+#define XK_MultipleCandidate             0xff3d
+#define XK_PreviousCandidate             0xff3e
+
+/* Japanese keyboard support */
+
+#define XK_Kanji                         0xff21  /* Kanji, Kanji convert */
+#define XK_Muhenkan                      0xff22  /* Cancel Conversion */
+#define XK_Henkan_Mode                   0xff23  /* Start/Stop Conversion */
+#define XK_Henkan                        0xff23  /* Alias for Henkan_Mode */
+#define XK_Romaji                        0xff24  /* to Romaji */
+#define XK_Hiragana                      0xff25  /* to Hiragana */
+#define XK_Katakana                      0xff26  /* to Katakana */
+#define XK_Hiragana_Katakana             0xff27  /* Hiragana/Katakana toggle */
+#define XK_Zenkaku                       0xff28  /* to Zenkaku */
+#define XK_Hankaku                       0xff29  /* to Hankaku */
+#define XK_Zenkaku_Hankaku               0xff2a  /* Zenkaku/Hankaku toggle */
+#define XK_Touroku                       0xff2b  /* Add to Dictionary */
+#define XK_Massyo                        0xff2c  /* Delete from Dictionary */
+#define XK_Kana_Lock                     0xff2d  /* Kana Lock */
+#define XK_Kana_Shift                    0xff2e  /* Kana Shift */
+#define XK_Eisu_Shift                    0xff2f  /* Alphanumeric Shift */
+#define XK_Eisu_toggle                   0xff30  /* Alphanumeric toggle */
+#define XK_Kanji_Bangou                  0xff37  /* Codeinput */
+#define XK_Zen_Koho                      0xff3d  /* Multiple/All Candidate(s) */
+#define XK_Mae_Koho                      0xff3e  /* Previous Candidate */
+
+/* 0xff31 thru 0xff3f are under XK_KOREAN */
+
+/* Cursor control & motion */
+
+#define XK_Home                          0xff50
+#define XK_Left                          0xff51  /* Move left, left arrow */
+#define XK_Up                            0xff52  /* Move up, up arrow */
+#define XK_Right                         0xff53  /* Move right, right arrow */
+#define XK_Down                          0xff54  /* Move down, down arrow */
+#define XK_Prior                         0xff55  /* Prior, previous */
+#define XK_Page_Up                       0xff55
+#define XK_Next                          0xff56  /* Next */
+#define XK_Page_Down                     0xff56
+#define XK_End                           0xff57  /* EOL */
+#define XK_Begin                         0xff58  /* BOL */
+
+
+/* Misc functions */
+
+#define XK_Select                        0xff60  /* Select, mark */
+#define XK_Print                         0xff61
+#define XK_Execute                       0xff62  /* Execute, run, do */
+#define XK_Insert                        0xff63  /* Insert, insert here */
+#define XK_Undo                          0xff65
+#define XK_Redo                          0xff66  /* Redo, again */
+#define XK_Menu                          0xff67
+#define XK_Find                          0xff68  /* Find, search */
+#define XK_Cancel                        0xff69  /* Cancel, stop, abort, exit */
+#define XK_Help                          0xff6a  /* Help */
+#define XK_Break                         0xff6b
+#define XK_Mode_switch                   0xff7e  /* Character set switch */
+#define XK_script_switch                 0xff7e  /* Alias for mode_switch */
+#define XK_Num_Lock                      0xff7f
+
+/* Keypad functions, keypad numbers cleverly chosen to map to ASCII */
+
+#define XK_KP_Space                      0xff80  /* Space */
+#define XK_KP_Tab                        0xff89
+#define XK_KP_Enter                      0xff8d  /* Enter */
+#define XK_KP_F1                         0xff91  /* PF1, KP_A, ... */
+#define XK_KP_F2                         0xff92
+#define XK_KP_F3                         0xff93
+#define XK_KP_F4                         0xff94
+#define XK_KP_Home                       0xff95
+#define XK_KP_Left                       0xff96
+#define XK_KP_Up                         0xff97
+#define XK_KP_Right                      0xff98
+#define XK_KP_Down                       0xff99
+#define XK_KP_Prior                      0xff9a
+#define XK_KP_Page_Up                    0xff9a
+#define XK_KP_Next                       0xff9b
+#define XK_KP_Page_Down                  0xff9b
+#define XK_KP_End                        0xff9c
+#define XK_KP_Begin                      0xff9d
+#define XK_KP_Insert                     0xff9e
+#define XK_KP_Delete                     0xff9f
+#define XK_KP_Equal                      0xffbd  /* Equals */
+#define XK_KP_Multiply                   0xffaa
+#define XK_KP_Add                        0xffab
+#define XK_KP_Separator                  0xffac  /* Separator, often comma */
+#define XK_KP_Subtract                   0xffad
+#define XK_KP_Decimal                    0xffae
+#define XK_KP_Divide                     0xffaf
+
+#define XK_KP_0                          0xffb0
+#define XK_KP_1                          0xffb1
+#define XK_KP_2                          0xffb2
+#define XK_KP_3                          0xffb3
+#define XK_KP_4                          0xffb4
+#define XK_KP_5                          0xffb5
+#define XK_KP_6                          0xffb6
+#define XK_KP_7                          0xffb7
+#define XK_KP_8                          0xffb8
+#define XK_KP_9                          0xffb9
+
+
+
+/*
+ * Auxiliary functions; note the duplicate definitions for left and right
+ * function keys;  Sun keyboards and a few other manufacturers have such
+ * function key groups on the left and/or right sides of the keyboard.
+ * We've not found a keyboard with more than 35 function keys total.
+ */
+
+#define XK_F1                            0xffbe
+#define XK_F2                            0xffbf
+#define XK_F3                            0xffc0
+#define XK_F4                            0xffc1
+#define XK_F5                            0xffc2
+#define XK_F6                            0xffc3
+#define XK_F7                            0xffc4
+#define XK_F8                            0xffc5
+#define XK_F9                            0xffc6
+#define XK_F10                           0xffc7
+#define XK_F11                           0xffc8
+#define XK_L1                            0xffc8
+#define XK_F12                           0xffc9
+#define XK_L2                            0xffc9
+#define XK_F13                           0xffca
+#define XK_L3                            0xffca
+#define XK_F14                           0xffcb
+#define XK_L4                            0xffcb
+#define XK_F15                           0xffcc
+#define XK_L5                            0xffcc
+#define XK_F16                           0xffcd
+#define XK_L6                            0xffcd
+#define XK_F17                           0xffce
+#define XK_L7                            0xffce
+#define XK_F18                           0xffcf
+#define XK_L8                            0xffcf
+#define XK_F19                           0xffd0
+#define XK_L9                            0xffd0
+#define XK_F20                           0xffd1
+#define XK_L10                           0xffd1
+#define XK_F21                           0xffd2
+#define XK_R1                            0xffd2
+#define XK_F22                           0xffd3
+#define XK_R2                            0xffd3
+#define XK_F23                           0xffd4
+#define XK_R3                            0xffd4
+#define XK_F24                           0xffd5
+#define XK_R4                            0xffd5
+#define XK_F25                           0xffd6
+#define XK_R5                            0xffd6
+#define XK_F26                           0xffd7
+#define XK_R6                            0xffd7
+#define XK_F27                           0xffd8
+#define XK_R7                            0xffd8
+#define XK_F28                           0xffd9
+#define XK_R8                            0xffd9
+#define XK_F29                           0xffda
+#define XK_R9                            0xffda
+#define XK_F30                           0xffdb
+#define XK_R10                           0xffdb
+#define XK_F31                           0xffdc
+#define XK_R11                           0xffdc
+#define XK_F32                           0xffdd
+#define XK_R12                           0xffdd
+#define XK_F33                           0xffde
+#define XK_R13                           0xffde
+#define XK_F34                           0xffdf
+#define XK_R14                           0xffdf
+#define XK_F35                           0xffe0
+#define XK_R15                           0xffe0
+
+/* Modifiers */
+
+#define XK_Shift_L                       0xffe1  /* Left shift */
+#define XK_Shift_R                       0xffe2  /* Right shift */
+#define XK_Control_L                     0xffe3  /* Left control */
+#define XK_Control_R                     0xffe4  /* Right control */
+#define XK_Caps_Lock                     0xffe5  /* Caps lock */
+#define XK_Shift_Lock                    0xffe6  /* Shift lock */
+
+#define XK_Meta_L                        0xffe7  /* Left meta */
+#define XK_Meta_R                        0xffe8  /* Right meta */
+#define XK_Alt_L                         0xffe9  /* Left alt */
+#define XK_Alt_R                         0xffea  /* Right alt */
+#define XK_Super_L                       0xffeb  /* Left super */
+#define XK_Super_R                       0xffec  /* Right super */
+#define XK_Hyper_L                       0xffed  /* Left hyper */
+#define XK_Hyper_R                       0xffee  /* Right hyper */
+#endif /* XK_MISCELLANY */
+
+/*
+ * Keyboard (XKB) Extension function and modifier keys
+ * (from Appendix C of "The X Keyboard Extension: Protocol Specification")
+ * Byte 3 = 0xfe
+ */
+
+#ifdef XK_XKB_KEYS
+#define XK_ISO_Lock                      0xfe01
+#define XK_ISO_Level2_Latch              0xfe02
+#define XK_ISO_Level3_Shift              0xfe03
+#define XK_ISO_Level3_Latch              0xfe04
+#define XK_ISO_Level3_Lock               0xfe05
+#define XK_ISO_Level5_Shift              0xfe11
+#define XK_ISO_Level5_Latch              0xfe12
+#define XK_ISO_Level5_Lock               0xfe13
+#define XK_ISO_Group_Shift               0xff7e  /* Alias for mode_switch */
+#define XK_ISO_Group_Latch               0xfe06
+#define XK_ISO_Group_Lock                0xfe07
+#define XK_ISO_Next_Group                0xfe08
+#define XK_ISO_Next_Group_Lock           0xfe09
+#define XK_ISO_Prev_Group                0xfe0a
+#define XK_ISO_Prev_Group_Lock           0xfe0b
+#define XK_ISO_First_Group               0xfe0c
+#define XK_ISO_First_Group_Lock          0xfe0d
+#define XK_ISO_Last_Group                0xfe0e
+#define XK_ISO_Last_Group_Lock           0xfe0f
+
+#define XK_ISO_Left_Tab                  0xfe20
+#define XK_ISO_Move_Line_Up              0xfe21
+#define XK_ISO_Move_Line_Down            0xfe22
+#define XK_ISO_Partial_Line_Up           0xfe23
+#define XK_ISO_Partial_Line_Down         0xfe24
+#define XK_ISO_Partial_Space_Left        0xfe25
+#define XK_ISO_Partial_Space_Right       0xfe26
+#define XK_ISO_Set_Margin_Left           0xfe27
+#define XK_ISO_Set_Margin_Right          0xfe28
+#define XK_ISO_Release_Margin_Left       0xfe29
+#define XK_ISO_Release_Margin_Right      0xfe2a
+#define XK_ISO_Release_Both_Margins      0xfe2b
+#define XK_ISO_Fast_Cursor_Left          0xfe2c
+#define XK_ISO_Fast_Cursor_Right         0xfe2d
+#define XK_ISO_Fast_Cursor_Up            0xfe2e
+#define XK_ISO_Fast_Cursor_Down          0xfe2f
+#define XK_ISO_Continuous_Underline      0xfe30
+#define XK_ISO_Discontinuous_Underline   0xfe31
+#define XK_ISO_Emphasize                 0xfe32
+#define XK_ISO_Center_Object             0xfe33
+#define XK_ISO_Enter                     0xfe34
+
+#define XK_dead_grave                    0xfe50
+#define XK_dead_acute                    0xfe51
+#define XK_dead_circumflex               0xfe52
+#define XK_dead_tilde                    0xfe53
+#define XK_dead_perispomeni              0xfe53  /* alias for dead_tilde */
+#define XK_dead_macron                   0xfe54
+#define XK_dead_breve                    0xfe55
+#define XK_dead_abovedot                 0xfe56
+#define XK_dead_diaeresis                0xfe57
+#define XK_dead_abovering                0xfe58
+#define XK_dead_doubleacute              0xfe59
+#define XK_dead_caron                    0xfe5a
+#define XK_dead_cedilla                  0xfe5b
+#define XK_dead_ogonek                   0xfe5c
+#define XK_dead_iota                     0xfe5d
+#define XK_dead_voiced_sound             0xfe5e
+#define XK_dead_semivoiced_sound         0xfe5f
+#define XK_dead_belowdot                 0xfe60
+#define XK_dead_hook                     0xfe61
+#define XK_dead_horn                     0xfe62
+#define XK_dead_stroke                   0xfe63
+#define XK_dead_abovecomma               0xfe64
+#define XK_dead_psili                    0xfe64  /* alias for dead_abovecomma */
+#define XK_dead_abovereversedcomma       0xfe65
+#define XK_dead_dasia                    0xfe65  /* alias for dead_abovereversedcomma */
+#define XK_dead_doublegrave              0xfe66
+#define XK_dead_belowring                0xfe67
+#define XK_dead_belowmacron              0xfe68
+#define XK_dead_belowcircumflex          0xfe69
+#define XK_dead_belowtilde               0xfe6a
+#define XK_dead_belowbreve               0xfe6b
+#define XK_dead_belowdiaeresis           0xfe6c
+#define XK_dead_invertedbreve            0xfe6d
+#define XK_dead_belowcomma               0xfe6e
+#define XK_dead_currency                 0xfe6f
+
+/* dead vowels for universal syllable entry */
+#define XK_dead_a                        0xfe80
+#define XK_dead_A                        0xfe81
+#define XK_dead_e                        0xfe82
+#define XK_dead_E                        0xfe83
+#define XK_dead_i                        0xfe84
+#define XK_dead_I                        0xfe85
+#define XK_dead_o                        0xfe86
+#define XK_dead_O                        0xfe87
+#define XK_dead_u                        0xfe88
+#define XK_dead_U                        0xfe89
+#define XK_dead_schwa                    0xfe8a
+#define XK_dead_SCHWA                    0xfe8b
+#define XK_dead_small_schwa              0xfe8a  /* deprecated, remove in 2025 */
+#define XK_dead_capital_schwa            0xfe8b  /* deprecated, remove in 2025 */
+
+#define XK_dead_greek                    0xfe8c
+
+#define XK_First_Virtual_Screen          0xfed0
+#define XK_Prev_Virtual_Screen           0xfed1
+#define XK_Next_Virtual_Screen           0xfed2
+#define XK_Last_Virtual_Screen           0xfed4
+#define XK_Terminate_Server              0xfed5
+
+#define XK_AccessX_Enable                0xfe70
+#define XK_AccessX_Feedback_Enable       0xfe71
+#define XK_RepeatKeys_Enable             0xfe72
+#define XK_SlowKeys_Enable               0xfe73
+#define XK_BounceKeys_Enable             0xfe74
+#define XK_StickyKeys_Enable             0xfe75
+#define XK_MouseKeys_Enable              0xfe76
+#define XK_MouseKeys_Accel_Enable        0xfe77
+#define XK_Overlay1_Enable               0xfe78
+#define XK_Overlay2_Enable               0xfe79
+#define XK_AudibleBell_Enable            0xfe7a
+
+#define XK_Pointer_Left                  0xfee0
+#define XK_Pointer_Right                 0xfee1
+#define XK_Pointer_Up                    0xfee2
+#define XK_Pointer_Down                  0xfee3
+#define XK_Pointer_UpLeft                0xfee4
+#define XK_Pointer_UpRight               0xfee5
+#define XK_Pointer_DownLeft              0xfee6
+#define XK_Pointer_DownRight             0xfee7
+#define XK_Pointer_Button_Dflt           0xfee8
+#define XK_Pointer_Button1               0xfee9
+#define XK_Pointer_Button2               0xfeea
+#define XK_Pointer_Button3               0xfeeb
+#define XK_Pointer_Button4               0xfeec
+#define XK_Pointer_Button5               0xfeed
+#define XK_Pointer_DblClick_Dflt         0xfeee
+#define XK_Pointer_DblClick1             0xfeef
+#define XK_Pointer_DblClick2             0xfef0
+#define XK_Pointer_DblClick3             0xfef1
+#define XK_Pointer_DblClick4             0xfef2
+#define XK_Pointer_DblClick5             0xfef3
+#define XK_Pointer_Drag_Dflt             0xfef4
+#define XK_Pointer_Drag1                 0xfef5
+#define XK_Pointer_Drag2                 0xfef6
+#define XK_Pointer_Drag3                 0xfef7
+#define XK_Pointer_Drag4                 0xfef8
+#define XK_Pointer_Drag5                 0xfefd
+
+#define XK_Pointer_EnableKeys            0xfef9
+#define XK_Pointer_Accelerate            0xfefa
+#define XK_Pointer_DfltBtnNext           0xfefb
+#define XK_Pointer_DfltBtnPrev           0xfefc
+
+/* Single-Stroke Multiple-Character N-Graph Keysyms For The X Input Method */
+
+#define XK_ch                            0xfea0
+#define XK_Ch                            0xfea1
+#define XK_CH                            0xfea2
+#define XK_c_h                           0xfea3
+#define XK_C_h                           0xfea4
+#define XK_C_H                           0xfea5
+
+#endif /* XK_XKB_KEYS */
+
+/*
+ * 3270 Terminal Keys
+ * Byte 3 = 0xfd
+ */
+
+#ifdef XK_3270
+#define XK_3270_Duplicate                0xfd01
+#define XK_3270_FieldMark                0xfd02
+#define XK_3270_Right2                   0xfd03
+#define XK_3270_Left2                    0xfd04
+#define XK_3270_BackTab                  0xfd05
+#define XK_3270_EraseEOF                 0xfd06
+#define XK_3270_EraseInput               0xfd07
+#define XK_3270_Reset                    0xfd08
+#define XK_3270_Quit                     0xfd09
+#define XK_3270_PA1                      0xfd0a
+#define XK_3270_PA2                      0xfd0b
+#define XK_3270_PA3                      0xfd0c
+#define XK_3270_Test                     0xfd0d
+#define XK_3270_Attn                     0xfd0e
+#define XK_3270_CursorBlink              0xfd0f
+#define XK_3270_AltCursor                0xfd10
+#define XK_3270_KeyClick                 0xfd11
+#define XK_3270_Jump                     0xfd12
+#define XK_3270_Ident                    0xfd13
+#define XK_3270_Rule                     0xfd14
+#define XK_3270_Copy                     0xfd15
+#define XK_3270_Play                     0xfd16
+#define XK_3270_Setup                    0xfd17
+#define XK_3270_Record                   0xfd18
+#define XK_3270_ChangeScreen             0xfd19
+#define XK_3270_DeleteWord               0xfd1a
+#define XK_3270_ExSelect                 0xfd1b
+#define XK_3270_CursorSelect             0xfd1c
+#define XK_3270_PrintScreen              0xfd1d
+#define XK_3270_Enter                    0xfd1e
+#endif /* XK_3270 */
+
+/*
+ * Latin 1
+ * (ISO/IEC 8859-1 = Unicode U+0020..U+00FF)
+ * Byte 3 = 0
+ */
+#ifdef XK_LATIN1
+#define XK_space                         0x0020  /* U+0020 SPACE */
+#define XK_exclam                        0x0021  /* U+0021 EXCLAMATION MARK */
+#define XK_quotedbl                      0x0022  /* U+0022 QUOTATION MARK */
+#define XK_numbersign                    0x0023  /* U+0023 NUMBER SIGN */
+#define XK_dollar                        0x0024  /* U+0024 DOLLAR SIGN */
+#define XK_percent                       0x0025  /* U+0025 PERCENT SIGN */
+#define XK_ampersand                     0x0026  /* U+0026 AMPERSAND */
+#define XK_apostrophe                    0x0027  /* U+0027 APOSTROPHE */
+#define XK_quoteright                    0x0027  /* deprecated */
+#define XK_parenleft                     0x0028  /* U+0028 LEFT PARENTHESIS */
+#define XK_parenright                    0x0029  /* U+0029 RIGHT PARENTHESIS */
+#define XK_asterisk                      0x002a  /* U+002A ASTERISK */
+#define XK_plus                          0x002b  /* U+002B PLUS SIGN */
+#define XK_comma                         0x002c  /* U+002C COMMA */
+#define XK_minus                         0x002d  /* U+002D HYPHEN-MINUS */
+#define XK_period                        0x002e  /* U+002E FULL STOP */
+#define XK_slash                         0x002f  /* U+002F SOLIDUS */
+#define XK_0                             0x0030  /* U+0030 DIGIT ZERO */
+#define XK_1                             0x0031  /* U+0031 DIGIT ONE */
+#define XK_2                             0x0032  /* U+0032 DIGIT TWO */
+#define XK_3                             0x0033  /* U+0033 DIGIT THREE */
+#define XK_4                             0x0034  /* U+0034 DIGIT FOUR */
+#define XK_5                             0x0035  /* U+0035 DIGIT FIVE */
+#define XK_6                             0x0036  /* U+0036 DIGIT SIX */
+#define XK_7                             0x0037  /* U+0037 DIGIT SEVEN */
+#define XK_8                             0x0038  /* U+0038 DIGIT EIGHT */
+#define XK_9                             0x0039  /* U+0039 DIGIT NINE */
+#define XK_colon                         0x003a  /* U+003A COLON */
+#define XK_semicolon                     0x003b  /* U+003B SEMICOLON */
+#define XK_less                          0x003c  /* U+003C LESS-THAN SIGN */
+#define XK_equal                         0x003d  /* U+003D EQUALS SIGN */
+#define XK_greater                       0x003e  /* U+003E GREATER-THAN SIGN */
+#define XK_question                      0x003f  /* U+003F QUESTION MARK */
+#define XK_at                            0x0040  /* U+0040 COMMERCIAL AT */
+#define XK_A                             0x0041  /* U+0041 LATIN CAPITAL LETTER A */
+#define XK_B                             0x0042  /* U+0042 LATIN CAPITAL LETTER B */
+#define XK_C                             0x0043  /* U+0043 LATIN CAPITAL LETTER C */
+#define XK_D                             0x0044  /* U+0044 LATIN CAPITAL LETTER D */
+#define XK_E                             0x0045  /* U+0045 LATIN CAPITAL LETTER E */
+#define XK_F                             0x0046  /* U+0046 LATIN CAPITAL LETTER F */
+#define XK_G                             0x0047  /* U+0047 LATIN CAPITAL LETTER G */
+#define XK_H                             0x0048  /* U+0048 LATIN CAPITAL LETTER H */
+#define XK_I                             0x0049  /* U+0049 LATIN CAPITAL LETTER I */
+#define XK_J                             0x004a  /* U+004A LATIN CAPITAL LETTER J */
+#define XK_K                             0x004b  /* U+004B LATIN CAPITAL LETTER K */
+#define XK_L                             0x004c  /* U+004C LATIN CAPITAL LETTER L */
+#define XK_M                             0x004d  /* U+004D LATIN CAPITAL LETTER M */
+#define XK_N                             0x004e  /* U+004E LATIN CAPITAL LETTER N */
+#define XK_O                             0x004f  /* U+004F LATIN CAPITAL LETTER O */
+#define XK_P                             0x0050  /* U+0050 LATIN CAPITAL LETTER P */
+#define XK_Q                             0x0051  /* U+0051 LATIN CAPITAL LETTER Q */
+#define XK_R                             0x0052  /* U+0052 LATIN CAPITAL LETTER R */
+#define XK_S                             0x0053  /* U+0053 LATIN CAPITAL LETTER S */
+#define XK_T                             0x0054  /* U+0054 LATIN CAPITAL LETTER T */
+#define XK_U                             0x0055  /* U+0055 LATIN CAPITAL LETTER U */
+#define XK_V                             0x0056  /* U+0056 LATIN CAPITAL LETTER V */
+#define XK_W                             0x0057  /* U+0057 LATIN CAPITAL LETTER W */
+#define XK_X                             0x0058  /* U+0058 LATIN CAPITAL LETTER X */
+#define XK_Y                             0x0059  /* U+0059 LATIN CAPITAL LETTER Y */
+#define XK_Z                             0x005a  /* U+005A LATIN CAPITAL LETTER Z */
+#define XK_bracketleft                   0x005b  /* U+005B LEFT SQUARE BRACKET */
+#define XK_backslash                     0x005c  /* U+005C REVERSE SOLIDUS */
+#define XK_bracketright                  0x005d  /* U+005D RIGHT SQUARE BRACKET */
+#define XK_asciicircum                   0x005e  /* U+005E CIRCUMFLEX ACCENT */
+#define XK_underscore                    0x005f  /* U+005F LOW LINE */
+#define XK_grave                         0x0060  /* U+0060 GRAVE ACCENT */
+#define XK_quoteleft                     0x0060  /* deprecated */
+#define XK_a                             0x0061  /* U+0061 LATIN SMALL LETTER A */
+#define XK_b                             0x0062  /* U+0062 LATIN SMALL LETTER B */
+#define XK_c                             0x0063  /* U+0063 LATIN SMALL LETTER C */
+#define XK_d                             0x0064  /* U+0064 LATIN SMALL LETTER D */
+#define XK_e                             0x0065  /* U+0065 LATIN SMALL LETTER E */
+#define XK_f                             0x0066  /* U+0066 LATIN SMALL LETTER F */
+#define XK_g                             0x0067  /* U+0067 LATIN SMALL LETTER G */
+#define XK_h                             0x0068  /* U+0068 LATIN SMALL LETTER H */
+#define XK_i                             0x0069  /* U+0069 LATIN SMALL LETTER I */
+#define XK_j                             0x006a  /* U+006A LATIN SMALL LETTER J */
+#define XK_k                             0x006b  /* U+006B LATIN SMALL LETTER K */
+#define XK_l                             0x006c  /* U+006C LATIN SMALL LETTER L */
+#define XK_m                             0x006d  /* U+006D LATIN SMALL LETTER M */
+#define XK_n                             0x006e  /* U+006E LATIN SMALL LETTER N */
+#define XK_o                             0x006f  /* U+006F LATIN SMALL LETTER O */
+#define XK_p                             0x0070  /* U+0070 LATIN SMALL LETTER P */
+#define XK_q                             0x0071  /* U+0071 LATIN SMALL LETTER Q */
+#define XK_r                             0x0072  /* U+0072 LATIN SMALL LETTER R */
+#define XK_s                             0x0073  /* U+0073 LATIN SMALL LETTER S */
+#define XK_t                             0x0074  /* U+0074 LATIN SMALL LETTER T */
+#define XK_u                             0x0075  /* U+0075 LATIN SMALL LETTER U */
+#define XK_v                             0x0076  /* U+0076 LATIN SMALL LETTER V */
+#define XK_w                             0x0077  /* U+0077 LATIN SMALL LETTER W */
+#define XK_x                             0x0078  /* U+0078 LATIN SMALL LETTER X */
+#define XK_y                             0x0079  /* U+0079 LATIN SMALL LETTER Y */
+#define XK_z                             0x007a  /* U+007A LATIN SMALL LETTER Z */
+#define XK_braceleft                     0x007b  /* U+007B LEFT CURLY BRACKET */
+#define XK_bar                           0x007c  /* U+007C VERTICAL LINE */
+#define XK_braceright                    0x007d  /* U+007D RIGHT CURLY BRACKET */
+#define XK_asciitilde                    0x007e  /* U+007E TILDE */
+
+#define XK_nobreakspace                  0x00a0  /* U+00A0 NO-BREAK SPACE */
+#define XK_exclamdown                    0x00a1  /* U+00A1 INVERTED EXCLAMATION MARK */
+#define XK_cent                          0x00a2  /* U+00A2 CENT SIGN */
+#define XK_sterling                      0x00a3  /* U+00A3 POUND SIGN */
+#define XK_currency                      0x00a4  /* U+00A4 CURRENCY SIGN */
+#define XK_yen                           0x00a5  /* U+00A5 YEN SIGN */
+#define XK_brokenbar                     0x00a6  /* U+00A6 BROKEN BAR */
+#define XK_section                       0x00a7  /* U+00A7 SECTION SIGN */
+#define XK_diaeresis                     0x00a8  /* U+00A8 DIAERESIS */
+#define XK_copyright                     0x00a9  /* U+00A9 COPYRIGHT SIGN */
+#define XK_ordfeminine                   0x00aa  /* U+00AA FEMININE ORDINAL INDICATOR */
+#define XK_guillemetleft                 0x00ab  /* U+00AB LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */
+#define XK_guillemotleft                 0x00ab  /* deprecated misspelling */
+#define XK_notsign                       0x00ac  /* U+00AC NOT SIGN */
+#define XK_hyphen                        0x00ad  /* U+00AD SOFT HYPHEN */
+#define XK_registered                    0x00ae  /* U+00AE REGISTERED SIGN */
+#define XK_macron                        0x00af  /* U+00AF MACRON */
+#define XK_degree                        0x00b0  /* U+00B0 DEGREE SIGN */
+#define XK_plusminus                     0x00b1  /* U+00B1 PLUS-MINUS SIGN */
+#define XK_twosuperior                   0x00b2  /* U+00B2 SUPERSCRIPT TWO */
+#define XK_threesuperior                 0x00b3  /* U+00B3 SUPERSCRIPT THREE */
+#define XK_acute                         0x00b4  /* U+00B4 ACUTE ACCENT */
+#define XK_mu                            0x00b5  /* U+00B5 MICRO SIGN */
+#define XK_paragraph                     0x00b6  /* U+00B6 PILCROW SIGN */
+#define XK_periodcentered                0x00b7  /* U+00B7 MIDDLE DOT */
+#define XK_cedilla                       0x00b8  /* U+00B8 CEDILLA */
+#define XK_onesuperior                   0x00b9  /* U+00B9 SUPERSCRIPT ONE */
+#define XK_ordmasculine                  0x00ba  /* U+00BA MASCULINE ORDINAL INDICATOR */
+#define XK_masculine                     0x00ba  /* deprecated inconsistent name */
+#define XK_guillemetright                0x00bb  /* U+00BB RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */
+#define XK_guillemotright                0x00bb  /* deprecated misspelling */
+#define XK_onequarter                    0x00bc  /* U+00BC VULGAR FRACTION ONE QUARTER */
+#define XK_onehalf                       0x00bd  /* U+00BD VULGAR FRACTION ONE HALF */
+#define XK_threequarters                 0x00be  /* U+00BE VULGAR FRACTION THREE QUARTERS */
+#define XK_questiondown                  0x00bf  /* U+00BF INVERTED QUESTION MARK */
+#define XK_Agrave                        0x00c0  /* U+00C0 LATIN CAPITAL LETTER A WITH GRAVE */
+#define XK_Aacute                        0x00c1  /* U+00C1 LATIN CAPITAL LETTER A WITH ACUTE */
+#define XK_Acircumflex                   0x00c2  /* U+00C2 LATIN CAPITAL LETTER A WITH CIRCUMFLEX */
+#define XK_Atilde                        0x00c3  /* U+00C3 LATIN CAPITAL LETTER A WITH TILDE */
+#define XK_Adiaeresis                    0x00c4  /* U+00C4 LATIN CAPITAL LETTER A WITH DIAERESIS */
+#define XK_Aring                         0x00c5  /* U+00C5 LATIN CAPITAL LETTER A WITH RING ABOVE */
+#define XK_AE                            0x00c6  /* U+00C6 LATIN CAPITAL LETTER AE */
+#define XK_Ccedilla                      0x00c7  /* U+00C7 LATIN CAPITAL LETTER C WITH CEDILLA */
+#define XK_Egrave                        0x00c8  /* U+00C8 LATIN CAPITAL LETTER E WITH GRAVE */
+#define XK_Eacute                        0x00c9  /* U+00C9 LATIN CAPITAL LETTER E WITH ACUTE */
+#define XK_Ecircumflex                   0x00ca  /* U+00CA LATIN CAPITAL LETTER E WITH CIRCUMFLEX */
+#define XK_Ediaeresis                    0x00cb  /* U+00CB LATIN CAPITAL LETTER E WITH DIAERESIS */
+#define XK_Igrave                        0x00cc  /* U+00CC LATIN CAPITAL LETTER I WITH GRAVE */
+#define XK_Iacute                        0x00cd  /* U+00CD LATIN CAPITAL LETTER I WITH ACUTE */
+#define XK_Icircumflex                   0x00ce  /* U+00CE LATIN CAPITAL LETTER I WITH CIRCUMFLEX */
+#define XK_Idiaeresis                    0x00cf  /* U+00CF LATIN CAPITAL LETTER I WITH DIAERESIS */
+#define XK_ETH                           0x00d0  /* U+00D0 LATIN CAPITAL LETTER ETH */
+#define XK_Eth                           0x00d0  /* deprecated */
+#define XK_Ntilde                        0x00d1  /* U+00D1 LATIN CAPITAL LETTER N WITH TILDE */
+#define XK_Ograve                        0x00d2  /* U+00D2 LATIN CAPITAL LETTER O WITH GRAVE */
+#define XK_Oacute                        0x00d3  /* U+00D3 LATIN CAPITAL LETTER O WITH ACUTE */
+#define XK_Ocircumflex                   0x00d4  /* U+00D4 LATIN CAPITAL LETTER O WITH CIRCUMFLEX */
+#define XK_Otilde                        0x00d5  /* U+00D5 LATIN CAPITAL LETTER O WITH TILDE */
+#define XK_Odiaeresis                    0x00d6  /* U+00D6 LATIN CAPITAL LETTER O WITH DIAERESIS */
+#define XK_multiply                      0x00d7  /* U+00D7 MULTIPLICATION SIGN */
+#define XK_Oslash                        0x00d8  /* U+00D8 LATIN CAPITAL LETTER O WITH STROKE */
+#define XK_Ooblique                      0x00d8  /* U+00D8 LATIN CAPITAL LETTER O WITH STROKE */
+#define XK_Ugrave                        0x00d9  /* U+00D9 LATIN CAPITAL LETTER U WITH GRAVE */
+#define XK_Uacute                        0x00da  /* U+00DA LATIN CAPITAL LETTER U WITH ACUTE */
+#define XK_Ucircumflex                   0x00db  /* U+00DB LATIN CAPITAL LETTER U WITH CIRCUMFLEX */
+#define XK_Udiaeresis                    0x00dc  /* U+00DC LATIN CAPITAL LETTER U WITH DIAERESIS */
+#define XK_Yacute                        0x00dd  /* U+00DD LATIN CAPITAL LETTER Y WITH ACUTE */
+#define XK_THORN                         0x00de  /* U+00DE LATIN CAPITAL LETTER THORN */
+#define XK_Thorn                         0x00de  /* deprecated */
+#define XK_ssharp                        0x00df  /* U+00DF LATIN SMALL LETTER SHARP S */
+#define XK_agrave                        0x00e0  /* U+00E0 LATIN SMALL LETTER A WITH GRAVE */
+#define XK_aacute                        0x00e1  /* U+00E1 LATIN SMALL LETTER A WITH ACUTE */
+#define XK_acircumflex                   0x00e2  /* U+00E2 LATIN SMALL LETTER A WITH CIRCUMFLEX */
+#define XK_atilde                        0x00e3  /* U+00E3 LATIN SMALL LETTER A WITH TILDE */
+#define XK_adiaeresis                    0x00e4  /* U+00E4 LATIN SMALL LETTER A WITH DIAERESIS */
+#define XK_aring                         0x00e5  /* U+00E5 LATIN SMALL LETTER A WITH RING ABOVE */
+#define XK_ae                            0x00e6  /* U+00E6 LATIN SMALL LETTER AE */
+#define XK_ccedilla                      0x00e7  /* U+00E7 LATIN SMALL LETTER C WITH CEDILLA */
+#define XK_egrave                        0x00e8  /* U+00E8 LATIN SMALL LETTER E WITH GRAVE */
+#define XK_eacute                        0x00e9  /* U+00E9 LATIN SMALL LETTER E WITH ACUTE */
+#define XK_ecircumflex                   0x00ea  /* U+00EA LATIN SMALL LETTER E WITH CIRCUMFLEX */
+#define XK_ediaeresis                    0x00eb  /* U+00EB LATIN SMALL LETTER E WITH DIAERESIS */
+#define XK_igrave                        0x00ec  /* U+00EC LATIN SMALL LETTER I WITH GRAVE */
+#define XK_iacute                        0x00ed  /* U+00ED LATIN SMALL LETTER I WITH ACUTE */
+#define XK_icircumflex                   0x00ee  /* U+00EE LATIN SMALL LETTER I WITH CIRCUMFLEX */
+#define XK_idiaeresis                    0x00ef  /* U+00EF LATIN SMALL LETTER I WITH DIAERESIS */
+#define XK_eth                           0x00f0  /* U+00F0 LATIN SMALL LETTER ETH */
+#define XK_ntilde                        0x00f1  /* U+00F1 LATIN SMALL LETTER N WITH TILDE */
+#define XK_ograve                        0x00f2  /* U+00F2 LATIN SMALL LETTER O WITH GRAVE */
+#define XK_oacute                        0x00f3  /* U+00F3 LATIN SMALL LETTER O WITH ACUTE */
+#define XK_ocircumflex                   0x00f4  /* U+00F4 LATIN SMALL LETTER O WITH CIRCUMFLEX */
+#define XK_otilde                        0x00f5  /* U+00F5 LATIN SMALL LETTER O WITH TILDE */
+#define XK_odiaeresis                    0x00f6  /* U+00F6 LATIN SMALL LETTER O WITH DIAERESIS */
+#define XK_division                      0x00f7  /* U+00F7 DIVISION SIGN */
+#define XK_oslash                        0x00f8  /* U+00F8 LATIN SMALL LETTER O WITH STROKE */
+#define XK_ooblique                      0x00f8  /* U+00F8 LATIN SMALL LETTER O WITH STROKE */
+#define XK_ugrave                        0x00f9  /* U+00F9 LATIN SMALL LETTER U WITH GRAVE */
+#define XK_uacute                        0x00fa  /* U+00FA LATIN SMALL LETTER U WITH ACUTE */
+#define XK_ucircumflex                   0x00fb  /* U+00FB LATIN SMALL LETTER U WITH CIRCUMFLEX */
+#define XK_udiaeresis                    0x00fc  /* U+00FC LATIN SMALL LETTER U WITH DIAERESIS */
+#define XK_yacute                        0x00fd  /* U+00FD LATIN SMALL LETTER Y WITH ACUTE */
+#define XK_thorn                         0x00fe  /* U+00FE LATIN SMALL LETTER THORN */
+#define XK_ydiaeresis                    0x00ff  /* U+00FF LATIN SMALL LETTER Y WITH DIAERESIS */
+#endif /* XK_LATIN1 */
+
+/*
+ * Latin 2
+ * Byte 3 = 1
+ */
+
+#ifdef XK_LATIN2
+#define XK_Aogonek                       0x01a1  /* U+0104 LATIN CAPITAL LETTER A WITH OGONEK */
+#define XK_breve                         0x01a2  /* U+02D8 BREVE */
+#define XK_Lstroke                       0x01a3  /* U+0141 LATIN CAPITAL LETTER L WITH STROKE */
+#define XK_Lcaron                        0x01a5  /* U+013D LATIN CAPITAL LETTER L WITH CARON */
+#define XK_Sacute                        0x01a6  /* U+015A LATIN CAPITAL LETTER S WITH ACUTE */
+#define XK_Scaron                        0x01a9  /* U+0160 LATIN CAPITAL LETTER S WITH CARON */
+#define XK_Scedilla                      0x01aa  /* U+015E LATIN CAPITAL LETTER S WITH CEDILLA */
+#define XK_Tcaron                        0x01ab  /* U+0164 LATIN CAPITAL LETTER T WITH CARON */
+#define XK_Zacute                        0x01ac  /* U+0179 LATIN CAPITAL LETTER Z WITH ACUTE */
+#define XK_Zcaron                        0x01ae  /* U+017D LATIN CAPITAL LETTER Z WITH CARON */
+#define XK_Zabovedot                     0x01af  /* U+017B LATIN CAPITAL LETTER Z WITH DOT ABOVE */
+#define XK_aogonek                       0x01b1  /* U+0105 LATIN SMALL LETTER A WITH OGONEK */
+#define XK_ogonek                        0x01b2  /* U+02DB OGONEK */
+#define XK_lstroke                       0x01b3  /* U+0142 LATIN SMALL LETTER L WITH STROKE */
+#define XK_lcaron                        0x01b5  /* U+013E LATIN SMALL LETTER L WITH CARON */
+#define XK_sacute                        0x01b6  /* U+015B LATIN SMALL LETTER S WITH ACUTE */
+#define XK_caron                         0x01b7  /* U+02C7 CARON */
+#define XK_scaron                        0x01b9  /* U+0161 LATIN SMALL LETTER S WITH CARON */
+#define XK_scedilla                      0x01ba  /* U+015F LATIN SMALL LETTER S WITH CEDILLA */
+#define XK_tcaron                        0x01bb  /* U+0165 LATIN SMALL LETTER T WITH CARON */
+#define XK_zacute                        0x01bc  /* U+017A LATIN SMALL LETTER Z WITH ACUTE */
+#define XK_doubleacute                   0x01bd  /* U+02DD DOUBLE ACUTE ACCENT */
+#define XK_zcaron                        0x01be  /* U+017E LATIN SMALL LETTER Z WITH CARON */
+#define XK_zabovedot                     0x01bf  /* U+017C LATIN SMALL LETTER Z WITH DOT ABOVE */
+#define XK_Racute                        0x01c0  /* U+0154 LATIN CAPITAL LETTER R WITH ACUTE */
+#define XK_Abreve                        0x01c3  /* U+0102 LATIN CAPITAL LETTER A WITH BREVE */
+#define XK_Lacute                        0x01c5  /* U+0139 LATIN CAPITAL LETTER L WITH ACUTE */
+#define XK_Cacute                        0x01c6  /* U+0106 LATIN CAPITAL LETTER C WITH ACUTE */
+#define XK_Ccaron                        0x01c8  /* U+010C LATIN CAPITAL LETTER C WITH CARON */
+#define XK_Eogonek                       0x01ca  /* U+0118 LATIN CAPITAL LETTER E WITH OGONEK */
+#define XK_Ecaron                        0x01cc  /* U+011A LATIN CAPITAL LETTER E WITH CARON */
+#define XK_Dcaron                        0x01cf  /* U+010E LATIN CAPITAL LETTER D WITH CARON */
+#define XK_Dstroke                       0x01d0  /* U+0110 LATIN CAPITAL LETTER D WITH STROKE */
+#define XK_Nacute                        0x01d1  /* U+0143 LATIN CAPITAL LETTER N WITH ACUTE */
+#define XK_Ncaron                        0x01d2  /* U+0147 LATIN CAPITAL LETTER N WITH CARON */
+#define XK_Odoubleacute                  0x01d5  /* U+0150 LATIN CAPITAL LETTER O WITH DOUBLE ACUTE */
+#define XK_Rcaron                        0x01d8  /* U+0158 LATIN CAPITAL LETTER R WITH CARON */
+#define XK_Uring                         0x01d9  /* U+016E LATIN CAPITAL LETTER U WITH RING ABOVE */
+#define XK_Udoubleacute                  0x01db  /* U+0170 LATIN CAPITAL LETTER U WITH DOUBLE ACUTE */
+#define XK_Tcedilla                      0x01de  /* U+0162 LATIN CAPITAL LETTER T WITH CEDILLA */
+#define XK_racute                        0x01e0  /* U+0155 LATIN SMALL LETTER R WITH ACUTE */
+#define XK_abreve                        0x01e3  /* U+0103 LATIN SMALL LETTER A WITH BREVE */
+#define XK_lacute                        0x01e5  /* U+013A LATIN SMALL LETTER L WITH ACUTE */
+#define XK_cacute                        0x01e6  /* U+0107 LATIN SMALL LETTER C WITH ACUTE */
+#define XK_ccaron                        0x01e8  /* U+010D LATIN SMALL LETTER C WITH CARON */
+#define XK_eogonek                       0x01ea  /* U+0119 LATIN SMALL LETTER E WITH OGONEK */
+#define XK_ecaron                        0x01ec  /* U+011B LATIN SMALL LETTER E WITH CARON */
+#define XK_dcaron                        0x01ef  /* U+010F LATIN SMALL LETTER D WITH CARON */
+#define XK_dstroke                       0x01f0  /* U+0111 LATIN SMALL LETTER D WITH STROKE */
+#define XK_nacute                        0x01f1  /* U+0144 LATIN SMALL LETTER N WITH ACUTE */
+#define XK_ncaron                        0x01f2  /* U+0148 LATIN SMALL LETTER N WITH CARON */
+#define XK_odoubleacute                  0x01f5  /* U+0151 LATIN SMALL LETTER O WITH DOUBLE ACUTE */
+#define XK_rcaron                        0x01f8  /* U+0159 LATIN SMALL LETTER R WITH CARON */
+#define XK_uring                         0x01f9  /* U+016F LATIN SMALL LETTER U WITH RING ABOVE */
+#define XK_udoubleacute                  0x01fb  /* U+0171 LATIN SMALL LETTER U WITH DOUBLE ACUTE */
+#define XK_tcedilla                      0x01fe  /* U+0163 LATIN SMALL LETTER T WITH CEDILLA */
+#define XK_abovedot                      0x01ff  /* U+02D9 DOT ABOVE */
+#endif /* XK_LATIN2 */
+
+/*
+ * Latin 3
+ * Byte 3 = 2
+ */
+
+#ifdef XK_LATIN3
+#define XK_Hstroke                       0x02a1  /* U+0126 LATIN CAPITAL LETTER H WITH STROKE */
+#define XK_Hcircumflex                   0x02a6  /* U+0124 LATIN CAPITAL LETTER H WITH CIRCUMFLEX */
+#define XK_Iabovedot                     0x02a9  /* U+0130 LATIN CAPITAL LETTER I WITH DOT ABOVE */
+#define XK_Gbreve                        0x02ab  /* U+011E LATIN CAPITAL LETTER G WITH BREVE */
+#define XK_Jcircumflex                   0x02ac  /* U+0134 LATIN CAPITAL LETTER J WITH CIRCUMFLEX */
+#define XK_hstroke                       0x02b1  /* U+0127 LATIN SMALL LETTER H WITH STROKE */
+#define XK_hcircumflex                   0x02b6  /* U+0125 LATIN SMALL LETTER H WITH CIRCUMFLEX */
+#define XK_idotless                      0x02b9  /* U+0131 LATIN SMALL LETTER DOTLESS I */
+#define XK_gbreve                        0x02bb  /* U+011F LATIN SMALL LETTER G WITH BREVE */
+#define XK_jcircumflex                   0x02bc  /* U+0135 LATIN SMALL LETTER J WITH CIRCUMFLEX */
+#define XK_Cabovedot                     0x02c5  /* U+010A LATIN CAPITAL LETTER C WITH DOT ABOVE */
+#define XK_Ccircumflex                   0x02c6  /* U+0108 LATIN CAPITAL LETTER C WITH CIRCUMFLEX */
+#define XK_Gabovedot                     0x02d5  /* U+0120 LATIN CAPITAL LETTER G WITH DOT ABOVE */
+#define XK_Gcircumflex                   0x02d8  /* U+011C LATIN CAPITAL LETTER G WITH CIRCUMFLEX */
+#define XK_Ubreve                        0x02dd  /* U+016C LATIN CAPITAL LETTER U WITH BREVE */
+#define XK_Scircumflex                   0x02de  /* U+015C LATIN CAPITAL LETTER S WITH CIRCUMFLEX */
+#define XK_cabovedot                     0x02e5  /* U+010B LATIN SMALL LETTER C WITH DOT ABOVE */
+#define XK_ccircumflex                   0x02e6  /* U+0109 LATIN SMALL LETTER C WITH CIRCUMFLEX */
+#define XK_gabovedot                     0x02f5  /* U+0121 LATIN SMALL LETTER G WITH DOT ABOVE */
+#define XK_gcircumflex                   0x02f8  /* U+011D LATIN SMALL LETTER G WITH CIRCUMFLEX */
+#define XK_ubreve                        0x02fd  /* U+016D LATIN SMALL LETTER U WITH BREVE */
+#define XK_scircumflex                   0x02fe  /* U+015D LATIN SMALL LETTER S WITH CIRCUMFLEX */
+#endif /* XK_LATIN3 */
+
+
+/*
+ * Latin 4
+ * Byte 3 = 3
+ */
+
+#ifdef XK_LATIN4
+#define XK_kra                           0x03a2  /* U+0138 LATIN SMALL LETTER KRA */
+#define XK_kappa                         0x03a2  /* deprecated */
+#define XK_Rcedilla                      0x03a3  /* U+0156 LATIN CAPITAL LETTER R WITH CEDILLA */
+#define XK_Itilde                        0x03a5  /* U+0128 LATIN CAPITAL LETTER I WITH TILDE */
+#define XK_Lcedilla                      0x03a6  /* U+013B LATIN CAPITAL LETTER L WITH CEDILLA */
+#define XK_Emacron                       0x03aa  /* U+0112 LATIN CAPITAL LETTER E WITH MACRON */
+#define XK_Gcedilla                      0x03ab  /* U+0122 LATIN CAPITAL LETTER G WITH CEDILLA */
+#define XK_Tslash                        0x03ac  /* U+0166 LATIN CAPITAL LETTER T WITH STROKE */
+#define XK_rcedilla                      0x03b3  /* U+0157 LATIN SMALL LETTER R WITH CEDILLA */
+#define XK_itilde                        0x03b5  /* U+0129 LATIN SMALL LETTER I WITH TILDE */
+#define XK_lcedilla                      0x03b6  /* U+013C LATIN SMALL LETTER L WITH CEDILLA */
+#define XK_emacron                       0x03ba  /* U+0113 LATIN SMALL LETTER E WITH MACRON */
+#define XK_gcedilla                      0x03bb  /* U+0123 LATIN SMALL LETTER G WITH CEDILLA */
+#define XK_tslash                        0x03bc  /* U+0167 LATIN SMALL LETTER T WITH STROKE */
+#define XK_ENG                           0x03bd  /* U+014A LATIN CAPITAL LETTER ENG */
+#define XK_eng                           0x03bf  /* U+014B LATIN SMALL LETTER ENG */
+#define XK_Amacron                       0x03c0  /* U+0100 LATIN CAPITAL LETTER A WITH MACRON */
+#define XK_Iogonek                       0x03c7  /* U+012E LATIN CAPITAL LETTER I WITH OGONEK */
+#define XK_Eabovedot                     0x03cc  /* U+0116 LATIN CAPITAL LETTER E WITH DOT ABOVE */
+#define XK_Imacron                       0x03cf  /* U+012A LATIN CAPITAL LETTER I WITH MACRON */
+#define XK_Ncedilla                      0x03d1  /* U+0145 LATIN CAPITAL LETTER N WITH CEDILLA */
+#define XK_Omacron                       0x03d2  /* U+014C LATIN CAPITAL LETTER O WITH MACRON */
+#define XK_Kcedilla                      0x03d3  /* U+0136 LATIN CAPITAL LETTER K WITH CEDILLA */
+#define XK_Uogonek                       0x03d9  /* U+0172 LATIN CAPITAL LETTER U WITH OGONEK */
+#define XK_Utilde                        0x03dd  /* U+0168 LATIN CAPITAL LETTER U WITH TILDE */
+#define XK_Umacron                       0x03de  /* U+016A LATIN CAPITAL LETTER U WITH MACRON */
+#define XK_amacron                       0x03e0  /* U+0101 LATIN SMALL LETTER A WITH MACRON */
+#define XK_iogonek                       0x03e7  /* U+012F LATIN SMALL LETTER I WITH OGONEK */
+#define XK_eabovedot                     0x03ec  /* U+0117 LATIN SMALL LETTER E WITH DOT ABOVE */
+#define XK_imacron                       0x03ef  /* U+012B LATIN SMALL LETTER I WITH MACRON */
+#define XK_ncedilla                      0x03f1  /* U+0146 LATIN SMALL LETTER N WITH CEDILLA */
+#define XK_omacron                       0x03f2  /* U+014D LATIN SMALL LETTER O WITH MACRON */
+#define XK_kcedilla                      0x03f3  /* U+0137 LATIN SMALL LETTER K WITH CEDILLA */
+#define XK_uogonek                       0x03f9  /* U+0173 LATIN SMALL LETTER U WITH OGONEK */
+#define XK_utilde                        0x03fd  /* U+0169 LATIN SMALL LETTER U WITH TILDE */
+#define XK_umacron                       0x03fe  /* U+016B LATIN SMALL LETTER U WITH MACRON */
+#endif /* XK_LATIN4 */
+
+/*
+ * Latin 8
+ */
+#ifdef XK_LATIN8
+#define XK_Wcircumflex                0x1000174  /* U+0174 LATIN CAPITAL LETTER W WITH CIRCUMFLEX */
+#define XK_wcircumflex                0x1000175  /* U+0175 LATIN SMALL LETTER W WITH CIRCUMFLEX */
+#define XK_Ycircumflex                0x1000176  /* U+0176 LATIN CAPITAL LETTER Y WITH CIRCUMFLEX */
+#define XK_ycircumflex                0x1000177  /* U+0177 LATIN SMALL LETTER Y WITH CIRCUMFLEX */
+#define XK_Babovedot                  0x1001e02  /* U+1E02 LATIN CAPITAL LETTER B WITH DOT ABOVE */
+#define XK_babovedot                  0x1001e03  /* U+1E03 LATIN SMALL LETTER B WITH DOT ABOVE */
+#define XK_Dabovedot                  0x1001e0a  /* U+1E0A LATIN CAPITAL LETTER D WITH DOT ABOVE */
+#define XK_dabovedot                  0x1001e0b  /* U+1E0B LATIN SMALL LETTER D WITH DOT ABOVE */
+#define XK_Fabovedot                  0x1001e1e  /* U+1E1E LATIN CAPITAL LETTER F WITH DOT ABOVE */
+#define XK_fabovedot                  0x1001e1f  /* U+1E1F LATIN SMALL LETTER F WITH DOT ABOVE */
+#define XK_Mabovedot                  0x1001e40  /* U+1E40 LATIN CAPITAL LETTER M WITH DOT ABOVE */
+#define XK_mabovedot                  0x1001e41  /* U+1E41 LATIN SMALL LETTER M WITH DOT ABOVE */
+#define XK_Pabovedot                  0x1001e56  /* U+1E56 LATIN CAPITAL LETTER P WITH DOT ABOVE */
+#define XK_pabovedot                  0x1001e57  /* U+1E57 LATIN SMALL LETTER P WITH DOT ABOVE */
+#define XK_Sabovedot                  0x1001e60  /* U+1E60 LATIN CAPITAL LETTER S WITH DOT ABOVE */
+#define XK_sabovedot                  0x1001e61  /* U+1E61 LATIN SMALL LETTER S WITH DOT ABOVE */
+#define XK_Tabovedot                  0x1001e6a  /* U+1E6A LATIN CAPITAL LETTER T WITH DOT ABOVE */
+#define XK_tabovedot                  0x1001e6b  /* U+1E6B LATIN SMALL LETTER T WITH DOT ABOVE */
+#define XK_Wgrave                     0x1001e80  /* U+1E80 LATIN CAPITAL LETTER W WITH GRAVE */
+#define XK_wgrave                     0x1001e81  /* U+1E81 LATIN SMALL LETTER W WITH GRAVE */
+#define XK_Wacute                     0x1001e82  /* U+1E82 LATIN CAPITAL LETTER W WITH ACUTE */
+#define XK_wacute                     0x1001e83  /* U+1E83 LATIN SMALL LETTER W WITH ACUTE */
+#define XK_Wdiaeresis                 0x1001e84  /* U+1E84 LATIN CAPITAL LETTER W WITH DIAERESIS */
+#define XK_wdiaeresis                 0x1001e85  /* U+1E85 LATIN SMALL LETTER W WITH DIAERESIS */
+#define XK_Ygrave                     0x1001ef2  /* U+1EF2 LATIN CAPITAL LETTER Y WITH GRAVE */
+#define XK_ygrave                     0x1001ef3  /* U+1EF3 LATIN SMALL LETTER Y WITH GRAVE */
+#endif /* XK_LATIN8 */
+
+/*
+ * Latin 9
+ * Byte 3 = 0x13
+ */
+
+#ifdef XK_LATIN9
+#define XK_OE                            0x13bc  /* U+0152 LATIN CAPITAL LIGATURE OE */
+#define XK_oe                            0x13bd  /* U+0153 LATIN SMALL LIGATURE OE */
+#define XK_Ydiaeresis                    0x13be  /* U+0178 LATIN CAPITAL LETTER Y WITH DIAERESIS */
+#endif /* XK_LATIN9 */
+
+/*
+ * Katakana
+ * Byte 3 = 4
+ */
+
+#ifdef XK_KATAKANA
+#define XK_overline                      0x047e  /* U+203E OVERLINE */
+#define XK_kana_fullstop                 0x04a1  /* U+3002 IDEOGRAPHIC FULL STOP */
+#define XK_kana_openingbracket           0x04a2  /* U+300C LEFT CORNER BRACKET */
+#define XK_kana_closingbracket           0x04a3  /* U+300D RIGHT CORNER BRACKET */
+#define XK_kana_comma                    0x04a4  /* U+3001 IDEOGRAPHIC COMMA */
+#define XK_kana_conjunctive              0x04a5  /* U+30FB KATAKANA MIDDLE DOT */
+#define XK_kana_middledot                0x04a5  /* deprecated */
+#define XK_kana_WO                       0x04a6  /* U+30F2 KATAKANA LETTER WO */
+#define XK_kana_a                        0x04a7  /* U+30A1 KATAKANA LETTER SMALL A */
+#define XK_kana_i                        0x04a8  /* U+30A3 KATAKANA LETTER SMALL I */
+#define XK_kana_u                        0x04a9  /* U+30A5 KATAKANA LETTER SMALL U */
+#define XK_kana_e                        0x04aa  /* U+30A7 KATAKANA LETTER SMALL E */
+#define XK_kana_o                        0x04ab  /* U+30A9 KATAKANA LETTER SMALL O */
+#define XK_kana_ya                       0x04ac  /* U+30E3 KATAKANA LETTER SMALL YA */
+#define XK_kana_yu                       0x04ad  /* U+30E5 KATAKANA LETTER SMALL YU */
+#define XK_kana_yo                       0x04ae  /* U+30E7 KATAKANA LETTER SMALL YO */
+#define XK_kana_tsu                      0x04af  /* U+30C3 KATAKANA LETTER SMALL TU */
+#define XK_kana_tu                       0x04af  /* deprecated */
+#define XK_prolongedsound                0x04b0  /* U+30FC KATAKANA-HIRAGANA PROLONGED SOUND MARK */
+#define XK_kana_A                        0x04b1  /* U+30A2 KATAKANA LETTER A */
+#define XK_kana_I                        0x04b2  /* U+30A4 KATAKANA LETTER I */
+#define XK_kana_U                        0x04b3  /* U+30A6 KATAKANA LETTER U */
+#define XK_kana_E                        0x04b4  /* U+30A8 KATAKANA LETTER E */
+#define XK_kana_O                        0x04b5  /* U+30AA KATAKANA LETTER O */
+#define XK_kana_KA                       0x04b6  /* U+30AB KATAKANA LETTER KA */
+#define XK_kana_KI                       0x04b7  /* U+30AD KATAKANA LETTER KI */
+#define XK_kana_KU                       0x04b8  /* U+30AF KATAKANA LETTER KU */
+#define XK_kana_KE                       0x04b9  /* U+30B1 KATAKANA LETTER KE */
+#define XK_kana_KO                       0x04ba  /* U+30B3 KATAKANA LETTER KO */
+#define XK_kana_SA                       0x04bb  /* U+30B5 KATAKANA LETTER SA */
+#define XK_kana_SHI                      0x04bc  /* U+30B7 KATAKANA LETTER SI */
+#define XK_kana_SU                       0x04bd  /* U+30B9 KATAKANA LETTER SU */
+#define XK_kana_SE                       0x04be  /* U+30BB KATAKANA LETTER SE */
+#define XK_kana_SO                       0x04bf  /* U+30BD KATAKANA LETTER SO */
+#define XK_kana_TA                       0x04c0  /* U+30BF KATAKANA LETTER TA */
+#define XK_kana_CHI                      0x04c1  /* U+30C1 KATAKANA LETTER TI */
+#define XK_kana_TI                       0x04c1  /* deprecated */
+#define XK_kana_TSU                      0x04c2  /* U+30C4 KATAKANA LETTER TU */
+#define XK_kana_TU                       0x04c2  /* deprecated */
+#define XK_kana_TE                       0x04c3  /* U+30C6 KATAKANA LETTER TE */
+#define XK_kana_TO                       0x04c4  /* U+30C8 KATAKANA LETTER TO */
+#define XK_kana_NA                       0x04c5  /* U+30CA KATAKANA LETTER NA */
+#define XK_kana_NI                       0x04c6  /* U+30CB KATAKANA LETTER NI */
+#define XK_kana_NU                       0x04c7  /* U+30CC KATAKANA LETTER NU */
+#define XK_kana_NE                       0x04c8  /* U+30CD KATAKANA LETTER NE */
+#define XK_kana_NO                       0x04c9  /* U+30CE KATAKANA LETTER NO */
+#define XK_kana_HA                       0x04ca  /* U+30CF KATAKANA LETTER HA */
+#define XK_kana_HI                       0x04cb  /* U+30D2 KATAKANA LETTER HI */
+#define XK_kana_FU                       0x04cc  /* U+30D5 KATAKANA LETTER HU */
+#define XK_kana_HU                       0x04cc  /* deprecated */
+#define XK_kana_HE                       0x04cd  /* U+30D8 KATAKANA LETTER HE */
+#define XK_kana_HO                       0x04ce  /* U+30DB KATAKANA LETTER HO */
+#define XK_kana_MA                       0x04cf  /* U+30DE KATAKANA LETTER MA */
+#define XK_kana_MI                       0x04d0  /* U+30DF KATAKANA LETTER MI */
+#define XK_kana_MU                       0x04d1  /* U+30E0 KATAKANA LETTER MU */
+#define XK_kana_ME                       0x04d2  /* U+30E1 KATAKANA LETTER ME */
+#define XK_kana_MO                       0x04d3  /* U+30E2 KATAKANA LETTER MO */
+#define XK_kana_YA                       0x04d4  /* U+30E4 KATAKANA LETTER YA */
+#define XK_kana_YU                       0x04d5  /* U+30E6 KATAKANA LETTER YU */
+#define XK_kana_YO                       0x04d6  /* U+30E8 KATAKANA LETTER YO */
+#define XK_kana_RA                       0x04d7  /* U+30E9 KATAKANA LETTER RA */
+#define XK_kana_RI                       0x04d8  /* U+30EA KATAKANA LETTER RI */
+#define XK_kana_RU                       0x04d9  /* U+30EB KATAKANA LETTER RU */
+#define XK_kana_RE                       0x04da  /* U+30EC KATAKANA LETTER RE */
+#define XK_kana_RO                       0x04db  /* U+30ED KATAKANA LETTER RO */
+#define XK_kana_WA                       0x04dc  /* U+30EF KATAKANA LETTER WA */
+#define XK_kana_N                        0x04dd  /* U+30F3 KATAKANA LETTER N */
+#define XK_voicedsound                   0x04de  /* U+309B KATAKANA-HIRAGANA VOICED SOUND MARK */
+#define XK_semivoicedsound               0x04df  /* U+309C KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK */
+#define XK_kana_switch                   0xff7e  /* Alias for mode_switch */
+#endif /* XK_KATAKANA */
+
+/*
+ * Arabic
+ * Byte 3 = 5
+ */
+
+#ifdef XK_ARABIC
+#define XK_Farsi_0                    0x10006f0  /* U+06F0 EXTENDED ARABIC-INDIC DIGIT ZERO */
+#define XK_Farsi_1                    0x10006f1  /* U+06F1 EXTENDED ARABIC-INDIC DIGIT ONE */
+#define XK_Farsi_2                    0x10006f2  /* U+06F2 EXTENDED ARABIC-INDIC DIGIT TWO */
+#define XK_Farsi_3                    0x10006f3  /* U+06F3 EXTENDED ARABIC-INDIC DIGIT THREE */
+#define XK_Farsi_4                    0x10006f4  /* U+06F4 EXTENDED ARABIC-INDIC DIGIT FOUR */
+#define XK_Farsi_5                    0x10006f5  /* U+06F5 EXTENDED ARABIC-INDIC DIGIT FIVE */
+#define XK_Farsi_6                    0x10006f6  /* U+06F6 EXTENDED ARABIC-INDIC DIGIT SIX */
+#define XK_Farsi_7                    0x10006f7  /* U+06F7 EXTENDED ARABIC-INDIC DIGIT SEVEN */
+#define XK_Farsi_8                    0x10006f8  /* U+06F8 EXTENDED ARABIC-INDIC DIGIT EIGHT */
+#define XK_Farsi_9                    0x10006f9  /* U+06F9 EXTENDED ARABIC-INDIC DIGIT NINE */
+#define XK_Arabic_percent             0x100066a  /* U+066A ARABIC PERCENT SIGN */
+#define XK_Arabic_superscript_alef    0x1000670  /* U+0670 ARABIC LETTER SUPERSCRIPT ALEF */
+#define XK_Arabic_tteh                0x1000679  /* U+0679 ARABIC LETTER TTEH */
+#define XK_Arabic_peh                 0x100067e  /* U+067E ARABIC LETTER PEH */
+#define XK_Arabic_tcheh               0x1000686  /* U+0686 ARABIC LETTER TCHEH */
+#define XK_Arabic_ddal                0x1000688  /* U+0688 ARABIC LETTER DDAL */
+#define XK_Arabic_rreh                0x1000691  /* U+0691 ARABIC LETTER RREH */
+#define XK_Arabic_comma                  0x05ac  /* U+060C ARABIC COMMA */
+#define XK_Arabic_fullstop            0x10006d4  /* U+06D4 ARABIC FULL STOP */
+#define XK_Arabic_0                   0x1000660  /* U+0660 ARABIC-INDIC DIGIT ZERO */
+#define XK_Arabic_1                   0x1000661  /* U+0661 ARABIC-INDIC DIGIT ONE */
+#define XK_Arabic_2                   0x1000662  /* U+0662 ARABIC-INDIC DIGIT TWO */
+#define XK_Arabic_3                   0x1000663  /* U+0663 ARABIC-INDIC DIGIT THREE */
+#define XK_Arabic_4                   0x1000664  /* U+0664 ARABIC-INDIC DIGIT FOUR */
+#define XK_Arabic_5                   0x1000665  /* U+0665 ARABIC-INDIC DIGIT FIVE */
+#define XK_Arabic_6                   0x1000666  /* U+0666 ARABIC-INDIC DIGIT SIX */
+#define XK_Arabic_7                   0x1000667  /* U+0667 ARABIC-INDIC DIGIT SEVEN */
+#define XK_Arabic_8                   0x1000668  /* U+0668 ARABIC-INDIC DIGIT EIGHT */
+#define XK_Arabic_9                   0x1000669  /* U+0669 ARABIC-INDIC DIGIT NINE */
+#define XK_Arabic_semicolon              0x05bb  /* U+061B ARABIC SEMICOLON */
+#define XK_Arabic_question_mark          0x05bf  /* U+061F ARABIC QUESTION MARK */
+#define XK_Arabic_hamza                  0x05c1  /* U+0621 ARABIC LETTER HAMZA */
+#define XK_Arabic_maddaonalef            0x05c2  /* U+0622 ARABIC LETTER ALEF WITH MADDA ABOVE */
+#define XK_Arabic_hamzaonalef            0x05c3  /* U+0623 ARABIC LETTER ALEF WITH HAMZA ABOVE */
+#define XK_Arabic_hamzaonwaw             0x05c4  /* U+0624 ARABIC LETTER WAW WITH HAMZA ABOVE */
+#define XK_Arabic_hamzaunderalef         0x05c5  /* U+0625 ARABIC LETTER ALEF WITH HAMZA BELOW */
+#define XK_Arabic_hamzaonyeh             0x05c6  /* U+0626 ARABIC LETTER YEH WITH HAMZA ABOVE */
+#define XK_Arabic_alef                   0x05c7  /* U+0627 ARABIC LETTER ALEF */
+#define XK_Arabic_beh                    0x05c8  /* U+0628 ARABIC LETTER BEH */
+#define XK_Arabic_tehmarbuta             0x05c9  /* U+0629 ARABIC LETTER TEH MARBUTA */
+#define XK_Arabic_teh                    0x05ca  /* U+062A ARABIC LETTER TEH */
+#define XK_Arabic_theh                   0x05cb  /* U+062B ARABIC LETTER THEH */
+#define XK_Arabic_jeem                   0x05cc  /* U+062C ARABIC LETTER JEEM */
+#define XK_Arabic_hah                    0x05cd  /* U+062D ARABIC LETTER HAH */
+#define XK_Arabic_khah                   0x05ce  /* U+062E ARABIC LETTER KHAH */
+#define XK_Arabic_dal                    0x05cf  /* U+062F ARABIC LETTER DAL */
+#define XK_Arabic_thal                   0x05d0  /* U+0630 ARABIC LETTER THAL */
+#define XK_Arabic_ra                     0x05d1  /* U+0631 ARABIC LETTER REH */
+#define XK_Arabic_zain                   0x05d2  /* U+0632 ARABIC LETTER ZAIN */
+#define XK_Arabic_seen                   0x05d3  /* U+0633 ARABIC LETTER SEEN */
+#define XK_Arabic_sheen                  0x05d4  /* U+0634 ARABIC LETTER SHEEN */
+#define XK_Arabic_sad                    0x05d5  /* U+0635 ARABIC LETTER SAD */
+#define XK_Arabic_dad                    0x05d6  /* U+0636 ARABIC LETTER DAD */
+#define XK_Arabic_tah                    0x05d7  /* U+0637 ARABIC LETTER TAH */
+#define XK_Arabic_zah                    0x05d8  /* U+0638 ARABIC LETTER ZAH */
+#define XK_Arabic_ain                    0x05d9  /* U+0639 ARABIC LETTER AIN */
+#define XK_Arabic_ghain                  0x05da  /* U+063A ARABIC LETTER GHAIN */
+#define XK_Arabic_tatweel                0x05e0  /* U+0640 ARABIC TATWEEL */
+#define XK_Arabic_feh                    0x05e1  /* U+0641 ARABIC LETTER FEH */
+#define XK_Arabic_qaf                    0x05e2  /* U+0642 ARABIC LETTER QAF */
+#define XK_Arabic_kaf                    0x05e3  /* U+0643 ARABIC LETTER KAF */
+#define XK_Arabic_lam                    0x05e4  /* U+0644 ARABIC LETTER LAM */
+#define XK_Arabic_meem                   0x05e5  /* U+0645 ARABIC LETTER MEEM */
+#define XK_Arabic_noon                   0x05e6  /* U+0646 ARABIC LETTER NOON */
+#define XK_Arabic_ha                     0x05e7  /* U+0647 ARABIC LETTER HEH */
+#define XK_Arabic_heh                    0x05e7  /* deprecated */
+#define XK_Arabic_waw                    0x05e8  /* U+0648 ARABIC LETTER WAW */
+#define XK_Arabic_alefmaksura            0x05e9  /* U+0649 ARABIC LETTER ALEF MAKSURA */
+#define XK_Arabic_yeh                    0x05ea  /* U+064A ARABIC LETTER YEH */
+#define XK_Arabic_fathatan               0x05eb  /* U+064B ARABIC FATHATAN */
+#define XK_Arabic_dammatan               0x05ec  /* U+064C ARABIC DAMMATAN */
+#define XK_Arabic_kasratan               0x05ed  /* U+064D ARABIC KASRATAN */
+#define XK_Arabic_fatha                  0x05ee  /* U+064E ARABIC FATHA */
+#define XK_Arabic_damma                  0x05ef  /* U+064F ARABIC DAMMA */
+#define XK_Arabic_kasra                  0x05f0  /* U+0650 ARABIC KASRA */
+#define XK_Arabic_shadda                 0x05f1  /* U+0651 ARABIC SHADDA */
+#define XK_Arabic_sukun                  0x05f2  /* U+0652 ARABIC SUKUN */
+#define XK_Arabic_madda_above         0x1000653  /* U+0653 ARABIC MADDAH ABOVE */
+#define XK_Arabic_hamza_above         0x1000654  /* U+0654 ARABIC HAMZA ABOVE */
+#define XK_Arabic_hamza_below         0x1000655  /* U+0655 ARABIC HAMZA BELOW */
+#define XK_Arabic_jeh                 0x1000698  /* U+0698 ARABIC LETTER JEH */
+#define XK_Arabic_veh                 0x10006a4  /* U+06A4 ARABIC LETTER VEH */
+#define XK_Arabic_keheh               0x10006a9  /* U+06A9 ARABIC LETTER KEHEH */
+#define XK_Arabic_gaf                 0x10006af  /* U+06AF ARABIC LETTER GAF */
+#define XK_Arabic_noon_ghunna         0x10006ba  /* U+06BA ARABIC LETTER NOON GHUNNA */
+#define XK_Arabic_heh_doachashmee     0x10006be  /* U+06BE ARABIC LETTER HEH DOACHASHMEE */
+#define XK_Farsi_yeh                  0x10006cc  /* U+06CC ARABIC LETTER FARSI YEH */
+#define XK_Arabic_farsi_yeh           0x10006cc  /* U+06CC ARABIC LETTER FARSI YEH */
+#define XK_Arabic_yeh_baree           0x10006d2  /* U+06D2 ARABIC LETTER YEH BARREE */
+#define XK_Arabic_heh_goal            0x10006c1  /* U+06C1 ARABIC LETTER HEH GOAL */
+#define XK_Arabic_switch                 0xff7e  /* Alias for mode_switch */
+#endif /* XK_ARABIC */
+
+/*
+ * Cyrillic
+ * Byte 3 = 6
+ */
+#ifdef XK_CYRILLIC
+#define XK_Cyrillic_GHE_bar           0x1000492  /* U+0492 CYRILLIC CAPITAL LETTER GHE WITH STROKE */
+#define XK_Cyrillic_ghe_bar           0x1000493  /* U+0493 CYRILLIC SMALL LETTER GHE WITH STROKE */
+#define XK_Cyrillic_ZHE_descender     0x1000496  /* U+0496 CYRILLIC CAPITAL LETTER ZHE WITH DESCENDER */
+#define XK_Cyrillic_zhe_descender     0x1000497  /* U+0497 CYRILLIC SMALL LETTER ZHE WITH DESCENDER */
+#define XK_Cyrillic_KA_descender      0x100049a  /* U+049A CYRILLIC CAPITAL LETTER KA WITH DESCENDER */
+#define XK_Cyrillic_ka_descender      0x100049b  /* U+049B CYRILLIC SMALL LETTER KA WITH DESCENDER */
+#define XK_Cyrillic_KA_vertstroke     0x100049c  /* U+049C CYRILLIC CAPITAL LETTER KA WITH VERTICAL STROKE */
+#define XK_Cyrillic_ka_vertstroke     0x100049d  /* U+049D CYRILLIC SMALL LETTER KA WITH VERTICAL STROKE */
+#define XK_Cyrillic_EN_descender      0x10004a2  /* U+04A2 CYRILLIC CAPITAL LETTER EN WITH DESCENDER */
+#define XK_Cyrillic_en_descender      0x10004a3  /* U+04A3 CYRILLIC SMALL LETTER EN WITH DESCENDER */
+#define XK_Cyrillic_U_straight        0x10004ae  /* U+04AE CYRILLIC CAPITAL LETTER STRAIGHT U */
+#define XK_Cyrillic_u_straight        0x10004af  /* U+04AF CYRILLIC SMALL LETTER STRAIGHT U */
+#define XK_Cyrillic_U_straight_bar    0x10004b0  /* U+04B0 CYRILLIC CAPITAL LETTER STRAIGHT U WITH STROKE */
+#define XK_Cyrillic_u_straight_bar    0x10004b1  /* U+04B1 CYRILLIC SMALL LETTER STRAIGHT U WITH STROKE */
+#define XK_Cyrillic_HA_descender      0x10004b2  /* U+04B2 CYRILLIC CAPITAL LETTER HA WITH DESCENDER */
+#define XK_Cyrillic_ha_descender      0x10004b3  /* U+04B3 CYRILLIC SMALL LETTER HA WITH DESCENDER */
+#define XK_Cyrillic_CHE_descender     0x10004b6  /* U+04B6 CYRILLIC CAPITAL LETTER CHE WITH DESCENDER */
+#define XK_Cyrillic_che_descender     0x10004b7  /* U+04B7 CYRILLIC SMALL LETTER CHE WITH DESCENDER */
+#define XK_Cyrillic_CHE_vertstroke    0x10004b8  /* U+04B8 CYRILLIC CAPITAL LETTER CHE WITH VERTICAL STROKE */
+#define XK_Cyrillic_che_vertstroke    0x10004b9  /* U+04B9 CYRILLIC SMALL LETTER CHE WITH VERTICAL STROKE */
+#define XK_Cyrillic_SHHA              0x10004ba  /* U+04BA CYRILLIC CAPITAL LETTER SHHA */
+#define XK_Cyrillic_shha              0x10004bb  /* U+04BB CYRILLIC SMALL LETTER SHHA */
+
+#define XK_Cyrillic_SCHWA             0x10004d8  /* U+04D8 CYRILLIC CAPITAL LETTER SCHWA */
+#define XK_Cyrillic_schwa             0x10004d9  /* U+04D9 CYRILLIC SMALL LETTER SCHWA */
+#define XK_Cyrillic_I_macron          0x10004e2  /* U+04E2 CYRILLIC CAPITAL LETTER I WITH MACRON */
+#define XK_Cyrillic_i_macron          0x10004e3  /* U+04E3 CYRILLIC SMALL LETTER I WITH MACRON */
+#define XK_Cyrillic_O_bar             0x10004e8  /* U+04E8 CYRILLIC CAPITAL LETTER BARRED O */
+#define XK_Cyrillic_o_bar             0x10004e9  /* U+04E9 CYRILLIC SMALL LETTER BARRED O */
+#define XK_Cyrillic_U_macron          0x10004ee  /* U+04EE CYRILLIC CAPITAL LETTER U WITH MACRON */
+#define XK_Cyrillic_u_macron          0x10004ef  /* U+04EF CYRILLIC SMALL LETTER U WITH MACRON */
+
+#define XK_Serbian_dje                   0x06a1  /* U+0452 CYRILLIC SMALL LETTER DJE */
+#define XK_Macedonia_gje                 0x06a2  /* U+0453 CYRILLIC SMALL LETTER GJE */
+#define XK_Cyrillic_io                   0x06a3  /* U+0451 CYRILLIC SMALL LETTER IO */
+#define XK_Ukrainian_ie                  0x06a4  /* U+0454 CYRILLIC SMALL LETTER UKRAINIAN IE */
+#define XK_Ukranian_je                   0x06a4  /* deprecated */
+#define XK_Macedonia_dse                 0x06a5  /* U+0455 CYRILLIC SMALL LETTER DZE */
+#define XK_Ukrainian_i                   0x06a6  /* U+0456 CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I */
+#define XK_Ukranian_i                    0x06a6  /* deprecated */
+#define XK_Ukrainian_yi                  0x06a7  /* U+0457 CYRILLIC SMALL LETTER YI */
+#define XK_Ukranian_yi                   0x06a7  /* deprecated */
+#define XK_Cyrillic_je                   0x06a8  /* U+0458 CYRILLIC SMALL LETTER JE */
+#define XK_Serbian_je                    0x06a8  /* deprecated */
+#define XK_Cyrillic_lje                  0x06a9  /* U+0459 CYRILLIC SMALL LETTER LJE */
+#define XK_Serbian_lje                   0x06a9  /* deprecated */
+#define XK_Cyrillic_nje                  0x06aa  /* U+045A CYRILLIC SMALL LETTER NJE */
+#define XK_Serbian_nje                   0x06aa  /* deprecated */
+#define XK_Serbian_tshe                  0x06ab  /* U+045B CYRILLIC SMALL LETTER TSHE */
+#define XK_Macedonia_kje                 0x06ac  /* U+045C CYRILLIC SMALL LETTER KJE */
+#define XK_Ukrainian_ghe_with_upturn     0x06ad  /* U+0491 CYRILLIC SMALL LETTER GHE WITH UPTURN */
+#define XK_Byelorussian_shortu           0x06ae  /* U+045E CYRILLIC SMALL LETTER SHORT U */
+#define XK_Cyrillic_dzhe                 0x06af  /* U+045F CYRILLIC SMALL LETTER DZHE */
+#define XK_Serbian_dze                   0x06af  /* deprecated */
+#define XK_numerosign                    0x06b0  /* U+2116 NUMERO SIGN */
+#define XK_Serbian_DJE                   0x06b1  /* U+0402 CYRILLIC CAPITAL LETTER DJE */
+#define XK_Macedonia_GJE                 0x06b2  /* U+0403 CYRILLIC CAPITAL LETTER GJE */
+#define XK_Cyrillic_IO                   0x06b3  /* U+0401 CYRILLIC CAPITAL LETTER IO */
+#define XK_Ukrainian_IE                  0x06b4  /* U+0404 CYRILLIC CAPITAL LETTER UKRAINIAN IE */
+#define XK_Ukranian_JE                   0x06b4  /* deprecated */
+#define XK_Macedonia_DSE                 0x06b5  /* U+0405 CYRILLIC CAPITAL LETTER DZE */
+#define XK_Ukrainian_I                   0x06b6  /* U+0406 CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I */
+#define XK_Ukranian_I                    0x06b6  /* deprecated */
+#define XK_Ukrainian_YI                  0x06b7  /* U+0407 CYRILLIC CAPITAL LETTER YI */
+#define XK_Ukranian_YI                   0x06b7  /* deprecated */
+#define XK_Cyrillic_JE                   0x06b8  /* U+0408 CYRILLIC CAPITAL LETTER JE */
+#define XK_Serbian_JE                    0x06b8  /* deprecated */
+#define XK_Cyrillic_LJE                  0x06b9  /* U+0409 CYRILLIC CAPITAL LETTER LJE */
+#define XK_Serbian_LJE                   0x06b9  /* deprecated */
+#define XK_Cyrillic_NJE                  0x06ba  /* U+040A CYRILLIC CAPITAL LETTER NJE */
+#define XK_Serbian_NJE                   0x06ba  /* deprecated */
+#define XK_Serbian_TSHE                  0x06bb  /* U+040B CYRILLIC CAPITAL LETTER TSHE */
+#define XK_Macedonia_KJE                 0x06bc  /* U+040C CYRILLIC CAPITAL LETTER KJE */
+#define XK_Ukrainian_GHE_WITH_UPTURN     0x06bd  /* U+0490 CYRILLIC CAPITAL LETTER GHE WITH UPTURN */
+#define XK_Byelorussian_SHORTU           0x06be  /* U+040E CYRILLIC CAPITAL LETTER SHORT U */
+#define XK_Cyrillic_DZHE                 0x06bf  /* U+040F CYRILLIC CAPITAL LETTER DZHE */
+#define XK_Serbian_DZE                   0x06bf  /* deprecated */
+#define XK_Cyrillic_yu                   0x06c0  /* U+044E CYRILLIC SMALL LETTER YU */
+#define XK_Cyrillic_a                    0x06c1  /* U+0430 CYRILLIC SMALL LETTER A */
+#define XK_Cyrillic_be                   0x06c2  /* U+0431 CYRILLIC SMALL LETTER BE */
+#define XK_Cyrillic_tse                  0x06c3  /* U+0446 CYRILLIC SMALL LETTER TSE */
+#define XK_Cyrillic_de                   0x06c4  /* U+0434 CYRILLIC SMALL LETTER DE */
+#define XK_Cyrillic_ie                   0x06c5  /* U+0435 CYRILLIC SMALL LETTER IE */
+#define XK_Cyrillic_ef                   0x06c6  /* U+0444 CYRILLIC SMALL LETTER EF */
+#define XK_Cyrillic_ghe                  0x06c7  /* U+0433 CYRILLIC SMALL LETTER GHE */
+#define XK_Cyrillic_ha                   0x06c8  /* U+0445 CYRILLIC SMALL LETTER HA */
+#define XK_Cyrillic_i                    0x06c9  /* U+0438 CYRILLIC SMALL LETTER I */
+#define XK_Cyrillic_shorti               0x06ca  /* U+0439 CYRILLIC SMALL LETTER SHORT I */
+#define XK_Cyrillic_ka                   0x06cb  /* U+043A CYRILLIC SMALL LETTER KA */
+#define XK_Cyrillic_el                   0x06cc  /* U+043B CYRILLIC SMALL LETTER EL */
+#define XK_Cyrillic_em                   0x06cd  /* U+043C CYRILLIC SMALL LETTER EM */
+#define XK_Cyrillic_en                   0x06ce  /* U+043D CYRILLIC SMALL LETTER EN */
+#define XK_Cyrillic_o                    0x06cf  /* U+043E CYRILLIC SMALL LETTER O */
+#define XK_Cyrillic_pe                   0x06d0  /* U+043F CYRILLIC SMALL LETTER PE */
+#define XK_Cyrillic_ya                   0x06d1  /* U+044F CYRILLIC SMALL LETTER YA */
+#define XK_Cyrillic_er                   0x06d2  /* U+0440 CYRILLIC SMALL LETTER ER */
+#define XK_Cyrillic_es                   0x06d3  /* U+0441 CYRILLIC SMALL LETTER ES */
+#define XK_Cyrillic_te                   0x06d4  /* U+0442 CYRILLIC SMALL LETTER TE */
+#define XK_Cyrillic_u                    0x06d5  /* U+0443 CYRILLIC SMALL LETTER U */
+#define XK_Cyrillic_zhe                  0x06d6  /* U+0436 CYRILLIC SMALL LETTER ZHE */
+#define XK_Cyrillic_ve                   0x06d7  /* U+0432 CYRILLIC SMALL LETTER VE */
+#define XK_Cyrillic_softsign             0x06d8  /* U+044C CYRILLIC SMALL LETTER SOFT SIGN */
+#define XK_Cyrillic_yeru                 0x06d9  /* U+044B CYRILLIC SMALL LETTER YERU */
+#define XK_Cyrillic_ze                   0x06da  /* U+0437 CYRILLIC SMALL LETTER ZE */
+#define XK_Cyrillic_sha                  0x06db  /* U+0448 CYRILLIC SMALL LETTER SHA */
+#define XK_Cyrillic_e                    0x06dc  /* U+044D CYRILLIC SMALL LETTER E */
+#define XK_Cyrillic_shcha                0x06dd  /* U+0449 CYRILLIC SMALL LETTER SHCHA */
+#define XK_Cyrillic_che                  0x06de  /* U+0447 CYRILLIC SMALL LETTER CHE */
+#define XK_Cyrillic_hardsign             0x06df  /* U+044A CYRILLIC SMALL LETTER HARD SIGN */
+#define XK_Cyrillic_YU                   0x06e0  /* U+042E CYRILLIC CAPITAL LETTER YU */
+#define XK_Cyrillic_A                    0x06e1  /* U+0410 CYRILLIC CAPITAL LETTER A */
+#define XK_Cyrillic_BE                   0x06e2  /* U+0411 CYRILLIC CAPITAL LETTER BE */
+#define XK_Cyrillic_TSE                  0x06e3  /* U+0426 CYRILLIC CAPITAL LETTER TSE */
+#define XK_Cyrillic_DE                   0x06e4  /* U+0414 CYRILLIC CAPITAL LETTER DE */
+#define XK_Cyrillic_IE                   0x06e5  /* U+0415 CYRILLIC CAPITAL LETTER IE */
+#define XK_Cyrillic_EF                   0x06e6  /* U+0424 CYRILLIC CAPITAL LETTER EF */
+#define XK_Cyrillic_GHE                  0x06e7  /* U+0413 CYRILLIC CAPITAL LETTER GHE */
+#define XK_Cyrillic_HA                   0x06e8  /* U+0425 CYRILLIC CAPITAL LETTER HA */
+#define XK_Cyrillic_I                    0x06e9  /* U+0418 CYRILLIC CAPITAL LETTER I */
+#define XK_Cyrillic_SHORTI               0x06ea  /* U+0419 CYRILLIC CAPITAL LETTER SHORT I */
+#define XK_Cyrillic_KA                   0x06eb  /* U+041A CYRILLIC CAPITAL LETTER KA */
+#define XK_Cyrillic_EL                   0x06ec  /* U+041B CYRILLIC CAPITAL LETTER EL */
+#define XK_Cyrillic_EM                   0x06ed  /* U+041C CYRILLIC CAPITAL LETTER EM */
+#define XK_Cyrillic_EN                   0x06ee  /* U+041D CYRILLIC CAPITAL LETTER EN */
+#define XK_Cyrillic_O                    0x06ef  /* U+041E CYRILLIC CAPITAL LETTER O */
+#define XK_Cyrillic_PE                   0x06f0  /* U+041F CYRILLIC CAPITAL LETTER PE */
+#define XK_Cyrillic_YA                   0x06f1  /* U+042F CYRILLIC CAPITAL LETTER YA */
+#define XK_Cyrillic_ER                   0x06f2  /* U+0420 CYRILLIC CAPITAL LETTER ER */
+#define XK_Cyrillic_ES                   0x06f3  /* U+0421 CYRILLIC CAPITAL LETTER ES */
+#define XK_Cyrillic_TE                   0x06f4  /* U+0422 CYRILLIC CAPITAL LETTER TE */
+#define XK_Cyrillic_U                    0x06f5  /* U+0423 CYRILLIC CAPITAL LETTER U */
+#define XK_Cyrillic_ZHE                  0x06f6  /* U+0416 CYRILLIC CAPITAL LETTER ZHE */
+#define XK_Cyrillic_VE                   0x06f7  /* U+0412 CYRILLIC CAPITAL LETTER VE */
+#define XK_Cyrillic_SOFTSIGN             0x06f8  /* U+042C CYRILLIC CAPITAL LETTER SOFT SIGN */
+#define XK_Cyrillic_YERU                 0x06f9  /* U+042B CYRILLIC CAPITAL LETTER YERU */
+#define XK_Cyrillic_ZE                   0x06fa  /* U+0417 CYRILLIC CAPITAL LETTER ZE */
+#define XK_Cyrillic_SHA                  0x06fb  /* U+0428 CYRILLIC CAPITAL LETTER SHA */
+#define XK_Cyrillic_E                    0x06fc  /* U+042D CYRILLIC CAPITAL LETTER E */
+#define XK_Cyrillic_SHCHA                0x06fd  /* U+0429 CYRILLIC CAPITAL LETTER SHCHA */
+#define XK_Cyrillic_CHE                  0x06fe  /* U+0427 CYRILLIC CAPITAL LETTER CHE */
+#define XK_Cyrillic_HARDSIGN             0x06ff  /* U+042A CYRILLIC CAPITAL LETTER HARD SIGN */
+#endif /* XK_CYRILLIC */
+
+/*
+ * Greek
+ * (based on an early draft of, and not quite identical to, ISO/IEC 8859-7)
+ * Byte 3 = 7
+ */
+
+#ifdef XK_GREEK
+#define XK_Greek_ALPHAaccent             0x07a1  /* U+0386 GREEK CAPITAL LETTER ALPHA WITH TONOS */
+#define XK_Greek_EPSILONaccent           0x07a2  /* U+0388 GREEK CAPITAL LETTER EPSILON WITH TONOS */
+#define XK_Greek_ETAaccent               0x07a3  /* U+0389 GREEK CAPITAL LETTER ETA WITH TONOS */
+#define XK_Greek_IOTAaccent              0x07a4  /* U+038A GREEK CAPITAL LETTER IOTA WITH TONOS */
+#define XK_Greek_IOTAdieresis            0x07a5  /* U+03AA GREEK CAPITAL LETTER IOTA WITH DIALYTIKA */
+#define XK_Greek_IOTAdiaeresis           0x07a5  /* old typo */
+#define XK_Greek_OMICRONaccent           0x07a7  /* U+038C GREEK CAPITAL LETTER OMICRON WITH TONOS */
+#define XK_Greek_UPSILONaccent           0x07a8  /* U+038E GREEK CAPITAL LETTER UPSILON WITH TONOS */
+#define XK_Greek_UPSILONdieresis         0x07a9  /* U+03AB GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA */
+#define XK_Greek_OMEGAaccent             0x07ab  /* U+038F GREEK CAPITAL LETTER OMEGA WITH TONOS */
+#define XK_Greek_accentdieresis          0x07ae  /* U+0385 GREEK DIALYTIKA TONOS */
+#define XK_Greek_horizbar                0x07af  /* U+2015 HORIZONTAL BAR */
+#define XK_Greek_alphaaccent             0x07b1  /* U+03AC GREEK SMALL LETTER ALPHA WITH TONOS */
+#define XK_Greek_epsilonaccent           0x07b2  /* U+03AD GREEK SMALL LETTER EPSILON WITH TONOS */
+#define XK_Greek_etaaccent               0x07b3  /* U+03AE GREEK SMALL LETTER ETA WITH TONOS */
+#define XK_Greek_iotaaccent              0x07b4  /* U+03AF GREEK SMALL LETTER IOTA WITH TONOS */
+#define XK_Greek_iotadieresis            0x07b5  /* U+03CA GREEK SMALL LETTER IOTA WITH DIALYTIKA */
+#define XK_Greek_iotaaccentdieresis      0x07b6  /* U+0390 GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS */
+#define XK_Greek_omicronaccent           0x07b7  /* U+03CC GREEK SMALL LETTER OMICRON WITH TONOS */
+#define XK_Greek_upsilonaccent           0x07b8  /* U+03CD GREEK SMALL LETTER UPSILON WITH TONOS */
+#define XK_Greek_upsilondieresis         0x07b9  /* U+03CB GREEK SMALL LETTER UPSILON WITH DIALYTIKA */
+#define XK_Greek_upsilonaccentdieresis   0x07ba  /* U+03B0 GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS */
+#define XK_Greek_omegaaccent             0x07bb  /* U+03CE GREEK SMALL LETTER OMEGA WITH TONOS */
+#define XK_Greek_ALPHA                   0x07c1  /* U+0391 GREEK CAPITAL LETTER ALPHA */
+#define XK_Greek_BETA                    0x07c2  /* U+0392 GREEK CAPITAL LETTER BETA */
+#define XK_Greek_GAMMA                   0x07c3  /* U+0393 GREEK CAPITAL LETTER GAMMA */
+#define XK_Greek_DELTA                   0x07c4  /* U+0394 GREEK CAPITAL LETTER DELTA */
+#define XK_Greek_EPSILON                 0x07c5  /* U+0395 GREEK CAPITAL LETTER EPSILON */
+#define XK_Greek_ZETA                    0x07c6  /* U+0396 GREEK CAPITAL LETTER ZETA */
+#define XK_Greek_ETA                     0x07c7  /* U+0397 GREEK CAPITAL LETTER ETA */
+#define XK_Greek_THETA                   0x07c8  /* U+0398 GREEK CAPITAL LETTER THETA */
+#define XK_Greek_IOTA                    0x07c9  /* U+0399 GREEK CAPITAL LETTER IOTA */
+#define XK_Greek_KAPPA                   0x07ca  /* U+039A GREEK CAPITAL LETTER KAPPA */
+#define XK_Greek_LAMDA                   0x07cb  /* U+039B GREEK CAPITAL LETTER LAMDA */
+#define XK_Greek_LAMBDA                  0x07cb  /* U+039B GREEK CAPITAL LETTER LAMDA */
+#define XK_Greek_MU                      0x07cc  /* U+039C GREEK CAPITAL LETTER MU */
+#define XK_Greek_NU                      0x07cd  /* U+039D GREEK CAPITAL LETTER NU */
+#define XK_Greek_XI                      0x07ce  /* U+039E GREEK CAPITAL LETTER XI */
+#define XK_Greek_OMICRON                 0x07cf  /* U+039F GREEK CAPITAL LETTER OMICRON */
+#define XK_Greek_PI                      0x07d0  /* U+03A0 GREEK CAPITAL LETTER PI */
+#define XK_Greek_RHO                     0x07d1  /* U+03A1 GREEK CAPITAL LETTER RHO */
+#define XK_Greek_SIGMA                   0x07d2  /* U+03A3 GREEK CAPITAL LETTER SIGMA */
+#define XK_Greek_TAU                     0x07d4  /* U+03A4 GREEK CAPITAL LETTER TAU */
+#define XK_Greek_UPSILON                 0x07d5  /* U+03A5 GREEK CAPITAL LETTER UPSILON */
+#define XK_Greek_PHI                     0x07d6  /* U+03A6 GREEK CAPITAL LETTER PHI */
+#define XK_Greek_CHI                     0x07d7  /* U+03A7 GREEK CAPITAL LETTER CHI */
+#define XK_Greek_PSI                     0x07d8  /* U+03A8 GREEK CAPITAL LETTER PSI */
+#define XK_Greek_OMEGA                   0x07d9  /* U+03A9 GREEK CAPITAL LETTER OMEGA */
+#define XK_Greek_alpha                   0x07e1  /* U+03B1 GREEK SMALL LETTER ALPHA */
+#define XK_Greek_beta                    0x07e2  /* U+03B2 GREEK SMALL LETTER BETA */
+#define XK_Greek_gamma                   0x07e3  /* U+03B3 GREEK SMALL LETTER GAMMA */
+#define XK_Greek_delta                   0x07e4  /* U+03B4 GREEK SMALL LETTER DELTA */
+#define XK_Greek_epsilon                 0x07e5  /* U+03B5 GREEK SMALL LETTER EPSILON */
+#define XK_Greek_zeta                    0x07e6  /* U+03B6 GREEK SMALL LETTER ZETA */
+#define XK_Greek_eta                     0x07e7  /* U+03B7 GREEK SMALL LETTER ETA */
+#define XK_Greek_theta                   0x07e8  /* U+03B8 GREEK SMALL LETTER THETA */
+#define XK_Greek_iota                    0x07e9  /* U+03B9 GREEK SMALL LETTER IOTA */
+#define XK_Greek_kappa                   0x07ea  /* U+03BA GREEK SMALL LETTER KAPPA */
+#define XK_Greek_lamda                   0x07eb  /* U+03BB GREEK SMALL LETTER LAMDA */
+#define XK_Greek_lambda                  0x07eb  /* U+03BB GREEK SMALL LETTER LAMDA */
+#define XK_Greek_mu                      0x07ec  /* U+03BC GREEK SMALL LETTER MU */
+#define XK_Greek_nu                      0x07ed  /* U+03BD GREEK SMALL LETTER NU */
+#define XK_Greek_xi                      0x07ee  /* U+03BE GREEK SMALL LETTER XI */
+#define XK_Greek_omicron                 0x07ef  /* U+03BF GREEK SMALL LETTER OMICRON */
+#define XK_Greek_pi                      0x07f0  /* U+03C0 GREEK SMALL LETTER PI */
+#define XK_Greek_rho                     0x07f1  /* U+03C1 GREEK SMALL LETTER RHO */
+#define XK_Greek_sigma                   0x07f2  /* U+03C3 GREEK SMALL LETTER SIGMA */
+#define XK_Greek_finalsmallsigma         0x07f3  /* U+03C2 GREEK SMALL LETTER FINAL SIGMA */
+#define XK_Greek_tau                     0x07f4  /* U+03C4 GREEK SMALL LETTER TAU */
+#define XK_Greek_upsilon                 0x07f5  /* U+03C5 GREEK SMALL LETTER UPSILON */
+#define XK_Greek_phi                     0x07f6  /* U+03C6 GREEK SMALL LETTER PHI */
+#define XK_Greek_chi                     0x07f7  /* U+03C7 GREEK SMALL LETTER CHI */
+#define XK_Greek_psi                     0x07f8  /* U+03C8 GREEK SMALL LETTER PSI */
+#define XK_Greek_omega                   0x07f9  /* U+03C9 GREEK SMALL LETTER OMEGA */
+#define XK_Greek_switch                  0xff7e  /* Alias for mode_switch */
+#endif /* XK_GREEK */
+
+/*
+ * Technical
+ * (from the DEC VT330/VT420 Technical Character Set, http://vt100.net/charsets/technical.html)
+ * Byte 3 = 8
+ */
+
+#ifdef XK_TECHNICAL
+#define XK_leftradical                   0x08a1  /* U+23B7 RADICAL SYMBOL BOTTOM */
+#define XK_topleftradical                0x08a2  /*(U+250C BOX DRAWINGS LIGHT DOWN AND RIGHT)*/
+#define XK_horizconnector                0x08a3  /*(U+2500 BOX DRAWINGS LIGHT HORIZONTAL)*/
+#define XK_topintegral                   0x08a4  /* U+2320 TOP HALF INTEGRAL */
+#define XK_botintegral                   0x08a5  /* U+2321 BOTTOM HALF INTEGRAL */
+#define XK_vertconnector                 0x08a6  /*(U+2502 BOX DRAWINGS LIGHT VERTICAL)*/
+#define XK_topleftsqbracket              0x08a7  /* U+23A1 LEFT SQUARE BRACKET UPPER CORNER */
+#define XK_botleftsqbracket              0x08a8  /* U+23A3 LEFT SQUARE BRACKET LOWER CORNER */
+#define XK_toprightsqbracket             0x08a9  /* U+23A4 RIGHT SQUARE BRACKET UPPER CORNER */
+#define XK_botrightsqbracket             0x08aa  /* U+23A6 RIGHT SQUARE BRACKET LOWER CORNER */
+#define XK_topleftparens                 0x08ab  /* U+239B LEFT PARENTHESIS UPPER HOOK */
+#define XK_botleftparens                 0x08ac  /* U+239D LEFT PARENTHESIS LOWER HOOK */
+#define XK_toprightparens                0x08ad  /* U+239E RIGHT PARENTHESIS UPPER HOOK */
+#define XK_botrightparens                0x08ae  /* U+23A0 RIGHT PARENTHESIS LOWER HOOK */
+#define XK_leftmiddlecurlybrace          0x08af  /* U+23A8 LEFT CURLY BRACKET MIDDLE PIECE */
+#define XK_rightmiddlecurlybrace         0x08b0  /* U+23AC RIGHT CURLY BRACKET MIDDLE PIECE */
+#define XK_topleftsummation              0x08b1
+#define XK_botleftsummation              0x08b2
+#define XK_topvertsummationconnector     0x08b3
+#define XK_botvertsummationconnector     0x08b4
+#define XK_toprightsummation             0x08b5
+#define XK_botrightsummation             0x08b6
+#define XK_rightmiddlesummation          0x08b7
+#define XK_lessthanequal                 0x08bc  /* U+2264 LESS-THAN OR EQUAL TO */
+#define XK_notequal                      0x08bd  /* U+2260 NOT EQUAL TO */
+#define XK_greaterthanequal              0x08be  /* U+2265 GREATER-THAN OR EQUAL TO */
+#define XK_integral                      0x08bf  /* U+222B INTEGRAL */
+#define XK_therefore                     0x08c0  /* U+2234 THEREFORE */
+#define XK_variation                     0x08c1  /* U+221D PROPORTIONAL TO */
+#define XK_infinity                      0x08c2  /* U+221E INFINITY */
+#define XK_nabla                         0x08c5  /* U+2207 NABLA */
+#define XK_approximate                   0x08c8  /* U+223C TILDE OPERATOR */
+#define XK_similarequal                  0x08c9  /* U+2243 ASYMPTOTICALLY EQUAL TO */
+#define XK_ifonlyif                      0x08cd  /* U+21D4 LEFT RIGHT DOUBLE ARROW */
+#define XK_implies                       0x08ce  /* U+21D2 RIGHTWARDS DOUBLE ARROW */
+#define XK_identical                     0x08cf  /* U+2261 IDENTICAL TO */
+#define XK_radical                       0x08d6  /* U+221A SQUARE ROOT */
+#define XK_includedin                    0x08da  /* U+2282 SUBSET OF */
+#define XK_includes                      0x08db  /* U+2283 SUPERSET OF */
+#define XK_intersection                  0x08dc  /* U+2229 INTERSECTION */
+#define XK_union                         0x08dd  /* U+222A UNION */
+#define XK_logicaland                    0x08de  /* U+2227 LOGICAL AND */
+#define XK_logicalor                     0x08df  /* U+2228 LOGICAL OR */
+#define XK_partialderivative             0x08ef  /* U+2202 PARTIAL DIFFERENTIAL */
+#define XK_function                      0x08f6  /* U+0192 LATIN SMALL LETTER F WITH HOOK */
+#define XK_leftarrow                     0x08fb  /* U+2190 LEFTWARDS ARROW */
+#define XK_uparrow                       0x08fc  /* U+2191 UPWARDS ARROW */
+#define XK_rightarrow                    0x08fd  /* U+2192 RIGHTWARDS ARROW */
+#define XK_downarrow                     0x08fe  /* U+2193 DOWNWARDS ARROW */
+#endif /* XK_TECHNICAL */
+
+/*
+ * Special
+ * (from the DEC VT100 Special Graphics Character Set)
+ * Byte 3 = 9
+ */
+
+#ifdef XK_SPECIAL
+#define XK_blank                         0x09df
+#define XK_soliddiamond                  0x09e0  /* U+25C6 BLACK DIAMOND */
+#define XK_checkerboard                  0x09e1  /* U+2592 MEDIUM SHADE */
+#define XK_ht                            0x09e2  /* U+2409 SYMBOL FOR HORIZONTAL TABULATION */
+#define XK_ff                            0x09e3  /* U+240C SYMBOL FOR FORM FEED */
+#define XK_cr                            0x09e4  /* U+240D SYMBOL FOR CARRIAGE RETURN */
+#define XK_lf                            0x09e5  /* U+240A SYMBOL FOR LINE FEED */
+#define XK_nl                            0x09e8  /* U+2424 SYMBOL FOR NEWLINE */
+#define XK_vt                            0x09e9  /* U+240B SYMBOL FOR VERTICAL TABULATION */
+#define XK_lowrightcorner                0x09ea  /* U+2518 BOX DRAWINGS LIGHT UP AND LEFT */
+#define XK_uprightcorner                 0x09eb  /* U+2510 BOX DRAWINGS LIGHT DOWN AND LEFT */
+#define XK_upleftcorner                  0x09ec  /* U+250C BOX DRAWINGS LIGHT DOWN AND RIGHT */
+#define XK_lowleftcorner                 0x09ed  /* U+2514 BOX DRAWINGS LIGHT UP AND RIGHT */
+#define XK_crossinglines                 0x09ee  /* U+253C BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL */
+#define XK_horizlinescan1                0x09ef  /* U+23BA HORIZONTAL SCAN LINE-1 */
+#define XK_horizlinescan3                0x09f0  /* U+23BB HORIZONTAL SCAN LINE-3 */
+#define XK_horizlinescan5                0x09f1  /* U+2500 BOX DRAWINGS LIGHT HORIZONTAL */
+#define XK_horizlinescan7                0x09f2  /* U+23BC HORIZONTAL SCAN LINE-7 */
+#define XK_horizlinescan9                0x09f3  /* U+23BD HORIZONTAL SCAN LINE-9 */
+#define XK_leftt                         0x09f4  /* U+251C BOX DRAWINGS LIGHT VERTICAL AND RIGHT */
+#define XK_rightt                        0x09f5  /* U+2524 BOX DRAWINGS LIGHT VERTICAL AND LEFT */
+#define XK_bott                          0x09f6  /* U+2534 BOX DRAWINGS LIGHT UP AND HORIZONTAL */
+#define XK_topt                          0x09f7  /* U+252C BOX DRAWINGS LIGHT DOWN AND HORIZONTAL */
+#define XK_vertbar                       0x09f8  /* U+2502 BOX DRAWINGS LIGHT VERTICAL */
+#endif /* XK_SPECIAL */
+
+/*
+ * Publishing
+ * (these are probably from a long forgotten DEC Publishing
+ * font that once shipped with DECwrite)
+ * Byte 3 = 0x0a
+ */
+
+#ifdef XK_PUBLISHING
+#define XK_emspace                       0x0aa1  /* U+2003 EM SPACE */
+#define XK_enspace                       0x0aa2  /* U+2002 EN SPACE */
+#define XK_em3space                      0x0aa3  /* U+2004 THREE-PER-EM SPACE */
+#define XK_em4space                      0x0aa4  /* U+2005 FOUR-PER-EM SPACE */
+#define XK_digitspace                    0x0aa5  /* U+2007 FIGURE SPACE */
+#define XK_punctspace                    0x0aa6  /* U+2008 PUNCTUATION SPACE */
+#define XK_thinspace                     0x0aa7  /* U+2009 THIN SPACE */
+#define XK_hairspace                     0x0aa8  /* U+200A HAIR SPACE */
+#define XK_emdash                        0x0aa9  /* U+2014 EM DASH */
+#define XK_endash                        0x0aaa  /* U+2013 EN DASH */
+#define XK_signifblank                   0x0aac  /*(U+2423 OPEN BOX)*/
+#define XK_ellipsis                      0x0aae  /* U+2026 HORIZONTAL ELLIPSIS */
+#define XK_doubbaselinedot               0x0aaf  /* U+2025 TWO DOT LEADER */
+#define XK_onethird                      0x0ab0  /* U+2153 VULGAR FRACTION ONE THIRD */
+#define XK_twothirds                     0x0ab1  /* U+2154 VULGAR FRACTION TWO THIRDS */
+#define XK_onefifth                      0x0ab2  /* U+2155 VULGAR FRACTION ONE FIFTH */
+#define XK_twofifths                     0x0ab3  /* U+2156 VULGAR FRACTION TWO FIFTHS */
+#define XK_threefifths                   0x0ab4  /* U+2157 VULGAR FRACTION THREE FIFTHS */
+#define XK_fourfifths                    0x0ab5  /* U+2158 VULGAR FRACTION FOUR FIFTHS */
+#define XK_onesixth                      0x0ab6  /* U+2159 VULGAR FRACTION ONE SIXTH */
+#define XK_fivesixths                    0x0ab7  /* U+215A VULGAR FRACTION FIVE SIXTHS */
+#define XK_careof                        0x0ab8  /* U+2105 CARE OF */
+#define XK_figdash                       0x0abb  /* U+2012 FIGURE DASH */
+#define XK_leftanglebracket              0x0abc  /*(U+2329 LEFT-POINTING ANGLE BRACKET)*/
+#define XK_decimalpoint                  0x0abd  /*(U+002E FULL STOP)*/
+#define XK_rightanglebracket             0x0abe  /*(U+232A RIGHT-POINTING ANGLE BRACKET)*/
+#define XK_marker                        0x0abf
+#define XK_oneeighth                     0x0ac3  /* U+215B VULGAR FRACTION ONE EIGHTH */
+#define XK_threeeighths                  0x0ac4  /* U+215C VULGAR FRACTION THREE EIGHTHS */
+#define XK_fiveeighths                   0x0ac5  /* U+215D VULGAR FRACTION FIVE EIGHTHS */
+#define XK_seveneighths                  0x0ac6  /* U+215E VULGAR FRACTION SEVEN EIGHTHS */
+#define XK_trademark                     0x0ac9  /* U+2122 TRADE MARK SIGN */
+#define XK_signaturemark                 0x0aca  /*(U+2613 SALTIRE)*/
+#define XK_trademarkincircle             0x0acb
+#define XK_leftopentriangle              0x0acc  /*(U+25C1 WHITE LEFT-POINTING TRIANGLE)*/
+#define XK_rightopentriangle             0x0acd  /*(U+25B7 WHITE RIGHT-POINTING TRIANGLE)*/
+#define XK_emopencircle                  0x0ace  /*(U+25CB WHITE CIRCLE)*/
+#define XK_emopenrectangle               0x0acf  /*(U+25AF WHITE VERTICAL RECTANGLE)*/
+#define XK_leftsinglequotemark           0x0ad0  /* U+2018 LEFT SINGLE QUOTATION MARK */
+#define XK_rightsinglequotemark          0x0ad1  /* U+2019 RIGHT SINGLE QUOTATION MARK */
+#define XK_leftdoublequotemark           0x0ad2  /* U+201C LEFT DOUBLE QUOTATION MARK */
+#define XK_rightdoublequotemark          0x0ad3  /* U+201D RIGHT DOUBLE QUOTATION MARK */
+#define XK_prescription                  0x0ad4  /* U+211E PRESCRIPTION TAKE */
+#define XK_permille                      0x0ad5  /* U+2030 PER MILLE SIGN */
+#define XK_minutes                       0x0ad6  /* U+2032 PRIME */
+#define XK_seconds                       0x0ad7  /* U+2033 DOUBLE PRIME */
+#define XK_latincross                    0x0ad9  /* U+271D LATIN CROSS */
+#define XK_hexagram                      0x0ada
+#define XK_filledrectbullet              0x0adb  /*(U+25AC BLACK RECTANGLE)*/
+#define XK_filledlefttribullet           0x0adc  /*(U+25C0 BLACK LEFT-POINTING TRIANGLE)*/
+#define XK_filledrighttribullet          0x0add  /*(U+25B6 BLACK RIGHT-POINTING TRIANGLE)*/
+#define XK_emfilledcircle                0x0ade  /*(U+25CF BLACK CIRCLE)*/
+#define XK_emfilledrect                  0x0adf  /*(U+25AE BLACK VERTICAL RECTANGLE)*/
+#define XK_enopencircbullet              0x0ae0  /*(U+25E6 WHITE BULLET)*/
+#define XK_enopensquarebullet            0x0ae1  /*(U+25AB WHITE SMALL SQUARE)*/
+#define XK_openrectbullet                0x0ae2  /*(U+25AD WHITE RECTANGLE)*/
+#define XK_opentribulletup               0x0ae3  /*(U+25B3 WHITE UP-POINTING TRIANGLE)*/
+#define XK_opentribulletdown             0x0ae4  /*(U+25BD WHITE DOWN-POINTING TRIANGLE)*/
+#define XK_openstar                      0x0ae5  /*(U+2606 WHITE STAR)*/
+#define XK_enfilledcircbullet            0x0ae6  /*(U+2022 BULLET)*/
+#define XK_enfilledsqbullet              0x0ae7  /*(U+25AA BLACK SMALL SQUARE)*/
+#define XK_filledtribulletup             0x0ae8  /*(U+25B2 BLACK UP-POINTING TRIANGLE)*/
+#define XK_filledtribulletdown           0x0ae9  /*(U+25BC BLACK DOWN-POINTING TRIANGLE)*/
+#define XK_leftpointer                   0x0aea  /*(U+261C WHITE LEFT POINTING INDEX)*/
+#define XK_rightpointer                  0x0aeb  /*(U+261E WHITE RIGHT POINTING INDEX)*/
+#define XK_club                          0x0aec  /* U+2663 BLACK CLUB SUIT */
+#define XK_diamond                       0x0aed  /* U+2666 BLACK DIAMOND SUIT */
+#define XK_heart                         0x0aee  /* U+2665 BLACK HEART SUIT */
+#define XK_maltesecross                  0x0af0  /* U+2720 MALTESE CROSS */
+#define XK_dagger                        0x0af1  /* U+2020 DAGGER */
+#define XK_doubledagger                  0x0af2  /* U+2021 DOUBLE DAGGER */
+#define XK_checkmark                     0x0af3  /* U+2713 CHECK MARK */
+#define XK_ballotcross                   0x0af4  /* U+2717 BALLOT X */
+#define XK_musicalsharp                  0x0af5  /* U+266F MUSIC SHARP SIGN */
+#define XK_musicalflat                   0x0af6  /* U+266D MUSIC FLAT SIGN */
+#define XK_malesymbol                    0x0af7  /* U+2642 MALE SIGN */
+#define XK_femalesymbol                  0x0af8  /* U+2640 FEMALE SIGN */
+#define XK_telephone                     0x0af9  /* U+260E BLACK TELEPHONE */
+#define XK_telephonerecorder             0x0afa  /* U+2315 TELEPHONE RECORDER */
+#define XK_phonographcopyright           0x0afb  /* U+2117 SOUND RECORDING COPYRIGHT */
+#define XK_caret                         0x0afc  /* U+2038 CARET */
+#define XK_singlelowquotemark            0x0afd  /* U+201A SINGLE LOW-9 QUOTATION MARK */
+#define XK_doublelowquotemark            0x0afe  /* U+201E DOUBLE LOW-9 QUOTATION MARK */
+#define XK_cursor                        0x0aff
+#endif /* XK_PUBLISHING */
+
+/*
+ * APL
+ * Byte 3 = 0x0b
+ */
+
+#ifdef XK_APL
+#define XK_leftcaret                     0x0ba3  /*(U+003C LESS-THAN SIGN)*/
+#define XK_rightcaret                    0x0ba6  /*(U+003E GREATER-THAN SIGN)*/
+#define XK_downcaret                     0x0ba8  /*(U+2228 LOGICAL OR)*/
+#define XK_upcaret                       0x0ba9  /*(U+2227 LOGICAL AND)*/
+#define XK_overbar                       0x0bc0  /*(U+00AF MACRON)*/
+#define XK_downtack                      0x0bc2  /* U+22A4 DOWN TACK */
+#define XK_upshoe                        0x0bc3  /*(U+2229 INTERSECTION)*/
+#define XK_downstile                     0x0bc4  /* U+230A LEFT FLOOR */
+#define XK_underbar                      0x0bc6  /*(U+005F LOW LINE)*/
+#define XK_jot                           0x0bca  /* U+2218 RING OPERATOR */
+#define XK_quad                          0x0bcc  /* U+2395 APL FUNCTIONAL SYMBOL QUAD */
+#define XK_uptack                        0x0bce  /* U+22A5 UP TACK */
+#define XK_circle                        0x0bcf  /* U+25CB WHITE CIRCLE */
+#define XK_upstile                       0x0bd3  /* U+2308 LEFT CEILING */
+#define XK_downshoe                      0x0bd6  /*(U+222A UNION)*/
+#define XK_rightshoe                     0x0bd8  /*(U+2283 SUPERSET OF)*/
+#define XK_leftshoe                      0x0bda  /*(U+2282 SUBSET OF)*/
+#define XK_lefttack                      0x0bdc  /* U+22A3 LEFT TACK */
+#define XK_righttack                     0x0bfc  /* U+22A2 RIGHT TACK */
+#endif /* XK_APL */
+
+/*
+ * Hebrew
+ * Byte 3 = 0x0c
+ */
+
+#ifdef XK_HEBREW
+#define XK_hebrew_doublelowline          0x0cdf  /* U+2017 DOUBLE LOW LINE */
+#define XK_hebrew_aleph                  0x0ce0  /* U+05D0 HEBREW LETTER ALEF */
+#define XK_hebrew_bet                    0x0ce1  /* U+05D1 HEBREW LETTER BET */
+#define XK_hebrew_beth                   0x0ce1  /* deprecated */
+#define XK_hebrew_gimel                  0x0ce2  /* U+05D2 HEBREW LETTER GIMEL */
+#define XK_hebrew_gimmel                 0x0ce2  /* deprecated */
+#define XK_hebrew_dalet                  0x0ce3  /* U+05D3 HEBREW LETTER DALET */
+#define XK_hebrew_daleth                 0x0ce3  /* deprecated */
+#define XK_hebrew_he                     0x0ce4  /* U+05D4 HEBREW LETTER HE */
+#define XK_hebrew_waw                    0x0ce5  /* U+05D5 HEBREW LETTER VAV */
+#define XK_hebrew_zain                   0x0ce6  /* U+05D6 HEBREW LETTER ZAYIN */
+#define XK_hebrew_zayin                  0x0ce6  /* deprecated */
+#define XK_hebrew_chet                   0x0ce7  /* U+05D7 HEBREW LETTER HET */
+#define XK_hebrew_het                    0x0ce7  /* deprecated */
+#define XK_hebrew_tet                    0x0ce8  /* U+05D8 HEBREW LETTER TET */
+#define XK_hebrew_teth                   0x0ce8  /* deprecated */
+#define XK_hebrew_yod                    0x0ce9  /* U+05D9 HEBREW LETTER YOD */
+#define XK_hebrew_finalkaph              0x0cea  /* U+05DA HEBREW LETTER FINAL KAF */
+#define XK_hebrew_kaph                   0x0ceb  /* U+05DB HEBREW LETTER KAF */
+#define XK_hebrew_lamed                  0x0cec  /* U+05DC HEBREW LETTER LAMED */
+#define XK_hebrew_finalmem               0x0ced  /* U+05DD HEBREW LETTER FINAL MEM */
+#define XK_hebrew_mem                    0x0cee  /* U+05DE HEBREW LETTER MEM */
+#define XK_hebrew_finalnun               0x0cef  /* U+05DF HEBREW LETTER FINAL NUN */
+#define XK_hebrew_nun                    0x0cf0  /* U+05E0 HEBREW LETTER NUN */
+#define XK_hebrew_samech                 0x0cf1  /* U+05E1 HEBREW LETTER SAMEKH */
+#define XK_hebrew_samekh                 0x0cf1  /* deprecated */
+#define XK_hebrew_ayin                   0x0cf2  /* U+05E2 HEBREW LETTER AYIN */
+#define XK_hebrew_finalpe                0x0cf3  /* U+05E3 HEBREW LETTER FINAL PE */
+#define XK_hebrew_pe                     0x0cf4  /* U+05E4 HEBREW LETTER PE */
+#define XK_hebrew_finalzade              0x0cf5  /* U+05E5 HEBREW LETTER FINAL TSADI */
+#define XK_hebrew_finalzadi              0x0cf5  /* deprecated */
+#define XK_hebrew_zade                   0x0cf6  /* U+05E6 HEBREW LETTER TSADI */
+#define XK_hebrew_zadi                   0x0cf6  /* deprecated */
+#define XK_hebrew_qoph                   0x0cf7  /* U+05E7 HEBREW LETTER QOF */
+#define XK_hebrew_kuf                    0x0cf7  /* deprecated */
+#define XK_hebrew_resh                   0x0cf8  /* U+05E8 HEBREW LETTER RESH */
+#define XK_hebrew_shin                   0x0cf9  /* U+05E9 HEBREW LETTER SHIN */
+#define XK_hebrew_taw                    0x0cfa  /* U+05EA HEBREW LETTER TAV */
+#define XK_hebrew_taf                    0x0cfa  /* deprecated */
+#define XK_Hebrew_switch                 0xff7e  /* Alias for mode_switch */
+#endif /* XK_HEBREW */
+
+/*
+ * Thai
+ * Byte 3 = 0x0d
+ */
+
+#ifdef XK_THAI
+#define XK_Thai_kokai                    0x0da1  /* U+0E01 THAI CHARACTER KO KAI */
+#define XK_Thai_khokhai                  0x0da2  /* U+0E02 THAI CHARACTER KHO KHAI */
+#define XK_Thai_khokhuat                 0x0da3  /* U+0E03 THAI CHARACTER KHO KHUAT */
+#define XK_Thai_khokhwai                 0x0da4  /* U+0E04 THAI CHARACTER KHO KHWAI */
+#define XK_Thai_khokhon                  0x0da5  /* U+0E05 THAI CHARACTER KHO KHON */
+#define XK_Thai_khorakhang               0x0da6  /* U+0E06 THAI CHARACTER KHO RAKHANG */
+#define XK_Thai_ngongu                   0x0da7  /* U+0E07 THAI CHARACTER NGO NGU */
+#define XK_Thai_chochan                  0x0da8  /* U+0E08 THAI CHARACTER CHO CHAN */
+#define XK_Thai_choching                 0x0da9  /* U+0E09 THAI CHARACTER CHO CHING */
+#define XK_Thai_chochang                 0x0daa  /* U+0E0A THAI CHARACTER CHO CHANG */
+#define XK_Thai_soso                     0x0dab  /* U+0E0B THAI CHARACTER SO SO */
+#define XK_Thai_chochoe                  0x0dac  /* U+0E0C THAI CHARACTER CHO CHOE */
+#define XK_Thai_yoying                   0x0dad  /* U+0E0D THAI CHARACTER YO YING */
+#define XK_Thai_dochada                  0x0dae  /* U+0E0E THAI CHARACTER DO CHADA */
+#define XK_Thai_topatak                  0x0daf  /* U+0E0F THAI CHARACTER TO PATAK */
+#define XK_Thai_thothan                  0x0db0  /* U+0E10 THAI CHARACTER THO THAN */
+#define XK_Thai_thonangmontho            0x0db1  /* U+0E11 THAI CHARACTER THO NANGMONTHO */
+#define XK_Thai_thophuthao               0x0db2  /* U+0E12 THAI CHARACTER THO PHUTHAO */
+#define XK_Thai_nonen                    0x0db3  /* U+0E13 THAI CHARACTER NO NEN */
+#define XK_Thai_dodek                    0x0db4  /* U+0E14 THAI CHARACTER DO DEK */
+#define XK_Thai_totao                    0x0db5  /* U+0E15 THAI CHARACTER TO TAO */
+#define XK_Thai_thothung                 0x0db6  /* U+0E16 THAI CHARACTER THO THUNG */
+#define XK_Thai_thothahan                0x0db7  /* U+0E17 THAI CHARACTER THO THAHAN */
+#define XK_Thai_thothong                 0x0db8  /* U+0E18 THAI CHARACTER THO THONG */
+#define XK_Thai_nonu                     0x0db9  /* U+0E19 THAI CHARACTER NO NU */
+#define XK_Thai_bobaimai                 0x0dba  /* U+0E1A THAI CHARACTER BO BAIMAI */
+#define XK_Thai_popla                    0x0dbb  /* U+0E1B THAI CHARACTER PO PLA */
+#define XK_Thai_phophung                 0x0dbc  /* U+0E1C THAI CHARACTER PHO PHUNG */
+#define XK_Thai_fofa                     0x0dbd  /* U+0E1D THAI CHARACTER FO FA */
+#define XK_Thai_phophan                  0x0dbe  /* U+0E1E THAI CHARACTER PHO PHAN */
+#define XK_Thai_fofan                    0x0dbf  /* U+0E1F THAI CHARACTER FO FAN */
+#define XK_Thai_phosamphao               0x0dc0  /* U+0E20 THAI CHARACTER PHO SAMPHAO */
+#define XK_Thai_moma                     0x0dc1  /* U+0E21 THAI CHARACTER MO MA */
+#define XK_Thai_yoyak                    0x0dc2  /* U+0E22 THAI CHARACTER YO YAK */
+#define XK_Thai_rorua                    0x0dc3  /* U+0E23 THAI CHARACTER RO RUA */
+#define XK_Thai_ru                       0x0dc4  /* U+0E24 THAI CHARACTER RU */
+#define XK_Thai_loling                   0x0dc5  /* U+0E25 THAI CHARACTER LO LING */
+#define XK_Thai_lu                       0x0dc6  /* U+0E26 THAI CHARACTER LU */
+#define XK_Thai_wowaen                   0x0dc7  /* U+0E27 THAI CHARACTER WO WAEN */
+#define XK_Thai_sosala                   0x0dc8  /* U+0E28 THAI CHARACTER SO SALA */
+#define XK_Thai_sorusi                   0x0dc9  /* U+0E29 THAI CHARACTER SO RUSI */
+#define XK_Thai_sosua                    0x0dca  /* U+0E2A THAI CHARACTER SO SUA */
+#define XK_Thai_hohip                    0x0dcb  /* U+0E2B THAI CHARACTER HO HIP */
+#define XK_Thai_lochula                  0x0dcc  /* U+0E2C THAI CHARACTER LO CHULA */
+#define XK_Thai_oang                     0x0dcd  /* U+0E2D THAI CHARACTER O ANG */
+#define XK_Thai_honokhuk                 0x0dce  /* U+0E2E THAI CHARACTER HO NOKHUK */
+#define XK_Thai_paiyannoi                0x0dcf  /* U+0E2F THAI CHARACTER PAIYANNOI */
+#define XK_Thai_saraa                    0x0dd0  /* U+0E30 THAI CHARACTER SARA A */
+#define XK_Thai_maihanakat               0x0dd1  /* U+0E31 THAI CHARACTER MAI HAN-AKAT */
+#define XK_Thai_saraaa                   0x0dd2  /* U+0E32 THAI CHARACTER SARA AA */
+#define XK_Thai_saraam                   0x0dd3  /* U+0E33 THAI CHARACTER SARA AM */
+#define XK_Thai_sarai                    0x0dd4  /* U+0E34 THAI CHARACTER SARA I */
+#define XK_Thai_saraii                   0x0dd5  /* U+0E35 THAI CHARACTER SARA II */
+#define XK_Thai_saraue                   0x0dd6  /* U+0E36 THAI CHARACTER SARA UE */
+#define XK_Thai_sarauee                  0x0dd7  /* U+0E37 THAI CHARACTER SARA UEE */
+#define XK_Thai_sarau                    0x0dd8  /* U+0E38 THAI CHARACTER SARA U */
+#define XK_Thai_sarauu                   0x0dd9  /* U+0E39 THAI CHARACTER SARA UU */
+#define XK_Thai_phinthu                  0x0dda  /* U+0E3A THAI CHARACTER PHINTHU */
+#define XK_Thai_maihanakat_maitho        0x0dde
+#define XK_Thai_baht                     0x0ddf  /* U+0E3F THAI CURRENCY SYMBOL BAHT */
+#define XK_Thai_sarae                    0x0de0  /* U+0E40 THAI CHARACTER SARA E */
+#define XK_Thai_saraae                   0x0de1  /* U+0E41 THAI CHARACTER SARA AE */
+#define XK_Thai_sarao                    0x0de2  /* U+0E42 THAI CHARACTER SARA O */
+#define XK_Thai_saraaimaimuan            0x0de3  /* U+0E43 THAI CHARACTER SARA AI MAIMUAN */
+#define XK_Thai_saraaimaimalai           0x0de4  /* U+0E44 THAI CHARACTER SARA AI MAIMALAI */
+#define XK_Thai_lakkhangyao              0x0de5  /* U+0E45 THAI CHARACTER LAKKHANGYAO */
+#define XK_Thai_maiyamok                 0x0de6  /* U+0E46 THAI CHARACTER MAIYAMOK */
+#define XK_Thai_maitaikhu                0x0de7  /* U+0E47 THAI CHARACTER MAITAIKHU */
+#define XK_Thai_maiek                    0x0de8  /* U+0E48 THAI CHARACTER MAI EK */
+#define XK_Thai_maitho                   0x0de9  /* U+0E49 THAI CHARACTER MAI THO */
+#define XK_Thai_maitri                   0x0dea  /* U+0E4A THAI CHARACTER MAI TRI */
+#define XK_Thai_maichattawa              0x0deb  /* U+0E4B THAI CHARACTER MAI CHATTAWA */
+#define XK_Thai_thanthakhat              0x0dec  /* U+0E4C THAI CHARACTER THANTHAKHAT */
+#define XK_Thai_nikhahit                 0x0ded  /* U+0E4D THAI CHARACTER NIKHAHIT */
+#define XK_Thai_leksun                   0x0df0  /* U+0E50 THAI DIGIT ZERO */
+#define XK_Thai_leknung                  0x0df1  /* U+0E51 THAI DIGIT ONE */
+#define XK_Thai_leksong                  0x0df2  /* U+0E52 THAI DIGIT TWO */
+#define XK_Thai_leksam                   0x0df3  /* U+0E53 THAI DIGIT THREE */
+#define XK_Thai_leksi                    0x0df4  /* U+0E54 THAI DIGIT FOUR */
+#define XK_Thai_lekha                    0x0df5  /* U+0E55 THAI DIGIT FIVE */
+#define XK_Thai_lekhok                   0x0df6  /* U+0E56 THAI DIGIT SIX */
+#define XK_Thai_lekchet                  0x0df7  /* U+0E57 THAI DIGIT SEVEN */
+#define XK_Thai_lekpaet                  0x0df8  /* U+0E58 THAI DIGIT EIGHT */
+#define XK_Thai_lekkao                   0x0df9  /* U+0E59 THAI DIGIT NINE */
+#endif /* XK_THAI */
+
+/*
+ * Korean
+ * Byte 3 = 0x0e
+ */
+
+#ifdef XK_KOREAN
+
+#define XK_Hangul                        0xff31  /* Hangul start/stop(toggle) */
+#define XK_Hangul_Start                  0xff32  /* Hangul start */
+#define XK_Hangul_End                    0xff33  /* Hangul end, English start */
+#define XK_Hangul_Hanja                  0xff34  /* Start Hangul->Hanja Conversion */
+#define XK_Hangul_Jamo                   0xff35  /* Hangul Jamo mode */
+#define XK_Hangul_Romaja                 0xff36  /* Hangul Romaja mode */
+#define XK_Hangul_Codeinput              0xff37  /* Hangul code input mode */
+#define XK_Hangul_Jeonja                 0xff38  /* Jeonja mode */
+#define XK_Hangul_Banja                  0xff39  /* Banja mode */
+#define XK_Hangul_PreHanja               0xff3a  /* Pre Hanja conversion */
+#define XK_Hangul_PostHanja              0xff3b  /* Post Hanja conversion */
+#define XK_Hangul_SingleCandidate        0xff3c  /* Single candidate */
+#define XK_Hangul_MultipleCandidate      0xff3d  /* Multiple candidate */
+#define XK_Hangul_PreviousCandidate      0xff3e  /* Previous candidate */
+#define XK_Hangul_Special                0xff3f  /* Special symbols */
+#define XK_Hangul_switch                 0xff7e  /* Alias for mode_switch */
+
+/* Hangul Consonant Characters */
+#define XK_Hangul_Kiyeog                 0x0ea1  /* U+3131 HANGUL LETTER KIYEOK */
+#define XK_Hangul_SsangKiyeog            0x0ea2  /* U+3132 HANGUL LETTER SSANGKIYEOK */
+#define XK_Hangul_KiyeogSios             0x0ea3  /* U+3133 HANGUL LETTER KIYEOK-SIOS */
+#define XK_Hangul_Nieun                  0x0ea4  /* U+3134 HANGUL LETTER NIEUN */
+#define XK_Hangul_NieunJieuj             0x0ea5  /* U+3135 HANGUL LETTER NIEUN-CIEUC */
+#define XK_Hangul_NieunHieuh             0x0ea6  /* U+3136 HANGUL LETTER NIEUN-HIEUH */
+#define XK_Hangul_Dikeud                 0x0ea7  /* U+3137 HANGUL LETTER TIKEUT */
+#define XK_Hangul_SsangDikeud            0x0ea8  /* U+3138 HANGUL LETTER SSANGTIKEUT */
+#define XK_Hangul_Rieul                  0x0ea9  /* U+3139 HANGUL LETTER RIEUL */
+#define XK_Hangul_RieulKiyeog            0x0eaa  /* U+313A HANGUL LETTER RIEUL-KIYEOK */
+#define XK_Hangul_RieulMieum             0x0eab  /* U+313B HANGUL LETTER RIEUL-MIEUM */
+#define XK_Hangul_RieulPieub             0x0eac  /* U+313C HANGUL LETTER RIEUL-PIEUP */
+#define XK_Hangul_RieulSios              0x0ead  /* U+313D HANGUL LETTER RIEUL-SIOS */
+#define XK_Hangul_RieulTieut             0x0eae  /* U+313E HANGUL LETTER RIEUL-THIEUTH */
+#define XK_Hangul_RieulPhieuf            0x0eaf  /* U+313F HANGUL LETTER RIEUL-PHIEUPH */
+#define XK_Hangul_RieulHieuh             0x0eb0  /* U+3140 HANGUL LETTER RIEUL-HIEUH */
+#define XK_Hangul_Mieum                  0x0eb1  /* U+3141 HANGUL LETTER MIEUM */
+#define XK_Hangul_Pieub                  0x0eb2  /* U+3142 HANGUL LETTER PIEUP */
+#define XK_Hangul_SsangPieub             0x0eb3  /* U+3143 HANGUL LETTER SSANGPIEUP */
+#define XK_Hangul_PieubSios              0x0eb4  /* U+3144 HANGUL LETTER PIEUP-SIOS */
+#define XK_Hangul_Sios                   0x0eb5  /* U+3145 HANGUL LETTER SIOS */
+#define XK_Hangul_SsangSios              0x0eb6  /* U+3146 HANGUL LETTER SSANGSIOS */
+#define XK_Hangul_Ieung                  0x0eb7  /* U+3147 HANGUL LETTER IEUNG */
+#define XK_Hangul_Jieuj                  0x0eb8  /* U+3148 HANGUL LETTER CIEUC */
+#define XK_Hangul_SsangJieuj             0x0eb9  /* U+3149 HANGUL LETTER SSANGCIEUC */
+#define XK_Hangul_Cieuc                  0x0eba  /* U+314A HANGUL LETTER CHIEUCH */
+#define XK_Hangul_Khieuq                 0x0ebb  /* U+314B HANGUL LETTER KHIEUKH */
+#define XK_Hangul_Tieut                  0x0ebc  /* U+314C HANGUL LETTER THIEUTH */
+#define XK_Hangul_Phieuf                 0x0ebd  /* U+314D HANGUL LETTER PHIEUPH */
+#define XK_Hangul_Hieuh                  0x0ebe  /* U+314E HANGUL LETTER HIEUH */
+
+/* Hangul Vowel Characters */
+#define XK_Hangul_A                      0x0ebf  /* U+314F HANGUL LETTER A */
+#define XK_Hangul_AE                     0x0ec0  /* U+3150 HANGUL LETTER AE */
+#define XK_Hangul_YA                     0x0ec1  /* U+3151 HANGUL LETTER YA */
+#define XK_Hangul_YAE                    0x0ec2  /* U+3152 HANGUL LETTER YAE */
+#define XK_Hangul_EO                     0x0ec3  /* U+3153 HANGUL LETTER EO */
+#define XK_Hangul_E                      0x0ec4  /* U+3154 HANGUL LETTER E */
+#define XK_Hangul_YEO                    0x0ec5  /* U+3155 HANGUL LETTER YEO */
+#define XK_Hangul_YE                     0x0ec6  /* U+3156 HANGUL LETTER YE */
+#define XK_Hangul_O                      0x0ec7  /* U+3157 HANGUL LETTER O */
+#define XK_Hangul_WA                     0x0ec8  /* U+3158 HANGUL LETTER WA */
+#define XK_Hangul_WAE                    0x0ec9  /* U+3159 HANGUL LETTER WAE */
+#define XK_Hangul_OE                     0x0eca  /* U+315A HANGUL LETTER OE */
+#define XK_Hangul_YO                     0x0ecb  /* U+315B HANGUL LETTER YO */
+#define XK_Hangul_U                      0x0ecc  /* U+315C HANGUL LETTER U */
+#define XK_Hangul_WEO                    0x0ecd  /* U+315D HANGUL LETTER WEO */
+#define XK_Hangul_WE                     0x0ece  /* U+315E HANGUL LETTER WE */
+#define XK_Hangul_WI                     0x0ecf  /* U+315F HANGUL LETTER WI */
+#define XK_Hangul_YU                     0x0ed0  /* U+3160 HANGUL LETTER YU */
+#define XK_Hangul_EU                     0x0ed1  /* U+3161 HANGUL LETTER EU */
+#define XK_Hangul_YI                     0x0ed2  /* U+3162 HANGUL LETTER YI */
+#define XK_Hangul_I                      0x0ed3  /* U+3163 HANGUL LETTER I */
+
+/* Hangul syllable-final (JongSeong) Characters */
+#define XK_Hangul_J_Kiyeog               0x0ed4  /* U+11A8 HANGUL JONGSEONG KIYEOK */
+#define XK_Hangul_J_SsangKiyeog          0x0ed5  /* U+11A9 HANGUL JONGSEONG SSANGKIYEOK */
+#define XK_Hangul_J_KiyeogSios           0x0ed6  /* U+11AA HANGUL JONGSEONG KIYEOK-SIOS */
+#define XK_Hangul_J_Nieun                0x0ed7  /* U+11AB HANGUL JONGSEONG NIEUN */
+#define XK_Hangul_J_NieunJieuj           0x0ed8  /* U+11AC HANGUL JONGSEONG NIEUN-CIEUC */
+#define XK_Hangul_J_NieunHieuh           0x0ed9  /* U+11AD HANGUL JONGSEONG NIEUN-HIEUH */
+#define XK_Hangul_J_Dikeud               0x0eda  /* U+11AE HANGUL JONGSEONG TIKEUT */
+#define XK_Hangul_J_Rieul                0x0edb  /* U+11AF HANGUL JONGSEONG RIEUL */
+#define XK_Hangul_J_RieulKiyeog          0x0edc  /* U+11B0 HANGUL JONGSEONG RIEUL-KIYEOK */
+#define XK_Hangul_J_RieulMieum           0x0edd  /* U+11B1 HANGUL JONGSEONG RIEUL-MIEUM */
+#define XK_Hangul_J_RieulPieub           0x0ede  /* U+11B2 HANGUL JONGSEONG RIEUL-PIEUP */
+#define XK_Hangul_J_RieulSios            0x0edf  /* U+11B3 HANGUL JONGSEONG RIEUL-SIOS */
+#define XK_Hangul_J_RieulTieut           0x0ee0  /* U+11B4 HANGUL JONGSEONG RIEUL-THIEUTH */
+#define XK_Hangul_J_RieulPhieuf          0x0ee1  /* U+11B5 HANGUL JONGSEONG RIEUL-PHIEUPH */
+#define XK_Hangul_J_RieulHieuh           0x0ee2  /* U+11B6 HANGUL JONGSEONG RIEUL-HIEUH */
+#define XK_Hangul_J_Mieum                0x0ee3  /* U+11B7 HANGUL JONGSEONG MIEUM */
+#define XK_Hangul_J_Pieub                0x0ee4  /* U+11B8 HANGUL JONGSEONG PIEUP */
+#define XK_Hangul_J_PieubSios            0x0ee5  /* U+11B9 HANGUL JONGSEONG PIEUP-SIOS */
+#define XK_Hangul_J_Sios                 0x0ee6  /* U+11BA HANGUL JONGSEONG SIOS */
+#define XK_Hangul_J_SsangSios            0x0ee7  /* U+11BB HANGUL JONGSEONG SSANGSIOS */
+#define XK_Hangul_J_Ieung                0x0ee8  /* U+11BC HANGUL JONGSEONG IEUNG */
+#define XK_Hangul_J_Jieuj                0x0ee9  /* U+11BD HANGUL JONGSEONG CIEUC */
+#define XK_Hangul_J_Cieuc                0x0eea  /* U+11BE HANGUL JONGSEONG CHIEUCH */
+#define XK_Hangul_J_Khieuq               0x0eeb  /* U+11BF HANGUL JONGSEONG KHIEUKH */
+#define XK_Hangul_J_Tieut                0x0eec  /* U+11C0 HANGUL JONGSEONG THIEUTH */
+#define XK_Hangul_J_Phieuf               0x0eed  /* U+11C1 HANGUL JONGSEONG PHIEUPH */
+#define XK_Hangul_J_Hieuh                0x0eee  /* U+11C2 HANGUL JONGSEONG HIEUH */
+
+/* Ancient Hangul Consonant Characters */
+#define XK_Hangul_RieulYeorinHieuh       0x0eef  /* U+316D HANGUL LETTER RIEUL-YEORINHIEUH */
+#define XK_Hangul_SunkyeongeumMieum      0x0ef0  /* U+3171 HANGUL LETTER KAPYEOUNMIEUM */
+#define XK_Hangul_SunkyeongeumPieub      0x0ef1  /* U+3178 HANGUL LETTER KAPYEOUNPIEUP */
+#define XK_Hangul_PanSios                0x0ef2  /* U+317F HANGUL LETTER PANSIOS */
+#define XK_Hangul_KkogjiDalrinIeung      0x0ef3  /* U+3181 HANGUL LETTER YESIEUNG */
+#define XK_Hangul_SunkyeongeumPhieuf     0x0ef4  /* U+3184 HANGUL LETTER KAPYEOUNPHIEUPH */
+#define XK_Hangul_YeorinHieuh            0x0ef5  /* U+3186 HANGUL LETTER YEORINHIEUH */
+
+/* Ancient Hangul Vowel Characters */
+#define XK_Hangul_AraeA                  0x0ef6  /* U+318D HANGUL LETTER ARAEA */
+#define XK_Hangul_AraeAE                 0x0ef7  /* U+318E HANGUL LETTER ARAEAE */
+
+/* Ancient Hangul syllable-final (JongSeong) Characters */
+#define XK_Hangul_J_PanSios              0x0ef8  /* U+11EB HANGUL JONGSEONG PANSIOS */
+#define XK_Hangul_J_KkogjiDalrinIeung    0x0ef9  /* U+11F0 HANGUL JONGSEONG YESIEUNG */
+#define XK_Hangul_J_YeorinHieuh          0x0efa  /* U+11F9 HANGUL JONGSEONG YEORINHIEUH */
+
+/* Korean currency symbol */
+#define XK_Korean_Won                    0x0eff  /*(U+20A9 WON SIGN)*/
+
+#endif /* XK_KOREAN */
+
+/*
+ * Armenian
+ */
+
+#ifdef XK_ARMENIAN
+#define XK_Armenian_ligature_ew       0x1000587  /* U+0587 ARMENIAN SMALL LIGATURE ECH YIWN */
+#define XK_Armenian_full_stop         0x1000589  /* U+0589 ARMENIAN FULL STOP */
+#define XK_Armenian_verjaket          0x1000589  /* U+0589 ARMENIAN FULL STOP */
+#define XK_Armenian_separation_mark   0x100055d  /* U+055D ARMENIAN COMMA */
+#define XK_Armenian_but               0x100055d  /* U+055D ARMENIAN COMMA */
+#define XK_Armenian_hyphen            0x100058a  /* U+058A ARMENIAN HYPHEN */
+#define XK_Armenian_yentamna          0x100058a  /* U+058A ARMENIAN HYPHEN */
+#define XK_Armenian_exclam            0x100055c  /* U+055C ARMENIAN EXCLAMATION MARK */
+#define XK_Armenian_amanak            0x100055c  /* U+055C ARMENIAN EXCLAMATION MARK */
+#define XK_Armenian_accent            0x100055b  /* U+055B ARMENIAN EMPHASIS MARK */
+#define XK_Armenian_shesht            0x100055b  /* U+055B ARMENIAN EMPHASIS MARK */
+#define XK_Armenian_question          0x100055e  /* U+055E ARMENIAN QUESTION MARK */
+#define XK_Armenian_paruyk            0x100055e  /* U+055E ARMENIAN QUESTION MARK */
+#define XK_Armenian_AYB               0x1000531  /* U+0531 ARMENIAN CAPITAL LETTER AYB */
+#define XK_Armenian_ayb               0x1000561  /* U+0561 ARMENIAN SMALL LETTER AYB */
+#define XK_Armenian_BEN               0x1000532  /* U+0532 ARMENIAN CAPITAL LETTER BEN */
+#define XK_Armenian_ben               0x1000562  /* U+0562 ARMENIAN SMALL LETTER BEN */
+#define XK_Armenian_GIM               0x1000533  /* U+0533 ARMENIAN CAPITAL LETTER GIM */
+#define XK_Armenian_gim               0x1000563  /* U+0563 ARMENIAN SMALL LETTER GIM */
+#define XK_Armenian_DA                0x1000534  /* U+0534 ARMENIAN CAPITAL LETTER DA */
+#define XK_Armenian_da                0x1000564  /* U+0564 ARMENIAN SMALL LETTER DA */
+#define XK_Armenian_YECH              0x1000535  /* U+0535 ARMENIAN CAPITAL LETTER ECH */
+#define XK_Armenian_yech              0x1000565  /* U+0565 ARMENIAN SMALL LETTER ECH */
+#define XK_Armenian_ZA                0x1000536  /* U+0536 ARMENIAN CAPITAL LETTER ZA */
+#define XK_Armenian_za                0x1000566  /* U+0566 ARMENIAN SMALL LETTER ZA */
+#define XK_Armenian_E                 0x1000537  /* U+0537 ARMENIAN CAPITAL LETTER EH */
+#define XK_Armenian_e                 0x1000567  /* U+0567 ARMENIAN SMALL LETTER EH */
+#define XK_Armenian_AT                0x1000538  /* U+0538 ARMENIAN CAPITAL LETTER ET */
+#define XK_Armenian_at                0x1000568  /* U+0568 ARMENIAN SMALL LETTER ET */
+#define XK_Armenian_TO                0x1000539  /* U+0539 ARMENIAN CAPITAL LETTER TO */
+#define XK_Armenian_to                0x1000569  /* U+0569 ARMENIAN SMALL LETTER TO */
+#define XK_Armenian_ZHE               0x100053a  /* U+053A ARMENIAN CAPITAL LETTER ZHE */
+#define XK_Armenian_zhe               0x100056a  /* U+056A ARMENIAN SMALL LETTER ZHE */
+#define XK_Armenian_INI               0x100053b  /* U+053B ARMENIAN CAPITAL LETTER INI */
+#define XK_Armenian_ini               0x100056b  /* U+056B ARMENIAN SMALL LETTER INI */
+#define XK_Armenian_LYUN              0x100053c  /* U+053C ARMENIAN CAPITAL LETTER LIWN */
+#define XK_Armenian_lyun              0x100056c  /* U+056C ARMENIAN SMALL LETTER LIWN */
+#define XK_Armenian_KHE               0x100053d  /* U+053D ARMENIAN CAPITAL LETTER XEH */
+#define XK_Armenian_khe               0x100056d  /* U+056D ARMENIAN SMALL LETTER XEH */
+#define XK_Armenian_TSA               0x100053e  /* U+053E ARMENIAN CAPITAL LETTER CA */
+#define XK_Armenian_tsa               0x100056e  /* U+056E ARMENIAN SMALL LETTER CA */
+#define XK_Armenian_KEN               0x100053f  /* U+053F ARMENIAN CAPITAL LETTER KEN */
+#define XK_Armenian_ken               0x100056f  /* U+056F ARMENIAN SMALL LETTER KEN */
+#define XK_Armenian_HO                0x1000540  /* U+0540 ARMENIAN CAPITAL LETTER HO */
+#define XK_Armenian_ho                0x1000570  /* U+0570 ARMENIAN SMALL LETTER HO */
+#define XK_Armenian_DZA               0x1000541  /* U+0541 ARMENIAN CAPITAL LETTER JA */
+#define XK_Armenian_dza               0x1000571  /* U+0571 ARMENIAN SMALL LETTER JA */
+#define XK_Armenian_GHAT              0x1000542  /* U+0542 ARMENIAN CAPITAL LETTER GHAD */
+#define XK_Armenian_ghat              0x1000572  /* U+0572 ARMENIAN SMALL LETTER GHAD */
+#define XK_Armenian_TCHE              0x1000543  /* U+0543 ARMENIAN CAPITAL LETTER CHEH */
+#define XK_Armenian_tche              0x1000573  /* U+0573 ARMENIAN SMALL LETTER CHEH */
+#define XK_Armenian_MEN               0x1000544  /* U+0544 ARMENIAN CAPITAL LETTER MEN */
+#define XK_Armenian_men               0x1000574  /* U+0574 ARMENIAN SMALL LETTER MEN */
+#define XK_Armenian_HI                0x1000545  /* U+0545 ARMENIAN CAPITAL LETTER YI */
+#define XK_Armenian_hi                0x1000575  /* U+0575 ARMENIAN SMALL LETTER YI */
+#define XK_Armenian_NU                0x1000546  /* U+0546 ARMENIAN CAPITAL LETTER NOW */
+#define XK_Armenian_nu                0x1000576  /* U+0576 ARMENIAN SMALL LETTER NOW */
+#define XK_Armenian_SHA               0x1000547  /* U+0547 ARMENIAN CAPITAL LETTER SHA */
+#define XK_Armenian_sha               0x1000577  /* U+0577 ARMENIAN SMALL LETTER SHA */
+#define XK_Armenian_VO                0x1000548  /* U+0548 ARMENIAN CAPITAL LETTER VO */
+#define XK_Armenian_vo                0x1000578  /* U+0578 ARMENIAN SMALL LETTER VO */
+#define XK_Armenian_CHA               0x1000549  /* U+0549 ARMENIAN CAPITAL LETTER CHA */
+#define XK_Armenian_cha               0x1000579  /* U+0579 ARMENIAN SMALL LETTER CHA */
+#define XK_Armenian_PE                0x100054a  /* U+054A ARMENIAN CAPITAL LETTER PEH */
+#define XK_Armenian_pe                0x100057a  /* U+057A ARMENIAN SMALL LETTER PEH */
+#define XK_Armenian_JE                0x100054b  /* U+054B ARMENIAN CAPITAL LETTER JHEH */
+#define XK_Armenian_je                0x100057b  /* U+057B ARMENIAN SMALL LETTER JHEH */
+#define XK_Armenian_RA                0x100054c  /* U+054C ARMENIAN CAPITAL LETTER RA */
+#define XK_Armenian_ra                0x100057c  /* U+057C ARMENIAN SMALL LETTER RA */
+#define XK_Armenian_SE                0x100054d  /* U+054D ARMENIAN CAPITAL LETTER SEH */
+#define XK_Armenian_se                0x100057d  /* U+057D ARMENIAN SMALL LETTER SEH */
+#define XK_Armenian_VEV               0x100054e  /* U+054E ARMENIAN CAPITAL LETTER VEW */
+#define XK_Armenian_vev               0x100057e  /* U+057E ARMENIAN SMALL LETTER VEW */
+#define XK_Armenian_TYUN              0x100054f  /* U+054F ARMENIAN CAPITAL LETTER TIWN */
+#define XK_Armenian_tyun              0x100057f  /* U+057F ARMENIAN SMALL LETTER TIWN */
+#define XK_Armenian_RE                0x1000550  /* U+0550 ARMENIAN CAPITAL LETTER REH */
+#define XK_Armenian_re                0x1000580  /* U+0580 ARMENIAN SMALL LETTER REH */
+#define XK_Armenian_TSO               0x1000551  /* U+0551 ARMENIAN CAPITAL LETTER CO */
+#define XK_Armenian_tso               0x1000581  /* U+0581 ARMENIAN SMALL LETTER CO */
+#define XK_Armenian_VYUN              0x1000552  /* U+0552 ARMENIAN CAPITAL LETTER YIWN */
+#define XK_Armenian_vyun              0x1000582  /* U+0582 ARMENIAN SMALL LETTER YIWN */
+#define XK_Armenian_PYUR              0x1000553  /* U+0553 ARMENIAN CAPITAL LETTER PIWR */
+#define XK_Armenian_pyur              0x1000583  /* U+0583 ARMENIAN SMALL LETTER PIWR */
+#define XK_Armenian_KE                0x1000554  /* U+0554 ARMENIAN CAPITAL LETTER KEH */
+#define XK_Armenian_ke                0x1000584  /* U+0584 ARMENIAN SMALL LETTER KEH */
+#define XK_Armenian_O                 0x1000555  /* U+0555 ARMENIAN CAPITAL LETTER OH */
+#define XK_Armenian_o                 0x1000585  /* U+0585 ARMENIAN SMALL LETTER OH */
+#define XK_Armenian_FE                0x1000556  /* U+0556 ARMENIAN CAPITAL LETTER FEH */
+#define XK_Armenian_fe                0x1000586  /* U+0586 ARMENIAN SMALL LETTER FEH */
+#define XK_Armenian_apostrophe        0x100055a  /* U+055A ARMENIAN APOSTROPHE */
+#endif /* XK_ARMENIAN */
+
+/*
+ * Georgian
+ */
+
+#ifdef XK_GEORGIAN
+#define XK_Georgian_an                0x10010d0  /* U+10D0 GEORGIAN LETTER AN */
+#define XK_Georgian_ban               0x10010d1  /* U+10D1 GEORGIAN LETTER BAN */
+#define XK_Georgian_gan               0x10010d2  /* U+10D2 GEORGIAN LETTER GAN */
+#define XK_Georgian_don               0x10010d3  /* U+10D3 GEORGIAN LETTER DON */
+#define XK_Georgian_en                0x10010d4  /* U+10D4 GEORGIAN LETTER EN */
+#define XK_Georgian_vin               0x10010d5  /* U+10D5 GEORGIAN LETTER VIN */
+#define XK_Georgian_zen               0x10010d6  /* U+10D6 GEORGIAN LETTER ZEN */
+#define XK_Georgian_tan               0x10010d7  /* U+10D7 GEORGIAN LETTER TAN */
+#define XK_Georgian_in                0x10010d8  /* U+10D8 GEORGIAN LETTER IN */
+#define XK_Georgian_kan               0x10010d9  /* U+10D9 GEORGIAN LETTER KAN */
+#define XK_Georgian_las               0x10010da  /* U+10DA GEORGIAN LETTER LAS */
+#define XK_Georgian_man               0x10010db  /* U+10DB GEORGIAN LETTER MAN */
+#define XK_Georgian_nar               0x10010dc  /* U+10DC GEORGIAN LETTER NAR */
+#define XK_Georgian_on                0x10010dd  /* U+10DD GEORGIAN LETTER ON */
+#define XK_Georgian_par               0x10010de  /* U+10DE GEORGIAN LETTER PAR */
+#define XK_Georgian_zhar              0x10010df  /* U+10DF GEORGIAN LETTER ZHAR */
+#define XK_Georgian_rae               0x10010e0  /* U+10E0 GEORGIAN LETTER RAE */
+#define XK_Georgian_san               0x10010e1  /* U+10E1 GEORGIAN LETTER SAN */
+#define XK_Georgian_tar               0x10010e2  /* U+10E2 GEORGIAN LETTER TAR */
+#define XK_Georgian_un                0x10010e3  /* U+10E3 GEORGIAN LETTER UN */
+#define XK_Georgian_phar              0x10010e4  /* U+10E4 GEORGIAN LETTER PHAR */
+#define XK_Georgian_khar              0x10010e5  /* U+10E5 GEORGIAN LETTER KHAR */
+#define XK_Georgian_ghan              0x10010e6  /* U+10E6 GEORGIAN LETTER GHAN */
+#define XK_Georgian_qar               0x10010e7  /* U+10E7 GEORGIAN LETTER QAR */
+#define XK_Georgian_shin              0x10010e8  /* U+10E8 GEORGIAN LETTER SHIN */
+#define XK_Georgian_chin              0x10010e9  /* U+10E9 GEORGIAN LETTER CHIN */
+#define XK_Georgian_can               0x10010ea  /* U+10EA GEORGIAN LETTER CAN */
+#define XK_Georgian_jil               0x10010eb  /* U+10EB GEORGIAN LETTER JIL */
+#define XK_Georgian_cil               0x10010ec  /* U+10EC GEORGIAN LETTER CIL */
+#define XK_Georgian_char              0x10010ed  /* U+10ED GEORGIAN LETTER CHAR */
+#define XK_Georgian_xan               0x10010ee  /* U+10EE GEORGIAN LETTER XAN */
+#define XK_Georgian_jhan              0x10010ef  /* U+10EF GEORGIAN LETTER JHAN */
+#define XK_Georgian_hae               0x10010f0  /* U+10F0 GEORGIAN LETTER HAE */
+#define XK_Georgian_he                0x10010f1  /* U+10F1 GEORGIAN LETTER HE */
+#define XK_Georgian_hie               0x10010f2  /* U+10F2 GEORGIAN LETTER HIE */
+#define XK_Georgian_we                0x10010f3  /* U+10F3 GEORGIAN LETTER WE */
+#define XK_Georgian_har               0x10010f4  /* U+10F4 GEORGIAN LETTER HAR */
+#define XK_Georgian_hoe               0x10010f5  /* U+10F5 GEORGIAN LETTER HOE */
+#define XK_Georgian_fi                0x10010f6  /* U+10F6 GEORGIAN LETTER FI */
+#endif /* XK_GEORGIAN */
+
+/*
+ * Azeri (and other Turkic or Caucasian languages)
+ */
+
+#ifdef XK_CAUCASUS
+/* latin */
+#define XK_Xabovedot                  0x1001e8a  /* U+1E8A LATIN CAPITAL LETTER X WITH DOT ABOVE */
+#define XK_Ibreve                     0x100012c  /* U+012C LATIN CAPITAL LETTER I WITH BREVE */
+#define XK_Zstroke                    0x10001b5  /* U+01B5 LATIN CAPITAL LETTER Z WITH STROKE */
+#define XK_Gcaron                     0x10001e6  /* U+01E6 LATIN CAPITAL LETTER G WITH CARON */
+#define XK_Ocaron                     0x10001d1  /* U+01D1 LATIN CAPITAL LETTER O WITH CARON */
+#define XK_Obarred                    0x100019f  /* U+019F LATIN CAPITAL LETTER O WITH MIDDLE TILDE */
+#define XK_xabovedot                  0x1001e8b  /* U+1E8B LATIN SMALL LETTER X WITH DOT ABOVE */
+#define XK_ibreve                     0x100012d  /* U+012D LATIN SMALL LETTER I WITH BREVE */
+#define XK_zstroke                    0x10001b6  /* U+01B6 LATIN SMALL LETTER Z WITH STROKE */
+#define XK_gcaron                     0x10001e7  /* U+01E7 LATIN SMALL LETTER G WITH CARON */
+#define XK_ocaron                     0x10001d2  /* U+01D2 LATIN SMALL LETTER O WITH CARON */
+#define XK_obarred                    0x1000275  /* U+0275 LATIN SMALL LETTER BARRED O */
+#define XK_SCHWA                      0x100018f  /* U+018F LATIN CAPITAL LETTER SCHWA */
+#define XK_schwa                      0x1000259  /* U+0259 LATIN SMALL LETTER SCHWA */
+#define XK_EZH                        0x10001b7  /* U+01B7 LATIN CAPITAL LETTER EZH */
+#define XK_ezh                        0x1000292  /* U+0292 LATIN SMALL LETTER EZH */
+/* those are not really Caucasus */
+/* For Inupiak */
+#define XK_Lbelowdot                  0x1001e36  /* U+1E36 LATIN CAPITAL LETTER L WITH DOT BELOW */
+#define XK_lbelowdot                  0x1001e37  /* U+1E37 LATIN SMALL LETTER L WITH DOT BELOW */
+#endif /* XK_CAUCASUS */
+
+/*
+ * Vietnamese
+ */
+
+#ifdef XK_VIETNAMESE
+#define XK_Abelowdot                  0x1001ea0  /* U+1EA0 LATIN CAPITAL LETTER A WITH DOT BELOW */
+#define XK_abelowdot                  0x1001ea1  /* U+1EA1 LATIN SMALL LETTER A WITH DOT BELOW */
+#define XK_Ahook                      0x1001ea2  /* U+1EA2 LATIN CAPITAL LETTER A WITH HOOK ABOVE */
+#define XK_ahook                      0x1001ea3  /* U+1EA3 LATIN SMALL LETTER A WITH HOOK ABOVE */
+#define XK_Acircumflexacute           0x1001ea4  /* U+1EA4 LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE */
+#define XK_acircumflexacute           0x1001ea5  /* U+1EA5 LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE */
+#define XK_Acircumflexgrave           0x1001ea6  /* U+1EA6 LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE */
+#define XK_acircumflexgrave           0x1001ea7  /* U+1EA7 LATIN SMALL LETTER A WITH CIRCUMFLEX AND GRAVE */
+#define XK_Acircumflexhook            0x1001ea8  /* U+1EA8 LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE */
+#define XK_acircumflexhook            0x1001ea9  /* U+1EA9 LATIN SMALL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE */
+#define XK_Acircumflextilde           0x1001eaa  /* U+1EAA LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE */
+#define XK_acircumflextilde           0x1001eab  /* U+1EAB LATIN SMALL LETTER A WITH CIRCUMFLEX AND TILDE */
+#define XK_Acircumflexbelowdot        0x1001eac  /* U+1EAC LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW */
+#define XK_acircumflexbelowdot        0x1001ead  /* U+1EAD LATIN SMALL LETTER A WITH CIRCUMFLEX AND DOT BELOW */
+#define XK_Abreveacute                0x1001eae  /* U+1EAE LATIN CAPITAL LETTER A WITH BREVE AND ACUTE */
+#define XK_abreveacute                0x1001eaf  /* U+1EAF LATIN SMALL LETTER A WITH BREVE AND ACUTE */
+#define XK_Abrevegrave                0x1001eb0  /* U+1EB0 LATIN CAPITAL LETTER A WITH BREVE AND GRAVE */
+#define XK_abrevegrave                0x1001eb1  /* U+1EB1 LATIN SMALL LETTER A WITH BREVE AND GRAVE */
+#define XK_Abrevehook                 0x1001eb2  /* U+1EB2 LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE */
+#define XK_abrevehook                 0x1001eb3  /* U+1EB3 LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE */
+#define XK_Abrevetilde                0x1001eb4  /* U+1EB4 LATIN CAPITAL LETTER A WITH BREVE AND TILDE */
+#define XK_abrevetilde                0x1001eb5  /* U+1EB5 LATIN SMALL LETTER A WITH BREVE AND TILDE */
+#define XK_Abrevebelowdot             0x1001eb6  /* U+1EB6 LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW */
+#define XK_abrevebelowdot             0x1001eb7  /* U+1EB7 LATIN SMALL LETTER A WITH BREVE AND DOT BELOW */
+#define XK_Ebelowdot                  0x1001eb8  /* U+1EB8 LATIN CAPITAL LETTER E WITH DOT BELOW */
+#define XK_ebelowdot                  0x1001eb9  /* U+1EB9 LATIN SMALL LETTER E WITH DOT BELOW */
+#define XK_Ehook                      0x1001eba  /* U+1EBA LATIN CAPITAL LETTER E WITH HOOK ABOVE */
+#define XK_ehook                      0x1001ebb  /* U+1EBB LATIN SMALL LETTER E WITH HOOK ABOVE */
+#define XK_Etilde                     0x1001ebc  /* U+1EBC LATIN CAPITAL LETTER E WITH TILDE */
+#define XK_etilde                     0x1001ebd  /* U+1EBD LATIN SMALL LETTER E WITH TILDE */
+#define XK_Ecircumflexacute           0x1001ebe  /* U+1EBE LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE */
+#define XK_ecircumflexacute           0x1001ebf  /* U+1EBF LATIN SMALL LETTER E WITH CIRCUMFLEX AND ACUTE */
+#define XK_Ecircumflexgrave           0x1001ec0  /* U+1EC0 LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND GRAVE */
+#define XK_ecircumflexgrave           0x1001ec1  /* U+1EC1 LATIN SMALL LETTER E WITH CIRCUMFLEX AND GRAVE */
+#define XK_Ecircumflexhook            0x1001ec2  /* U+1EC2 LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE */
+#define XK_ecircumflexhook            0x1001ec3  /* U+1EC3 LATIN SMALL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE */
+#define XK_Ecircumflextilde           0x1001ec4  /* U+1EC4 LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND TILDE */
+#define XK_ecircumflextilde           0x1001ec5  /* U+1EC5 LATIN SMALL LETTER E WITH CIRCUMFLEX AND TILDE */
+#define XK_Ecircumflexbelowdot        0x1001ec6  /* U+1EC6 LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND DOT BELOW */
+#define XK_ecircumflexbelowdot        0x1001ec7  /* U+1EC7 LATIN SMALL LETTER E WITH CIRCUMFLEX AND DOT BELOW */
+#define XK_Ihook                      0x1001ec8  /* U+1EC8 LATIN CAPITAL LETTER I WITH HOOK ABOVE */
+#define XK_ihook                      0x1001ec9  /* U+1EC9 LATIN SMALL LETTER I WITH HOOK ABOVE */
+#define XK_Ibelowdot                  0x1001eca  /* U+1ECA LATIN CAPITAL LETTER I WITH DOT BELOW */
+#define XK_ibelowdot                  0x1001ecb  /* U+1ECB LATIN SMALL LETTER I WITH DOT BELOW */
+#define XK_Obelowdot                  0x1001ecc  /* U+1ECC LATIN CAPITAL LETTER O WITH DOT BELOW */
+#define XK_obelowdot                  0x1001ecd  /* U+1ECD LATIN SMALL LETTER O WITH DOT BELOW */
+#define XK_Ohook                      0x1001ece  /* U+1ECE LATIN CAPITAL LETTER O WITH HOOK ABOVE */
+#define XK_ohook                      0x1001ecf  /* U+1ECF LATIN SMALL LETTER O WITH HOOK ABOVE */
+#define XK_Ocircumflexacute           0x1001ed0  /* U+1ED0 LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE */
+#define XK_ocircumflexacute           0x1001ed1  /* U+1ED1 LATIN SMALL LETTER O WITH CIRCUMFLEX AND ACUTE */
+#define XK_Ocircumflexgrave           0x1001ed2  /* U+1ED2 LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND GRAVE */
+#define XK_ocircumflexgrave           0x1001ed3  /* U+1ED3 LATIN SMALL LETTER O WITH CIRCUMFLEX AND GRAVE */
+#define XK_Ocircumflexhook            0x1001ed4  /* U+1ED4 LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE */
+#define XK_ocircumflexhook            0x1001ed5  /* U+1ED5 LATIN SMALL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE */
+#define XK_Ocircumflextilde           0x1001ed6  /* U+1ED6 LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND TILDE */
+#define XK_ocircumflextilde           0x1001ed7  /* U+1ED7 LATIN SMALL LETTER O WITH CIRCUMFLEX AND TILDE */
+#define XK_Ocircumflexbelowdot        0x1001ed8  /* U+1ED8 LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND DOT BELOW */
+#define XK_ocircumflexbelowdot        0x1001ed9  /* U+1ED9 LATIN SMALL LETTER O WITH CIRCUMFLEX AND DOT BELOW */
+#define XK_Ohornacute                 0x1001eda  /* U+1EDA LATIN CAPITAL LETTER O WITH HORN AND ACUTE */
+#define XK_ohornacute                 0x1001edb  /* U+1EDB LATIN SMALL LETTER O WITH HORN AND ACUTE */
+#define XK_Ohorngrave                 0x1001edc  /* U+1EDC LATIN CAPITAL LETTER O WITH HORN AND GRAVE */
+#define XK_ohorngrave                 0x1001edd  /* U+1EDD LATIN SMALL LETTER O WITH HORN AND GRAVE */
+#define XK_Ohornhook                  0x1001ede  /* U+1EDE LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE */
+#define XK_ohornhook                  0x1001edf  /* U+1EDF LATIN SMALL LETTER O WITH HORN AND HOOK ABOVE */
+#define XK_Ohorntilde                 0x1001ee0  /* U+1EE0 LATIN CAPITAL LETTER O WITH HORN AND TILDE */
+#define XK_ohorntilde                 0x1001ee1  /* U+1EE1 LATIN SMALL LETTER O WITH HORN AND TILDE */
+#define XK_Ohornbelowdot              0x1001ee2  /* U+1EE2 LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW */
+#define XK_ohornbelowdot              0x1001ee3  /* U+1EE3 LATIN SMALL LETTER O WITH HORN AND DOT BELOW */
+#define XK_Ubelowdot                  0x1001ee4  /* U+1EE4 LATIN CAPITAL LETTER U WITH DOT BELOW */
+#define XK_ubelowdot                  0x1001ee5  /* U+1EE5 LATIN SMALL LETTER U WITH DOT BELOW */
+#define XK_Uhook                      0x1001ee6  /* U+1EE6 LATIN CAPITAL LETTER U WITH HOOK ABOVE */
+#define XK_uhook                      0x1001ee7  /* U+1EE7 LATIN SMALL LETTER U WITH HOOK ABOVE */
+#define XK_Uhornacute                 0x1001ee8  /* U+1EE8 LATIN CAPITAL LETTER U WITH HORN AND ACUTE */
+#define XK_uhornacute                 0x1001ee9  /* U+1EE9 LATIN SMALL LETTER U WITH HORN AND ACUTE */
+#define XK_Uhorngrave                 0x1001eea  /* U+1EEA LATIN CAPITAL LETTER U WITH HORN AND GRAVE */
+#define XK_uhorngrave                 0x1001eeb  /* U+1EEB LATIN SMALL LETTER U WITH HORN AND GRAVE */
+#define XK_Uhornhook                  0x1001eec  /* U+1EEC LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE */
+#define XK_uhornhook                  0x1001eed  /* U+1EED LATIN SMALL LETTER U WITH HORN AND HOOK ABOVE */
+#define XK_Uhorntilde                 0x1001eee  /* U+1EEE LATIN CAPITAL LETTER U WITH HORN AND TILDE */
+#define XK_uhorntilde                 0x1001eef  /* U+1EEF LATIN SMALL LETTER U WITH HORN AND TILDE */
+#define XK_Uhornbelowdot              0x1001ef0  /* U+1EF0 LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW */
+#define XK_uhornbelowdot              0x1001ef1  /* U+1EF1 LATIN SMALL LETTER U WITH HORN AND DOT BELOW */
+#define XK_Ybelowdot                  0x1001ef4  /* U+1EF4 LATIN CAPITAL LETTER Y WITH DOT BELOW */
+#define XK_ybelowdot                  0x1001ef5  /* U+1EF5 LATIN SMALL LETTER Y WITH DOT BELOW */
+#define XK_Yhook                      0x1001ef6  /* U+1EF6 LATIN CAPITAL LETTER Y WITH HOOK ABOVE */
+#define XK_yhook                      0x1001ef7  /* U+1EF7 LATIN SMALL LETTER Y WITH HOOK ABOVE */
+#define XK_Ytilde                     0x1001ef8  /* U+1EF8 LATIN CAPITAL LETTER Y WITH TILDE */
+#define XK_ytilde                     0x1001ef9  /* U+1EF9 LATIN SMALL LETTER Y WITH TILDE */
+#define XK_Ohorn                      0x10001a0  /* U+01A0 LATIN CAPITAL LETTER O WITH HORN */
+#define XK_ohorn                      0x10001a1  /* U+01A1 LATIN SMALL LETTER O WITH HORN */
+#define XK_Uhorn                      0x10001af  /* U+01AF LATIN CAPITAL LETTER U WITH HORN */
+#define XK_uhorn                      0x10001b0  /* U+01B0 LATIN SMALL LETTER U WITH HORN */
+#define XK_combining_tilde            0x1000303  /* U+0303 COMBINING TILDE */
+#define XK_combining_grave            0x1000300  /* U+0300 COMBINING GRAVE ACCENT */
+#define XK_combining_acute            0x1000301  /* U+0301 COMBINING ACUTE ACCENT */
+#define XK_combining_hook             0x1000309  /* U+0309 COMBINING HOOK ABOVE */
+#define XK_combining_belowdot         0x1000323  /* U+0323 COMBINING DOT BELOW */
+
+#endif /* XK_VIETNAMESE */
+
+#ifdef XK_CURRENCY
+#define XK_EcuSign                    0x10020a0  /* U+20A0 EURO-CURRENCY SIGN */
+#define XK_ColonSign                  0x10020a1  /* U+20A1 COLON SIGN */
+#define XK_CruzeiroSign               0x10020a2  /* U+20A2 CRUZEIRO SIGN */
+#define XK_FFrancSign                 0x10020a3  /* U+20A3 FRENCH FRANC SIGN */
+#define XK_LiraSign                   0x10020a4  /* U+20A4 LIRA SIGN */
+#define XK_MillSign                   0x10020a5  /* U+20A5 MILL SIGN */
+#define XK_NairaSign                  0x10020a6  /* U+20A6 NAIRA SIGN */
+#define XK_PesetaSign                 0x10020a7  /* U+20A7 PESETA SIGN */
+#define XK_RupeeSign                  0x10020a8  /* U+20A8 RUPEE SIGN */
+#define XK_WonSign                    0x10020a9  /* U+20A9 WON SIGN */
+#define XK_NewSheqelSign              0x10020aa  /* U+20AA NEW SHEQEL SIGN */
+#define XK_DongSign                   0x10020ab  /* U+20AB DONG SIGN */
+#define XK_EuroSign                      0x20ac  /* U+20AC EURO SIGN */
+#endif /* XK_CURRENCY */
+
+#ifdef XK_MATHEMATICAL
+/* one, two and three are defined above. */
+#define XK_zerosuperior               0x1002070  /* U+2070 SUPERSCRIPT ZERO */
+#define XK_foursuperior               0x1002074  /* U+2074 SUPERSCRIPT FOUR */
+#define XK_fivesuperior               0x1002075  /* U+2075 SUPERSCRIPT FIVE */
+#define XK_sixsuperior                0x1002076  /* U+2076 SUPERSCRIPT SIX */
+#define XK_sevensuperior              0x1002077  /* U+2077 SUPERSCRIPT SEVEN */
+#define XK_eightsuperior              0x1002078  /* U+2078 SUPERSCRIPT EIGHT */
+#define XK_ninesuperior               0x1002079  /* U+2079 SUPERSCRIPT NINE */
+#define XK_zerosubscript              0x1002080  /* U+2080 SUBSCRIPT ZERO */
+#define XK_onesubscript               0x1002081  /* U+2081 SUBSCRIPT ONE */
+#define XK_twosubscript               0x1002082  /* U+2082 SUBSCRIPT TWO */
+#define XK_threesubscript             0x1002083  /* U+2083 SUBSCRIPT THREE */
+#define XK_foursubscript              0x1002084  /* U+2084 SUBSCRIPT FOUR */
+#define XK_fivesubscript              0x1002085  /* U+2085 SUBSCRIPT FIVE */
+#define XK_sixsubscript               0x1002086  /* U+2086 SUBSCRIPT SIX */
+#define XK_sevensubscript             0x1002087  /* U+2087 SUBSCRIPT SEVEN */
+#define XK_eightsubscript             0x1002088  /* U+2088 SUBSCRIPT EIGHT */
+#define XK_ninesubscript              0x1002089  /* U+2089 SUBSCRIPT NINE */
+#define XK_partdifferential           0x1002202  /* U+2202 PARTIAL DIFFERENTIAL */
+#define XK_emptyset                   0x1002205  /* U+2205 NULL SET */
+#define XK_elementof                  0x1002208  /* U+2208 ELEMENT OF */
+#define XK_notelementof               0x1002209  /* U+2209 NOT AN ELEMENT OF */
+#define XK_containsas                 0x100220B  /* U+220B CONTAINS AS MEMBER */
+#define XK_squareroot                 0x100221A  /* U+221A SQUARE ROOT */
+#define XK_cuberoot                   0x100221B  /* U+221B CUBE ROOT */
+#define XK_fourthroot                 0x100221C  /* U+221C FOURTH ROOT */
+#define XK_dintegral                  0x100222C  /* U+222C DOUBLE INTEGRAL */
+#define XK_tintegral                  0x100222D  /* U+222D TRIPLE INTEGRAL */
+#define XK_because                    0x1002235  /* U+2235 BECAUSE */
+#define XK_approxeq                   0x1002248  /*(U+2248 ALMOST EQUAL TO)*/
+#define XK_notapproxeq                0x1002247  /*(U+2247 NEITHER APPROXIMATELY NOR ACTUALLY EQUAL TO)*/
+#define XK_notidentical               0x1002262  /* U+2262 NOT IDENTICAL TO */
+#define XK_stricteq                   0x1002263  /* U+2263 STRICTLY EQUIVALENT TO */
+#endif /* XK_MATHEMATICAL */
+
+#ifdef XK_BRAILLE
+#define XK_braille_dot_1                 0xfff1
+#define XK_braille_dot_2                 0xfff2
+#define XK_braille_dot_3                 0xfff3
+#define XK_braille_dot_4                 0xfff4
+#define XK_braille_dot_5                 0xfff5
+#define XK_braille_dot_6                 0xfff6
+#define XK_braille_dot_7                 0xfff7
+#define XK_braille_dot_8                 0xfff8
+#define XK_braille_dot_9                 0xfff9
+#define XK_braille_dot_10                0xfffa
+#define XK_braille_blank              0x1002800  /* U+2800 BRAILLE PATTERN BLANK */
+#define XK_braille_dots_1             0x1002801  /* U+2801 BRAILLE PATTERN DOTS-1 */
+#define XK_braille_dots_2             0x1002802  /* U+2802 BRAILLE PATTERN DOTS-2 */
+#define XK_braille_dots_12            0x1002803  /* U+2803 BRAILLE PATTERN DOTS-12 */
+#define XK_braille_dots_3             0x1002804  /* U+2804 BRAILLE PATTERN DOTS-3 */
+#define XK_braille_dots_13            0x1002805  /* U+2805 BRAILLE PATTERN DOTS-13 */
+#define XK_braille_dots_23            0x1002806  /* U+2806 BRAILLE PATTERN DOTS-23 */
+#define XK_braille_dots_123           0x1002807  /* U+2807 BRAILLE PATTERN DOTS-123 */
+#define XK_braille_dots_4             0x1002808  /* U+2808 BRAILLE PATTERN DOTS-4 */
+#define XK_braille_dots_14            0x1002809  /* U+2809 BRAILLE PATTERN DOTS-14 */
+#define XK_braille_dots_24            0x100280a  /* U+280a BRAILLE PATTERN DOTS-24 */
+#define XK_braille_dots_124           0x100280b  /* U+280b BRAILLE PATTERN DOTS-124 */
+#define XK_braille_dots_34            0x100280c  /* U+280c BRAILLE PATTERN DOTS-34 */
+#define XK_braille_dots_134           0x100280d  /* U+280d BRAILLE PATTERN DOTS-134 */
+#define XK_braille_dots_234           0x100280e  /* U+280e BRAILLE PATTERN DOTS-234 */
+#define XK_braille_dots_1234          0x100280f  /* U+280f BRAILLE PATTERN DOTS-1234 */
+#define XK_braille_dots_5             0x1002810  /* U+2810 BRAILLE PATTERN DOTS-5 */
+#define XK_braille_dots_15            0x1002811  /* U+2811 BRAILLE PATTERN DOTS-15 */
+#define XK_braille_dots_25            0x1002812  /* U+2812 BRAILLE PATTERN DOTS-25 */
+#define XK_braille_dots_125           0x1002813  /* U+2813 BRAILLE PATTERN DOTS-125 */
+#define XK_braille_dots_35            0x1002814  /* U+2814 BRAILLE PATTERN DOTS-35 */
+#define XK_braille_dots_135           0x1002815  /* U+2815 BRAILLE PATTERN DOTS-135 */
+#define XK_braille_dots_235           0x1002816  /* U+2816 BRAILLE PATTERN DOTS-235 */
+#define XK_braille_dots_1235          0x1002817  /* U+2817 BRAILLE PATTERN DOTS-1235 */
+#define XK_braille_dots_45            0x1002818  /* U+2818 BRAILLE PATTERN DOTS-45 */
+#define XK_braille_dots_145           0x1002819  /* U+2819 BRAILLE PATTERN DOTS-145 */
+#define XK_braille_dots_245           0x100281a  /* U+281a BRAILLE PATTERN DOTS-245 */
+#define XK_braille_dots_1245          0x100281b  /* U+281b BRAILLE PATTERN DOTS-1245 */
+#define XK_braille_dots_345           0x100281c  /* U+281c BRAILLE PATTERN DOTS-345 */
+#define XK_braille_dots_1345          0x100281d  /* U+281d BRAILLE PATTERN DOTS-1345 */
+#define XK_braille_dots_2345          0x100281e  /* U+281e BRAILLE PATTERN DOTS-2345 */
+#define XK_braille_dots_12345         0x100281f  /* U+281f BRAILLE PATTERN DOTS-12345 */
+#define XK_braille_dots_6             0x1002820  /* U+2820 BRAILLE PATTERN DOTS-6 */
+#define XK_braille_dots_16            0x1002821  /* U+2821 BRAILLE PATTERN DOTS-16 */
+#define XK_braille_dots_26            0x1002822  /* U+2822 BRAILLE PATTERN DOTS-26 */
+#define XK_braille_dots_126           0x1002823  /* U+2823 BRAILLE PATTERN DOTS-126 */
+#define XK_braille_dots_36            0x1002824  /* U+2824 BRAILLE PATTERN DOTS-36 */
+#define XK_braille_dots_136           0x1002825  /* U+2825 BRAILLE PATTERN DOTS-136 */
+#define XK_braille_dots_236           0x1002826  /* U+2826 BRAILLE PATTERN DOTS-236 */
+#define XK_braille_dots_1236          0x1002827  /* U+2827 BRAILLE PATTERN DOTS-1236 */
+#define XK_braille_dots_46            0x1002828  /* U+2828 BRAILLE PATTERN DOTS-46 */
+#define XK_braille_dots_146           0x1002829  /* U+2829 BRAILLE PATTERN DOTS-146 */
+#define XK_braille_dots_246           0x100282a  /* U+282a BRAILLE PATTERN DOTS-246 */
+#define XK_braille_dots_1246          0x100282b  /* U+282b BRAILLE PATTERN DOTS-1246 */
+#define XK_braille_dots_346           0x100282c  /* U+282c BRAILLE PATTERN DOTS-346 */
+#define XK_braille_dots_1346          0x100282d  /* U+282d BRAILLE PATTERN DOTS-1346 */
+#define XK_braille_dots_2346          0x100282e  /* U+282e BRAILLE PATTERN DOTS-2346 */
+#define XK_braille_dots_12346         0x100282f  /* U+282f BRAILLE PATTERN DOTS-12346 */
+#define XK_braille_dots_56            0x1002830  /* U+2830 BRAILLE PATTERN DOTS-56 */
+#define XK_braille_dots_156           0x1002831  /* U+2831 BRAILLE PATTERN DOTS-156 */
+#define XK_braille_dots_256           0x1002832  /* U+2832 BRAILLE PATTERN DOTS-256 */
+#define XK_braille_dots_1256          0x1002833  /* U+2833 BRAILLE PATTERN DOTS-1256 */
+#define XK_braille_dots_356           0x1002834  /* U+2834 BRAILLE PATTERN DOTS-356 */
+#define XK_braille_dots_1356          0x1002835  /* U+2835 BRAILLE PATTERN DOTS-1356 */
+#define XK_braille_dots_2356          0x1002836  /* U+2836 BRAILLE PATTERN DOTS-2356 */
+#define XK_braille_dots_12356         0x1002837  /* U+2837 BRAILLE PATTERN DOTS-12356 */
+#define XK_braille_dots_456           0x1002838  /* U+2838 BRAILLE PATTERN DOTS-456 */
+#define XK_braille_dots_1456          0x1002839  /* U+2839 BRAILLE PATTERN DOTS-1456 */
+#define XK_braille_dots_2456          0x100283a  /* U+283a BRAILLE PATTERN DOTS-2456 */
+#define XK_braille_dots_12456         0x100283b  /* U+283b BRAILLE PATTERN DOTS-12456 */
+#define XK_braille_dots_3456          0x100283c  /* U+283c BRAILLE PATTERN DOTS-3456 */
+#define XK_braille_dots_13456         0x100283d  /* U+283d BRAILLE PATTERN DOTS-13456 */
+#define XK_braille_dots_23456         0x100283e  /* U+283e BRAILLE PATTERN DOTS-23456 */
+#define XK_braille_dots_123456        0x100283f  /* U+283f BRAILLE PATTERN DOTS-123456 */
+#define XK_braille_dots_7             0x1002840  /* U+2840 BRAILLE PATTERN DOTS-7 */
+#define XK_braille_dots_17            0x1002841  /* U+2841 BRAILLE PATTERN DOTS-17 */
+#define XK_braille_dots_27            0x1002842  /* U+2842 BRAILLE PATTERN DOTS-27 */
+#define XK_braille_dots_127           0x1002843  /* U+2843 BRAILLE PATTERN DOTS-127 */
+#define XK_braille_dots_37            0x1002844  /* U+2844 BRAILLE PATTERN DOTS-37 */
+#define XK_braille_dots_137           0x1002845  /* U+2845 BRAILLE PATTERN DOTS-137 */
+#define XK_braille_dots_237           0x1002846  /* U+2846 BRAILLE PATTERN DOTS-237 */
+#define XK_braille_dots_1237          0x1002847  /* U+2847 BRAILLE PATTERN DOTS-1237 */
+#define XK_braille_dots_47            0x1002848  /* U+2848 BRAILLE PATTERN DOTS-47 */
+#define XK_braille_dots_147           0x1002849  /* U+2849 BRAILLE PATTERN DOTS-147 */
+#define XK_braille_dots_247           0x100284a  /* U+284a BRAILLE PATTERN DOTS-247 */
+#define XK_braille_dots_1247          0x100284b  /* U+284b BRAILLE PATTERN DOTS-1247 */
+#define XK_braille_dots_347           0x100284c  /* U+284c BRAILLE PATTERN DOTS-347 */
+#define XK_braille_dots_1347          0x100284d  /* U+284d BRAILLE PATTERN DOTS-1347 */
+#define XK_braille_dots_2347          0x100284e  /* U+284e BRAILLE PATTERN DOTS-2347 */
+#define XK_braille_dots_12347         0x100284f  /* U+284f BRAILLE PATTERN DOTS-12347 */
+#define XK_braille_dots_57            0x1002850  /* U+2850 BRAILLE PATTERN DOTS-57 */
+#define XK_braille_dots_157           0x1002851  /* U+2851 BRAILLE PATTERN DOTS-157 */
+#define XK_braille_dots_257           0x1002852  /* U+2852 BRAILLE PATTERN DOTS-257 */
+#define XK_braille_dots_1257          0x1002853  /* U+2853 BRAILLE PATTERN DOTS-1257 */
+#define XK_braille_dots_357           0x1002854  /* U+2854 BRAILLE PATTERN DOTS-357 */
+#define XK_braille_dots_1357          0x1002855  /* U+2855 BRAILLE PATTERN DOTS-1357 */
+#define XK_braille_dots_2357          0x1002856  /* U+2856 BRAILLE PATTERN DOTS-2357 */
+#define XK_braille_dots_12357         0x1002857  /* U+2857 BRAILLE PATTERN DOTS-12357 */
+#define XK_braille_dots_457           0x1002858  /* U+2858 BRAILLE PATTERN DOTS-457 */
+#define XK_braille_dots_1457          0x1002859  /* U+2859 BRAILLE PATTERN DOTS-1457 */
+#define XK_braille_dots_2457          0x100285a  /* U+285a BRAILLE PATTERN DOTS-2457 */
+#define XK_braille_dots_12457         0x100285b  /* U+285b BRAILLE PATTERN DOTS-12457 */
+#define XK_braille_dots_3457          0x100285c  /* U+285c BRAILLE PATTERN DOTS-3457 */
+#define XK_braille_dots_13457         0x100285d  /* U+285d BRAILLE PATTERN DOTS-13457 */
+#define XK_braille_dots_23457         0x100285e  /* U+285e BRAILLE PATTERN DOTS-23457 */
+#define XK_braille_dots_123457        0x100285f  /* U+285f BRAILLE PATTERN DOTS-123457 */
+#define XK_braille_dots_67            0x1002860  /* U+2860 BRAILLE PATTERN DOTS-67 */
+#define XK_braille_dots_167           0x1002861  /* U+2861 BRAILLE PATTERN DOTS-167 */
+#define XK_braille_dots_267           0x1002862  /* U+2862 BRAILLE PATTERN DOTS-267 */
+#define XK_braille_dots_1267          0x1002863  /* U+2863 BRAILLE PATTERN DOTS-1267 */
+#define XK_braille_dots_367           0x1002864  /* U+2864 BRAILLE PATTERN DOTS-367 */
+#define XK_braille_dots_1367          0x1002865  /* U+2865 BRAILLE PATTERN DOTS-1367 */
+#define XK_braille_dots_2367          0x1002866  /* U+2866 BRAILLE PATTERN DOTS-2367 */
+#define XK_braille_dots_12367         0x1002867  /* U+2867 BRAILLE PATTERN DOTS-12367 */
+#define XK_braille_dots_467           0x1002868  /* U+2868 BRAILLE PATTERN DOTS-467 */
+#define XK_braille_dots_1467          0x1002869  /* U+2869 BRAILLE PATTERN DOTS-1467 */
+#define XK_braille_dots_2467          0x100286a  /* U+286a BRAILLE PATTERN DOTS-2467 */
+#define XK_braille_dots_12467         0x100286b  /* U+286b BRAILLE PATTERN DOTS-12467 */
+#define XK_braille_dots_3467          0x100286c  /* U+286c BRAILLE PATTERN DOTS-3467 */
+#define XK_braille_dots_13467         0x100286d  /* U+286d BRAILLE PATTERN DOTS-13467 */
+#define XK_braille_dots_23467         0x100286e  /* U+286e BRAILLE PATTERN DOTS-23467 */
+#define XK_braille_dots_123467        0x100286f  /* U+286f BRAILLE PATTERN DOTS-123467 */
+#define XK_braille_dots_567           0x1002870  /* U+2870 BRAILLE PATTERN DOTS-567 */
+#define XK_braille_dots_1567          0x1002871  /* U+2871 BRAILLE PATTERN DOTS-1567 */
+#define XK_braille_dots_2567          0x1002872  /* U+2872 BRAILLE PATTERN DOTS-2567 */
+#define XK_braille_dots_12567         0x1002873  /* U+2873 BRAILLE PATTERN DOTS-12567 */
+#define XK_braille_dots_3567          0x1002874  /* U+2874 BRAILLE PATTERN DOTS-3567 */
+#define XK_braille_dots_13567         0x1002875  /* U+2875 BRAILLE PATTERN DOTS-13567 */
+#define XK_braille_dots_23567         0x1002876  /* U+2876 BRAILLE PATTERN DOTS-23567 */
+#define XK_braille_dots_123567        0x1002877  /* U+2877 BRAILLE PATTERN DOTS-123567 */
+#define XK_braille_dots_4567          0x1002878  /* U+2878 BRAILLE PATTERN DOTS-4567 */
+#define XK_braille_dots_14567         0x1002879  /* U+2879 BRAILLE PATTERN DOTS-14567 */
+#define XK_braille_dots_24567         0x100287a  /* U+287a BRAILLE PATTERN DOTS-24567 */
+#define XK_braille_dots_124567        0x100287b  /* U+287b BRAILLE PATTERN DOTS-124567 */
+#define XK_braille_dots_34567         0x100287c  /* U+287c BRAILLE PATTERN DOTS-34567 */
+#define XK_braille_dots_134567        0x100287d  /* U+287d BRAILLE PATTERN DOTS-134567 */
+#define XK_braille_dots_234567        0x100287e  /* U+287e BRAILLE PATTERN DOTS-234567 */
+#define XK_braille_dots_1234567       0x100287f  /* U+287f BRAILLE PATTERN DOTS-1234567 */
+#define XK_braille_dots_8             0x1002880  /* U+2880 BRAILLE PATTERN DOTS-8 */
+#define XK_braille_dots_18            0x1002881  /* U+2881 BRAILLE PATTERN DOTS-18 */
+#define XK_braille_dots_28            0x1002882  /* U+2882 BRAILLE PATTERN DOTS-28 */
+#define XK_braille_dots_128           0x1002883  /* U+2883 BRAILLE PATTERN DOTS-128 */
+#define XK_braille_dots_38            0x1002884  /* U+2884 BRAILLE PATTERN DOTS-38 */
+#define XK_braille_dots_138           0x1002885  /* U+2885 BRAILLE PATTERN DOTS-138 */
+#define XK_braille_dots_238           0x1002886  /* U+2886 BRAILLE PATTERN DOTS-238 */
+#define XK_braille_dots_1238          0x1002887  /* U+2887 BRAILLE PATTERN DOTS-1238 */
+#define XK_braille_dots_48            0x1002888  /* U+2888 BRAILLE PATTERN DOTS-48 */
+#define XK_braille_dots_148           0x1002889  /* U+2889 BRAILLE PATTERN DOTS-148 */
+#define XK_braille_dots_248           0x100288a  /* U+288a BRAILLE PATTERN DOTS-248 */
+#define XK_braille_dots_1248          0x100288b  /* U+288b BRAILLE PATTERN DOTS-1248 */
+#define XK_braille_dots_348           0x100288c  /* U+288c BRAILLE PATTERN DOTS-348 */
+#define XK_braille_dots_1348          0x100288d  /* U+288d BRAILLE PATTERN DOTS-1348 */
+#define XK_braille_dots_2348          0x100288e  /* U+288e BRAILLE PATTERN DOTS-2348 */
+#define XK_braille_dots_12348         0x100288f  /* U+288f BRAILLE PATTERN DOTS-12348 */
+#define XK_braille_dots_58            0x1002890  /* U+2890 BRAILLE PATTERN DOTS-58 */
+#define XK_braille_dots_158           0x1002891  /* U+2891 BRAILLE PATTERN DOTS-158 */
+#define XK_braille_dots_258           0x1002892  /* U+2892 BRAILLE PATTERN DOTS-258 */
+#define XK_braille_dots_1258          0x1002893  /* U+2893 BRAILLE PATTERN DOTS-1258 */
+#define XK_braille_dots_358           0x1002894  /* U+2894 BRAILLE PATTERN DOTS-358 */
+#define XK_braille_dots_1358          0x1002895  /* U+2895 BRAILLE PATTERN DOTS-1358 */
+#define XK_braille_dots_2358          0x1002896  /* U+2896 BRAILLE PATTERN DOTS-2358 */
+#define XK_braille_dots_12358         0x1002897  /* U+2897 BRAILLE PATTERN DOTS-12358 */
+#define XK_braille_dots_458           0x1002898  /* U+2898 BRAILLE PATTERN DOTS-458 */
+#define XK_braille_dots_1458          0x1002899  /* U+2899 BRAILLE PATTERN DOTS-1458 */
+#define XK_braille_dots_2458          0x100289a  /* U+289a BRAILLE PATTERN DOTS-2458 */
+#define XK_braille_dots_12458         0x100289b  /* U+289b BRAILLE PATTERN DOTS-12458 */
+#define XK_braille_dots_3458          0x100289c  /* U+289c BRAILLE PATTERN DOTS-3458 */
+#define XK_braille_dots_13458         0x100289d  /* U+289d BRAILLE PATTERN DOTS-13458 */
+#define XK_braille_dots_23458         0x100289e  /* U+289e BRAILLE PATTERN DOTS-23458 */
+#define XK_braille_dots_123458        0x100289f  /* U+289f BRAILLE PATTERN DOTS-123458 */
+#define XK_braille_dots_68            0x10028a0  /* U+28a0 BRAILLE PATTERN DOTS-68 */
+#define XK_braille_dots_168           0x10028a1  /* U+28a1 BRAILLE PATTERN DOTS-168 */
+#define XK_braille_dots_268           0x10028a2  /* U+28a2 BRAILLE PATTERN DOTS-268 */
+#define XK_braille_dots_1268          0x10028a3  /* U+28a3 BRAILLE PATTERN DOTS-1268 */
+#define XK_braille_dots_368           0x10028a4  /* U+28a4 BRAILLE PATTERN DOTS-368 */
+#define XK_braille_dots_1368          0x10028a5  /* U+28a5 BRAILLE PATTERN DOTS-1368 */
+#define XK_braille_dots_2368          0x10028a6  /* U+28a6 BRAILLE PATTERN DOTS-2368 */
+#define XK_braille_dots_12368         0x10028a7  /* U+28a7 BRAILLE PATTERN DOTS-12368 */
+#define XK_braille_dots_468           0x10028a8  /* U+28a8 BRAILLE PATTERN DOTS-468 */
+#define XK_braille_dots_1468          0x10028a9  /* U+28a9 BRAILLE PATTERN DOTS-1468 */
+#define XK_braille_dots_2468          0x10028aa  /* U+28aa BRAILLE PATTERN DOTS-2468 */
+#define XK_braille_dots_12468         0x10028ab  /* U+28ab BRAILLE PATTERN DOTS-12468 */
+#define XK_braille_dots_3468          0x10028ac  /* U+28ac BRAILLE PATTERN DOTS-3468 */
+#define XK_braille_dots_13468         0x10028ad  /* U+28ad BRAILLE PATTERN DOTS-13468 */
+#define XK_braille_dots_23468         0x10028ae  /* U+28ae BRAILLE PATTERN DOTS-23468 */
+#define XK_braille_dots_123468        0x10028af  /* U+28af BRAILLE PATTERN DOTS-123468 */
+#define XK_braille_dots_568           0x10028b0  /* U+28b0 BRAILLE PATTERN DOTS-568 */
+#define XK_braille_dots_1568          0x10028b1  /* U+28b1 BRAILLE PATTERN DOTS-1568 */
+#define XK_braille_dots_2568          0x10028b2  /* U+28b2 BRAILLE PATTERN DOTS-2568 */
+#define XK_braille_dots_12568         0x10028b3  /* U+28b3 BRAILLE PATTERN DOTS-12568 */
+#define XK_braille_dots_3568          0x10028b4  /* U+28b4 BRAILLE PATTERN DOTS-3568 */
+#define XK_braille_dots_13568         0x10028b5  /* U+28b5 BRAILLE PATTERN DOTS-13568 */
+#define XK_braille_dots_23568         0x10028b6  /* U+28b6 BRAILLE PATTERN DOTS-23568 */
+#define XK_braille_dots_123568        0x10028b7  /* U+28b7 BRAILLE PATTERN DOTS-123568 */
+#define XK_braille_dots_4568          0x10028b8  /* U+28b8 BRAILLE PATTERN DOTS-4568 */
+#define XK_braille_dots_14568         0x10028b9  /* U+28b9 BRAILLE PATTERN DOTS-14568 */
+#define XK_braille_dots_24568         0x10028ba  /* U+28ba BRAILLE PATTERN DOTS-24568 */
+#define XK_braille_dots_124568        0x10028bb  /* U+28bb BRAILLE PATTERN DOTS-124568 */
+#define XK_braille_dots_34568         0x10028bc  /* U+28bc BRAILLE PATTERN DOTS-34568 */
+#define XK_braille_dots_134568        0x10028bd  /* U+28bd BRAILLE PATTERN DOTS-134568 */
+#define XK_braille_dots_234568        0x10028be  /* U+28be BRAILLE PATTERN DOTS-234568 */
+#define XK_braille_dots_1234568       0x10028bf  /* U+28bf BRAILLE PATTERN DOTS-1234568 */
+#define XK_braille_dots_78            0x10028c0  /* U+28c0 BRAILLE PATTERN DOTS-78 */
+#define XK_braille_dots_178           0x10028c1  /* U+28c1 BRAILLE PATTERN DOTS-178 */
+#define XK_braille_dots_278           0x10028c2  /* U+28c2 BRAILLE PATTERN DOTS-278 */
+#define XK_braille_dots_1278          0x10028c3  /* U+28c3 BRAILLE PATTERN DOTS-1278 */
+#define XK_braille_dots_378           0x10028c4  /* U+28c4 BRAILLE PATTERN DOTS-378 */
+#define XK_braille_dots_1378          0x10028c5  /* U+28c5 BRAILLE PATTERN DOTS-1378 */
+#define XK_braille_dots_2378          0x10028c6  /* U+28c6 BRAILLE PATTERN DOTS-2378 */
+#define XK_braille_dots_12378         0x10028c7  /* U+28c7 BRAILLE PATTERN DOTS-12378 */
+#define XK_braille_dots_478           0x10028c8  /* U+28c8 BRAILLE PATTERN DOTS-478 */
+#define XK_braille_dots_1478          0x10028c9  /* U+28c9 BRAILLE PATTERN DOTS-1478 */
+#define XK_braille_dots_2478          0x10028ca  /* U+28ca BRAILLE PATTERN DOTS-2478 */
+#define XK_braille_dots_12478         0x10028cb  /* U+28cb BRAILLE PATTERN DOTS-12478 */
+#define XK_braille_dots_3478          0x10028cc  /* U+28cc BRAILLE PATTERN DOTS-3478 */
+#define XK_braille_dots_13478         0x10028cd  /* U+28cd BRAILLE PATTERN DOTS-13478 */
+#define XK_braille_dots_23478         0x10028ce  /* U+28ce BRAILLE PATTERN DOTS-23478 */
+#define XK_braille_dots_123478        0x10028cf  /* U+28cf BRAILLE PATTERN DOTS-123478 */
+#define XK_braille_dots_578           0x10028d0  /* U+28d0 BRAILLE PATTERN DOTS-578 */
+#define XK_braille_dots_1578          0x10028d1  /* U+28d1 BRAILLE PATTERN DOTS-1578 */
+#define XK_braille_dots_2578          0x10028d2  /* U+28d2 BRAILLE PATTERN DOTS-2578 */
+#define XK_braille_dots_12578         0x10028d3  /* U+28d3 BRAILLE PATTERN DOTS-12578 */
+#define XK_braille_dots_3578          0x10028d4  /* U+28d4 BRAILLE PATTERN DOTS-3578 */
+#define XK_braille_dots_13578         0x10028d5  /* U+28d5 BRAILLE PATTERN DOTS-13578 */
+#define XK_braille_dots_23578         0x10028d6  /* U+28d6 BRAILLE PATTERN DOTS-23578 */
+#define XK_braille_dots_123578        0x10028d7  /* U+28d7 BRAILLE PATTERN DOTS-123578 */
+#define XK_braille_dots_4578          0x10028d8  /* U+28d8 BRAILLE PATTERN DOTS-4578 */
+#define XK_braille_dots_14578         0x10028d9  /* U+28d9 BRAILLE PATTERN DOTS-14578 */
+#define XK_braille_dots_24578         0x10028da  /* U+28da BRAILLE PATTERN DOTS-24578 */
+#define XK_braille_dots_124578        0x10028db  /* U+28db BRAILLE PATTERN DOTS-124578 */
+#define XK_braille_dots_34578         0x10028dc  /* U+28dc BRAILLE PATTERN DOTS-34578 */
+#define XK_braille_dots_134578        0x10028dd  /* U+28dd BRAILLE PATTERN DOTS-134578 */
+#define XK_braille_dots_234578        0x10028de  /* U+28de BRAILLE PATTERN DOTS-234578 */
+#define XK_braille_dots_1234578       0x10028df  /* U+28df BRAILLE PATTERN DOTS-1234578 */
+#define XK_braille_dots_678           0x10028e0  /* U+28e0 BRAILLE PATTERN DOTS-678 */
+#define XK_braille_dots_1678          0x10028e1  /* U+28e1 BRAILLE PATTERN DOTS-1678 */
+#define XK_braille_dots_2678          0x10028e2  /* U+28e2 BRAILLE PATTERN DOTS-2678 */
+#define XK_braille_dots_12678         0x10028e3  /* U+28e3 BRAILLE PATTERN DOTS-12678 */
+#define XK_braille_dots_3678          0x10028e4  /* U+28e4 BRAILLE PATTERN DOTS-3678 */
+#define XK_braille_dots_13678         0x10028e5  /* U+28e5 BRAILLE PATTERN DOTS-13678 */
+#define XK_braille_dots_23678         0x10028e6  /* U+28e6 BRAILLE PATTERN DOTS-23678 */
+#define XK_braille_dots_123678        0x10028e7  /* U+28e7 BRAILLE PATTERN DOTS-123678 */
+#define XK_braille_dots_4678          0x10028e8  /* U+28e8 BRAILLE PATTERN DOTS-4678 */
+#define XK_braille_dots_14678         0x10028e9  /* U+28e9 BRAILLE PATTERN DOTS-14678 */
+#define XK_braille_dots_24678         0x10028ea  /* U+28ea BRAILLE PATTERN DOTS-24678 */
+#define XK_braille_dots_124678        0x10028eb  /* U+28eb BRAILLE PATTERN DOTS-124678 */
+#define XK_braille_dots_34678         0x10028ec  /* U+28ec BRAILLE PATTERN DOTS-34678 */
+#define XK_braille_dots_134678        0x10028ed  /* U+28ed BRAILLE PATTERN DOTS-134678 */
+#define XK_braille_dots_234678        0x10028ee  /* U+28ee BRAILLE PATTERN DOTS-234678 */
+#define XK_braille_dots_1234678       0x10028ef  /* U+28ef BRAILLE PATTERN DOTS-1234678 */
+#define XK_braille_dots_5678          0x10028f0  /* U+28f0 BRAILLE PATTERN DOTS-5678 */
+#define XK_braille_dots_15678         0x10028f1  /* U+28f1 BRAILLE PATTERN DOTS-15678 */
+#define XK_braille_dots_25678         0x10028f2  /* U+28f2 BRAILLE PATTERN DOTS-25678 */
+#define XK_braille_dots_125678        0x10028f3  /* U+28f3 BRAILLE PATTERN DOTS-125678 */
+#define XK_braille_dots_35678         0x10028f4  /* U+28f4 BRAILLE PATTERN DOTS-35678 */
+#define XK_braille_dots_135678        0x10028f5  /* U+28f5 BRAILLE PATTERN DOTS-135678 */
+#define XK_braille_dots_235678        0x10028f6  /* U+28f6 BRAILLE PATTERN DOTS-235678 */
+#define XK_braille_dots_1235678       0x10028f7  /* U+28f7 BRAILLE PATTERN DOTS-1235678 */
+#define XK_braille_dots_45678         0x10028f8  /* U+28f8 BRAILLE PATTERN DOTS-45678 */
+#define XK_braille_dots_145678        0x10028f9  /* U+28f9 BRAILLE PATTERN DOTS-145678 */
+#define XK_braille_dots_245678        0x10028fa  /* U+28fa BRAILLE PATTERN DOTS-245678 */
+#define XK_braille_dots_1245678       0x10028fb  /* U+28fb BRAILLE PATTERN DOTS-1245678 */
+#define XK_braille_dots_345678        0x10028fc  /* U+28fc BRAILLE PATTERN DOTS-345678 */
+#define XK_braille_dots_1345678       0x10028fd  /* U+28fd BRAILLE PATTERN DOTS-1345678 */
+#define XK_braille_dots_2345678       0x10028fe  /* U+28fe BRAILLE PATTERN DOTS-2345678 */
+#define XK_braille_dots_12345678      0x10028ff  /* U+28ff BRAILLE PATTERN DOTS-12345678 */
+#endif /* XK_BRAILLE */
+
+/*
+ * Sinhala (http://unicode.org/charts/PDF/U0D80.pdf)
+ * http://www.nongnu.org/sinhala/doc/transliteration/sinhala-transliteration_6.html
+ */
+
+#ifdef XK_SINHALA
+#define XK_Sinh_ng            0x1000d82  /* U+0D82 SINHALA ANUSVARAYA */
+#define XK_Sinh_h2            0x1000d83  /* U+0D83 SINHALA VISARGAYA */
+#define XK_Sinh_a             0x1000d85  /* U+0D85 SINHALA AYANNA */
+#define XK_Sinh_aa            0x1000d86  /* U+0D86 SINHALA AAYANNA */
+#define XK_Sinh_ae            0x1000d87  /* U+0D87 SINHALA AEYANNA */
+#define XK_Sinh_aee           0x1000d88  /* U+0D88 SINHALA AEEYANNA */
+#define XK_Sinh_i             0x1000d89  /* U+0D89 SINHALA IYANNA */
+#define XK_Sinh_ii            0x1000d8a  /* U+0D8A SINHALA IIYANNA */
+#define XK_Sinh_u             0x1000d8b  /* U+0D8B SINHALA UYANNA */
+#define XK_Sinh_uu            0x1000d8c  /* U+0D8C SINHALA UUYANNA */
+#define XK_Sinh_ri            0x1000d8d  /* U+0D8D SINHALA IRUYANNA */
+#define XK_Sinh_rii           0x1000d8e  /* U+0D8E SINHALA IRUUYANNA */
+#define XK_Sinh_lu            0x1000d8f  /* U+0D8F SINHALA ILUYANNA */
+#define XK_Sinh_luu           0x1000d90  /* U+0D90 SINHALA ILUUYANNA */
+#define XK_Sinh_e             0x1000d91  /* U+0D91 SINHALA EYANNA */
+#define XK_Sinh_ee            0x1000d92  /* U+0D92 SINHALA EEYANNA */
+#define XK_Sinh_ai            0x1000d93  /* U+0D93 SINHALA AIYANNA */
+#define XK_Sinh_o             0x1000d94  /* U+0D94 SINHALA OYANNA */
+#define XK_Sinh_oo            0x1000d95  /* U+0D95 SINHALA OOYANNA */
+#define XK_Sinh_au            0x1000d96  /* U+0D96 SINHALA AUYANNA */
+#define XK_Sinh_ka            0x1000d9a  /* U+0D9A SINHALA KAYANNA */
+#define XK_Sinh_kha           0x1000d9b  /* U+0D9B SINHALA MAHA. KAYANNA */
+#define XK_Sinh_ga            0x1000d9c  /* U+0D9C SINHALA GAYANNA */
+#define XK_Sinh_gha           0x1000d9d  /* U+0D9D SINHALA MAHA. GAYANNA */
+#define XK_Sinh_ng2           0x1000d9e  /* U+0D9E SINHALA KANTAJA NAASIKYAYA */
+#define XK_Sinh_nga           0x1000d9f  /* U+0D9F SINHALA SANYAKA GAYANNA */
+#define XK_Sinh_ca            0x1000da0  /* U+0DA0 SINHALA CAYANNA */
+#define XK_Sinh_cha           0x1000da1  /* U+0DA1 SINHALA MAHA. CAYANNA */
+#define XK_Sinh_ja            0x1000da2  /* U+0DA2 SINHALA JAYANNA */
+#define XK_Sinh_jha           0x1000da3  /* U+0DA3 SINHALA MAHA. JAYANNA */
+#define XK_Sinh_nya           0x1000da4  /* U+0DA4 SINHALA TAALUJA NAASIKYAYA */
+#define XK_Sinh_jnya          0x1000da5  /* U+0DA5 SINHALA TAALUJA SANYOOGA NAASIKYAYA */
+#define XK_Sinh_nja           0x1000da6  /* U+0DA6 SINHALA SANYAKA JAYANNA */
+#define XK_Sinh_tta           0x1000da7  /* U+0DA7 SINHALA TTAYANNA */
+#define XK_Sinh_ttha          0x1000da8  /* U+0DA8 SINHALA MAHA. TTAYANNA */
+#define XK_Sinh_dda           0x1000da9  /* U+0DA9 SINHALA DDAYANNA */
+#define XK_Sinh_ddha          0x1000daa  /* U+0DAA SINHALA MAHA. DDAYANNA */
+#define XK_Sinh_nna           0x1000dab  /* U+0DAB SINHALA MUURDHAJA NAYANNA */
+#define XK_Sinh_ndda          0x1000dac  /* U+0DAC SINHALA SANYAKA DDAYANNA */
+#define XK_Sinh_tha           0x1000dad  /* U+0DAD SINHALA TAYANNA */
+#define XK_Sinh_thha          0x1000dae  /* U+0DAE SINHALA MAHA. TAYANNA */
+#define XK_Sinh_dha           0x1000daf  /* U+0DAF SINHALA DAYANNA */
+#define XK_Sinh_dhha          0x1000db0  /* U+0DB0 SINHALA MAHA. DAYANNA */
+#define XK_Sinh_na            0x1000db1  /* U+0DB1 SINHALA DANTAJA NAYANNA */
+#define XK_Sinh_ndha          0x1000db3  /* U+0DB3 SINHALA SANYAKA DAYANNA */
+#define XK_Sinh_pa            0x1000db4  /* U+0DB4 SINHALA PAYANNA */
+#define XK_Sinh_pha           0x1000db5  /* U+0DB5 SINHALA MAHA. PAYANNA */
+#define XK_Sinh_ba            0x1000db6  /* U+0DB6 SINHALA BAYANNA */
+#define XK_Sinh_bha           0x1000db7  /* U+0DB7 SINHALA MAHA. BAYANNA */
+#define XK_Sinh_ma            0x1000db8  /* U+0DB8 SINHALA MAYANNA */
+#define XK_Sinh_mba           0x1000db9  /* U+0DB9 SINHALA AMBA BAYANNA */
+#define XK_Sinh_ya            0x1000dba  /* U+0DBA SINHALA YAYANNA */
+#define XK_Sinh_ra            0x1000dbb  /* U+0DBB SINHALA RAYANNA */
+#define XK_Sinh_la            0x1000dbd  /* U+0DBD SINHALA DANTAJA LAYANNA */
+#define XK_Sinh_va            0x1000dc0  /* U+0DC0 SINHALA VAYANNA */
+#define XK_Sinh_sha           0x1000dc1  /* U+0DC1 SINHALA TAALUJA SAYANNA */
+#define XK_Sinh_ssha          0x1000dc2  /* U+0DC2 SINHALA MUURDHAJA SAYANNA */
+#define XK_Sinh_sa            0x1000dc3  /* U+0DC3 SINHALA DANTAJA SAYANNA */
+#define XK_Sinh_ha            0x1000dc4  /* U+0DC4 SINHALA HAYANNA */
+#define XK_Sinh_lla           0x1000dc5  /* U+0DC5 SINHALA MUURDHAJA LAYANNA */
+#define XK_Sinh_fa            0x1000dc6  /* U+0DC6 SINHALA FAYANNA */
+#define XK_Sinh_al            0x1000dca  /* U+0DCA SINHALA AL-LAKUNA */
+#define XK_Sinh_aa2           0x1000dcf  /* U+0DCF SINHALA AELA-PILLA */
+#define XK_Sinh_ae2           0x1000dd0  /* U+0DD0 SINHALA AEDA-PILLA */
+#define XK_Sinh_aee2          0x1000dd1  /* U+0DD1 SINHALA DIGA AEDA-PILLA */
+#define XK_Sinh_i2            0x1000dd2  /* U+0DD2 SINHALA IS-PILLA */
+#define XK_Sinh_ii2           0x1000dd3  /* U+0DD3 SINHALA DIGA IS-PILLA */
+#define XK_Sinh_u2            0x1000dd4  /* U+0DD4 SINHALA PAA-PILLA */
+#define XK_Sinh_uu2           0x1000dd6  /* U+0DD6 SINHALA DIGA PAA-PILLA */
+#define XK_Sinh_ru2           0x1000dd8  /* U+0DD8 SINHALA GAETTA-PILLA */
+#define XK_Sinh_e2            0x1000dd9  /* U+0DD9 SINHALA KOMBUVA */
+#define XK_Sinh_ee2           0x1000dda  /* U+0DDA SINHALA DIGA KOMBUVA */
+#define XK_Sinh_ai2           0x1000ddb  /* U+0DDB SINHALA KOMBU DEKA */
+#define XK_Sinh_o2            0x1000ddc  /* U+0DDC SINHALA KOMBUVA HAA AELA-PILLA*/
+#define XK_Sinh_oo2           0x1000ddd  /* U+0DDD SINHALA KOMBUVA HAA DIGA AELA-PILLA*/
+#define XK_Sinh_au2           0x1000dde  /* U+0DDE SINHALA KOMBUVA HAA GAYANUKITTA */
+#define XK_Sinh_lu2           0x1000ddf  /* U+0DDF SINHALA GAYANUKITTA */
+#define XK_Sinh_ruu2          0x1000df2  /* U+0DF2 SINHALA DIGA GAETTA-PILLA */
+#define XK_Sinh_luu2          0x1000df3  /* U+0DF3 SINHALA DIGA GAYANUKITTA */
+#define XK_Sinh_kunddaliya    0x1000df4  /* U+0DF4 SINHALA KUNDDALIYA */
+#endif /* XK_SINHALA */
diff --git a/depends/libxcb/depends/xorgproto/include/X11/meson.build b/depends/libxcb/depends/xorgproto/include/X11/meson.build
new file mode 100644
index 0000000..556e090
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/X11/meson.build
@@ -0,0 +1,62 @@
+fd_set_maybe_headers = [ 'sys/param.h',
+                         'sys/types.h',
+                         'sys/time.h',
+                         'sys/select.h'
+]
+fd_set_headers = ''
+foreach h : fd_set_maybe_headers
+    if cc.has_header(h)
+        fd_set_headers += '#include <' + h + '>\n'
+    endif
+endforeach
+
+# generated headers. try not to make more of these, please.
+if cc.has_member('fd_set', 'fds_bits', prefix: fd_set_headers)
+    fds_bits = 'fds_bits'
+elif cc.has_member('fd_set', '__fds_bits', prefix: fd_set_headers)
+    fds_bits = '__fds_bits'
+else
+    error('Your fd_set is too weird.')
+endif
+xpoll_config = configuration_data()
+xpoll_config.set('USE_FDS_BITS', fds_bits)
+configure_file(input : 'Xpoll.h.in',
+               output : 'Xpoll.h',
+               install : true,
+               install_dir : get_option('includedir') + '/X11',
+               configuration: xpoll_config)
+
+install_headers(
+    'ap_keysym.h',
+    'DECkeysym.h',
+    'HPkeysym.h',
+    'keysymdef.h',
+    'keysym.h',
+    'Sunkeysym.h',
+    'Xalloca.h',
+    'Xarch.h',
+    'Xatom.h',
+    'Xdefs.h',
+    'XF86keysym.h',
+    'Xfuncs.h',
+    'Xfuncproto.h',
+    'X.h',
+    'Xmd.h',
+    'Xosdefs.h',
+    'Xos.h',
+    'Xos_r.h',
+    'Xproto.h',
+    'Xprotostr.h',
+    'Xthreads.h',
+    'Xw32defs.h',
+    'XWDFile.h',
+    'Xwindows.h',
+    'Xwinsock.h',
+    subdir : 'X11')
+
+subdir('dri')
+subdir('extensions')
+subdir('fonts')
+if get_option('legacy') == true
+    subdir('PM')
+endif
diff --git a/depends/libxcb/depends/xorgproto/include/meson.build b/depends/libxcb/depends/xorgproto/include/meson.build
new file mode 100644
index 0000000..805ef90
--- /dev/null
+++ b/depends/libxcb/depends/xorgproto/include/meson.build
@@ -0,0 +1,2 @@
+subdir('GL')
+subdir('X11')
diff --git a/depends/libxcb/include/xcb/bigreq.h b/depends/libxcb/include/xcb/bigreq.h
new file mode 100644
index 0000000..bfb9527
--- /dev/null
+++ b/depends/libxcb/include/xcb/bigreq.h
@@ -0,0 +1,109 @@
+/*
+ * This file generated automatically from bigreq.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_BigRequests_API XCB BigRequests API
+ * @brief BigRequests XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __BIGREQ_H
+#define __BIGREQ_H
+
+#include "xcb.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_BIGREQUESTS_MAJOR_VERSION 0
+#define XCB_BIGREQUESTS_MINOR_VERSION 0
+
+extern xcb_extension_t xcb_big_requests_id;
+
+/**
+ * @brief xcb_big_requests_enable_cookie_t
+ **/
+typedef struct xcb_big_requests_enable_cookie_t {
+    unsigned int sequence;
+} xcb_big_requests_enable_cookie_t;
+
+/** Opcode for xcb_big_requests_enable. */
+#define XCB_BIG_REQUESTS_ENABLE 0
+
+/**
+ * @brief xcb_big_requests_enable_request_t
+ **/
+typedef struct xcb_big_requests_enable_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_big_requests_enable_request_t;
+
+/**
+ * @brief xcb_big_requests_enable_reply_t
+ **/
+typedef struct xcb_big_requests_enable_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t maximum_request_length;
+} xcb_big_requests_enable_reply_t;
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_big_requests_enable_cookie_t
+xcb_big_requests_enable (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_big_requests_enable_cookie_t
+xcb_big_requests_enable_unchecked (xcb_connection_t *c);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_big_requests_enable_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_big_requests_enable_reply_t *
+xcb_big_requests_enable_reply (xcb_connection_t                  *c,
+                               xcb_big_requests_enable_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/composite.h b/depends/libxcb/include/xcb/composite.h
new file mode 100644
index 0000000..6daddea
--- /dev/null
+++ b/depends/libxcb/include/xcb/composite.h
@@ -0,0 +1,504 @@
+/*
+ * This file generated automatically from composite.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_Composite_API XCB Composite API
+ * @brief Composite XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __COMPOSITE_H
+#define __COMPOSITE_H
+
+#include "xcb.h"
+#include "xproto.h"
+#include "xfixes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_COMPOSITE_MAJOR_VERSION 0
+#define XCB_COMPOSITE_MINOR_VERSION 4
+
+extern xcb_extension_t xcb_composite_id;
+
+typedef enum xcb_composite_redirect_t {
+    XCB_COMPOSITE_REDIRECT_AUTOMATIC = 0,
+    XCB_COMPOSITE_REDIRECT_MANUAL = 1
+} xcb_composite_redirect_t;
+
+/**
+ * @brief xcb_composite_query_version_cookie_t
+ **/
+typedef struct xcb_composite_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_composite_query_version_cookie_t;
+
+/** Opcode for xcb_composite_query_version. */
+#define XCB_COMPOSITE_QUERY_VERSION 0
+
+/**
+ * @brief xcb_composite_query_version_request_t
+ **/
+typedef struct xcb_composite_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t client_major_version;
+    uint32_t client_minor_version;
+} xcb_composite_query_version_request_t;
+
+/**
+ * @brief xcb_composite_query_version_reply_t
+ **/
+typedef struct xcb_composite_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t major_version;
+    uint32_t minor_version;
+    uint8_t  pad1[16];
+} xcb_composite_query_version_reply_t;
+
+/** Opcode for xcb_composite_redirect_window. */
+#define XCB_COMPOSITE_REDIRECT_WINDOW 1
+
+/**
+ * @brief xcb_composite_redirect_window_request_t
+ **/
+typedef struct xcb_composite_redirect_window_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    uint8_t      update;
+    uint8_t      pad0[3];
+} xcb_composite_redirect_window_request_t;
+
+/** Opcode for xcb_composite_redirect_subwindows. */
+#define XCB_COMPOSITE_REDIRECT_SUBWINDOWS 2
+
+/**
+ * @brief xcb_composite_redirect_subwindows_request_t
+ **/
+typedef struct xcb_composite_redirect_subwindows_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    uint8_t      update;
+    uint8_t      pad0[3];
+} xcb_composite_redirect_subwindows_request_t;
+
+/** Opcode for xcb_composite_unredirect_window. */
+#define XCB_COMPOSITE_UNREDIRECT_WINDOW 3
+
+/**
+ * @brief xcb_composite_unredirect_window_request_t
+ **/
+typedef struct xcb_composite_unredirect_window_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    uint8_t      update;
+    uint8_t      pad0[3];
+} xcb_composite_unredirect_window_request_t;
+
+/** Opcode for xcb_composite_unredirect_subwindows. */
+#define XCB_COMPOSITE_UNREDIRECT_SUBWINDOWS 4
+
+/**
+ * @brief xcb_composite_unredirect_subwindows_request_t
+ **/
+typedef struct xcb_composite_unredirect_subwindows_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    uint8_t      update;
+    uint8_t      pad0[3];
+} xcb_composite_unredirect_subwindows_request_t;
+
+/** Opcode for xcb_composite_create_region_from_border_clip. */
+#define XCB_COMPOSITE_CREATE_REGION_FROM_BORDER_CLIP 5
+
+/**
+ * @brief xcb_composite_create_region_from_border_clip_request_t
+ **/
+typedef struct xcb_composite_create_region_from_border_clip_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_xfixes_region_t region;
+    xcb_window_t        window;
+} xcb_composite_create_region_from_border_clip_request_t;
+
+/** Opcode for xcb_composite_name_window_pixmap. */
+#define XCB_COMPOSITE_NAME_WINDOW_PIXMAP 6
+
+/**
+ * @brief xcb_composite_name_window_pixmap_request_t
+ **/
+typedef struct xcb_composite_name_window_pixmap_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    xcb_pixmap_t pixmap;
+} xcb_composite_name_window_pixmap_request_t;
+
+/**
+ * @brief xcb_composite_get_overlay_window_cookie_t
+ **/
+typedef struct xcb_composite_get_overlay_window_cookie_t {
+    unsigned int sequence;
+} xcb_composite_get_overlay_window_cookie_t;
+
+/** Opcode for xcb_composite_get_overlay_window. */
+#define XCB_COMPOSITE_GET_OVERLAY_WINDOW 7
+
+/**
+ * @brief xcb_composite_get_overlay_window_request_t
+ **/
+typedef struct xcb_composite_get_overlay_window_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_composite_get_overlay_window_request_t;
+
+/**
+ * @brief xcb_composite_get_overlay_window_reply_t
+ **/
+typedef struct xcb_composite_get_overlay_window_reply_t {
+    uint8_t      response_type;
+    uint8_t      pad0;
+    uint16_t     sequence;
+    uint32_t     length;
+    xcb_window_t overlay_win;
+    uint8_t      pad1[20];
+} xcb_composite_get_overlay_window_reply_t;
+
+/** Opcode for xcb_composite_release_overlay_window. */
+#define XCB_COMPOSITE_RELEASE_OVERLAY_WINDOW 8
+
+/**
+ * @brief xcb_composite_release_overlay_window_request_t
+ **/
+typedef struct xcb_composite_release_overlay_window_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_composite_release_overlay_window_request_t;
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_composite_query_version_cookie_t
+xcb_composite_query_version (xcb_connection_t *c,
+                             uint32_t          client_major_version,
+                             uint32_t          client_minor_version);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_composite_query_version_cookie_t
+xcb_composite_query_version_unchecked (xcb_connection_t *c,
+                                       uint32_t          client_major_version,
+                                       uint32_t          client_minor_version);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_composite_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_composite_query_version_reply_t *
+xcb_composite_query_version_reply (xcb_connection_t                      *c,
+                                   xcb_composite_query_version_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_composite_redirect_window_checked (xcb_connection_t *c,
+                                       xcb_window_t      window,
+                                       uint8_t           update);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_composite_redirect_window (xcb_connection_t *c,
+                               xcb_window_t      window,
+                               uint8_t           update);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_composite_redirect_subwindows_checked (xcb_connection_t *c,
+                                           xcb_window_t      window,
+                                           uint8_t           update);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_composite_redirect_subwindows (xcb_connection_t *c,
+                                   xcb_window_t      window,
+                                   uint8_t           update);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_composite_unredirect_window_checked (xcb_connection_t *c,
+                                         xcb_window_t      window,
+                                         uint8_t           update);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_composite_unredirect_window (xcb_connection_t *c,
+                                 xcb_window_t      window,
+                                 uint8_t           update);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_composite_unredirect_subwindows_checked (xcb_connection_t *c,
+                                             xcb_window_t      window,
+                                             uint8_t           update);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_composite_unredirect_subwindows (xcb_connection_t *c,
+                                     xcb_window_t      window,
+                                     uint8_t           update);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_composite_create_region_from_border_clip_checked (xcb_connection_t    *c,
+                                                      xcb_xfixes_region_t  region,
+                                                      xcb_window_t         window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_composite_create_region_from_border_clip (xcb_connection_t    *c,
+                                              xcb_xfixes_region_t  region,
+                                              xcb_window_t         window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_composite_name_window_pixmap_checked (xcb_connection_t *c,
+                                          xcb_window_t      window,
+                                          xcb_pixmap_t      pixmap);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_composite_name_window_pixmap (xcb_connection_t *c,
+                                  xcb_window_t      window,
+                                  xcb_pixmap_t      pixmap);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_composite_get_overlay_window_cookie_t
+xcb_composite_get_overlay_window (xcb_connection_t *c,
+                                  xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_composite_get_overlay_window_cookie_t
+xcb_composite_get_overlay_window_unchecked (xcb_connection_t *c,
+                                            xcb_window_t      window);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_composite_get_overlay_window_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_composite_get_overlay_window_reply_t *
+xcb_composite_get_overlay_window_reply (xcb_connection_t                           *c,
+                                        xcb_composite_get_overlay_window_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_composite_release_overlay_window_checked (xcb_connection_t *c,
+                                              xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_composite_release_overlay_window (xcb_connection_t *c,
+                                      xcb_window_t      window);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/damage.h b/depends/libxcb/include/xcb/damage.h
new file mode 100644
index 0000000..ff99ccb
--- /dev/null
+++ b/depends/libxcb/include/xcb/damage.h
@@ -0,0 +1,368 @@
+/*
+ * This file generated automatically from damage.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_Damage_API XCB Damage API
+ * @brief Damage XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __DAMAGE_H
+#define __DAMAGE_H
+
+#include "xcb.h"
+#include "xproto.h"
+#include "xfixes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_DAMAGE_MAJOR_VERSION 1
+#define XCB_DAMAGE_MINOR_VERSION 1
+
+extern xcb_extension_t xcb_damage_id;
+
+typedef uint32_t xcb_damage_damage_t;
+
+/**
+ * @brief xcb_damage_damage_iterator_t
+ **/
+typedef struct xcb_damage_damage_iterator_t {
+    xcb_damage_damage_t *data;
+    int                  rem;
+    int                  index;
+} xcb_damage_damage_iterator_t;
+
+typedef enum xcb_damage_report_level_t {
+    XCB_DAMAGE_REPORT_LEVEL_RAW_RECTANGLES = 0,
+    XCB_DAMAGE_REPORT_LEVEL_DELTA_RECTANGLES = 1,
+    XCB_DAMAGE_REPORT_LEVEL_BOUNDING_BOX = 2,
+    XCB_DAMAGE_REPORT_LEVEL_NON_EMPTY = 3
+} xcb_damage_report_level_t;
+
+/** Opcode for xcb_damage_bad_damage. */
+#define XCB_DAMAGE_BAD_DAMAGE 0
+
+/**
+ * @brief xcb_damage_bad_damage_error_t
+ **/
+typedef struct xcb_damage_bad_damage_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_damage_bad_damage_error_t;
+
+/**
+ * @brief xcb_damage_query_version_cookie_t
+ **/
+typedef struct xcb_damage_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_damage_query_version_cookie_t;
+
+/** Opcode for xcb_damage_query_version. */
+#define XCB_DAMAGE_QUERY_VERSION 0
+
+/**
+ * @brief xcb_damage_query_version_request_t
+ **/
+typedef struct xcb_damage_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t client_major_version;
+    uint32_t client_minor_version;
+} xcb_damage_query_version_request_t;
+
+/**
+ * @brief xcb_damage_query_version_reply_t
+ **/
+typedef struct xcb_damage_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t major_version;
+    uint32_t minor_version;
+    uint8_t  pad1[16];
+} xcb_damage_query_version_reply_t;
+
+/** Opcode for xcb_damage_create. */
+#define XCB_DAMAGE_CREATE 1
+
+/**
+ * @brief xcb_damage_create_request_t
+ **/
+typedef struct xcb_damage_create_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_damage_damage_t damage;
+    xcb_drawable_t      drawable;
+    uint8_t             level;
+    uint8_t             pad0[3];
+} xcb_damage_create_request_t;
+
+/** Opcode for xcb_damage_destroy. */
+#define XCB_DAMAGE_DESTROY 2
+
+/**
+ * @brief xcb_damage_destroy_request_t
+ **/
+typedef struct xcb_damage_destroy_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_damage_damage_t damage;
+} xcb_damage_destroy_request_t;
+
+/** Opcode for xcb_damage_subtract. */
+#define XCB_DAMAGE_SUBTRACT 3
+
+/**
+ * @brief xcb_damage_subtract_request_t
+ **/
+typedef struct xcb_damage_subtract_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_damage_damage_t damage;
+    xcb_xfixes_region_t repair;
+    xcb_xfixes_region_t parts;
+} xcb_damage_subtract_request_t;
+
+/** Opcode for xcb_damage_add. */
+#define XCB_DAMAGE_ADD 4
+
+/**
+ * @brief xcb_damage_add_request_t
+ **/
+typedef struct xcb_damage_add_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_drawable_t      drawable;
+    xcb_xfixes_region_t region;
+} xcb_damage_add_request_t;
+
+/** Opcode for xcb_damage_notify. */
+#define XCB_DAMAGE_NOTIFY 0
+
+/**
+ * @brief xcb_damage_notify_event_t
+ **/
+typedef struct xcb_damage_notify_event_t {
+    uint8_t             response_type;
+    uint8_t             level;
+    uint16_t            sequence;
+    xcb_drawable_t      drawable;
+    xcb_damage_damage_t damage;
+    xcb_timestamp_t     timestamp;
+    xcb_rectangle_t     area;
+    xcb_rectangle_t     geometry;
+} xcb_damage_notify_event_t;
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_damage_damage_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_damage_damage_t)
+ */
+void
+xcb_damage_damage_next (xcb_damage_damage_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_damage_damage_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_damage_damage_end (xcb_damage_damage_iterator_t i);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_damage_query_version_cookie_t
+xcb_damage_query_version (xcb_connection_t *c,
+                          uint32_t          client_major_version,
+                          uint32_t          client_minor_version);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_damage_query_version_cookie_t
+xcb_damage_query_version_unchecked (xcb_connection_t *c,
+                                    uint32_t          client_major_version,
+                                    uint32_t          client_minor_version);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_damage_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_damage_query_version_reply_t *
+xcb_damage_query_version_reply (xcb_connection_t                   *c,
+                                xcb_damage_query_version_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_damage_create_checked (xcb_connection_t    *c,
+                           xcb_damage_damage_t  damage,
+                           xcb_drawable_t       drawable,
+                           uint8_t              level);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_damage_create (xcb_connection_t    *c,
+                   xcb_damage_damage_t  damage,
+                   xcb_drawable_t       drawable,
+                   uint8_t              level);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_damage_destroy_checked (xcb_connection_t    *c,
+                            xcb_damage_damage_t  damage);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_damage_destroy (xcb_connection_t    *c,
+                    xcb_damage_damage_t  damage);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_damage_subtract_checked (xcb_connection_t    *c,
+                             xcb_damage_damage_t  damage,
+                             xcb_xfixes_region_t  repair,
+                             xcb_xfixes_region_t  parts);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_damage_subtract (xcb_connection_t    *c,
+                     xcb_damage_damage_t  damage,
+                     xcb_xfixes_region_t  repair,
+                     xcb_xfixes_region_t  parts);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_damage_add_checked (xcb_connection_t    *c,
+                        xcb_drawable_t       drawable,
+                        xcb_xfixes_region_t  region);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_damage_add (xcb_connection_t    *c,
+                xcb_drawable_t       drawable,
+                xcb_xfixes_region_t  region);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/dpms.h b/depends/libxcb/include/xcb/dpms.h
new file mode 100644
index 0000000..95aa91d
--- /dev/null
+++ b/depends/libxcb/include/xcb/dpms.h
@@ -0,0 +1,511 @@
+/*
+ * This file generated automatically from dpms.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_DPMS_API XCB DPMS API
+ * @brief DPMS XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __DPMS_H
+#define __DPMS_H
+
+#include "xcb.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_DPMS_MAJOR_VERSION 0
+#define XCB_DPMS_MINOR_VERSION 0
+
+extern xcb_extension_t xcb_dpms_id;
+
+/**
+ * @brief xcb_dpms_get_version_cookie_t
+ **/
+typedef struct xcb_dpms_get_version_cookie_t {
+    unsigned int sequence;
+} xcb_dpms_get_version_cookie_t;
+
+/** Opcode for xcb_dpms_get_version. */
+#define XCB_DPMS_GET_VERSION 0
+
+/**
+ * @brief xcb_dpms_get_version_request_t
+ **/
+typedef struct xcb_dpms_get_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint16_t client_major_version;
+    uint16_t client_minor_version;
+} xcb_dpms_get_version_request_t;
+
+/**
+ * @brief xcb_dpms_get_version_reply_t
+ **/
+typedef struct xcb_dpms_get_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t server_major_version;
+    uint16_t server_minor_version;
+} xcb_dpms_get_version_reply_t;
+
+/**
+ * @brief xcb_dpms_capable_cookie_t
+ **/
+typedef struct xcb_dpms_capable_cookie_t {
+    unsigned int sequence;
+} xcb_dpms_capable_cookie_t;
+
+/** Opcode for xcb_dpms_capable. */
+#define XCB_DPMS_CAPABLE 1
+
+/**
+ * @brief xcb_dpms_capable_request_t
+ **/
+typedef struct xcb_dpms_capable_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_dpms_capable_request_t;
+
+/**
+ * @brief xcb_dpms_capable_reply_t
+ **/
+typedef struct xcb_dpms_capable_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  capable;
+    uint8_t  pad1[23];
+} xcb_dpms_capable_reply_t;
+
+/**
+ * @brief xcb_dpms_get_timeouts_cookie_t
+ **/
+typedef struct xcb_dpms_get_timeouts_cookie_t {
+    unsigned int sequence;
+} xcb_dpms_get_timeouts_cookie_t;
+
+/** Opcode for xcb_dpms_get_timeouts. */
+#define XCB_DPMS_GET_TIMEOUTS 2
+
+/**
+ * @brief xcb_dpms_get_timeouts_request_t
+ **/
+typedef struct xcb_dpms_get_timeouts_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_dpms_get_timeouts_request_t;
+
+/**
+ * @brief xcb_dpms_get_timeouts_reply_t
+ **/
+typedef struct xcb_dpms_get_timeouts_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t standby_timeout;
+    uint16_t suspend_timeout;
+    uint16_t off_timeout;
+    uint8_t  pad1[18];
+} xcb_dpms_get_timeouts_reply_t;
+
+/** Opcode for xcb_dpms_set_timeouts. */
+#define XCB_DPMS_SET_TIMEOUTS 3
+
+/**
+ * @brief xcb_dpms_set_timeouts_request_t
+ **/
+typedef struct xcb_dpms_set_timeouts_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint16_t standby_timeout;
+    uint16_t suspend_timeout;
+    uint16_t off_timeout;
+} xcb_dpms_set_timeouts_request_t;
+
+/** Opcode for xcb_dpms_enable. */
+#define XCB_DPMS_ENABLE 4
+
+/**
+ * @brief xcb_dpms_enable_request_t
+ **/
+typedef struct xcb_dpms_enable_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_dpms_enable_request_t;
+
+/** Opcode for xcb_dpms_disable. */
+#define XCB_DPMS_DISABLE 5
+
+/**
+ * @brief xcb_dpms_disable_request_t
+ **/
+typedef struct xcb_dpms_disable_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_dpms_disable_request_t;
+
+typedef enum xcb_dpms_dpms_mode_t {
+    XCB_DPMS_DPMS_MODE_ON = 0,
+    XCB_DPMS_DPMS_MODE_STANDBY = 1,
+    XCB_DPMS_DPMS_MODE_SUSPEND = 2,
+    XCB_DPMS_DPMS_MODE_OFF = 3
+} xcb_dpms_dpms_mode_t;
+
+/** Opcode for xcb_dpms_force_level. */
+#define XCB_DPMS_FORCE_LEVEL 6
+
+/**
+ * @brief xcb_dpms_force_level_request_t
+ **/
+typedef struct xcb_dpms_force_level_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint16_t power_level;
+} xcb_dpms_force_level_request_t;
+
+/**
+ * @brief xcb_dpms_info_cookie_t
+ **/
+typedef struct xcb_dpms_info_cookie_t {
+    unsigned int sequence;
+} xcb_dpms_info_cookie_t;
+
+/** Opcode for xcb_dpms_info. */
+#define XCB_DPMS_INFO 7
+
+/**
+ * @brief xcb_dpms_info_request_t
+ **/
+typedef struct xcb_dpms_info_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_dpms_info_request_t;
+
+/**
+ * @brief xcb_dpms_info_reply_t
+ **/
+typedef struct xcb_dpms_info_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t power_level;
+    uint8_t  state;
+    uint8_t  pad1[21];
+} xcb_dpms_info_reply_t;
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dpms_get_version_cookie_t
+xcb_dpms_get_version (xcb_connection_t *c,
+                      uint16_t          client_major_version,
+                      uint16_t          client_minor_version);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dpms_get_version_cookie_t
+xcb_dpms_get_version_unchecked (xcb_connection_t *c,
+                                uint16_t          client_major_version,
+                                uint16_t          client_minor_version);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dpms_get_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dpms_get_version_reply_t *
+xcb_dpms_get_version_reply (xcb_connection_t               *c,
+                            xcb_dpms_get_version_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dpms_capable_cookie_t
+xcb_dpms_capable (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dpms_capable_cookie_t
+xcb_dpms_capable_unchecked (xcb_connection_t *c);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dpms_capable_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dpms_capable_reply_t *
+xcb_dpms_capable_reply (xcb_connection_t           *c,
+                        xcb_dpms_capable_cookie_t   cookie  /**< */,
+                        xcb_generic_error_t       **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dpms_get_timeouts_cookie_t
+xcb_dpms_get_timeouts (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dpms_get_timeouts_cookie_t
+xcb_dpms_get_timeouts_unchecked (xcb_connection_t *c);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dpms_get_timeouts_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dpms_get_timeouts_reply_t *
+xcb_dpms_get_timeouts_reply (xcb_connection_t                *c,
+                             xcb_dpms_get_timeouts_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_dpms_set_timeouts_checked (xcb_connection_t *c,
+                               uint16_t          standby_timeout,
+                               uint16_t          suspend_timeout,
+                               uint16_t          off_timeout);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_dpms_set_timeouts (xcb_connection_t *c,
+                       uint16_t          standby_timeout,
+                       uint16_t          suspend_timeout,
+                       uint16_t          off_timeout);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_dpms_enable_checked (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_dpms_enable (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_dpms_disable_checked (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_dpms_disable (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_dpms_force_level_checked (xcb_connection_t *c,
+                              uint16_t          power_level);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_dpms_force_level (xcb_connection_t *c,
+                      uint16_t          power_level);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dpms_info_cookie_t
+xcb_dpms_info (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dpms_info_cookie_t
+xcb_dpms_info_unchecked (xcb_connection_t *c);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dpms_info_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dpms_info_reply_t *
+xcb_dpms_info_reply (xcb_connection_t        *c,
+                     xcb_dpms_info_cookie_t   cookie  /**< */,
+                     xcb_generic_error_t    **e);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/dri2.h b/depends/libxcb/include/xcb/dri2.h
new file mode 100644
index 0000000..4ec2f40
--- /dev/null
+++ b/depends/libxcb/include/xcb/dri2.h
@@ -0,0 +1,1305 @@
+/*
+ * This file generated automatically from dri2.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_DRI2_API XCB DRI2 API
+ * @brief DRI2 XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __DRI2_H
+#define __DRI2_H
+
+#include "xcb.h"
+#include "xproto.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_DRI2_MAJOR_VERSION 1
+#define XCB_DRI2_MINOR_VERSION 4
+
+extern xcb_extension_t xcb_dri2_id;
+
+typedef enum xcb_dri2_attachment_t {
+    XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT = 0,
+    XCB_DRI2_ATTACHMENT_BUFFER_BACK_LEFT = 1,
+    XCB_DRI2_ATTACHMENT_BUFFER_FRONT_RIGHT = 2,
+    XCB_DRI2_ATTACHMENT_BUFFER_BACK_RIGHT = 3,
+    XCB_DRI2_ATTACHMENT_BUFFER_DEPTH = 4,
+    XCB_DRI2_ATTACHMENT_BUFFER_STENCIL = 5,
+    XCB_DRI2_ATTACHMENT_BUFFER_ACCUM = 6,
+    XCB_DRI2_ATTACHMENT_BUFFER_FAKE_FRONT_LEFT = 7,
+    XCB_DRI2_ATTACHMENT_BUFFER_FAKE_FRONT_RIGHT = 8,
+    XCB_DRI2_ATTACHMENT_BUFFER_DEPTH_STENCIL = 9,
+    XCB_DRI2_ATTACHMENT_BUFFER_HIZ = 10
+} xcb_dri2_attachment_t;
+
+typedef enum xcb_dri2_driver_type_t {
+    XCB_DRI2_DRIVER_TYPE_DRI = 0,
+    XCB_DRI2_DRIVER_TYPE_VDPAU = 1
+} xcb_dri2_driver_type_t;
+
+typedef enum xcb_dri2_event_type_t {
+    XCB_DRI2_EVENT_TYPE_EXCHANGE_COMPLETE = 1,
+    XCB_DRI2_EVENT_TYPE_BLIT_COMPLETE = 2,
+    XCB_DRI2_EVENT_TYPE_FLIP_COMPLETE = 3
+} xcb_dri2_event_type_t;
+
+/**
+ * @brief xcb_dri2_dri2_buffer_t
+ **/
+typedef struct xcb_dri2_dri2_buffer_t {
+    uint32_t attachment;
+    uint32_t name;
+    uint32_t pitch;
+    uint32_t cpp;
+    uint32_t flags;
+} xcb_dri2_dri2_buffer_t;
+
+/**
+ * @brief xcb_dri2_dri2_buffer_iterator_t
+ **/
+typedef struct xcb_dri2_dri2_buffer_iterator_t {
+    xcb_dri2_dri2_buffer_t *data;
+    int                     rem;
+    int                     index;
+} xcb_dri2_dri2_buffer_iterator_t;
+
+/**
+ * @brief xcb_dri2_attach_format_t
+ **/
+typedef struct xcb_dri2_attach_format_t {
+    uint32_t attachment;
+    uint32_t format;
+} xcb_dri2_attach_format_t;
+
+/**
+ * @brief xcb_dri2_attach_format_iterator_t
+ **/
+typedef struct xcb_dri2_attach_format_iterator_t {
+    xcb_dri2_attach_format_t *data;
+    int                       rem;
+    int                       index;
+} xcb_dri2_attach_format_iterator_t;
+
+/**
+ * @brief xcb_dri2_query_version_cookie_t
+ **/
+typedef struct xcb_dri2_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_dri2_query_version_cookie_t;
+
+/** Opcode for xcb_dri2_query_version. */
+#define XCB_DRI2_QUERY_VERSION 0
+
+/**
+ * @brief xcb_dri2_query_version_request_t
+ **/
+typedef struct xcb_dri2_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t major_version;
+    uint32_t minor_version;
+} xcb_dri2_query_version_request_t;
+
+/**
+ * @brief xcb_dri2_query_version_reply_t
+ **/
+typedef struct xcb_dri2_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t major_version;
+    uint32_t minor_version;
+} xcb_dri2_query_version_reply_t;
+
+/**
+ * @brief xcb_dri2_connect_cookie_t
+ **/
+typedef struct xcb_dri2_connect_cookie_t {
+    unsigned int sequence;
+} xcb_dri2_connect_cookie_t;
+
+/** Opcode for xcb_dri2_connect. */
+#define XCB_DRI2_CONNECT 1
+
+/**
+ * @brief xcb_dri2_connect_request_t
+ **/
+typedef struct xcb_dri2_connect_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    uint32_t     driver_type;
+} xcb_dri2_connect_request_t;
+
+/**
+ * @brief xcb_dri2_connect_reply_t
+ **/
+typedef struct xcb_dri2_connect_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t driver_name_length;
+    uint32_t device_name_length;
+    uint8_t  pad1[16];
+} xcb_dri2_connect_reply_t;
+
+/**
+ * @brief xcb_dri2_authenticate_cookie_t
+ **/
+typedef struct xcb_dri2_authenticate_cookie_t {
+    unsigned int sequence;
+} xcb_dri2_authenticate_cookie_t;
+
+/** Opcode for xcb_dri2_authenticate. */
+#define XCB_DRI2_AUTHENTICATE 2
+
+/**
+ * @brief xcb_dri2_authenticate_request_t
+ **/
+typedef struct xcb_dri2_authenticate_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    uint32_t     magic;
+} xcb_dri2_authenticate_request_t;
+
+/**
+ * @brief xcb_dri2_authenticate_reply_t
+ **/
+typedef struct xcb_dri2_authenticate_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t authenticated;
+} xcb_dri2_authenticate_reply_t;
+
+/** Opcode for xcb_dri2_create_drawable. */
+#define XCB_DRI2_CREATE_DRAWABLE 3
+
+/**
+ * @brief xcb_dri2_create_drawable_request_t
+ **/
+typedef struct xcb_dri2_create_drawable_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+} xcb_dri2_create_drawable_request_t;
+
+/** Opcode for xcb_dri2_destroy_drawable. */
+#define XCB_DRI2_DESTROY_DRAWABLE 4
+
+/**
+ * @brief xcb_dri2_destroy_drawable_request_t
+ **/
+typedef struct xcb_dri2_destroy_drawable_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+} xcb_dri2_destroy_drawable_request_t;
+
+/**
+ * @brief xcb_dri2_get_buffers_cookie_t
+ **/
+typedef struct xcb_dri2_get_buffers_cookie_t {
+    unsigned int sequence;
+} xcb_dri2_get_buffers_cookie_t;
+
+/** Opcode for xcb_dri2_get_buffers. */
+#define XCB_DRI2_GET_BUFFERS 5
+
+/**
+ * @brief xcb_dri2_get_buffers_request_t
+ **/
+typedef struct xcb_dri2_get_buffers_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    uint32_t       count;
+} xcb_dri2_get_buffers_request_t;
+
+/**
+ * @brief xcb_dri2_get_buffers_reply_t
+ **/
+typedef struct xcb_dri2_get_buffers_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t width;
+    uint32_t height;
+    uint32_t count;
+    uint8_t  pad1[12];
+} xcb_dri2_get_buffers_reply_t;
+
+/**
+ * @brief xcb_dri2_copy_region_cookie_t
+ **/
+typedef struct xcb_dri2_copy_region_cookie_t {
+    unsigned int sequence;
+} xcb_dri2_copy_region_cookie_t;
+
+/** Opcode for xcb_dri2_copy_region. */
+#define XCB_DRI2_COPY_REGION 6
+
+/**
+ * @brief xcb_dri2_copy_region_request_t
+ **/
+typedef struct xcb_dri2_copy_region_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    uint32_t       region;
+    uint32_t       dest;
+    uint32_t       src;
+} xcb_dri2_copy_region_request_t;
+
+/**
+ * @brief xcb_dri2_copy_region_reply_t
+ **/
+typedef struct xcb_dri2_copy_region_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+} xcb_dri2_copy_region_reply_t;
+
+/**
+ * @brief xcb_dri2_get_buffers_with_format_cookie_t
+ **/
+typedef struct xcb_dri2_get_buffers_with_format_cookie_t {
+    unsigned int sequence;
+} xcb_dri2_get_buffers_with_format_cookie_t;
+
+/** Opcode for xcb_dri2_get_buffers_with_format. */
+#define XCB_DRI2_GET_BUFFERS_WITH_FORMAT 7
+
+/**
+ * @brief xcb_dri2_get_buffers_with_format_request_t
+ **/
+typedef struct xcb_dri2_get_buffers_with_format_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    uint32_t       count;
+} xcb_dri2_get_buffers_with_format_request_t;
+
+/**
+ * @brief xcb_dri2_get_buffers_with_format_reply_t
+ **/
+typedef struct xcb_dri2_get_buffers_with_format_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t width;
+    uint32_t height;
+    uint32_t count;
+    uint8_t  pad1[12];
+} xcb_dri2_get_buffers_with_format_reply_t;
+
+/**
+ * @brief xcb_dri2_swap_buffers_cookie_t
+ **/
+typedef struct xcb_dri2_swap_buffers_cookie_t {
+    unsigned int sequence;
+} xcb_dri2_swap_buffers_cookie_t;
+
+/** Opcode for xcb_dri2_swap_buffers. */
+#define XCB_DRI2_SWAP_BUFFERS 8
+
+/**
+ * @brief xcb_dri2_swap_buffers_request_t
+ **/
+typedef struct xcb_dri2_swap_buffers_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    uint32_t       target_msc_hi;
+    uint32_t       target_msc_lo;
+    uint32_t       divisor_hi;
+    uint32_t       divisor_lo;
+    uint32_t       remainder_hi;
+    uint32_t       remainder_lo;
+} xcb_dri2_swap_buffers_request_t;
+
+/**
+ * @brief xcb_dri2_swap_buffers_reply_t
+ **/
+typedef struct xcb_dri2_swap_buffers_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t swap_hi;
+    uint32_t swap_lo;
+} xcb_dri2_swap_buffers_reply_t;
+
+/**
+ * @brief xcb_dri2_get_msc_cookie_t
+ **/
+typedef struct xcb_dri2_get_msc_cookie_t {
+    unsigned int sequence;
+} xcb_dri2_get_msc_cookie_t;
+
+/** Opcode for xcb_dri2_get_msc. */
+#define XCB_DRI2_GET_MSC 9
+
+/**
+ * @brief xcb_dri2_get_msc_request_t
+ **/
+typedef struct xcb_dri2_get_msc_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+} xcb_dri2_get_msc_request_t;
+
+/**
+ * @brief xcb_dri2_get_msc_reply_t
+ **/
+typedef struct xcb_dri2_get_msc_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t ust_hi;
+    uint32_t ust_lo;
+    uint32_t msc_hi;
+    uint32_t msc_lo;
+    uint32_t sbc_hi;
+    uint32_t sbc_lo;
+} xcb_dri2_get_msc_reply_t;
+
+/**
+ * @brief xcb_dri2_wait_msc_cookie_t
+ **/
+typedef struct xcb_dri2_wait_msc_cookie_t {
+    unsigned int sequence;
+} xcb_dri2_wait_msc_cookie_t;
+
+/** Opcode for xcb_dri2_wait_msc. */
+#define XCB_DRI2_WAIT_MSC 10
+
+/**
+ * @brief xcb_dri2_wait_msc_request_t
+ **/
+typedef struct xcb_dri2_wait_msc_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    uint32_t       target_msc_hi;
+    uint32_t       target_msc_lo;
+    uint32_t       divisor_hi;
+    uint32_t       divisor_lo;
+    uint32_t       remainder_hi;
+    uint32_t       remainder_lo;
+} xcb_dri2_wait_msc_request_t;
+
+/**
+ * @brief xcb_dri2_wait_msc_reply_t
+ **/
+typedef struct xcb_dri2_wait_msc_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t ust_hi;
+    uint32_t ust_lo;
+    uint32_t msc_hi;
+    uint32_t msc_lo;
+    uint32_t sbc_hi;
+    uint32_t sbc_lo;
+} xcb_dri2_wait_msc_reply_t;
+
+/**
+ * @brief xcb_dri2_wait_sbc_cookie_t
+ **/
+typedef struct xcb_dri2_wait_sbc_cookie_t {
+    unsigned int sequence;
+} xcb_dri2_wait_sbc_cookie_t;
+
+/** Opcode for xcb_dri2_wait_sbc. */
+#define XCB_DRI2_WAIT_SBC 11
+
+/**
+ * @brief xcb_dri2_wait_sbc_request_t
+ **/
+typedef struct xcb_dri2_wait_sbc_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    uint32_t       target_sbc_hi;
+    uint32_t       target_sbc_lo;
+} xcb_dri2_wait_sbc_request_t;
+
+/**
+ * @brief xcb_dri2_wait_sbc_reply_t
+ **/
+typedef struct xcb_dri2_wait_sbc_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t ust_hi;
+    uint32_t ust_lo;
+    uint32_t msc_hi;
+    uint32_t msc_lo;
+    uint32_t sbc_hi;
+    uint32_t sbc_lo;
+} xcb_dri2_wait_sbc_reply_t;
+
+/** Opcode for xcb_dri2_swap_interval. */
+#define XCB_DRI2_SWAP_INTERVAL 12
+
+/**
+ * @brief xcb_dri2_swap_interval_request_t
+ **/
+typedef struct xcb_dri2_swap_interval_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    uint32_t       interval;
+} xcb_dri2_swap_interval_request_t;
+
+/**
+ * @brief xcb_dri2_get_param_cookie_t
+ **/
+typedef struct xcb_dri2_get_param_cookie_t {
+    unsigned int sequence;
+} xcb_dri2_get_param_cookie_t;
+
+/** Opcode for xcb_dri2_get_param. */
+#define XCB_DRI2_GET_PARAM 13
+
+/**
+ * @brief xcb_dri2_get_param_request_t
+ **/
+typedef struct xcb_dri2_get_param_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    uint32_t       param;
+} xcb_dri2_get_param_request_t;
+
+/**
+ * @brief xcb_dri2_get_param_reply_t
+ **/
+typedef struct xcb_dri2_get_param_reply_t {
+    uint8_t  response_type;
+    uint8_t  is_param_recognized;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t value_hi;
+    uint32_t value_lo;
+} xcb_dri2_get_param_reply_t;
+
+/** Opcode for xcb_dri2_buffer_swap_complete. */
+#define XCB_DRI2_BUFFER_SWAP_COMPLETE 0
+
+/**
+ * @brief xcb_dri2_buffer_swap_complete_event_t
+ **/
+typedef struct xcb_dri2_buffer_swap_complete_event_t {
+    uint8_t        response_type;
+    uint8_t        pad0;
+    uint16_t       sequence;
+    uint16_t       event_type;
+    uint8_t        pad1[2];
+    xcb_drawable_t drawable;
+    uint32_t       ust_hi;
+    uint32_t       ust_lo;
+    uint32_t       msc_hi;
+    uint32_t       msc_lo;
+    uint32_t       sbc;
+} xcb_dri2_buffer_swap_complete_event_t;
+
+/** Opcode for xcb_dri2_invalidate_buffers. */
+#define XCB_DRI2_INVALIDATE_BUFFERS 1
+
+/**
+ * @brief xcb_dri2_invalidate_buffers_event_t
+ **/
+typedef struct xcb_dri2_invalidate_buffers_event_t {
+    uint8_t        response_type;
+    uint8_t        pad0;
+    uint16_t       sequence;
+    xcb_drawable_t drawable;
+} xcb_dri2_invalidate_buffers_event_t;
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_dri2_dri2_buffer_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_dri2_dri2_buffer_t)
+ */
+void
+xcb_dri2_dri2_buffer_next (xcb_dri2_dri2_buffer_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_dri2_dri2_buffer_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_dri2_dri2_buffer_end (xcb_dri2_dri2_buffer_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_dri2_attach_format_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_dri2_attach_format_t)
+ */
+void
+xcb_dri2_attach_format_next (xcb_dri2_attach_format_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_dri2_attach_format_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_dri2_attach_format_end (xcb_dri2_attach_format_iterator_t i);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dri2_query_version_cookie_t
+xcb_dri2_query_version (xcb_connection_t *c,
+                        uint32_t          major_version,
+                        uint32_t          minor_version);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dri2_query_version_cookie_t
+xcb_dri2_query_version_unchecked (xcb_connection_t *c,
+                                  uint32_t          major_version,
+                                  uint32_t          minor_version);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dri2_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dri2_query_version_reply_t *
+xcb_dri2_query_version_reply (xcb_connection_t                 *c,
+                              xcb_dri2_query_version_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+int
+xcb_dri2_connect_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dri2_connect_cookie_t
+xcb_dri2_connect (xcb_connection_t *c,
+                  xcb_window_t      window,
+                  uint32_t          driver_type);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dri2_connect_cookie_t
+xcb_dri2_connect_unchecked (xcb_connection_t *c,
+                            xcb_window_t      window,
+                            uint32_t          driver_type);
+
+char *
+xcb_dri2_connect_driver_name (const xcb_dri2_connect_reply_t *R);
+
+int
+xcb_dri2_connect_driver_name_length (const xcb_dri2_connect_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_dri2_connect_driver_name_end (const xcb_dri2_connect_reply_t *R);
+
+void *
+xcb_dri2_connect_alignment_pad (const xcb_dri2_connect_reply_t *R);
+
+int
+xcb_dri2_connect_alignment_pad_length (const xcb_dri2_connect_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_dri2_connect_alignment_pad_end (const xcb_dri2_connect_reply_t *R);
+
+char *
+xcb_dri2_connect_device_name (const xcb_dri2_connect_reply_t *R);
+
+int
+xcb_dri2_connect_device_name_length (const xcb_dri2_connect_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_dri2_connect_device_name_end (const xcb_dri2_connect_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dri2_connect_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dri2_connect_reply_t *
+xcb_dri2_connect_reply (xcb_connection_t           *c,
+                        xcb_dri2_connect_cookie_t   cookie  /**< */,
+                        xcb_generic_error_t       **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dri2_authenticate_cookie_t
+xcb_dri2_authenticate (xcb_connection_t *c,
+                       xcb_window_t      window,
+                       uint32_t          magic);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dri2_authenticate_cookie_t
+xcb_dri2_authenticate_unchecked (xcb_connection_t *c,
+                                 xcb_window_t      window,
+                                 uint32_t          magic);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dri2_authenticate_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dri2_authenticate_reply_t *
+xcb_dri2_authenticate_reply (xcb_connection_t                *c,
+                             xcb_dri2_authenticate_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_dri2_create_drawable_checked (xcb_connection_t *c,
+                                  xcb_drawable_t    drawable);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_dri2_create_drawable (xcb_connection_t *c,
+                          xcb_drawable_t    drawable);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_dri2_destroy_drawable_checked (xcb_connection_t *c,
+                                   xcb_drawable_t    drawable);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_dri2_destroy_drawable (xcb_connection_t *c,
+                           xcb_drawable_t    drawable);
+
+int
+xcb_dri2_get_buffers_sizeof (const void  *_buffer,
+                             uint32_t     attachments_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dri2_get_buffers_cookie_t
+xcb_dri2_get_buffers (xcb_connection_t *c,
+                      xcb_drawable_t    drawable,
+                      uint32_t          count,
+                      uint32_t          attachments_len,
+                      const uint32_t   *attachments);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dri2_get_buffers_cookie_t
+xcb_dri2_get_buffers_unchecked (xcb_connection_t *c,
+                                xcb_drawable_t    drawable,
+                                uint32_t          count,
+                                uint32_t          attachments_len,
+                                const uint32_t   *attachments);
+
+xcb_dri2_dri2_buffer_t *
+xcb_dri2_get_buffers_buffers (const xcb_dri2_get_buffers_reply_t *R);
+
+int
+xcb_dri2_get_buffers_buffers_length (const xcb_dri2_get_buffers_reply_t *R);
+
+xcb_dri2_dri2_buffer_iterator_t
+xcb_dri2_get_buffers_buffers_iterator (const xcb_dri2_get_buffers_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dri2_get_buffers_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dri2_get_buffers_reply_t *
+xcb_dri2_get_buffers_reply (xcb_connection_t               *c,
+                            xcb_dri2_get_buffers_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dri2_copy_region_cookie_t
+xcb_dri2_copy_region (xcb_connection_t *c,
+                      xcb_drawable_t    drawable,
+                      uint32_t          region,
+                      uint32_t          dest,
+                      uint32_t          src);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dri2_copy_region_cookie_t
+xcb_dri2_copy_region_unchecked (xcb_connection_t *c,
+                                xcb_drawable_t    drawable,
+                                uint32_t          region,
+                                uint32_t          dest,
+                                uint32_t          src);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dri2_copy_region_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dri2_copy_region_reply_t *
+xcb_dri2_copy_region_reply (xcb_connection_t               *c,
+                            xcb_dri2_copy_region_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e);
+
+int
+xcb_dri2_get_buffers_with_format_sizeof (const void  *_buffer,
+                                         uint32_t     attachments_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dri2_get_buffers_with_format_cookie_t
+xcb_dri2_get_buffers_with_format (xcb_connection_t               *c,
+                                  xcb_drawable_t                  drawable,
+                                  uint32_t                        count,
+                                  uint32_t                        attachments_len,
+                                  const xcb_dri2_attach_format_t *attachments);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dri2_get_buffers_with_format_cookie_t
+xcb_dri2_get_buffers_with_format_unchecked (xcb_connection_t               *c,
+                                            xcb_drawable_t                  drawable,
+                                            uint32_t                        count,
+                                            uint32_t                        attachments_len,
+                                            const xcb_dri2_attach_format_t *attachments);
+
+xcb_dri2_dri2_buffer_t *
+xcb_dri2_get_buffers_with_format_buffers (const xcb_dri2_get_buffers_with_format_reply_t *R);
+
+int
+xcb_dri2_get_buffers_with_format_buffers_length (const xcb_dri2_get_buffers_with_format_reply_t *R);
+
+xcb_dri2_dri2_buffer_iterator_t
+xcb_dri2_get_buffers_with_format_buffers_iterator (const xcb_dri2_get_buffers_with_format_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dri2_get_buffers_with_format_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dri2_get_buffers_with_format_reply_t *
+xcb_dri2_get_buffers_with_format_reply (xcb_connection_t                           *c,
+                                        xcb_dri2_get_buffers_with_format_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dri2_swap_buffers_cookie_t
+xcb_dri2_swap_buffers (xcb_connection_t *c,
+                       xcb_drawable_t    drawable,
+                       uint32_t          target_msc_hi,
+                       uint32_t          target_msc_lo,
+                       uint32_t          divisor_hi,
+                       uint32_t          divisor_lo,
+                       uint32_t          remainder_hi,
+                       uint32_t          remainder_lo);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dri2_swap_buffers_cookie_t
+xcb_dri2_swap_buffers_unchecked (xcb_connection_t *c,
+                                 xcb_drawable_t    drawable,
+                                 uint32_t          target_msc_hi,
+                                 uint32_t          target_msc_lo,
+                                 uint32_t          divisor_hi,
+                                 uint32_t          divisor_lo,
+                                 uint32_t          remainder_hi,
+                                 uint32_t          remainder_lo);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dri2_swap_buffers_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dri2_swap_buffers_reply_t *
+xcb_dri2_swap_buffers_reply (xcb_connection_t                *c,
+                             xcb_dri2_swap_buffers_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dri2_get_msc_cookie_t
+xcb_dri2_get_msc (xcb_connection_t *c,
+                  xcb_drawable_t    drawable);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dri2_get_msc_cookie_t
+xcb_dri2_get_msc_unchecked (xcb_connection_t *c,
+                            xcb_drawable_t    drawable);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dri2_get_msc_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dri2_get_msc_reply_t *
+xcb_dri2_get_msc_reply (xcb_connection_t           *c,
+                        xcb_dri2_get_msc_cookie_t   cookie  /**< */,
+                        xcb_generic_error_t       **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dri2_wait_msc_cookie_t
+xcb_dri2_wait_msc (xcb_connection_t *c,
+                   xcb_drawable_t    drawable,
+                   uint32_t          target_msc_hi,
+                   uint32_t          target_msc_lo,
+                   uint32_t          divisor_hi,
+                   uint32_t          divisor_lo,
+                   uint32_t          remainder_hi,
+                   uint32_t          remainder_lo);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dri2_wait_msc_cookie_t
+xcb_dri2_wait_msc_unchecked (xcb_connection_t *c,
+                             xcb_drawable_t    drawable,
+                             uint32_t          target_msc_hi,
+                             uint32_t          target_msc_lo,
+                             uint32_t          divisor_hi,
+                             uint32_t          divisor_lo,
+                             uint32_t          remainder_hi,
+                             uint32_t          remainder_lo);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dri2_wait_msc_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dri2_wait_msc_reply_t *
+xcb_dri2_wait_msc_reply (xcb_connection_t            *c,
+                         xcb_dri2_wait_msc_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dri2_wait_sbc_cookie_t
+xcb_dri2_wait_sbc (xcb_connection_t *c,
+                   xcb_drawable_t    drawable,
+                   uint32_t          target_sbc_hi,
+                   uint32_t          target_sbc_lo);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dri2_wait_sbc_cookie_t
+xcb_dri2_wait_sbc_unchecked (xcb_connection_t *c,
+                             xcb_drawable_t    drawable,
+                             uint32_t          target_sbc_hi,
+                             uint32_t          target_sbc_lo);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dri2_wait_sbc_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dri2_wait_sbc_reply_t *
+xcb_dri2_wait_sbc_reply (xcb_connection_t            *c,
+                         xcb_dri2_wait_sbc_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_dri2_swap_interval_checked (xcb_connection_t *c,
+                                xcb_drawable_t    drawable,
+                                uint32_t          interval);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_dri2_swap_interval (xcb_connection_t *c,
+                        xcb_drawable_t    drawable,
+                        uint32_t          interval);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dri2_get_param_cookie_t
+xcb_dri2_get_param (xcb_connection_t *c,
+                    xcb_drawable_t    drawable,
+                    uint32_t          param);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dri2_get_param_cookie_t
+xcb_dri2_get_param_unchecked (xcb_connection_t *c,
+                              xcb_drawable_t    drawable,
+                              uint32_t          param);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dri2_get_param_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dri2_get_param_reply_t *
+xcb_dri2_get_param_reply (xcb_connection_t             *c,
+                          xcb_dri2_get_param_cookie_t   cookie  /**< */,
+                          xcb_generic_error_t         **e);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/dri3.h b/depends/libxcb/include/xcb/dri3.h
new file mode 100644
index 0000000..a4038f6
--- /dev/null
+++ b/depends/libxcb/include/xcb/dri3.h
@@ -0,0 +1,884 @@
+/*
+ * This file generated automatically from dri3.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_DRI3_API XCB DRI3 API
+ * @brief DRI3 XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __DRI3_H
+#define __DRI3_H
+
+#include "xcb.h"
+#include "xproto.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_DRI3_MAJOR_VERSION 1
+#define XCB_DRI3_MINOR_VERSION 3
+
+extern xcb_extension_t xcb_dri3_id;
+
+/**
+ * @brief xcb_dri3_query_version_cookie_t
+ **/
+typedef struct xcb_dri3_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_dri3_query_version_cookie_t;
+
+/** Opcode for xcb_dri3_query_version. */
+#define XCB_DRI3_QUERY_VERSION 0
+
+/**
+ * @brief xcb_dri3_query_version_request_t
+ **/
+typedef struct xcb_dri3_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t major_version;
+    uint32_t minor_version;
+} xcb_dri3_query_version_request_t;
+
+/**
+ * @brief xcb_dri3_query_version_reply_t
+ **/
+typedef struct xcb_dri3_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t major_version;
+    uint32_t minor_version;
+} xcb_dri3_query_version_reply_t;
+
+/**
+ * @brief xcb_dri3_open_cookie_t
+ **/
+typedef struct xcb_dri3_open_cookie_t {
+    unsigned int sequence;
+} xcb_dri3_open_cookie_t;
+
+/** Opcode for xcb_dri3_open. */
+#define XCB_DRI3_OPEN 1
+
+/**
+ * @brief xcb_dri3_open_request_t
+ **/
+typedef struct xcb_dri3_open_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    uint32_t       provider;
+} xcb_dri3_open_request_t;
+
+/**
+ * @brief xcb_dri3_open_reply_t
+ **/
+typedef struct xcb_dri3_open_reply_t {
+    uint8_t  response_type;
+    uint8_t  nfd;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad0[24];
+} xcb_dri3_open_reply_t;
+
+/** Opcode for xcb_dri3_pixmap_from_buffer. */
+#define XCB_DRI3_PIXMAP_FROM_BUFFER 2
+
+/**
+ * @brief xcb_dri3_pixmap_from_buffer_request_t
+ **/
+typedef struct xcb_dri3_pixmap_from_buffer_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_pixmap_t   pixmap;
+    xcb_drawable_t drawable;
+    uint32_t       size;
+    uint16_t       width;
+    uint16_t       height;
+    uint16_t       stride;
+    uint8_t        depth;
+    uint8_t        bpp;
+} xcb_dri3_pixmap_from_buffer_request_t;
+
+/**
+ * @brief xcb_dri3_buffer_from_pixmap_cookie_t
+ **/
+typedef struct xcb_dri3_buffer_from_pixmap_cookie_t {
+    unsigned int sequence;
+} xcb_dri3_buffer_from_pixmap_cookie_t;
+
+/** Opcode for xcb_dri3_buffer_from_pixmap. */
+#define XCB_DRI3_BUFFER_FROM_PIXMAP 3
+
+/**
+ * @brief xcb_dri3_buffer_from_pixmap_request_t
+ **/
+typedef struct xcb_dri3_buffer_from_pixmap_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_pixmap_t pixmap;
+} xcb_dri3_buffer_from_pixmap_request_t;
+
+/**
+ * @brief xcb_dri3_buffer_from_pixmap_reply_t
+ **/
+typedef struct xcb_dri3_buffer_from_pixmap_reply_t {
+    uint8_t  response_type;
+    uint8_t  nfd;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t size;
+    uint16_t width;
+    uint16_t height;
+    uint16_t stride;
+    uint8_t  depth;
+    uint8_t  bpp;
+    uint8_t  pad0[12];
+} xcb_dri3_buffer_from_pixmap_reply_t;
+
+/** Opcode for xcb_dri3_fence_from_fd. */
+#define XCB_DRI3_FENCE_FROM_FD 4
+
+/**
+ * @brief xcb_dri3_fence_from_fd_request_t
+ **/
+typedef struct xcb_dri3_fence_from_fd_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    uint32_t       fence;
+    uint8_t        initially_triggered;
+    uint8_t        pad0[3];
+} xcb_dri3_fence_from_fd_request_t;
+
+/**
+ * @brief xcb_dri3_fd_from_fence_cookie_t
+ **/
+typedef struct xcb_dri3_fd_from_fence_cookie_t {
+    unsigned int sequence;
+} xcb_dri3_fd_from_fence_cookie_t;
+
+/** Opcode for xcb_dri3_fd_from_fence. */
+#define XCB_DRI3_FD_FROM_FENCE 5
+
+/**
+ * @brief xcb_dri3_fd_from_fence_request_t
+ **/
+typedef struct xcb_dri3_fd_from_fence_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    uint32_t       fence;
+} xcb_dri3_fd_from_fence_request_t;
+
+/**
+ * @brief xcb_dri3_fd_from_fence_reply_t
+ **/
+typedef struct xcb_dri3_fd_from_fence_reply_t {
+    uint8_t  response_type;
+    uint8_t  nfd;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad0[24];
+} xcb_dri3_fd_from_fence_reply_t;
+
+/**
+ * @brief xcb_dri3_get_supported_modifiers_cookie_t
+ **/
+typedef struct xcb_dri3_get_supported_modifiers_cookie_t {
+    unsigned int sequence;
+} xcb_dri3_get_supported_modifiers_cookie_t;
+
+/** Opcode for xcb_dri3_get_supported_modifiers. */
+#define XCB_DRI3_GET_SUPPORTED_MODIFIERS 6
+
+/**
+ * @brief xcb_dri3_get_supported_modifiers_request_t
+ **/
+typedef struct xcb_dri3_get_supported_modifiers_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t window;
+    uint8_t  depth;
+    uint8_t  bpp;
+    uint8_t  pad0[2];
+} xcb_dri3_get_supported_modifiers_request_t;
+
+/**
+ * @brief xcb_dri3_get_supported_modifiers_reply_t
+ **/
+typedef struct xcb_dri3_get_supported_modifiers_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t num_window_modifiers;
+    uint32_t num_screen_modifiers;
+    uint8_t  pad1[16];
+} xcb_dri3_get_supported_modifiers_reply_t;
+
+/** Opcode for xcb_dri3_pixmap_from_buffers. */
+#define XCB_DRI3_PIXMAP_FROM_BUFFERS 7
+
+/**
+ * @brief xcb_dri3_pixmap_from_buffers_request_t
+ **/
+typedef struct xcb_dri3_pixmap_from_buffers_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_pixmap_t pixmap;
+    xcb_window_t window;
+    uint8_t      num_buffers;
+    uint8_t      pad0[3];
+    uint16_t     width;
+    uint16_t     height;
+    uint32_t     stride0;
+    uint32_t     offset0;
+    uint32_t     stride1;
+    uint32_t     offset1;
+    uint32_t     stride2;
+    uint32_t     offset2;
+    uint32_t     stride3;
+    uint32_t     offset3;
+    uint8_t      depth;
+    uint8_t      bpp;
+    uint8_t      pad1[2];
+    uint64_t     modifier;
+} xcb_dri3_pixmap_from_buffers_request_t;
+
+/**
+ * @brief xcb_dri3_buffers_from_pixmap_cookie_t
+ **/
+typedef struct xcb_dri3_buffers_from_pixmap_cookie_t {
+    unsigned int sequence;
+} xcb_dri3_buffers_from_pixmap_cookie_t;
+
+/** Opcode for xcb_dri3_buffers_from_pixmap. */
+#define XCB_DRI3_BUFFERS_FROM_PIXMAP 8
+
+/**
+ * @brief xcb_dri3_buffers_from_pixmap_request_t
+ **/
+typedef struct xcb_dri3_buffers_from_pixmap_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_pixmap_t pixmap;
+} xcb_dri3_buffers_from_pixmap_request_t;
+
+/**
+ * @brief xcb_dri3_buffers_from_pixmap_reply_t
+ **/
+typedef struct xcb_dri3_buffers_from_pixmap_reply_t {
+    uint8_t  response_type;
+    uint8_t  nfd;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t width;
+    uint16_t height;
+    uint8_t  pad0[4];
+    uint64_t modifier;
+    uint8_t  depth;
+    uint8_t  bpp;
+    uint8_t  pad1[6];
+} xcb_dri3_buffers_from_pixmap_reply_t;
+
+/** Opcode for xcb_dri3_set_drm_device_in_use. */
+#define XCB_DRI3_SET_DRM_DEVICE_IN_USE 9
+
+/**
+ * @brief xcb_dri3_set_drm_device_in_use_request_t
+ **/
+typedef struct xcb_dri3_set_drm_device_in_use_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    uint32_t     drmMajor;
+    uint32_t     drmMinor;
+} xcb_dri3_set_drm_device_in_use_request_t;
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dri3_query_version_cookie_t
+xcb_dri3_query_version (xcb_connection_t *c,
+                        uint32_t          major_version,
+                        uint32_t          minor_version);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dri3_query_version_cookie_t
+xcb_dri3_query_version_unchecked (xcb_connection_t *c,
+                                  uint32_t          major_version,
+                                  uint32_t          minor_version);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dri3_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dri3_query_version_reply_t *
+xcb_dri3_query_version_reply (xcb_connection_t                 *c,
+                              xcb_dri3_query_version_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dri3_open_cookie_t
+xcb_dri3_open (xcb_connection_t *c,
+               xcb_drawable_t    drawable,
+               uint32_t          provider);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dri3_open_cookie_t
+xcb_dri3_open_unchecked (xcb_connection_t *c,
+                         xcb_drawable_t    drawable,
+                         uint32_t          provider);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dri3_open_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dri3_open_reply_t *
+xcb_dri3_open_reply (xcb_connection_t        *c,
+                     xcb_dri3_open_cookie_t   cookie  /**< */,
+                     xcb_generic_error_t    **e);
+
+/**
+ * Return the reply fds
+ * @param c      The connection
+ * @param reply  The reply
+ *
+ * Returns a pointer to the array of reply fds of the reply.
+ *
+ * The returned value points into the reply and must not be free().
+ * The fds are not managed by xcb. You must close() them before freeing the reply.
+ */
+int *
+xcb_dri3_open_reply_fds (xcb_connection_t       *c  /**< */,
+                         xcb_dri3_open_reply_t  *reply);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_dri3_pixmap_from_buffer_checked (xcb_connection_t *c,
+                                     xcb_pixmap_t      pixmap,
+                                     xcb_drawable_t    drawable,
+                                     uint32_t          size,
+                                     uint16_t          width,
+                                     uint16_t          height,
+                                     uint16_t          stride,
+                                     uint8_t           depth,
+                                     uint8_t           bpp,
+                                     int32_t           pixmap_fd);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_dri3_pixmap_from_buffer (xcb_connection_t *c,
+                             xcb_pixmap_t      pixmap,
+                             xcb_drawable_t    drawable,
+                             uint32_t          size,
+                             uint16_t          width,
+                             uint16_t          height,
+                             uint16_t          stride,
+                             uint8_t           depth,
+                             uint8_t           bpp,
+                             int32_t           pixmap_fd);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dri3_buffer_from_pixmap_cookie_t
+xcb_dri3_buffer_from_pixmap (xcb_connection_t *c,
+                             xcb_pixmap_t      pixmap);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dri3_buffer_from_pixmap_cookie_t
+xcb_dri3_buffer_from_pixmap_unchecked (xcb_connection_t *c,
+                                       xcb_pixmap_t      pixmap);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dri3_buffer_from_pixmap_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dri3_buffer_from_pixmap_reply_t *
+xcb_dri3_buffer_from_pixmap_reply (xcb_connection_t                      *c,
+                                   xcb_dri3_buffer_from_pixmap_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e);
+
+/**
+ * Return the reply fds
+ * @param c      The connection
+ * @param reply  The reply
+ *
+ * Returns a pointer to the array of reply fds of the reply.
+ *
+ * The returned value points into the reply and must not be free().
+ * The fds are not managed by xcb. You must close() them before freeing the reply.
+ */
+int *
+xcb_dri3_buffer_from_pixmap_reply_fds (xcb_connection_t                     *c  /**< */,
+                                       xcb_dri3_buffer_from_pixmap_reply_t  *reply);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_dri3_fence_from_fd_checked (xcb_connection_t *c,
+                                xcb_drawable_t    drawable,
+                                uint32_t          fence,
+                                uint8_t           initially_triggered,
+                                int32_t           fence_fd);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_dri3_fence_from_fd (xcb_connection_t *c,
+                        xcb_drawable_t    drawable,
+                        uint32_t          fence,
+                        uint8_t           initially_triggered,
+                        int32_t           fence_fd);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dri3_fd_from_fence_cookie_t
+xcb_dri3_fd_from_fence (xcb_connection_t *c,
+                        xcb_drawable_t    drawable,
+                        uint32_t          fence);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dri3_fd_from_fence_cookie_t
+xcb_dri3_fd_from_fence_unchecked (xcb_connection_t *c,
+                                  xcb_drawable_t    drawable,
+                                  uint32_t          fence);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dri3_fd_from_fence_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dri3_fd_from_fence_reply_t *
+xcb_dri3_fd_from_fence_reply (xcb_connection_t                 *c,
+                              xcb_dri3_fd_from_fence_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+/**
+ * Return the reply fds
+ * @param c      The connection
+ * @param reply  The reply
+ *
+ * Returns a pointer to the array of reply fds of the reply.
+ *
+ * The returned value points into the reply and must not be free().
+ * The fds are not managed by xcb. You must close() them before freeing the reply.
+ */
+int *
+xcb_dri3_fd_from_fence_reply_fds (xcb_connection_t                *c  /**< */,
+                                  xcb_dri3_fd_from_fence_reply_t  *reply);
+
+int
+xcb_dri3_get_supported_modifiers_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dri3_get_supported_modifiers_cookie_t
+xcb_dri3_get_supported_modifiers (xcb_connection_t *c,
+                                  uint32_t          window,
+                                  uint8_t           depth,
+                                  uint8_t           bpp);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dri3_get_supported_modifiers_cookie_t
+xcb_dri3_get_supported_modifiers_unchecked (xcb_connection_t *c,
+                                            uint32_t          window,
+                                            uint8_t           depth,
+                                            uint8_t           bpp);
+
+uint64_t *
+xcb_dri3_get_supported_modifiers_window_modifiers (const xcb_dri3_get_supported_modifiers_reply_t *R);
+
+int
+xcb_dri3_get_supported_modifiers_window_modifiers_length (const xcb_dri3_get_supported_modifiers_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_dri3_get_supported_modifiers_window_modifiers_end (const xcb_dri3_get_supported_modifiers_reply_t *R);
+
+uint64_t *
+xcb_dri3_get_supported_modifiers_screen_modifiers (const xcb_dri3_get_supported_modifiers_reply_t *R);
+
+int
+xcb_dri3_get_supported_modifiers_screen_modifiers_length (const xcb_dri3_get_supported_modifiers_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_dri3_get_supported_modifiers_screen_modifiers_end (const xcb_dri3_get_supported_modifiers_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dri3_get_supported_modifiers_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dri3_get_supported_modifiers_reply_t *
+xcb_dri3_get_supported_modifiers_reply (xcb_connection_t                           *c,
+                                        xcb_dri3_get_supported_modifiers_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_dri3_pixmap_from_buffers_checked (xcb_connection_t *c,
+                                      xcb_pixmap_t      pixmap,
+                                      xcb_window_t      window,
+                                      uint8_t           num_buffers,
+                                      uint16_t          width,
+                                      uint16_t          height,
+                                      uint32_t          stride0,
+                                      uint32_t          offset0,
+                                      uint32_t          stride1,
+                                      uint32_t          offset1,
+                                      uint32_t          stride2,
+                                      uint32_t          offset2,
+                                      uint32_t          stride3,
+                                      uint32_t          offset3,
+                                      uint8_t           depth,
+                                      uint8_t           bpp,
+                                      uint64_t          modifier,
+                                      const int32_t    *buffers);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_dri3_pixmap_from_buffers (xcb_connection_t *c,
+                              xcb_pixmap_t      pixmap,
+                              xcb_window_t      window,
+                              uint8_t           num_buffers,
+                              uint16_t          width,
+                              uint16_t          height,
+                              uint32_t          stride0,
+                              uint32_t          offset0,
+                              uint32_t          stride1,
+                              uint32_t          offset1,
+                              uint32_t          stride2,
+                              uint32_t          offset2,
+                              uint32_t          stride3,
+                              uint32_t          offset3,
+                              uint8_t           depth,
+                              uint8_t           bpp,
+                              uint64_t          modifier,
+                              const int32_t    *buffers);
+
+int
+xcb_dri3_buffers_from_pixmap_sizeof (const void  *_buffer,
+                                     int32_t      buffers);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_dri3_buffers_from_pixmap_cookie_t
+xcb_dri3_buffers_from_pixmap (xcb_connection_t *c,
+                              xcb_pixmap_t      pixmap);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_dri3_buffers_from_pixmap_cookie_t
+xcb_dri3_buffers_from_pixmap_unchecked (xcb_connection_t *c,
+                                        xcb_pixmap_t      pixmap);
+
+uint32_t *
+xcb_dri3_buffers_from_pixmap_strides (const xcb_dri3_buffers_from_pixmap_reply_t *R);
+
+int
+xcb_dri3_buffers_from_pixmap_strides_length (const xcb_dri3_buffers_from_pixmap_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_dri3_buffers_from_pixmap_strides_end (const xcb_dri3_buffers_from_pixmap_reply_t *R);
+
+uint32_t *
+xcb_dri3_buffers_from_pixmap_offsets (const xcb_dri3_buffers_from_pixmap_reply_t *R);
+
+int
+xcb_dri3_buffers_from_pixmap_offsets_length (const xcb_dri3_buffers_from_pixmap_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_dri3_buffers_from_pixmap_offsets_end (const xcb_dri3_buffers_from_pixmap_reply_t *R);
+
+int32_t *
+xcb_dri3_buffers_from_pixmap_buffers (const xcb_dri3_buffers_from_pixmap_reply_t *R);
+
+int
+xcb_dri3_buffers_from_pixmap_buffers_length (const xcb_dri3_buffers_from_pixmap_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_dri3_buffers_from_pixmap_buffers_end (const xcb_dri3_buffers_from_pixmap_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_dri3_buffers_from_pixmap_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_dri3_buffers_from_pixmap_reply_t *
+xcb_dri3_buffers_from_pixmap_reply (xcb_connection_t                       *c,
+                                    xcb_dri3_buffers_from_pixmap_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e);
+
+/**
+ * Return the reply fds
+ * @param c      The connection
+ * @param reply  The reply
+ *
+ * Returns a pointer to the array of reply fds of the reply.
+ *
+ * The returned value points into the reply and must not be free().
+ * The fds are not managed by xcb. You must close() them before freeing the reply.
+ */
+int *
+xcb_dri3_buffers_from_pixmap_reply_fds (xcb_connection_t                      *c  /**< */,
+                                        xcb_dri3_buffers_from_pixmap_reply_t  *reply);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_dri3_set_drm_device_in_use_checked (xcb_connection_t *c,
+                                        xcb_window_t      window,
+                                        uint32_t          drmMajor,
+                                        uint32_t          drmMinor);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_dri3_set_drm_device_in_use (xcb_connection_t *c,
+                                xcb_window_t      window,
+                                uint32_t          drmMajor,
+                                uint32_t          drmMinor);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/ge.h b/depends/libxcb/include/xcb/ge.h
new file mode 100644
index 0000000..9887e57
--- /dev/null
+++ b/depends/libxcb/include/xcb/ge.h
@@ -0,0 +1,117 @@
+/*
+ * This file generated automatically from ge.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_GenericEvent_API XCB GenericEvent API
+ * @brief GenericEvent XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __GE_H
+#define __GE_H
+
+#include "xcb.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_GENERICEVENT_MAJOR_VERSION 1
+#define XCB_GENERICEVENT_MINOR_VERSION 0
+
+extern xcb_extension_t xcb_genericevent_id;
+
+/**
+ * @brief xcb_genericevent_query_version_cookie_t
+ **/
+typedef struct xcb_genericevent_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_genericevent_query_version_cookie_t;
+
+/** Opcode for xcb_genericevent_query_version. */
+#define XCB_GENERICEVENT_QUERY_VERSION 0
+
+/**
+ * @brief xcb_genericevent_query_version_request_t
+ **/
+typedef struct xcb_genericevent_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint16_t client_major_version;
+    uint16_t client_minor_version;
+} xcb_genericevent_query_version_request_t;
+
+/**
+ * @brief xcb_genericevent_query_version_reply_t
+ **/
+typedef struct xcb_genericevent_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t major_version;
+    uint16_t minor_version;
+    uint8_t  pad1[20];
+} xcb_genericevent_query_version_reply_t;
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_genericevent_query_version_cookie_t
+xcb_genericevent_query_version (xcb_connection_t *c,
+                                uint16_t          client_major_version,
+                                uint16_t          client_minor_version);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_genericevent_query_version_cookie_t
+xcb_genericevent_query_version_unchecked (xcb_connection_t *c,
+                                          uint16_t          client_major_version,
+                                          uint16_t          client_minor_version);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_genericevent_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_genericevent_query_version_reply_t *
+xcb_genericevent_query_version_reply (xcb_connection_t                         *c,
+                                      xcb_genericevent_query_version_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/glx.h b/depends/libxcb/include/xcb/glx.h
new file mode 100644
index 0000000..d864bcc
--- /dev/null
+++ b/depends/libxcb/include/xcb/glx.h
@@ -0,0 +1,8657 @@
+/*
+ * This file generated automatically from glx.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_Glx_API XCB Glx API
+ * @brief Glx XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __GLX_H
+#define __GLX_H
+
+#include "xcb.h"
+#include "xproto.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_GLX_MAJOR_VERSION 1
+#define XCB_GLX_MINOR_VERSION 4
+
+extern xcb_extension_t xcb_glx_id;
+
+typedef uint32_t xcb_glx_pixmap_t;
+
+/**
+ * @brief xcb_glx_pixmap_iterator_t
+ **/
+typedef struct xcb_glx_pixmap_iterator_t {
+    xcb_glx_pixmap_t *data;
+    int               rem;
+    int               index;
+} xcb_glx_pixmap_iterator_t;
+
+typedef uint32_t xcb_glx_context_t;
+
+/**
+ * @brief xcb_glx_context_iterator_t
+ **/
+typedef struct xcb_glx_context_iterator_t {
+    xcb_glx_context_t *data;
+    int                rem;
+    int                index;
+} xcb_glx_context_iterator_t;
+
+typedef uint32_t xcb_glx_pbuffer_t;
+
+/**
+ * @brief xcb_glx_pbuffer_iterator_t
+ **/
+typedef struct xcb_glx_pbuffer_iterator_t {
+    xcb_glx_pbuffer_t *data;
+    int                rem;
+    int                index;
+} xcb_glx_pbuffer_iterator_t;
+
+typedef uint32_t xcb_glx_window_t;
+
+/**
+ * @brief xcb_glx_window_iterator_t
+ **/
+typedef struct xcb_glx_window_iterator_t {
+    xcb_glx_window_t *data;
+    int               rem;
+    int               index;
+} xcb_glx_window_iterator_t;
+
+typedef uint32_t xcb_glx_fbconfig_t;
+
+/**
+ * @brief xcb_glx_fbconfig_iterator_t
+ **/
+typedef struct xcb_glx_fbconfig_iterator_t {
+    xcb_glx_fbconfig_t *data;
+    int                 rem;
+    int                 index;
+} xcb_glx_fbconfig_iterator_t;
+
+typedef uint32_t xcb_glx_drawable_t;
+
+/**
+ * @brief xcb_glx_drawable_iterator_t
+ **/
+typedef struct xcb_glx_drawable_iterator_t {
+    xcb_glx_drawable_t *data;
+    int                 rem;
+    int                 index;
+} xcb_glx_drawable_iterator_t;
+
+typedef float xcb_glx_float32_t;
+
+/**
+ * @brief xcb_glx_float32_iterator_t
+ **/
+typedef struct xcb_glx_float32_iterator_t {
+    xcb_glx_float32_t *data;
+    int                rem;
+    int                index;
+} xcb_glx_float32_iterator_t;
+
+typedef double xcb_glx_float64_t;
+
+/**
+ * @brief xcb_glx_float64_iterator_t
+ **/
+typedef struct xcb_glx_float64_iterator_t {
+    xcb_glx_float64_t *data;
+    int                rem;
+    int                index;
+} xcb_glx_float64_iterator_t;
+
+typedef uint32_t xcb_glx_bool32_t;
+
+/**
+ * @brief xcb_glx_bool32_iterator_t
+ **/
+typedef struct xcb_glx_bool32_iterator_t {
+    xcb_glx_bool32_t *data;
+    int               rem;
+    int               index;
+} xcb_glx_bool32_iterator_t;
+
+typedef uint32_t xcb_glx_context_tag_t;
+
+/**
+ * @brief xcb_glx_context_tag_iterator_t
+ **/
+typedef struct xcb_glx_context_tag_iterator_t {
+    xcb_glx_context_tag_t *data;
+    int                    rem;
+    int                    index;
+} xcb_glx_context_tag_iterator_t;
+
+/** Opcode for xcb_glx_generic. */
+#define XCB_GLX_GENERIC -1
+
+/**
+ * @brief xcb_glx_generic_error_t
+ **/
+typedef struct xcb_glx_generic_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+    uint8_t  pad0[21];
+} xcb_glx_generic_error_t;
+
+/** Opcode for xcb_glx_bad_context. */
+#define XCB_GLX_BAD_CONTEXT 0
+
+typedef xcb_glx_generic_error_t xcb_glx_bad_context_error_t;
+
+/** Opcode for xcb_glx_bad_context_state. */
+#define XCB_GLX_BAD_CONTEXT_STATE 1
+
+typedef xcb_glx_generic_error_t xcb_glx_bad_context_state_error_t;
+
+/** Opcode for xcb_glx_bad_drawable. */
+#define XCB_GLX_BAD_DRAWABLE 2
+
+typedef xcb_glx_generic_error_t xcb_glx_bad_drawable_error_t;
+
+/** Opcode for xcb_glx_bad_pixmap. */
+#define XCB_GLX_BAD_PIXMAP 3
+
+typedef xcb_glx_generic_error_t xcb_glx_bad_pixmap_error_t;
+
+/** Opcode for xcb_glx_bad_context_tag. */
+#define XCB_GLX_BAD_CONTEXT_TAG 4
+
+typedef xcb_glx_generic_error_t xcb_glx_bad_context_tag_error_t;
+
+/** Opcode for xcb_glx_bad_current_window. */
+#define XCB_GLX_BAD_CURRENT_WINDOW 5
+
+typedef xcb_glx_generic_error_t xcb_glx_bad_current_window_error_t;
+
+/** Opcode for xcb_glx_bad_render_request. */
+#define XCB_GLX_BAD_RENDER_REQUEST 6
+
+typedef xcb_glx_generic_error_t xcb_glx_bad_render_request_error_t;
+
+/** Opcode for xcb_glx_bad_large_request. */
+#define XCB_GLX_BAD_LARGE_REQUEST 7
+
+typedef xcb_glx_generic_error_t xcb_glx_bad_large_request_error_t;
+
+/** Opcode for xcb_glx_unsupported_private_request. */
+#define XCB_GLX_UNSUPPORTED_PRIVATE_REQUEST 8
+
+typedef xcb_glx_generic_error_t xcb_glx_unsupported_private_request_error_t;
+
+/** Opcode for xcb_glx_bad_fb_config. */
+#define XCB_GLX_BAD_FB_CONFIG 9
+
+typedef xcb_glx_generic_error_t xcb_glx_bad_fb_config_error_t;
+
+/** Opcode for xcb_glx_bad_pbuffer. */
+#define XCB_GLX_BAD_PBUFFER 10
+
+typedef xcb_glx_generic_error_t xcb_glx_bad_pbuffer_error_t;
+
+/** Opcode for xcb_glx_bad_current_drawable. */
+#define XCB_GLX_BAD_CURRENT_DRAWABLE 11
+
+typedef xcb_glx_generic_error_t xcb_glx_bad_current_drawable_error_t;
+
+/** Opcode for xcb_glx_bad_window. */
+#define XCB_GLX_BAD_WINDOW 12
+
+typedef xcb_glx_generic_error_t xcb_glx_bad_window_error_t;
+
+/** Opcode for xcb_glx_glx_bad_profile_arb. */
+#define XCB_GLX_GLX_BAD_PROFILE_ARB 13
+
+typedef xcb_glx_generic_error_t xcb_glx_glx_bad_profile_arb_error_t;
+
+/** Opcode for xcb_glx_pbuffer_clobber. */
+#define XCB_GLX_PBUFFER_CLOBBER 0
+
+/**
+ * @brief xcb_glx_pbuffer_clobber_event_t
+ **/
+typedef struct xcb_glx_pbuffer_clobber_event_t {
+    uint8_t            response_type;
+    uint8_t            pad0;
+    uint16_t           sequence;
+    uint16_t           event_type;
+    uint16_t           draw_type;
+    xcb_glx_drawable_t drawable;
+    uint32_t           b_mask;
+    uint16_t           aux_buffer;
+    uint16_t           x;
+    uint16_t           y;
+    uint16_t           width;
+    uint16_t           height;
+    uint16_t           count;
+    uint8_t            pad1[4];
+} xcb_glx_pbuffer_clobber_event_t;
+
+/** Opcode for xcb_glx_buffer_swap_complete. */
+#define XCB_GLX_BUFFER_SWAP_COMPLETE 1
+
+/**
+ * @brief xcb_glx_buffer_swap_complete_event_t
+ **/
+typedef struct xcb_glx_buffer_swap_complete_event_t {
+    uint8_t            response_type;
+    uint8_t            pad0;
+    uint16_t           sequence;
+    uint16_t           event_type;
+    uint8_t            pad1[2];
+    xcb_glx_drawable_t drawable;
+    uint32_t           ust_hi;
+    uint32_t           ust_lo;
+    uint32_t           msc_hi;
+    uint32_t           msc_lo;
+    uint32_t           sbc;
+} xcb_glx_buffer_swap_complete_event_t;
+
+typedef enum xcb_glx_pbcet_t {
+    XCB_GLX_PBCET_DAMAGED = 32791,
+    XCB_GLX_PBCET_SAVED = 32792
+} xcb_glx_pbcet_t;
+
+typedef enum xcb_glx_pbcdt_t {
+    XCB_GLX_PBCDT_WINDOW = 32793,
+    XCB_GLX_PBCDT_PBUFFER = 32794
+} xcb_glx_pbcdt_t;
+
+/** Opcode for xcb_glx_render. */
+#define XCB_GLX_RENDER 1
+
+/**
+ * @brief xcb_glx_render_request_t
+ **/
+typedef struct xcb_glx_render_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+} xcb_glx_render_request_t;
+
+/** Opcode for xcb_glx_render_large. */
+#define XCB_GLX_RENDER_LARGE 2
+
+/**
+ * @brief xcb_glx_render_large_request_t
+ **/
+typedef struct xcb_glx_render_large_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint16_t              request_num;
+    uint16_t              request_total;
+    uint32_t              data_len;
+} xcb_glx_render_large_request_t;
+
+/** Opcode for xcb_glx_create_context. */
+#define XCB_GLX_CREATE_CONTEXT 3
+
+/**
+ * @brief xcb_glx_create_context_request_t
+ **/
+typedef struct xcb_glx_create_context_request_t {
+    uint8_t           major_opcode;
+    uint8_t           minor_opcode;
+    uint16_t          length;
+    xcb_glx_context_t context;
+    xcb_visualid_t    visual;
+    uint32_t          screen;
+    xcb_glx_context_t share_list;
+    uint8_t           is_direct;
+    uint8_t           pad0[3];
+} xcb_glx_create_context_request_t;
+
+/** Opcode for xcb_glx_destroy_context. */
+#define XCB_GLX_DESTROY_CONTEXT 4
+
+/**
+ * @brief xcb_glx_destroy_context_request_t
+ **/
+typedef struct xcb_glx_destroy_context_request_t {
+    uint8_t           major_opcode;
+    uint8_t           minor_opcode;
+    uint16_t          length;
+    xcb_glx_context_t context;
+} xcb_glx_destroy_context_request_t;
+
+/**
+ * @brief xcb_glx_make_current_cookie_t
+ **/
+typedef struct xcb_glx_make_current_cookie_t {
+    unsigned int sequence;
+} xcb_glx_make_current_cookie_t;
+
+/** Opcode for xcb_glx_make_current. */
+#define XCB_GLX_MAKE_CURRENT 5
+
+/**
+ * @brief xcb_glx_make_current_request_t
+ **/
+typedef struct xcb_glx_make_current_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_drawable_t    drawable;
+    xcb_glx_context_t     context;
+    xcb_glx_context_tag_t old_context_tag;
+} xcb_glx_make_current_request_t;
+
+/**
+ * @brief xcb_glx_make_current_reply_t
+ **/
+typedef struct xcb_glx_make_current_reply_t {
+    uint8_t               response_type;
+    uint8_t               pad0;
+    uint16_t              sequence;
+    uint32_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint8_t               pad1[20];
+} xcb_glx_make_current_reply_t;
+
+/**
+ * @brief xcb_glx_is_direct_cookie_t
+ **/
+typedef struct xcb_glx_is_direct_cookie_t {
+    unsigned int sequence;
+} xcb_glx_is_direct_cookie_t;
+
+/** Opcode for xcb_glx_is_direct. */
+#define XCB_GLX_IS_DIRECT 6
+
+/**
+ * @brief xcb_glx_is_direct_request_t
+ **/
+typedef struct xcb_glx_is_direct_request_t {
+    uint8_t           major_opcode;
+    uint8_t           minor_opcode;
+    uint16_t          length;
+    xcb_glx_context_t context;
+} xcb_glx_is_direct_request_t;
+
+/**
+ * @brief xcb_glx_is_direct_reply_t
+ **/
+typedef struct xcb_glx_is_direct_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  is_direct;
+    uint8_t  pad1[23];
+} xcb_glx_is_direct_reply_t;
+
+/**
+ * @brief xcb_glx_query_version_cookie_t
+ **/
+typedef struct xcb_glx_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_glx_query_version_cookie_t;
+
+/** Opcode for xcb_glx_query_version. */
+#define XCB_GLX_QUERY_VERSION 7
+
+/**
+ * @brief xcb_glx_query_version_request_t
+ **/
+typedef struct xcb_glx_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t major_version;
+    uint32_t minor_version;
+} xcb_glx_query_version_request_t;
+
+/**
+ * @brief xcb_glx_query_version_reply_t
+ **/
+typedef struct xcb_glx_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t major_version;
+    uint32_t minor_version;
+    uint8_t  pad1[16];
+} xcb_glx_query_version_reply_t;
+
+/** Opcode for xcb_glx_wait_gl. */
+#define XCB_GLX_WAIT_GL 8
+
+/**
+ * @brief xcb_glx_wait_gl_request_t
+ **/
+typedef struct xcb_glx_wait_gl_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+} xcb_glx_wait_gl_request_t;
+
+/** Opcode for xcb_glx_wait_x. */
+#define XCB_GLX_WAIT_X 9
+
+/**
+ * @brief xcb_glx_wait_x_request_t
+ **/
+typedef struct xcb_glx_wait_x_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+} xcb_glx_wait_x_request_t;
+
+/** Opcode for xcb_glx_copy_context. */
+#define XCB_GLX_COPY_CONTEXT 10
+
+/**
+ * @brief xcb_glx_copy_context_request_t
+ **/
+typedef struct xcb_glx_copy_context_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_t     src;
+    xcb_glx_context_t     dest;
+    uint32_t              mask;
+    xcb_glx_context_tag_t src_context_tag;
+} xcb_glx_copy_context_request_t;
+
+typedef enum xcb_glx_gc_t {
+    XCB_GLX_GC_GL_CURRENT_BIT = 1,
+    XCB_GLX_GC_GL_POINT_BIT = 2,
+    XCB_GLX_GC_GL_LINE_BIT = 4,
+    XCB_GLX_GC_GL_POLYGON_BIT = 8,
+    XCB_GLX_GC_GL_POLYGON_STIPPLE_BIT = 16,
+    XCB_GLX_GC_GL_PIXEL_MODE_BIT = 32,
+    XCB_GLX_GC_GL_LIGHTING_BIT = 64,
+    XCB_GLX_GC_GL_FOG_BIT = 128,
+    XCB_GLX_GC_GL_DEPTH_BUFFER_BIT = 256,
+    XCB_GLX_GC_GL_ACCUM_BUFFER_BIT = 512,
+    XCB_GLX_GC_GL_STENCIL_BUFFER_BIT = 1024,
+    XCB_GLX_GC_GL_VIEWPORT_BIT = 2048,
+    XCB_GLX_GC_GL_TRANSFORM_BIT = 4096,
+    XCB_GLX_GC_GL_ENABLE_BIT = 8192,
+    XCB_GLX_GC_GL_COLOR_BUFFER_BIT = 16384,
+    XCB_GLX_GC_GL_HINT_BIT = 32768,
+    XCB_GLX_GC_GL_EVAL_BIT = 65536,
+    XCB_GLX_GC_GL_LIST_BIT = 131072,
+    XCB_GLX_GC_GL_TEXTURE_BIT = 262144,
+    XCB_GLX_GC_GL_SCISSOR_BIT = 524288,
+    XCB_GLX_GC_GL_ALL_ATTRIB_BITS = 16777215
+} xcb_glx_gc_t;
+
+/** Opcode for xcb_glx_swap_buffers. */
+#define XCB_GLX_SWAP_BUFFERS 11
+
+/**
+ * @brief xcb_glx_swap_buffers_request_t
+ **/
+typedef struct xcb_glx_swap_buffers_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    xcb_glx_drawable_t    drawable;
+} xcb_glx_swap_buffers_request_t;
+
+/** Opcode for xcb_glx_use_x_font. */
+#define XCB_GLX_USE_X_FONT 12
+
+/**
+ * @brief xcb_glx_use_x_font_request_t
+ **/
+typedef struct xcb_glx_use_x_font_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    xcb_font_t            font;
+    uint32_t              first;
+    uint32_t              count;
+    uint32_t              list_base;
+} xcb_glx_use_x_font_request_t;
+
+/** Opcode for xcb_glx_create_glx_pixmap. */
+#define XCB_GLX_CREATE_GLX_PIXMAP 13
+
+/**
+ * @brief xcb_glx_create_glx_pixmap_request_t
+ **/
+typedef struct xcb_glx_create_glx_pixmap_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    uint32_t         screen;
+    xcb_visualid_t   visual;
+    xcb_pixmap_t     pixmap;
+    xcb_glx_pixmap_t glx_pixmap;
+} xcb_glx_create_glx_pixmap_request_t;
+
+/**
+ * @brief xcb_glx_get_visual_configs_cookie_t
+ **/
+typedef struct xcb_glx_get_visual_configs_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_visual_configs_cookie_t;
+
+/** Opcode for xcb_glx_get_visual_configs. */
+#define XCB_GLX_GET_VISUAL_CONFIGS 14
+
+/**
+ * @brief xcb_glx_get_visual_configs_request_t
+ **/
+typedef struct xcb_glx_get_visual_configs_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t screen;
+} xcb_glx_get_visual_configs_request_t;
+
+/**
+ * @brief xcb_glx_get_visual_configs_reply_t
+ **/
+typedef struct xcb_glx_get_visual_configs_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t num_visuals;
+    uint32_t num_properties;
+    uint8_t  pad1[16];
+} xcb_glx_get_visual_configs_reply_t;
+
+/** Opcode for xcb_glx_destroy_glx_pixmap. */
+#define XCB_GLX_DESTROY_GLX_PIXMAP 15
+
+/**
+ * @brief xcb_glx_destroy_glx_pixmap_request_t
+ **/
+typedef struct xcb_glx_destroy_glx_pixmap_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_glx_pixmap_t glx_pixmap;
+} xcb_glx_destroy_glx_pixmap_request_t;
+
+/** Opcode for xcb_glx_vendor_private. */
+#define XCB_GLX_VENDOR_PRIVATE 16
+
+/**
+ * @brief xcb_glx_vendor_private_request_t
+ **/
+typedef struct xcb_glx_vendor_private_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    uint32_t              vendor_code;
+    xcb_glx_context_tag_t context_tag;
+} xcb_glx_vendor_private_request_t;
+
+/**
+ * @brief xcb_glx_vendor_private_with_reply_cookie_t
+ **/
+typedef struct xcb_glx_vendor_private_with_reply_cookie_t {
+    unsigned int sequence;
+} xcb_glx_vendor_private_with_reply_cookie_t;
+
+/** Opcode for xcb_glx_vendor_private_with_reply. */
+#define XCB_GLX_VENDOR_PRIVATE_WITH_REPLY 17
+
+/**
+ * @brief xcb_glx_vendor_private_with_reply_request_t
+ **/
+typedef struct xcb_glx_vendor_private_with_reply_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    uint32_t              vendor_code;
+    xcb_glx_context_tag_t context_tag;
+} xcb_glx_vendor_private_with_reply_request_t;
+
+/**
+ * @brief xcb_glx_vendor_private_with_reply_reply_t
+ **/
+typedef struct xcb_glx_vendor_private_with_reply_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t retval;
+    uint8_t  data1[24];
+} xcb_glx_vendor_private_with_reply_reply_t;
+
+/**
+ * @brief xcb_glx_query_extensions_string_cookie_t
+ **/
+typedef struct xcb_glx_query_extensions_string_cookie_t {
+    unsigned int sequence;
+} xcb_glx_query_extensions_string_cookie_t;
+
+/** Opcode for xcb_glx_query_extensions_string. */
+#define XCB_GLX_QUERY_EXTENSIONS_STRING 18
+
+/**
+ * @brief xcb_glx_query_extensions_string_request_t
+ **/
+typedef struct xcb_glx_query_extensions_string_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t screen;
+} xcb_glx_query_extensions_string_request_t;
+
+/**
+ * @brief xcb_glx_query_extensions_string_reply_t
+ **/
+typedef struct xcb_glx_query_extensions_string_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t n;
+    uint8_t  pad2[16];
+} xcb_glx_query_extensions_string_reply_t;
+
+/**
+ * @brief xcb_glx_query_server_string_cookie_t
+ **/
+typedef struct xcb_glx_query_server_string_cookie_t {
+    unsigned int sequence;
+} xcb_glx_query_server_string_cookie_t;
+
+/** Opcode for xcb_glx_query_server_string. */
+#define XCB_GLX_QUERY_SERVER_STRING 19
+
+/**
+ * @brief xcb_glx_query_server_string_request_t
+ **/
+typedef struct xcb_glx_query_server_string_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t screen;
+    uint32_t name;
+} xcb_glx_query_server_string_request_t;
+
+/**
+ * @brief xcb_glx_query_server_string_reply_t
+ **/
+typedef struct xcb_glx_query_server_string_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t str_len;
+    uint8_t  pad2[16];
+} xcb_glx_query_server_string_reply_t;
+
+/** Opcode for xcb_glx_client_info. */
+#define XCB_GLX_CLIENT_INFO 20
+
+/**
+ * @brief xcb_glx_client_info_request_t
+ **/
+typedef struct xcb_glx_client_info_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t major_version;
+    uint32_t minor_version;
+    uint32_t str_len;
+} xcb_glx_client_info_request_t;
+
+/**
+ * @brief xcb_glx_get_fb_configs_cookie_t
+ **/
+typedef struct xcb_glx_get_fb_configs_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_fb_configs_cookie_t;
+
+/** Opcode for xcb_glx_get_fb_configs. */
+#define XCB_GLX_GET_FB_CONFIGS 21
+
+/**
+ * @brief xcb_glx_get_fb_configs_request_t
+ **/
+typedef struct xcb_glx_get_fb_configs_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t screen;
+} xcb_glx_get_fb_configs_request_t;
+
+/**
+ * @brief xcb_glx_get_fb_configs_reply_t
+ **/
+typedef struct xcb_glx_get_fb_configs_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t num_FB_configs;
+    uint32_t num_properties;
+    uint8_t  pad1[16];
+} xcb_glx_get_fb_configs_reply_t;
+
+/** Opcode for xcb_glx_create_pixmap. */
+#define XCB_GLX_CREATE_PIXMAP 22
+
+/**
+ * @brief xcb_glx_create_pixmap_request_t
+ **/
+typedef struct xcb_glx_create_pixmap_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    uint32_t           screen;
+    xcb_glx_fbconfig_t fbconfig;
+    xcb_pixmap_t       pixmap;
+    xcb_glx_pixmap_t   glx_pixmap;
+    uint32_t           num_attribs;
+} xcb_glx_create_pixmap_request_t;
+
+/** Opcode for xcb_glx_destroy_pixmap. */
+#define XCB_GLX_DESTROY_PIXMAP 23
+
+/**
+ * @brief xcb_glx_destroy_pixmap_request_t
+ **/
+typedef struct xcb_glx_destroy_pixmap_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_glx_pixmap_t glx_pixmap;
+} xcb_glx_destroy_pixmap_request_t;
+
+/** Opcode for xcb_glx_create_new_context. */
+#define XCB_GLX_CREATE_NEW_CONTEXT 24
+
+/**
+ * @brief xcb_glx_create_new_context_request_t
+ **/
+typedef struct xcb_glx_create_new_context_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_glx_context_t  context;
+    xcb_glx_fbconfig_t fbconfig;
+    uint32_t           screen;
+    uint32_t           render_type;
+    xcb_glx_context_t  share_list;
+    uint8_t            is_direct;
+    uint8_t            pad0[3];
+} xcb_glx_create_new_context_request_t;
+
+/**
+ * @brief xcb_glx_query_context_cookie_t
+ **/
+typedef struct xcb_glx_query_context_cookie_t {
+    unsigned int sequence;
+} xcb_glx_query_context_cookie_t;
+
+/** Opcode for xcb_glx_query_context. */
+#define XCB_GLX_QUERY_CONTEXT 25
+
+/**
+ * @brief xcb_glx_query_context_request_t
+ **/
+typedef struct xcb_glx_query_context_request_t {
+    uint8_t           major_opcode;
+    uint8_t           minor_opcode;
+    uint16_t          length;
+    xcb_glx_context_t context;
+} xcb_glx_query_context_request_t;
+
+/**
+ * @brief xcb_glx_query_context_reply_t
+ **/
+typedef struct xcb_glx_query_context_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t num_attribs;
+    uint8_t  pad1[20];
+} xcb_glx_query_context_reply_t;
+
+/**
+ * @brief xcb_glx_make_context_current_cookie_t
+ **/
+typedef struct xcb_glx_make_context_current_cookie_t {
+    unsigned int sequence;
+} xcb_glx_make_context_current_cookie_t;
+
+/** Opcode for xcb_glx_make_context_current. */
+#define XCB_GLX_MAKE_CONTEXT_CURRENT 26
+
+/**
+ * @brief xcb_glx_make_context_current_request_t
+ **/
+typedef struct xcb_glx_make_context_current_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t old_context_tag;
+    xcb_glx_drawable_t    drawable;
+    xcb_glx_drawable_t    read_drawable;
+    xcb_glx_context_t     context;
+} xcb_glx_make_context_current_request_t;
+
+/**
+ * @brief xcb_glx_make_context_current_reply_t
+ **/
+typedef struct xcb_glx_make_context_current_reply_t {
+    uint8_t               response_type;
+    uint8_t               pad0;
+    uint16_t              sequence;
+    uint32_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint8_t               pad1[20];
+} xcb_glx_make_context_current_reply_t;
+
+/** Opcode for xcb_glx_create_pbuffer. */
+#define XCB_GLX_CREATE_PBUFFER 27
+
+/**
+ * @brief xcb_glx_create_pbuffer_request_t
+ **/
+typedef struct xcb_glx_create_pbuffer_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    uint32_t           screen;
+    xcb_glx_fbconfig_t fbconfig;
+    xcb_glx_pbuffer_t  pbuffer;
+    uint32_t           num_attribs;
+} xcb_glx_create_pbuffer_request_t;
+
+/** Opcode for xcb_glx_destroy_pbuffer. */
+#define XCB_GLX_DESTROY_PBUFFER 28
+
+/**
+ * @brief xcb_glx_destroy_pbuffer_request_t
+ **/
+typedef struct xcb_glx_destroy_pbuffer_request_t {
+    uint8_t           major_opcode;
+    uint8_t           minor_opcode;
+    uint16_t          length;
+    xcb_glx_pbuffer_t pbuffer;
+} xcb_glx_destroy_pbuffer_request_t;
+
+/**
+ * @brief xcb_glx_get_drawable_attributes_cookie_t
+ **/
+typedef struct xcb_glx_get_drawable_attributes_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_drawable_attributes_cookie_t;
+
+/** Opcode for xcb_glx_get_drawable_attributes. */
+#define XCB_GLX_GET_DRAWABLE_ATTRIBUTES 29
+
+/**
+ * @brief xcb_glx_get_drawable_attributes_request_t
+ **/
+typedef struct xcb_glx_get_drawable_attributes_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_glx_drawable_t drawable;
+} xcb_glx_get_drawable_attributes_request_t;
+
+/**
+ * @brief xcb_glx_get_drawable_attributes_reply_t
+ **/
+typedef struct xcb_glx_get_drawable_attributes_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t num_attribs;
+    uint8_t  pad1[20];
+} xcb_glx_get_drawable_attributes_reply_t;
+
+/** Opcode for xcb_glx_change_drawable_attributes. */
+#define XCB_GLX_CHANGE_DRAWABLE_ATTRIBUTES 30
+
+/**
+ * @brief xcb_glx_change_drawable_attributes_request_t
+ **/
+typedef struct xcb_glx_change_drawable_attributes_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_glx_drawable_t drawable;
+    uint32_t           num_attribs;
+} xcb_glx_change_drawable_attributes_request_t;
+
+/** Opcode for xcb_glx_create_window. */
+#define XCB_GLX_CREATE_WINDOW 31
+
+/**
+ * @brief xcb_glx_create_window_request_t
+ **/
+typedef struct xcb_glx_create_window_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    uint32_t           screen;
+    xcb_glx_fbconfig_t fbconfig;
+    xcb_window_t       window;
+    xcb_glx_window_t   glx_window;
+    uint32_t           num_attribs;
+} xcb_glx_create_window_request_t;
+
+/** Opcode for xcb_glx_delete_window. */
+#define XCB_GLX_DELETE_WINDOW 32
+
+/**
+ * @brief xcb_glx_delete_window_request_t
+ **/
+typedef struct xcb_glx_delete_window_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_glx_window_t glxwindow;
+} xcb_glx_delete_window_request_t;
+
+/** Opcode for xcb_glx_set_client_info_arb. */
+#define XCB_GLX_SET_CLIENT_INFO_ARB 33
+
+/**
+ * @brief xcb_glx_set_client_info_arb_request_t
+ **/
+typedef struct xcb_glx_set_client_info_arb_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t major_version;
+    uint32_t minor_version;
+    uint32_t num_versions;
+    uint32_t gl_str_len;
+    uint32_t glx_str_len;
+} xcb_glx_set_client_info_arb_request_t;
+
+/** Opcode for xcb_glx_create_context_attribs_arb. */
+#define XCB_GLX_CREATE_CONTEXT_ATTRIBS_ARB 34
+
+/**
+ * @brief xcb_glx_create_context_attribs_arb_request_t
+ **/
+typedef struct xcb_glx_create_context_attribs_arb_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_glx_context_t  context;
+    xcb_glx_fbconfig_t fbconfig;
+    uint32_t           screen;
+    xcb_glx_context_t  share_list;
+    uint8_t            is_direct;
+    uint8_t            pad0[3];
+    uint32_t           num_attribs;
+} xcb_glx_create_context_attribs_arb_request_t;
+
+/** Opcode for xcb_glx_set_client_info_2arb. */
+#define XCB_GLX_SET_CLIENT_INFO_2ARB 35
+
+/**
+ * @brief xcb_glx_set_client_info_2arb_request_t
+ **/
+typedef struct xcb_glx_set_client_info_2arb_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t major_version;
+    uint32_t minor_version;
+    uint32_t num_versions;
+    uint32_t gl_str_len;
+    uint32_t glx_str_len;
+} xcb_glx_set_client_info_2arb_request_t;
+
+/** Opcode for xcb_glx_new_list. */
+#define XCB_GLX_NEW_LIST 101
+
+/**
+ * @brief xcb_glx_new_list_request_t
+ **/
+typedef struct xcb_glx_new_list_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              list;
+    uint32_t              mode;
+} xcb_glx_new_list_request_t;
+
+/** Opcode for xcb_glx_end_list. */
+#define XCB_GLX_END_LIST 102
+
+/**
+ * @brief xcb_glx_end_list_request_t
+ **/
+typedef struct xcb_glx_end_list_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+} xcb_glx_end_list_request_t;
+
+/** Opcode for xcb_glx_delete_lists. */
+#define XCB_GLX_DELETE_LISTS 103
+
+/**
+ * @brief xcb_glx_delete_lists_request_t
+ **/
+typedef struct xcb_glx_delete_lists_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              list;
+    int32_t               range;
+} xcb_glx_delete_lists_request_t;
+
+/**
+ * @brief xcb_glx_gen_lists_cookie_t
+ **/
+typedef struct xcb_glx_gen_lists_cookie_t {
+    unsigned int sequence;
+} xcb_glx_gen_lists_cookie_t;
+
+/** Opcode for xcb_glx_gen_lists. */
+#define XCB_GLX_GEN_LISTS 104
+
+/**
+ * @brief xcb_glx_gen_lists_request_t
+ **/
+typedef struct xcb_glx_gen_lists_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    int32_t               range;
+} xcb_glx_gen_lists_request_t;
+
+/**
+ * @brief xcb_glx_gen_lists_reply_t
+ **/
+typedef struct xcb_glx_gen_lists_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t ret_val;
+} xcb_glx_gen_lists_reply_t;
+
+/** Opcode for xcb_glx_feedback_buffer. */
+#define XCB_GLX_FEEDBACK_BUFFER 105
+
+/**
+ * @brief xcb_glx_feedback_buffer_request_t
+ **/
+typedef struct xcb_glx_feedback_buffer_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    int32_t               size;
+    int32_t               type;
+} xcb_glx_feedback_buffer_request_t;
+
+/** Opcode for xcb_glx_select_buffer. */
+#define XCB_GLX_SELECT_BUFFER 106
+
+/**
+ * @brief xcb_glx_select_buffer_request_t
+ **/
+typedef struct xcb_glx_select_buffer_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    int32_t               size;
+} xcb_glx_select_buffer_request_t;
+
+/**
+ * @brief xcb_glx_render_mode_cookie_t
+ **/
+typedef struct xcb_glx_render_mode_cookie_t {
+    unsigned int sequence;
+} xcb_glx_render_mode_cookie_t;
+
+/** Opcode for xcb_glx_render_mode. */
+#define XCB_GLX_RENDER_MODE 107
+
+/**
+ * @brief xcb_glx_render_mode_request_t
+ **/
+typedef struct xcb_glx_render_mode_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              mode;
+} xcb_glx_render_mode_request_t;
+
+/**
+ * @brief xcb_glx_render_mode_reply_t
+ **/
+typedef struct xcb_glx_render_mode_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t ret_val;
+    uint32_t n;
+    uint32_t new_mode;
+    uint8_t  pad1[12];
+} xcb_glx_render_mode_reply_t;
+
+typedef enum xcb_glx_rm_t {
+    XCB_GLX_RM_GL_RENDER = 7168,
+    XCB_GLX_RM_GL_FEEDBACK = 7169,
+    XCB_GLX_RM_GL_SELECT = 7170
+} xcb_glx_rm_t;
+
+/**
+ * @brief xcb_glx_finish_cookie_t
+ **/
+typedef struct xcb_glx_finish_cookie_t {
+    unsigned int sequence;
+} xcb_glx_finish_cookie_t;
+
+/** Opcode for xcb_glx_finish. */
+#define XCB_GLX_FINISH 108
+
+/**
+ * @brief xcb_glx_finish_request_t
+ **/
+typedef struct xcb_glx_finish_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+} xcb_glx_finish_request_t;
+
+/**
+ * @brief xcb_glx_finish_reply_t
+ **/
+typedef struct xcb_glx_finish_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+} xcb_glx_finish_reply_t;
+
+/** Opcode for xcb_glx_pixel_storef. */
+#define XCB_GLX_PIXEL_STOREF 109
+
+/**
+ * @brief xcb_glx_pixel_storef_request_t
+ **/
+typedef struct xcb_glx_pixel_storef_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              pname;
+    xcb_glx_float32_t     datum;
+} xcb_glx_pixel_storef_request_t;
+
+/** Opcode for xcb_glx_pixel_storei. */
+#define XCB_GLX_PIXEL_STOREI 110
+
+/**
+ * @brief xcb_glx_pixel_storei_request_t
+ **/
+typedef struct xcb_glx_pixel_storei_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              pname;
+    int32_t               datum;
+} xcb_glx_pixel_storei_request_t;
+
+/**
+ * @brief xcb_glx_read_pixels_cookie_t
+ **/
+typedef struct xcb_glx_read_pixels_cookie_t {
+    unsigned int sequence;
+} xcb_glx_read_pixels_cookie_t;
+
+/** Opcode for xcb_glx_read_pixels. */
+#define XCB_GLX_READ_PIXELS 111
+
+/**
+ * @brief xcb_glx_read_pixels_request_t
+ **/
+typedef struct xcb_glx_read_pixels_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    int32_t               x;
+    int32_t               y;
+    int32_t               width;
+    int32_t               height;
+    uint32_t              format;
+    uint32_t              type;
+    uint8_t               swap_bytes;
+    uint8_t               lsb_first;
+} xcb_glx_read_pixels_request_t;
+
+/**
+ * @brief xcb_glx_read_pixels_reply_t
+ **/
+typedef struct xcb_glx_read_pixels_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[24];
+} xcb_glx_read_pixels_reply_t;
+
+/**
+ * @brief xcb_glx_get_booleanv_cookie_t
+ **/
+typedef struct xcb_glx_get_booleanv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_booleanv_cookie_t;
+
+/** Opcode for xcb_glx_get_booleanv. */
+#define XCB_GLX_GET_BOOLEANV 112
+
+/**
+ * @brief xcb_glx_get_booleanv_request_t
+ **/
+typedef struct xcb_glx_get_booleanv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    int32_t               pname;
+} xcb_glx_get_booleanv_request_t;
+
+/**
+ * @brief xcb_glx_get_booleanv_reply_t
+ **/
+typedef struct xcb_glx_get_booleanv_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t n;
+    uint8_t  datum;
+    uint8_t  pad2[15];
+} xcb_glx_get_booleanv_reply_t;
+
+/**
+ * @brief xcb_glx_get_clip_plane_cookie_t
+ **/
+typedef struct xcb_glx_get_clip_plane_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_clip_plane_cookie_t;
+
+/** Opcode for xcb_glx_get_clip_plane. */
+#define XCB_GLX_GET_CLIP_PLANE 113
+
+/**
+ * @brief xcb_glx_get_clip_plane_request_t
+ **/
+typedef struct xcb_glx_get_clip_plane_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    int32_t               plane;
+} xcb_glx_get_clip_plane_request_t;
+
+/**
+ * @brief xcb_glx_get_clip_plane_reply_t
+ **/
+typedef struct xcb_glx_get_clip_plane_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[24];
+} xcb_glx_get_clip_plane_reply_t;
+
+/**
+ * @brief xcb_glx_get_doublev_cookie_t
+ **/
+typedef struct xcb_glx_get_doublev_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_doublev_cookie_t;
+
+/** Opcode for xcb_glx_get_doublev. */
+#define XCB_GLX_GET_DOUBLEV 114
+
+/**
+ * @brief xcb_glx_get_doublev_request_t
+ **/
+typedef struct xcb_glx_get_doublev_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              pname;
+} xcb_glx_get_doublev_request_t;
+
+/**
+ * @brief xcb_glx_get_doublev_reply_t
+ **/
+typedef struct xcb_glx_get_doublev_reply_t {
+    uint8_t           response_type;
+    uint8_t           pad0;
+    uint16_t          sequence;
+    uint32_t          length;
+    uint8_t           pad1[4];
+    uint32_t          n;
+    xcb_glx_float64_t datum;
+    uint8_t           pad2[8];
+} xcb_glx_get_doublev_reply_t;
+
+/**
+ * @brief xcb_glx_get_error_cookie_t
+ **/
+typedef struct xcb_glx_get_error_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_error_cookie_t;
+
+/** Opcode for xcb_glx_get_error. */
+#define XCB_GLX_GET_ERROR 115
+
+/**
+ * @brief xcb_glx_get_error_request_t
+ **/
+typedef struct xcb_glx_get_error_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+} xcb_glx_get_error_request_t;
+
+/**
+ * @brief xcb_glx_get_error_reply_t
+ **/
+typedef struct xcb_glx_get_error_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    int32_t  error;
+} xcb_glx_get_error_reply_t;
+
+/**
+ * @brief xcb_glx_get_floatv_cookie_t
+ **/
+typedef struct xcb_glx_get_floatv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_floatv_cookie_t;
+
+/** Opcode for xcb_glx_get_floatv. */
+#define XCB_GLX_GET_FLOATV 116
+
+/**
+ * @brief xcb_glx_get_floatv_request_t
+ **/
+typedef struct xcb_glx_get_floatv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              pname;
+} xcb_glx_get_floatv_request_t;
+
+/**
+ * @brief xcb_glx_get_floatv_reply_t
+ **/
+typedef struct xcb_glx_get_floatv_reply_t {
+    uint8_t           response_type;
+    uint8_t           pad0;
+    uint16_t          sequence;
+    uint32_t          length;
+    uint8_t           pad1[4];
+    uint32_t          n;
+    xcb_glx_float32_t datum;
+    uint8_t           pad2[12];
+} xcb_glx_get_floatv_reply_t;
+
+/**
+ * @brief xcb_glx_get_integerv_cookie_t
+ **/
+typedef struct xcb_glx_get_integerv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_integerv_cookie_t;
+
+/** Opcode for xcb_glx_get_integerv. */
+#define XCB_GLX_GET_INTEGERV 117
+
+/**
+ * @brief xcb_glx_get_integerv_request_t
+ **/
+typedef struct xcb_glx_get_integerv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              pname;
+} xcb_glx_get_integerv_request_t;
+
+/**
+ * @brief xcb_glx_get_integerv_reply_t
+ **/
+typedef struct xcb_glx_get_integerv_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t n;
+    int32_t  datum;
+    uint8_t  pad2[12];
+} xcb_glx_get_integerv_reply_t;
+
+/**
+ * @brief xcb_glx_get_lightfv_cookie_t
+ **/
+typedef struct xcb_glx_get_lightfv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_lightfv_cookie_t;
+
+/** Opcode for xcb_glx_get_lightfv. */
+#define XCB_GLX_GET_LIGHTFV 118
+
+/**
+ * @brief xcb_glx_get_lightfv_request_t
+ **/
+typedef struct xcb_glx_get_lightfv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              light;
+    uint32_t              pname;
+} xcb_glx_get_lightfv_request_t;
+
+/**
+ * @brief xcb_glx_get_lightfv_reply_t
+ **/
+typedef struct xcb_glx_get_lightfv_reply_t {
+    uint8_t           response_type;
+    uint8_t           pad0;
+    uint16_t          sequence;
+    uint32_t          length;
+    uint8_t           pad1[4];
+    uint32_t          n;
+    xcb_glx_float32_t datum;
+    uint8_t           pad2[12];
+} xcb_glx_get_lightfv_reply_t;
+
+/**
+ * @brief xcb_glx_get_lightiv_cookie_t
+ **/
+typedef struct xcb_glx_get_lightiv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_lightiv_cookie_t;
+
+/** Opcode for xcb_glx_get_lightiv. */
+#define XCB_GLX_GET_LIGHTIV 119
+
+/**
+ * @brief xcb_glx_get_lightiv_request_t
+ **/
+typedef struct xcb_glx_get_lightiv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              light;
+    uint32_t              pname;
+} xcb_glx_get_lightiv_request_t;
+
+/**
+ * @brief xcb_glx_get_lightiv_reply_t
+ **/
+typedef struct xcb_glx_get_lightiv_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t n;
+    int32_t  datum;
+    uint8_t  pad2[12];
+} xcb_glx_get_lightiv_reply_t;
+
+/**
+ * @brief xcb_glx_get_mapdv_cookie_t
+ **/
+typedef struct xcb_glx_get_mapdv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_mapdv_cookie_t;
+
+/** Opcode for xcb_glx_get_mapdv. */
+#define XCB_GLX_GET_MAPDV 120
+
+/**
+ * @brief xcb_glx_get_mapdv_request_t
+ **/
+typedef struct xcb_glx_get_mapdv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              query;
+} xcb_glx_get_mapdv_request_t;
+
+/**
+ * @brief xcb_glx_get_mapdv_reply_t
+ **/
+typedef struct xcb_glx_get_mapdv_reply_t {
+    uint8_t           response_type;
+    uint8_t           pad0;
+    uint16_t          sequence;
+    uint32_t          length;
+    uint8_t           pad1[4];
+    uint32_t          n;
+    xcb_glx_float64_t datum;
+    uint8_t           pad2[8];
+} xcb_glx_get_mapdv_reply_t;
+
+/**
+ * @brief xcb_glx_get_mapfv_cookie_t
+ **/
+typedef struct xcb_glx_get_mapfv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_mapfv_cookie_t;
+
+/** Opcode for xcb_glx_get_mapfv. */
+#define XCB_GLX_GET_MAPFV 121
+
+/**
+ * @brief xcb_glx_get_mapfv_request_t
+ **/
+typedef struct xcb_glx_get_mapfv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              query;
+} xcb_glx_get_mapfv_request_t;
+
+/**
+ * @brief xcb_glx_get_mapfv_reply_t
+ **/
+typedef struct xcb_glx_get_mapfv_reply_t {
+    uint8_t           response_type;
+    uint8_t           pad0;
+    uint16_t          sequence;
+    uint32_t          length;
+    uint8_t           pad1[4];
+    uint32_t          n;
+    xcb_glx_float32_t datum;
+    uint8_t           pad2[12];
+} xcb_glx_get_mapfv_reply_t;
+
+/**
+ * @brief xcb_glx_get_mapiv_cookie_t
+ **/
+typedef struct xcb_glx_get_mapiv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_mapiv_cookie_t;
+
+/** Opcode for xcb_glx_get_mapiv. */
+#define XCB_GLX_GET_MAPIV 122
+
+/**
+ * @brief xcb_glx_get_mapiv_request_t
+ **/
+typedef struct xcb_glx_get_mapiv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              query;
+} xcb_glx_get_mapiv_request_t;
+
+/**
+ * @brief xcb_glx_get_mapiv_reply_t
+ **/
+typedef struct xcb_glx_get_mapiv_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t n;
+    int32_t  datum;
+    uint8_t  pad2[12];
+} xcb_glx_get_mapiv_reply_t;
+
+/**
+ * @brief xcb_glx_get_materialfv_cookie_t
+ **/
+typedef struct xcb_glx_get_materialfv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_materialfv_cookie_t;
+
+/** Opcode for xcb_glx_get_materialfv. */
+#define XCB_GLX_GET_MATERIALFV 123
+
+/**
+ * @brief xcb_glx_get_materialfv_request_t
+ **/
+typedef struct xcb_glx_get_materialfv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              face;
+    uint32_t              pname;
+} xcb_glx_get_materialfv_request_t;
+
+/**
+ * @brief xcb_glx_get_materialfv_reply_t
+ **/
+typedef struct xcb_glx_get_materialfv_reply_t {
+    uint8_t           response_type;
+    uint8_t           pad0;
+    uint16_t          sequence;
+    uint32_t          length;
+    uint8_t           pad1[4];
+    uint32_t          n;
+    xcb_glx_float32_t datum;
+    uint8_t           pad2[12];
+} xcb_glx_get_materialfv_reply_t;
+
+/**
+ * @brief xcb_glx_get_materialiv_cookie_t
+ **/
+typedef struct xcb_glx_get_materialiv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_materialiv_cookie_t;
+
+/** Opcode for xcb_glx_get_materialiv. */
+#define XCB_GLX_GET_MATERIALIV 124
+
+/**
+ * @brief xcb_glx_get_materialiv_request_t
+ **/
+typedef struct xcb_glx_get_materialiv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              face;
+    uint32_t              pname;
+} xcb_glx_get_materialiv_request_t;
+
+/**
+ * @brief xcb_glx_get_materialiv_reply_t
+ **/
+typedef struct xcb_glx_get_materialiv_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t n;
+    int32_t  datum;
+    uint8_t  pad2[12];
+} xcb_glx_get_materialiv_reply_t;
+
+/**
+ * @brief xcb_glx_get_pixel_mapfv_cookie_t
+ **/
+typedef struct xcb_glx_get_pixel_mapfv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_pixel_mapfv_cookie_t;
+
+/** Opcode for xcb_glx_get_pixel_mapfv. */
+#define XCB_GLX_GET_PIXEL_MAPFV 125
+
+/**
+ * @brief xcb_glx_get_pixel_mapfv_request_t
+ **/
+typedef struct xcb_glx_get_pixel_mapfv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              map;
+} xcb_glx_get_pixel_mapfv_request_t;
+
+/**
+ * @brief xcb_glx_get_pixel_mapfv_reply_t
+ **/
+typedef struct xcb_glx_get_pixel_mapfv_reply_t {
+    uint8_t           response_type;
+    uint8_t           pad0;
+    uint16_t          sequence;
+    uint32_t          length;
+    uint8_t           pad1[4];
+    uint32_t          n;
+    xcb_glx_float32_t datum;
+    uint8_t           pad2[12];
+} xcb_glx_get_pixel_mapfv_reply_t;
+
+/**
+ * @brief xcb_glx_get_pixel_mapuiv_cookie_t
+ **/
+typedef struct xcb_glx_get_pixel_mapuiv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_pixel_mapuiv_cookie_t;
+
+/** Opcode for xcb_glx_get_pixel_mapuiv. */
+#define XCB_GLX_GET_PIXEL_MAPUIV 126
+
+/**
+ * @brief xcb_glx_get_pixel_mapuiv_request_t
+ **/
+typedef struct xcb_glx_get_pixel_mapuiv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              map;
+} xcb_glx_get_pixel_mapuiv_request_t;
+
+/**
+ * @brief xcb_glx_get_pixel_mapuiv_reply_t
+ **/
+typedef struct xcb_glx_get_pixel_mapuiv_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t n;
+    uint32_t datum;
+    uint8_t  pad2[12];
+} xcb_glx_get_pixel_mapuiv_reply_t;
+
+/**
+ * @brief xcb_glx_get_pixel_mapusv_cookie_t
+ **/
+typedef struct xcb_glx_get_pixel_mapusv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_pixel_mapusv_cookie_t;
+
+/** Opcode for xcb_glx_get_pixel_mapusv. */
+#define XCB_GLX_GET_PIXEL_MAPUSV 127
+
+/**
+ * @brief xcb_glx_get_pixel_mapusv_request_t
+ **/
+typedef struct xcb_glx_get_pixel_mapusv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              map;
+} xcb_glx_get_pixel_mapusv_request_t;
+
+/**
+ * @brief xcb_glx_get_pixel_mapusv_reply_t
+ **/
+typedef struct xcb_glx_get_pixel_mapusv_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t n;
+    uint16_t datum;
+    uint8_t  pad2[16];
+} xcb_glx_get_pixel_mapusv_reply_t;
+
+/**
+ * @brief xcb_glx_get_polygon_stipple_cookie_t
+ **/
+typedef struct xcb_glx_get_polygon_stipple_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_polygon_stipple_cookie_t;
+
+/** Opcode for xcb_glx_get_polygon_stipple. */
+#define XCB_GLX_GET_POLYGON_STIPPLE 128
+
+/**
+ * @brief xcb_glx_get_polygon_stipple_request_t
+ **/
+typedef struct xcb_glx_get_polygon_stipple_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint8_t               lsb_first;
+} xcb_glx_get_polygon_stipple_request_t;
+
+/**
+ * @brief xcb_glx_get_polygon_stipple_reply_t
+ **/
+typedef struct xcb_glx_get_polygon_stipple_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[24];
+} xcb_glx_get_polygon_stipple_reply_t;
+
+/**
+ * @brief xcb_glx_get_string_cookie_t
+ **/
+typedef struct xcb_glx_get_string_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_string_cookie_t;
+
+/** Opcode for xcb_glx_get_string. */
+#define XCB_GLX_GET_STRING 129
+
+/**
+ * @brief xcb_glx_get_string_request_t
+ **/
+typedef struct xcb_glx_get_string_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              name;
+} xcb_glx_get_string_request_t;
+
+/**
+ * @brief xcb_glx_get_string_reply_t
+ **/
+typedef struct xcb_glx_get_string_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t n;
+    uint8_t  pad2[16];
+} xcb_glx_get_string_reply_t;
+
+/**
+ * @brief xcb_glx_get_tex_envfv_cookie_t
+ **/
+typedef struct xcb_glx_get_tex_envfv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_tex_envfv_cookie_t;
+
+/** Opcode for xcb_glx_get_tex_envfv. */
+#define XCB_GLX_GET_TEX_ENVFV 130
+
+/**
+ * @brief xcb_glx_get_tex_envfv_request_t
+ **/
+typedef struct xcb_glx_get_tex_envfv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              pname;
+} xcb_glx_get_tex_envfv_request_t;
+
+/**
+ * @brief xcb_glx_get_tex_envfv_reply_t
+ **/
+typedef struct xcb_glx_get_tex_envfv_reply_t {
+    uint8_t           response_type;
+    uint8_t           pad0;
+    uint16_t          sequence;
+    uint32_t          length;
+    uint8_t           pad1[4];
+    uint32_t          n;
+    xcb_glx_float32_t datum;
+    uint8_t           pad2[12];
+} xcb_glx_get_tex_envfv_reply_t;
+
+/**
+ * @brief xcb_glx_get_tex_enviv_cookie_t
+ **/
+typedef struct xcb_glx_get_tex_enviv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_tex_enviv_cookie_t;
+
+/** Opcode for xcb_glx_get_tex_enviv. */
+#define XCB_GLX_GET_TEX_ENVIV 131
+
+/**
+ * @brief xcb_glx_get_tex_enviv_request_t
+ **/
+typedef struct xcb_glx_get_tex_enviv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              pname;
+} xcb_glx_get_tex_enviv_request_t;
+
+/**
+ * @brief xcb_glx_get_tex_enviv_reply_t
+ **/
+typedef struct xcb_glx_get_tex_enviv_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t n;
+    int32_t  datum;
+    uint8_t  pad2[12];
+} xcb_glx_get_tex_enviv_reply_t;
+
+/**
+ * @brief xcb_glx_get_tex_gendv_cookie_t
+ **/
+typedef struct xcb_glx_get_tex_gendv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_tex_gendv_cookie_t;
+
+/** Opcode for xcb_glx_get_tex_gendv. */
+#define XCB_GLX_GET_TEX_GENDV 132
+
+/**
+ * @brief xcb_glx_get_tex_gendv_request_t
+ **/
+typedef struct xcb_glx_get_tex_gendv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              coord;
+    uint32_t              pname;
+} xcb_glx_get_tex_gendv_request_t;
+
+/**
+ * @brief xcb_glx_get_tex_gendv_reply_t
+ **/
+typedef struct xcb_glx_get_tex_gendv_reply_t {
+    uint8_t           response_type;
+    uint8_t           pad0;
+    uint16_t          sequence;
+    uint32_t          length;
+    uint8_t           pad1[4];
+    uint32_t          n;
+    xcb_glx_float64_t datum;
+    uint8_t           pad2[8];
+} xcb_glx_get_tex_gendv_reply_t;
+
+/**
+ * @brief xcb_glx_get_tex_genfv_cookie_t
+ **/
+typedef struct xcb_glx_get_tex_genfv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_tex_genfv_cookie_t;
+
+/** Opcode for xcb_glx_get_tex_genfv. */
+#define XCB_GLX_GET_TEX_GENFV 133
+
+/**
+ * @brief xcb_glx_get_tex_genfv_request_t
+ **/
+typedef struct xcb_glx_get_tex_genfv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              coord;
+    uint32_t              pname;
+} xcb_glx_get_tex_genfv_request_t;
+
+/**
+ * @brief xcb_glx_get_tex_genfv_reply_t
+ **/
+typedef struct xcb_glx_get_tex_genfv_reply_t {
+    uint8_t           response_type;
+    uint8_t           pad0;
+    uint16_t          sequence;
+    uint32_t          length;
+    uint8_t           pad1[4];
+    uint32_t          n;
+    xcb_glx_float32_t datum;
+    uint8_t           pad2[12];
+} xcb_glx_get_tex_genfv_reply_t;
+
+/**
+ * @brief xcb_glx_get_tex_geniv_cookie_t
+ **/
+typedef struct xcb_glx_get_tex_geniv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_tex_geniv_cookie_t;
+
+/** Opcode for xcb_glx_get_tex_geniv. */
+#define XCB_GLX_GET_TEX_GENIV 134
+
+/**
+ * @brief xcb_glx_get_tex_geniv_request_t
+ **/
+typedef struct xcb_glx_get_tex_geniv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              coord;
+    uint32_t              pname;
+} xcb_glx_get_tex_geniv_request_t;
+
+/**
+ * @brief xcb_glx_get_tex_geniv_reply_t
+ **/
+typedef struct xcb_glx_get_tex_geniv_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t n;
+    int32_t  datum;
+    uint8_t  pad2[12];
+} xcb_glx_get_tex_geniv_reply_t;
+
+/**
+ * @brief xcb_glx_get_tex_image_cookie_t
+ **/
+typedef struct xcb_glx_get_tex_image_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_tex_image_cookie_t;
+
+/** Opcode for xcb_glx_get_tex_image. */
+#define XCB_GLX_GET_TEX_IMAGE 135
+
+/**
+ * @brief xcb_glx_get_tex_image_request_t
+ **/
+typedef struct xcb_glx_get_tex_image_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    int32_t               level;
+    uint32_t              format;
+    uint32_t              type;
+    uint8_t               swap_bytes;
+} xcb_glx_get_tex_image_request_t;
+
+/**
+ * @brief xcb_glx_get_tex_image_reply_t
+ **/
+typedef struct xcb_glx_get_tex_image_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[8];
+    int32_t  width;
+    int32_t  height;
+    int32_t  depth;
+    uint8_t  pad2[4];
+} xcb_glx_get_tex_image_reply_t;
+
+/**
+ * @brief xcb_glx_get_tex_parameterfv_cookie_t
+ **/
+typedef struct xcb_glx_get_tex_parameterfv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_tex_parameterfv_cookie_t;
+
+/** Opcode for xcb_glx_get_tex_parameterfv. */
+#define XCB_GLX_GET_TEX_PARAMETERFV 136
+
+/**
+ * @brief xcb_glx_get_tex_parameterfv_request_t
+ **/
+typedef struct xcb_glx_get_tex_parameterfv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              pname;
+} xcb_glx_get_tex_parameterfv_request_t;
+
+/**
+ * @brief xcb_glx_get_tex_parameterfv_reply_t
+ **/
+typedef struct xcb_glx_get_tex_parameterfv_reply_t {
+    uint8_t           response_type;
+    uint8_t           pad0;
+    uint16_t          sequence;
+    uint32_t          length;
+    uint8_t           pad1[4];
+    uint32_t          n;
+    xcb_glx_float32_t datum;
+    uint8_t           pad2[12];
+} xcb_glx_get_tex_parameterfv_reply_t;
+
+/**
+ * @brief xcb_glx_get_tex_parameteriv_cookie_t
+ **/
+typedef struct xcb_glx_get_tex_parameteriv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_tex_parameteriv_cookie_t;
+
+/** Opcode for xcb_glx_get_tex_parameteriv. */
+#define XCB_GLX_GET_TEX_PARAMETERIV 137
+
+/**
+ * @brief xcb_glx_get_tex_parameteriv_request_t
+ **/
+typedef struct xcb_glx_get_tex_parameteriv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              pname;
+} xcb_glx_get_tex_parameteriv_request_t;
+
+/**
+ * @brief xcb_glx_get_tex_parameteriv_reply_t
+ **/
+typedef struct xcb_glx_get_tex_parameteriv_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t n;
+    int32_t  datum;
+    uint8_t  pad2[12];
+} xcb_glx_get_tex_parameteriv_reply_t;
+
+/**
+ * @brief xcb_glx_get_tex_level_parameterfv_cookie_t
+ **/
+typedef struct xcb_glx_get_tex_level_parameterfv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_tex_level_parameterfv_cookie_t;
+
+/** Opcode for xcb_glx_get_tex_level_parameterfv. */
+#define XCB_GLX_GET_TEX_LEVEL_PARAMETERFV 138
+
+/**
+ * @brief xcb_glx_get_tex_level_parameterfv_request_t
+ **/
+typedef struct xcb_glx_get_tex_level_parameterfv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    int32_t               level;
+    uint32_t              pname;
+} xcb_glx_get_tex_level_parameterfv_request_t;
+
+/**
+ * @brief xcb_glx_get_tex_level_parameterfv_reply_t
+ **/
+typedef struct xcb_glx_get_tex_level_parameterfv_reply_t {
+    uint8_t           response_type;
+    uint8_t           pad0;
+    uint16_t          sequence;
+    uint32_t          length;
+    uint8_t           pad1[4];
+    uint32_t          n;
+    xcb_glx_float32_t datum;
+    uint8_t           pad2[12];
+} xcb_glx_get_tex_level_parameterfv_reply_t;
+
+/**
+ * @brief xcb_glx_get_tex_level_parameteriv_cookie_t
+ **/
+typedef struct xcb_glx_get_tex_level_parameteriv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_tex_level_parameteriv_cookie_t;
+
+/** Opcode for xcb_glx_get_tex_level_parameteriv. */
+#define XCB_GLX_GET_TEX_LEVEL_PARAMETERIV 139
+
+/**
+ * @brief xcb_glx_get_tex_level_parameteriv_request_t
+ **/
+typedef struct xcb_glx_get_tex_level_parameteriv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    int32_t               level;
+    uint32_t              pname;
+} xcb_glx_get_tex_level_parameteriv_request_t;
+
+/**
+ * @brief xcb_glx_get_tex_level_parameteriv_reply_t
+ **/
+typedef struct xcb_glx_get_tex_level_parameteriv_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t n;
+    int32_t  datum;
+    uint8_t  pad2[12];
+} xcb_glx_get_tex_level_parameteriv_reply_t;
+
+/**
+ * @brief xcb_glx_is_enabled_cookie_t
+ **/
+typedef struct xcb_glx_is_enabled_cookie_t {
+    unsigned int sequence;
+} xcb_glx_is_enabled_cookie_t;
+
+/** Opcode for xcb_glx_is_enabled. */
+#define XCB_GLX_IS_ENABLED 140
+
+/**
+ * @brief xcb_glx_is_enabled_request_t
+ **/
+typedef struct xcb_glx_is_enabled_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              capability;
+} xcb_glx_is_enabled_request_t;
+
+/**
+ * @brief xcb_glx_is_enabled_reply_t
+ **/
+typedef struct xcb_glx_is_enabled_reply_t {
+    uint8_t          response_type;
+    uint8_t          pad0;
+    uint16_t         sequence;
+    uint32_t         length;
+    xcb_glx_bool32_t ret_val;
+} xcb_glx_is_enabled_reply_t;
+
+/**
+ * @brief xcb_glx_is_list_cookie_t
+ **/
+typedef struct xcb_glx_is_list_cookie_t {
+    unsigned int sequence;
+} xcb_glx_is_list_cookie_t;
+
+/** Opcode for xcb_glx_is_list. */
+#define XCB_GLX_IS_LIST 141
+
+/**
+ * @brief xcb_glx_is_list_request_t
+ **/
+typedef struct xcb_glx_is_list_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              list;
+} xcb_glx_is_list_request_t;
+
+/**
+ * @brief xcb_glx_is_list_reply_t
+ **/
+typedef struct xcb_glx_is_list_reply_t {
+    uint8_t          response_type;
+    uint8_t          pad0;
+    uint16_t         sequence;
+    uint32_t         length;
+    xcb_glx_bool32_t ret_val;
+} xcb_glx_is_list_reply_t;
+
+/** Opcode for xcb_glx_flush. */
+#define XCB_GLX_FLUSH 142
+
+/**
+ * @brief xcb_glx_flush_request_t
+ **/
+typedef struct xcb_glx_flush_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+} xcb_glx_flush_request_t;
+
+/**
+ * @brief xcb_glx_are_textures_resident_cookie_t
+ **/
+typedef struct xcb_glx_are_textures_resident_cookie_t {
+    unsigned int sequence;
+} xcb_glx_are_textures_resident_cookie_t;
+
+/** Opcode for xcb_glx_are_textures_resident. */
+#define XCB_GLX_ARE_TEXTURES_RESIDENT 143
+
+/**
+ * @brief xcb_glx_are_textures_resident_request_t
+ **/
+typedef struct xcb_glx_are_textures_resident_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    int32_t               n;
+} xcb_glx_are_textures_resident_request_t;
+
+/**
+ * @brief xcb_glx_are_textures_resident_reply_t
+ **/
+typedef struct xcb_glx_are_textures_resident_reply_t {
+    uint8_t          response_type;
+    uint8_t          pad0;
+    uint16_t         sequence;
+    uint32_t         length;
+    xcb_glx_bool32_t ret_val;
+    uint8_t          pad1[20];
+} xcb_glx_are_textures_resident_reply_t;
+
+/** Opcode for xcb_glx_delete_textures. */
+#define XCB_GLX_DELETE_TEXTURES 144
+
+/**
+ * @brief xcb_glx_delete_textures_request_t
+ **/
+typedef struct xcb_glx_delete_textures_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    int32_t               n;
+} xcb_glx_delete_textures_request_t;
+
+/**
+ * @brief xcb_glx_gen_textures_cookie_t
+ **/
+typedef struct xcb_glx_gen_textures_cookie_t {
+    unsigned int sequence;
+} xcb_glx_gen_textures_cookie_t;
+
+/** Opcode for xcb_glx_gen_textures. */
+#define XCB_GLX_GEN_TEXTURES 145
+
+/**
+ * @brief xcb_glx_gen_textures_request_t
+ **/
+typedef struct xcb_glx_gen_textures_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    int32_t               n;
+} xcb_glx_gen_textures_request_t;
+
+/**
+ * @brief xcb_glx_gen_textures_reply_t
+ **/
+typedef struct xcb_glx_gen_textures_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[24];
+} xcb_glx_gen_textures_reply_t;
+
+/**
+ * @brief xcb_glx_is_texture_cookie_t
+ **/
+typedef struct xcb_glx_is_texture_cookie_t {
+    unsigned int sequence;
+} xcb_glx_is_texture_cookie_t;
+
+/** Opcode for xcb_glx_is_texture. */
+#define XCB_GLX_IS_TEXTURE 146
+
+/**
+ * @brief xcb_glx_is_texture_request_t
+ **/
+typedef struct xcb_glx_is_texture_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              texture;
+} xcb_glx_is_texture_request_t;
+
+/**
+ * @brief xcb_glx_is_texture_reply_t
+ **/
+typedef struct xcb_glx_is_texture_reply_t {
+    uint8_t          response_type;
+    uint8_t          pad0;
+    uint16_t         sequence;
+    uint32_t         length;
+    xcb_glx_bool32_t ret_val;
+} xcb_glx_is_texture_reply_t;
+
+/**
+ * @brief xcb_glx_get_color_table_cookie_t
+ **/
+typedef struct xcb_glx_get_color_table_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_color_table_cookie_t;
+
+/** Opcode for xcb_glx_get_color_table. */
+#define XCB_GLX_GET_COLOR_TABLE 147
+
+/**
+ * @brief xcb_glx_get_color_table_request_t
+ **/
+typedef struct xcb_glx_get_color_table_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              format;
+    uint32_t              type;
+    uint8_t               swap_bytes;
+} xcb_glx_get_color_table_request_t;
+
+/**
+ * @brief xcb_glx_get_color_table_reply_t
+ **/
+typedef struct xcb_glx_get_color_table_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[8];
+    int32_t  width;
+    uint8_t  pad2[12];
+} xcb_glx_get_color_table_reply_t;
+
+/**
+ * @brief xcb_glx_get_color_table_parameterfv_cookie_t
+ **/
+typedef struct xcb_glx_get_color_table_parameterfv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_color_table_parameterfv_cookie_t;
+
+/** Opcode for xcb_glx_get_color_table_parameterfv. */
+#define XCB_GLX_GET_COLOR_TABLE_PARAMETERFV 148
+
+/**
+ * @brief xcb_glx_get_color_table_parameterfv_request_t
+ **/
+typedef struct xcb_glx_get_color_table_parameterfv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              pname;
+} xcb_glx_get_color_table_parameterfv_request_t;
+
+/**
+ * @brief xcb_glx_get_color_table_parameterfv_reply_t
+ **/
+typedef struct xcb_glx_get_color_table_parameterfv_reply_t {
+    uint8_t           response_type;
+    uint8_t           pad0;
+    uint16_t          sequence;
+    uint32_t          length;
+    uint8_t           pad1[4];
+    uint32_t          n;
+    xcb_glx_float32_t datum;
+    uint8_t           pad2[12];
+} xcb_glx_get_color_table_parameterfv_reply_t;
+
+/**
+ * @brief xcb_glx_get_color_table_parameteriv_cookie_t
+ **/
+typedef struct xcb_glx_get_color_table_parameteriv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_color_table_parameteriv_cookie_t;
+
+/** Opcode for xcb_glx_get_color_table_parameteriv. */
+#define XCB_GLX_GET_COLOR_TABLE_PARAMETERIV 149
+
+/**
+ * @brief xcb_glx_get_color_table_parameteriv_request_t
+ **/
+typedef struct xcb_glx_get_color_table_parameteriv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              pname;
+} xcb_glx_get_color_table_parameteriv_request_t;
+
+/**
+ * @brief xcb_glx_get_color_table_parameteriv_reply_t
+ **/
+typedef struct xcb_glx_get_color_table_parameteriv_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t n;
+    int32_t  datum;
+    uint8_t  pad2[12];
+} xcb_glx_get_color_table_parameteriv_reply_t;
+
+/**
+ * @brief xcb_glx_get_convolution_filter_cookie_t
+ **/
+typedef struct xcb_glx_get_convolution_filter_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_convolution_filter_cookie_t;
+
+/** Opcode for xcb_glx_get_convolution_filter. */
+#define XCB_GLX_GET_CONVOLUTION_FILTER 150
+
+/**
+ * @brief xcb_glx_get_convolution_filter_request_t
+ **/
+typedef struct xcb_glx_get_convolution_filter_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              format;
+    uint32_t              type;
+    uint8_t               swap_bytes;
+} xcb_glx_get_convolution_filter_request_t;
+
+/**
+ * @brief xcb_glx_get_convolution_filter_reply_t
+ **/
+typedef struct xcb_glx_get_convolution_filter_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[8];
+    int32_t  width;
+    int32_t  height;
+    uint8_t  pad2[8];
+} xcb_glx_get_convolution_filter_reply_t;
+
+/**
+ * @brief xcb_glx_get_convolution_parameterfv_cookie_t
+ **/
+typedef struct xcb_glx_get_convolution_parameterfv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_convolution_parameterfv_cookie_t;
+
+/** Opcode for xcb_glx_get_convolution_parameterfv. */
+#define XCB_GLX_GET_CONVOLUTION_PARAMETERFV 151
+
+/**
+ * @brief xcb_glx_get_convolution_parameterfv_request_t
+ **/
+typedef struct xcb_glx_get_convolution_parameterfv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              pname;
+} xcb_glx_get_convolution_parameterfv_request_t;
+
+/**
+ * @brief xcb_glx_get_convolution_parameterfv_reply_t
+ **/
+typedef struct xcb_glx_get_convolution_parameterfv_reply_t {
+    uint8_t           response_type;
+    uint8_t           pad0;
+    uint16_t          sequence;
+    uint32_t          length;
+    uint8_t           pad1[4];
+    uint32_t          n;
+    xcb_glx_float32_t datum;
+    uint8_t           pad2[12];
+} xcb_glx_get_convolution_parameterfv_reply_t;
+
+/**
+ * @brief xcb_glx_get_convolution_parameteriv_cookie_t
+ **/
+typedef struct xcb_glx_get_convolution_parameteriv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_convolution_parameteriv_cookie_t;
+
+/** Opcode for xcb_glx_get_convolution_parameteriv. */
+#define XCB_GLX_GET_CONVOLUTION_PARAMETERIV 152
+
+/**
+ * @brief xcb_glx_get_convolution_parameteriv_request_t
+ **/
+typedef struct xcb_glx_get_convolution_parameteriv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              pname;
+} xcb_glx_get_convolution_parameteriv_request_t;
+
+/**
+ * @brief xcb_glx_get_convolution_parameteriv_reply_t
+ **/
+typedef struct xcb_glx_get_convolution_parameteriv_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t n;
+    int32_t  datum;
+    uint8_t  pad2[12];
+} xcb_glx_get_convolution_parameteriv_reply_t;
+
+/**
+ * @brief xcb_glx_get_separable_filter_cookie_t
+ **/
+typedef struct xcb_glx_get_separable_filter_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_separable_filter_cookie_t;
+
+/** Opcode for xcb_glx_get_separable_filter. */
+#define XCB_GLX_GET_SEPARABLE_FILTER 153
+
+/**
+ * @brief xcb_glx_get_separable_filter_request_t
+ **/
+typedef struct xcb_glx_get_separable_filter_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              format;
+    uint32_t              type;
+    uint8_t               swap_bytes;
+} xcb_glx_get_separable_filter_request_t;
+
+/**
+ * @brief xcb_glx_get_separable_filter_reply_t
+ **/
+typedef struct xcb_glx_get_separable_filter_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[8];
+    int32_t  row_w;
+    int32_t  col_h;
+    uint8_t  pad2[8];
+} xcb_glx_get_separable_filter_reply_t;
+
+/**
+ * @brief xcb_glx_get_histogram_cookie_t
+ **/
+typedef struct xcb_glx_get_histogram_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_histogram_cookie_t;
+
+/** Opcode for xcb_glx_get_histogram. */
+#define XCB_GLX_GET_HISTOGRAM 154
+
+/**
+ * @brief xcb_glx_get_histogram_request_t
+ **/
+typedef struct xcb_glx_get_histogram_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              format;
+    uint32_t              type;
+    uint8_t               swap_bytes;
+    uint8_t               reset;
+} xcb_glx_get_histogram_request_t;
+
+/**
+ * @brief xcb_glx_get_histogram_reply_t
+ **/
+typedef struct xcb_glx_get_histogram_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[8];
+    int32_t  width;
+    uint8_t  pad2[12];
+} xcb_glx_get_histogram_reply_t;
+
+/**
+ * @brief xcb_glx_get_histogram_parameterfv_cookie_t
+ **/
+typedef struct xcb_glx_get_histogram_parameterfv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_histogram_parameterfv_cookie_t;
+
+/** Opcode for xcb_glx_get_histogram_parameterfv. */
+#define XCB_GLX_GET_HISTOGRAM_PARAMETERFV 155
+
+/**
+ * @brief xcb_glx_get_histogram_parameterfv_request_t
+ **/
+typedef struct xcb_glx_get_histogram_parameterfv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              pname;
+} xcb_glx_get_histogram_parameterfv_request_t;
+
+/**
+ * @brief xcb_glx_get_histogram_parameterfv_reply_t
+ **/
+typedef struct xcb_glx_get_histogram_parameterfv_reply_t {
+    uint8_t           response_type;
+    uint8_t           pad0;
+    uint16_t          sequence;
+    uint32_t          length;
+    uint8_t           pad1[4];
+    uint32_t          n;
+    xcb_glx_float32_t datum;
+    uint8_t           pad2[12];
+} xcb_glx_get_histogram_parameterfv_reply_t;
+
+/**
+ * @brief xcb_glx_get_histogram_parameteriv_cookie_t
+ **/
+typedef struct xcb_glx_get_histogram_parameteriv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_histogram_parameteriv_cookie_t;
+
+/** Opcode for xcb_glx_get_histogram_parameteriv. */
+#define XCB_GLX_GET_HISTOGRAM_PARAMETERIV 156
+
+/**
+ * @brief xcb_glx_get_histogram_parameteriv_request_t
+ **/
+typedef struct xcb_glx_get_histogram_parameteriv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              pname;
+} xcb_glx_get_histogram_parameteriv_request_t;
+
+/**
+ * @brief xcb_glx_get_histogram_parameteriv_reply_t
+ **/
+typedef struct xcb_glx_get_histogram_parameteriv_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t n;
+    int32_t  datum;
+    uint8_t  pad2[12];
+} xcb_glx_get_histogram_parameteriv_reply_t;
+
+/**
+ * @brief xcb_glx_get_minmax_cookie_t
+ **/
+typedef struct xcb_glx_get_minmax_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_minmax_cookie_t;
+
+/** Opcode for xcb_glx_get_minmax. */
+#define XCB_GLX_GET_MINMAX 157
+
+/**
+ * @brief xcb_glx_get_minmax_request_t
+ **/
+typedef struct xcb_glx_get_minmax_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              format;
+    uint32_t              type;
+    uint8_t               swap_bytes;
+    uint8_t               reset;
+} xcb_glx_get_minmax_request_t;
+
+/**
+ * @brief xcb_glx_get_minmax_reply_t
+ **/
+typedef struct xcb_glx_get_minmax_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[24];
+} xcb_glx_get_minmax_reply_t;
+
+/**
+ * @brief xcb_glx_get_minmax_parameterfv_cookie_t
+ **/
+typedef struct xcb_glx_get_minmax_parameterfv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_minmax_parameterfv_cookie_t;
+
+/** Opcode for xcb_glx_get_minmax_parameterfv. */
+#define XCB_GLX_GET_MINMAX_PARAMETERFV 158
+
+/**
+ * @brief xcb_glx_get_minmax_parameterfv_request_t
+ **/
+typedef struct xcb_glx_get_minmax_parameterfv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              pname;
+} xcb_glx_get_minmax_parameterfv_request_t;
+
+/**
+ * @brief xcb_glx_get_minmax_parameterfv_reply_t
+ **/
+typedef struct xcb_glx_get_minmax_parameterfv_reply_t {
+    uint8_t           response_type;
+    uint8_t           pad0;
+    uint16_t          sequence;
+    uint32_t          length;
+    uint8_t           pad1[4];
+    uint32_t          n;
+    xcb_glx_float32_t datum;
+    uint8_t           pad2[12];
+} xcb_glx_get_minmax_parameterfv_reply_t;
+
+/**
+ * @brief xcb_glx_get_minmax_parameteriv_cookie_t
+ **/
+typedef struct xcb_glx_get_minmax_parameteriv_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_minmax_parameteriv_cookie_t;
+
+/** Opcode for xcb_glx_get_minmax_parameteriv. */
+#define XCB_GLX_GET_MINMAX_PARAMETERIV 159
+
+/**
+ * @brief xcb_glx_get_minmax_parameteriv_request_t
+ **/
+typedef struct xcb_glx_get_minmax_parameteriv_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              pname;
+} xcb_glx_get_minmax_parameteriv_request_t;
+
+/**
+ * @brief xcb_glx_get_minmax_parameteriv_reply_t
+ **/
+typedef struct xcb_glx_get_minmax_parameteriv_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t n;
+    int32_t  datum;
+    uint8_t  pad2[12];
+} xcb_glx_get_minmax_parameteriv_reply_t;
+
+/**
+ * @brief xcb_glx_get_compressed_tex_image_arb_cookie_t
+ **/
+typedef struct xcb_glx_get_compressed_tex_image_arb_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_compressed_tex_image_arb_cookie_t;
+
+/** Opcode for xcb_glx_get_compressed_tex_image_arb. */
+#define XCB_GLX_GET_COMPRESSED_TEX_IMAGE_ARB 160
+
+/**
+ * @brief xcb_glx_get_compressed_tex_image_arb_request_t
+ **/
+typedef struct xcb_glx_get_compressed_tex_image_arb_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    int32_t               level;
+} xcb_glx_get_compressed_tex_image_arb_request_t;
+
+/**
+ * @brief xcb_glx_get_compressed_tex_image_arb_reply_t
+ **/
+typedef struct xcb_glx_get_compressed_tex_image_arb_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[8];
+    int32_t  size;
+    uint8_t  pad2[12];
+} xcb_glx_get_compressed_tex_image_arb_reply_t;
+
+/** Opcode for xcb_glx_delete_queries_arb. */
+#define XCB_GLX_DELETE_QUERIES_ARB 161
+
+/**
+ * @brief xcb_glx_delete_queries_arb_request_t
+ **/
+typedef struct xcb_glx_delete_queries_arb_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    int32_t               n;
+} xcb_glx_delete_queries_arb_request_t;
+
+/**
+ * @brief xcb_glx_gen_queries_arb_cookie_t
+ **/
+typedef struct xcb_glx_gen_queries_arb_cookie_t {
+    unsigned int sequence;
+} xcb_glx_gen_queries_arb_cookie_t;
+
+/** Opcode for xcb_glx_gen_queries_arb. */
+#define XCB_GLX_GEN_QUERIES_ARB 162
+
+/**
+ * @brief xcb_glx_gen_queries_arb_request_t
+ **/
+typedef struct xcb_glx_gen_queries_arb_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    int32_t               n;
+} xcb_glx_gen_queries_arb_request_t;
+
+/**
+ * @brief xcb_glx_gen_queries_arb_reply_t
+ **/
+typedef struct xcb_glx_gen_queries_arb_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[24];
+} xcb_glx_gen_queries_arb_reply_t;
+
+/**
+ * @brief xcb_glx_is_query_arb_cookie_t
+ **/
+typedef struct xcb_glx_is_query_arb_cookie_t {
+    unsigned int sequence;
+} xcb_glx_is_query_arb_cookie_t;
+
+/** Opcode for xcb_glx_is_query_arb. */
+#define XCB_GLX_IS_QUERY_ARB 163
+
+/**
+ * @brief xcb_glx_is_query_arb_request_t
+ **/
+typedef struct xcb_glx_is_query_arb_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              id;
+} xcb_glx_is_query_arb_request_t;
+
+/**
+ * @brief xcb_glx_is_query_arb_reply_t
+ **/
+typedef struct xcb_glx_is_query_arb_reply_t {
+    uint8_t          response_type;
+    uint8_t          pad0;
+    uint16_t         sequence;
+    uint32_t         length;
+    xcb_glx_bool32_t ret_val;
+} xcb_glx_is_query_arb_reply_t;
+
+/**
+ * @brief xcb_glx_get_queryiv_arb_cookie_t
+ **/
+typedef struct xcb_glx_get_queryiv_arb_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_queryiv_arb_cookie_t;
+
+/** Opcode for xcb_glx_get_queryiv_arb. */
+#define XCB_GLX_GET_QUERYIV_ARB 164
+
+/**
+ * @brief xcb_glx_get_queryiv_arb_request_t
+ **/
+typedef struct xcb_glx_get_queryiv_arb_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              target;
+    uint32_t              pname;
+} xcb_glx_get_queryiv_arb_request_t;
+
+/**
+ * @brief xcb_glx_get_queryiv_arb_reply_t
+ **/
+typedef struct xcb_glx_get_queryiv_arb_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t n;
+    int32_t  datum;
+    uint8_t  pad2[12];
+} xcb_glx_get_queryiv_arb_reply_t;
+
+/**
+ * @brief xcb_glx_get_query_objectiv_arb_cookie_t
+ **/
+typedef struct xcb_glx_get_query_objectiv_arb_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_query_objectiv_arb_cookie_t;
+
+/** Opcode for xcb_glx_get_query_objectiv_arb. */
+#define XCB_GLX_GET_QUERY_OBJECTIV_ARB 165
+
+/**
+ * @brief xcb_glx_get_query_objectiv_arb_request_t
+ **/
+typedef struct xcb_glx_get_query_objectiv_arb_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              id;
+    uint32_t              pname;
+} xcb_glx_get_query_objectiv_arb_request_t;
+
+/**
+ * @brief xcb_glx_get_query_objectiv_arb_reply_t
+ **/
+typedef struct xcb_glx_get_query_objectiv_arb_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t n;
+    int32_t  datum;
+    uint8_t  pad2[12];
+} xcb_glx_get_query_objectiv_arb_reply_t;
+
+/**
+ * @brief xcb_glx_get_query_objectuiv_arb_cookie_t
+ **/
+typedef struct xcb_glx_get_query_objectuiv_arb_cookie_t {
+    unsigned int sequence;
+} xcb_glx_get_query_objectuiv_arb_cookie_t;
+
+/** Opcode for xcb_glx_get_query_objectuiv_arb. */
+#define XCB_GLX_GET_QUERY_OBJECTUIV_ARB 166
+
+/**
+ * @brief xcb_glx_get_query_objectuiv_arb_request_t
+ **/
+typedef struct xcb_glx_get_query_objectuiv_arb_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_glx_context_tag_t context_tag;
+    uint32_t              id;
+    uint32_t              pname;
+} xcb_glx_get_query_objectuiv_arb_request_t;
+
+/**
+ * @brief xcb_glx_get_query_objectuiv_arb_reply_t
+ **/
+typedef struct xcb_glx_get_query_objectuiv_arb_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[4];
+    uint32_t n;
+    uint32_t datum;
+    uint8_t  pad2[12];
+} xcb_glx_get_query_objectuiv_arb_reply_t;
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_glx_pixmap_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_glx_pixmap_t)
+ */
+void
+xcb_glx_pixmap_next (xcb_glx_pixmap_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_glx_pixmap_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_glx_pixmap_end (xcb_glx_pixmap_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_glx_context_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_glx_context_t)
+ */
+void
+xcb_glx_context_next (xcb_glx_context_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_glx_context_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_glx_context_end (xcb_glx_context_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_glx_pbuffer_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_glx_pbuffer_t)
+ */
+void
+xcb_glx_pbuffer_next (xcb_glx_pbuffer_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_glx_pbuffer_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_glx_pbuffer_end (xcb_glx_pbuffer_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_glx_window_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_glx_window_t)
+ */
+void
+xcb_glx_window_next (xcb_glx_window_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_glx_window_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_glx_window_end (xcb_glx_window_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_glx_fbconfig_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_glx_fbconfig_t)
+ */
+void
+xcb_glx_fbconfig_next (xcb_glx_fbconfig_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_glx_fbconfig_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_glx_fbconfig_end (xcb_glx_fbconfig_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_glx_drawable_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_glx_drawable_t)
+ */
+void
+xcb_glx_drawable_next (xcb_glx_drawable_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_glx_drawable_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_glx_drawable_end (xcb_glx_drawable_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_glx_float32_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_glx_float32_t)
+ */
+void
+xcb_glx_float32_next (xcb_glx_float32_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_glx_float32_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_glx_float32_end (xcb_glx_float32_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_glx_float64_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_glx_float64_t)
+ */
+void
+xcb_glx_float64_next (xcb_glx_float64_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_glx_float64_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_glx_float64_end (xcb_glx_float64_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_glx_bool32_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_glx_bool32_t)
+ */
+void
+xcb_glx_bool32_next (xcb_glx_bool32_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_glx_bool32_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_glx_bool32_end (xcb_glx_bool32_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_glx_context_tag_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_glx_context_tag_t)
+ */
+void
+xcb_glx_context_tag_next (xcb_glx_context_tag_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_glx_context_tag_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_glx_context_tag_end (xcb_glx_context_tag_iterator_t i);
+
+int
+xcb_glx_render_sizeof (const void  *_buffer,
+                       uint32_t     data_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_render_checked (xcb_connection_t      *c,
+                        xcb_glx_context_tag_t  context_tag,
+                        uint32_t               data_len,
+                        const uint8_t         *data);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_render (xcb_connection_t      *c,
+                xcb_glx_context_tag_t  context_tag,
+                uint32_t               data_len,
+                const uint8_t         *data);
+
+uint8_t *
+xcb_glx_render_data (const xcb_glx_render_request_t *R);
+
+int
+xcb_glx_render_data_length (const xcb_glx_render_request_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_render_data_end (const xcb_glx_render_request_t *R);
+
+int
+xcb_glx_render_large_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_render_large_checked (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              uint16_t               request_num,
+                              uint16_t               request_total,
+                              uint32_t               data_len,
+                              const uint8_t         *data);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_render_large (xcb_connection_t      *c,
+                      xcb_glx_context_tag_t  context_tag,
+                      uint16_t               request_num,
+                      uint16_t               request_total,
+                      uint32_t               data_len,
+                      const uint8_t         *data);
+
+uint8_t *
+xcb_glx_render_large_data (const xcb_glx_render_large_request_t *R);
+
+int
+xcb_glx_render_large_data_length (const xcb_glx_render_large_request_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_render_large_data_end (const xcb_glx_render_large_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_create_context_checked (xcb_connection_t  *c,
+                                xcb_glx_context_t  context,
+                                xcb_visualid_t     visual,
+                                uint32_t           screen,
+                                xcb_glx_context_t  share_list,
+                                uint8_t            is_direct);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_create_context (xcb_connection_t  *c,
+                        xcb_glx_context_t  context,
+                        xcb_visualid_t     visual,
+                        uint32_t           screen,
+                        xcb_glx_context_t  share_list,
+                        uint8_t            is_direct);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_destroy_context_checked (xcb_connection_t  *c,
+                                 xcb_glx_context_t  context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_destroy_context (xcb_connection_t  *c,
+                         xcb_glx_context_t  context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_make_current_cookie_t
+xcb_glx_make_current (xcb_connection_t      *c,
+                      xcb_glx_drawable_t     drawable,
+                      xcb_glx_context_t      context,
+                      xcb_glx_context_tag_t  old_context_tag);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_make_current_cookie_t
+xcb_glx_make_current_unchecked (xcb_connection_t      *c,
+                                xcb_glx_drawable_t     drawable,
+                                xcb_glx_context_t      context,
+                                xcb_glx_context_tag_t  old_context_tag);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_make_current_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_make_current_reply_t *
+xcb_glx_make_current_reply (xcb_connection_t               *c,
+                            xcb_glx_make_current_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_is_direct_cookie_t
+xcb_glx_is_direct (xcb_connection_t  *c,
+                   xcb_glx_context_t  context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_is_direct_cookie_t
+xcb_glx_is_direct_unchecked (xcb_connection_t  *c,
+                             xcb_glx_context_t  context);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_is_direct_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_is_direct_reply_t *
+xcb_glx_is_direct_reply (xcb_connection_t            *c,
+                         xcb_glx_is_direct_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_query_version_cookie_t
+xcb_glx_query_version (xcb_connection_t *c,
+                       uint32_t          major_version,
+                       uint32_t          minor_version);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_query_version_cookie_t
+xcb_glx_query_version_unchecked (xcb_connection_t *c,
+                                 uint32_t          major_version,
+                                 uint32_t          minor_version);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_query_version_reply_t *
+xcb_glx_query_version_reply (xcb_connection_t                *c,
+                             xcb_glx_query_version_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_wait_gl_checked (xcb_connection_t      *c,
+                         xcb_glx_context_tag_t  context_tag);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_wait_gl (xcb_connection_t      *c,
+                 xcb_glx_context_tag_t  context_tag);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_wait_x_checked (xcb_connection_t      *c,
+                        xcb_glx_context_tag_t  context_tag);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_wait_x (xcb_connection_t      *c,
+                xcb_glx_context_tag_t  context_tag);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_copy_context_checked (xcb_connection_t      *c,
+                              xcb_glx_context_t      src,
+                              xcb_glx_context_t      dest,
+                              uint32_t               mask,
+                              xcb_glx_context_tag_t  src_context_tag);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_copy_context (xcb_connection_t      *c,
+                      xcb_glx_context_t      src,
+                      xcb_glx_context_t      dest,
+                      uint32_t               mask,
+                      xcb_glx_context_tag_t  src_context_tag);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_swap_buffers_checked (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              xcb_glx_drawable_t     drawable);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_swap_buffers (xcb_connection_t      *c,
+                      xcb_glx_context_tag_t  context_tag,
+                      xcb_glx_drawable_t     drawable);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_use_x_font_checked (xcb_connection_t      *c,
+                            xcb_glx_context_tag_t  context_tag,
+                            xcb_font_t             font,
+                            uint32_t               first,
+                            uint32_t               count,
+                            uint32_t               list_base);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_use_x_font (xcb_connection_t      *c,
+                    xcb_glx_context_tag_t  context_tag,
+                    xcb_font_t             font,
+                    uint32_t               first,
+                    uint32_t               count,
+                    uint32_t               list_base);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_create_glx_pixmap_checked (xcb_connection_t *c,
+                                   uint32_t          screen,
+                                   xcb_visualid_t    visual,
+                                   xcb_pixmap_t      pixmap,
+                                   xcb_glx_pixmap_t  glx_pixmap);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_create_glx_pixmap (xcb_connection_t *c,
+                           uint32_t          screen,
+                           xcb_visualid_t    visual,
+                           xcb_pixmap_t      pixmap,
+                           xcb_glx_pixmap_t  glx_pixmap);
+
+int
+xcb_glx_get_visual_configs_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_visual_configs_cookie_t
+xcb_glx_get_visual_configs (xcb_connection_t *c,
+                            uint32_t          screen);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_visual_configs_cookie_t
+xcb_glx_get_visual_configs_unchecked (xcb_connection_t *c,
+                                      uint32_t          screen);
+
+uint32_t *
+xcb_glx_get_visual_configs_property_list (const xcb_glx_get_visual_configs_reply_t *R);
+
+int
+xcb_glx_get_visual_configs_property_list_length (const xcb_glx_get_visual_configs_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_visual_configs_property_list_end (const xcb_glx_get_visual_configs_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_visual_configs_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_visual_configs_reply_t *
+xcb_glx_get_visual_configs_reply (xcb_connection_t                     *c,
+                                  xcb_glx_get_visual_configs_cookie_t   cookie  /**< */,
+                                  xcb_generic_error_t                 **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_destroy_glx_pixmap_checked (xcb_connection_t *c,
+                                    xcb_glx_pixmap_t  glx_pixmap);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_destroy_glx_pixmap (xcb_connection_t *c,
+                            xcb_glx_pixmap_t  glx_pixmap);
+
+int
+xcb_glx_vendor_private_sizeof (const void  *_buffer,
+                               uint32_t     data_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_vendor_private_checked (xcb_connection_t      *c,
+                                uint32_t               vendor_code,
+                                xcb_glx_context_tag_t  context_tag,
+                                uint32_t               data_len,
+                                const uint8_t         *data);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_vendor_private (xcb_connection_t      *c,
+                        uint32_t               vendor_code,
+                        xcb_glx_context_tag_t  context_tag,
+                        uint32_t               data_len,
+                        const uint8_t         *data);
+
+uint8_t *
+xcb_glx_vendor_private_data (const xcb_glx_vendor_private_request_t *R);
+
+int
+xcb_glx_vendor_private_data_length (const xcb_glx_vendor_private_request_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_vendor_private_data_end (const xcb_glx_vendor_private_request_t *R);
+
+int
+xcb_glx_vendor_private_with_reply_sizeof (const void  *_buffer,
+                                          uint32_t     data_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_vendor_private_with_reply_cookie_t
+xcb_glx_vendor_private_with_reply (xcb_connection_t      *c,
+                                   uint32_t               vendor_code,
+                                   xcb_glx_context_tag_t  context_tag,
+                                   uint32_t               data_len,
+                                   const uint8_t         *data);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_vendor_private_with_reply_cookie_t
+xcb_glx_vendor_private_with_reply_unchecked (xcb_connection_t      *c,
+                                             uint32_t               vendor_code,
+                                             xcb_glx_context_tag_t  context_tag,
+                                             uint32_t               data_len,
+                                             const uint8_t         *data);
+
+uint8_t *
+xcb_glx_vendor_private_with_reply_data_2 (const xcb_glx_vendor_private_with_reply_reply_t *R);
+
+int
+xcb_glx_vendor_private_with_reply_data_2_length (const xcb_glx_vendor_private_with_reply_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_vendor_private_with_reply_data_2_end (const xcb_glx_vendor_private_with_reply_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_vendor_private_with_reply_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_vendor_private_with_reply_reply_t *
+xcb_glx_vendor_private_with_reply_reply (xcb_connection_t                            *c,
+                                         xcb_glx_vendor_private_with_reply_cookie_t   cookie  /**< */,
+                                         xcb_generic_error_t                        **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_query_extensions_string_cookie_t
+xcb_glx_query_extensions_string (xcb_connection_t *c,
+                                 uint32_t          screen);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_query_extensions_string_cookie_t
+xcb_glx_query_extensions_string_unchecked (xcb_connection_t *c,
+                                           uint32_t          screen);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_query_extensions_string_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_query_extensions_string_reply_t *
+xcb_glx_query_extensions_string_reply (xcb_connection_t                          *c,
+                                       xcb_glx_query_extensions_string_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e);
+
+int
+xcb_glx_query_server_string_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_query_server_string_cookie_t
+xcb_glx_query_server_string (xcb_connection_t *c,
+                             uint32_t          screen,
+                             uint32_t          name);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_query_server_string_cookie_t
+xcb_glx_query_server_string_unchecked (xcb_connection_t *c,
+                                       uint32_t          screen,
+                                       uint32_t          name);
+
+char *
+xcb_glx_query_server_string_string (const xcb_glx_query_server_string_reply_t *R);
+
+int
+xcb_glx_query_server_string_string_length (const xcb_glx_query_server_string_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_query_server_string_string_end (const xcb_glx_query_server_string_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_query_server_string_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_query_server_string_reply_t *
+xcb_glx_query_server_string_reply (xcb_connection_t                      *c,
+                                   xcb_glx_query_server_string_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e);
+
+int
+xcb_glx_client_info_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_client_info_checked (xcb_connection_t *c,
+                             uint32_t          major_version,
+                             uint32_t          minor_version,
+                             uint32_t          str_len,
+                             const char       *string);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_client_info (xcb_connection_t *c,
+                     uint32_t          major_version,
+                     uint32_t          minor_version,
+                     uint32_t          str_len,
+                     const char       *string);
+
+char *
+xcb_glx_client_info_string (const xcb_glx_client_info_request_t *R);
+
+int
+xcb_glx_client_info_string_length (const xcb_glx_client_info_request_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_client_info_string_end (const xcb_glx_client_info_request_t *R);
+
+int
+xcb_glx_get_fb_configs_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_fb_configs_cookie_t
+xcb_glx_get_fb_configs (xcb_connection_t *c,
+                        uint32_t          screen);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_fb_configs_cookie_t
+xcb_glx_get_fb_configs_unchecked (xcb_connection_t *c,
+                                  uint32_t          screen);
+
+uint32_t *
+xcb_glx_get_fb_configs_property_list (const xcb_glx_get_fb_configs_reply_t *R);
+
+int
+xcb_glx_get_fb_configs_property_list_length (const xcb_glx_get_fb_configs_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_fb_configs_property_list_end (const xcb_glx_get_fb_configs_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_fb_configs_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_fb_configs_reply_t *
+xcb_glx_get_fb_configs_reply (xcb_connection_t                 *c,
+                              xcb_glx_get_fb_configs_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+int
+xcb_glx_create_pixmap_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_create_pixmap_checked (xcb_connection_t   *c,
+                               uint32_t            screen,
+                               xcb_glx_fbconfig_t  fbconfig,
+                               xcb_pixmap_t        pixmap,
+                               xcb_glx_pixmap_t    glx_pixmap,
+                               uint32_t            num_attribs,
+                               const uint32_t     *attribs);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_create_pixmap (xcb_connection_t   *c,
+                       uint32_t            screen,
+                       xcb_glx_fbconfig_t  fbconfig,
+                       xcb_pixmap_t        pixmap,
+                       xcb_glx_pixmap_t    glx_pixmap,
+                       uint32_t            num_attribs,
+                       const uint32_t     *attribs);
+
+uint32_t *
+xcb_glx_create_pixmap_attribs (const xcb_glx_create_pixmap_request_t *R);
+
+int
+xcb_glx_create_pixmap_attribs_length (const xcb_glx_create_pixmap_request_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_create_pixmap_attribs_end (const xcb_glx_create_pixmap_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_destroy_pixmap_checked (xcb_connection_t *c,
+                                xcb_glx_pixmap_t  glx_pixmap);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_destroy_pixmap (xcb_connection_t *c,
+                        xcb_glx_pixmap_t  glx_pixmap);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_create_new_context_checked (xcb_connection_t   *c,
+                                    xcb_glx_context_t   context,
+                                    xcb_glx_fbconfig_t  fbconfig,
+                                    uint32_t            screen,
+                                    uint32_t            render_type,
+                                    xcb_glx_context_t   share_list,
+                                    uint8_t             is_direct);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_create_new_context (xcb_connection_t   *c,
+                            xcb_glx_context_t   context,
+                            xcb_glx_fbconfig_t  fbconfig,
+                            uint32_t            screen,
+                            uint32_t            render_type,
+                            xcb_glx_context_t   share_list,
+                            uint8_t             is_direct);
+
+int
+xcb_glx_query_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_query_context_cookie_t
+xcb_glx_query_context (xcb_connection_t  *c,
+                       xcb_glx_context_t  context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_query_context_cookie_t
+xcb_glx_query_context_unchecked (xcb_connection_t  *c,
+                                 xcb_glx_context_t  context);
+
+uint32_t *
+xcb_glx_query_context_attribs (const xcb_glx_query_context_reply_t *R);
+
+int
+xcb_glx_query_context_attribs_length (const xcb_glx_query_context_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_query_context_attribs_end (const xcb_glx_query_context_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_query_context_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_query_context_reply_t *
+xcb_glx_query_context_reply (xcb_connection_t                *c,
+                             xcb_glx_query_context_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_make_context_current_cookie_t
+xcb_glx_make_context_current (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  old_context_tag,
+                              xcb_glx_drawable_t     drawable,
+                              xcb_glx_drawable_t     read_drawable,
+                              xcb_glx_context_t      context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_make_context_current_cookie_t
+xcb_glx_make_context_current_unchecked (xcb_connection_t      *c,
+                                        xcb_glx_context_tag_t  old_context_tag,
+                                        xcb_glx_drawable_t     drawable,
+                                        xcb_glx_drawable_t     read_drawable,
+                                        xcb_glx_context_t      context);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_make_context_current_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_make_context_current_reply_t *
+xcb_glx_make_context_current_reply (xcb_connection_t                       *c,
+                                    xcb_glx_make_context_current_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e);
+
+int
+xcb_glx_create_pbuffer_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_create_pbuffer_checked (xcb_connection_t   *c,
+                                uint32_t            screen,
+                                xcb_glx_fbconfig_t  fbconfig,
+                                xcb_glx_pbuffer_t   pbuffer,
+                                uint32_t            num_attribs,
+                                const uint32_t     *attribs);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_create_pbuffer (xcb_connection_t   *c,
+                        uint32_t            screen,
+                        xcb_glx_fbconfig_t  fbconfig,
+                        xcb_glx_pbuffer_t   pbuffer,
+                        uint32_t            num_attribs,
+                        const uint32_t     *attribs);
+
+uint32_t *
+xcb_glx_create_pbuffer_attribs (const xcb_glx_create_pbuffer_request_t *R);
+
+int
+xcb_glx_create_pbuffer_attribs_length (const xcb_glx_create_pbuffer_request_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_create_pbuffer_attribs_end (const xcb_glx_create_pbuffer_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_destroy_pbuffer_checked (xcb_connection_t  *c,
+                                 xcb_glx_pbuffer_t  pbuffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_destroy_pbuffer (xcb_connection_t  *c,
+                         xcb_glx_pbuffer_t  pbuffer);
+
+int
+xcb_glx_get_drawable_attributes_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_drawable_attributes_cookie_t
+xcb_glx_get_drawable_attributes (xcb_connection_t   *c,
+                                 xcb_glx_drawable_t  drawable);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_drawable_attributes_cookie_t
+xcb_glx_get_drawable_attributes_unchecked (xcb_connection_t   *c,
+                                           xcb_glx_drawable_t  drawable);
+
+uint32_t *
+xcb_glx_get_drawable_attributes_attribs (const xcb_glx_get_drawable_attributes_reply_t *R);
+
+int
+xcb_glx_get_drawable_attributes_attribs_length (const xcb_glx_get_drawable_attributes_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_drawable_attributes_attribs_end (const xcb_glx_get_drawable_attributes_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_drawable_attributes_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_drawable_attributes_reply_t *
+xcb_glx_get_drawable_attributes_reply (xcb_connection_t                          *c,
+                                       xcb_glx_get_drawable_attributes_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e);
+
+int
+xcb_glx_change_drawable_attributes_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_change_drawable_attributes_checked (xcb_connection_t   *c,
+                                            xcb_glx_drawable_t  drawable,
+                                            uint32_t            num_attribs,
+                                            const uint32_t     *attribs);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_change_drawable_attributes (xcb_connection_t   *c,
+                                    xcb_glx_drawable_t  drawable,
+                                    uint32_t            num_attribs,
+                                    const uint32_t     *attribs);
+
+uint32_t *
+xcb_glx_change_drawable_attributes_attribs (const xcb_glx_change_drawable_attributes_request_t *R);
+
+int
+xcb_glx_change_drawable_attributes_attribs_length (const xcb_glx_change_drawable_attributes_request_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_change_drawable_attributes_attribs_end (const xcb_glx_change_drawable_attributes_request_t *R);
+
+int
+xcb_glx_create_window_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_create_window_checked (xcb_connection_t   *c,
+                               uint32_t            screen,
+                               xcb_glx_fbconfig_t  fbconfig,
+                               xcb_window_t        window,
+                               xcb_glx_window_t    glx_window,
+                               uint32_t            num_attribs,
+                               const uint32_t     *attribs);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_create_window (xcb_connection_t   *c,
+                       uint32_t            screen,
+                       xcb_glx_fbconfig_t  fbconfig,
+                       xcb_window_t        window,
+                       xcb_glx_window_t    glx_window,
+                       uint32_t            num_attribs,
+                       const uint32_t     *attribs);
+
+uint32_t *
+xcb_glx_create_window_attribs (const xcb_glx_create_window_request_t *R);
+
+int
+xcb_glx_create_window_attribs_length (const xcb_glx_create_window_request_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_create_window_attribs_end (const xcb_glx_create_window_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_delete_window_checked (xcb_connection_t *c,
+                               xcb_glx_window_t  glxwindow);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_delete_window (xcb_connection_t *c,
+                       xcb_glx_window_t  glxwindow);
+
+int
+xcb_glx_set_client_info_arb_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_set_client_info_arb_checked (xcb_connection_t *c,
+                                     uint32_t          major_version,
+                                     uint32_t          minor_version,
+                                     uint32_t          num_versions,
+                                     uint32_t          gl_str_len,
+                                     uint32_t          glx_str_len,
+                                     const uint32_t   *gl_versions,
+                                     const char       *gl_extension_string,
+                                     const char       *glx_extension_string);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_set_client_info_arb (xcb_connection_t *c,
+                             uint32_t          major_version,
+                             uint32_t          minor_version,
+                             uint32_t          num_versions,
+                             uint32_t          gl_str_len,
+                             uint32_t          glx_str_len,
+                             const uint32_t   *gl_versions,
+                             const char       *gl_extension_string,
+                             const char       *glx_extension_string);
+
+uint32_t *
+xcb_glx_set_client_info_arb_gl_versions (const xcb_glx_set_client_info_arb_request_t *R);
+
+int
+xcb_glx_set_client_info_arb_gl_versions_length (const xcb_glx_set_client_info_arb_request_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_set_client_info_arb_gl_versions_end (const xcb_glx_set_client_info_arb_request_t *R);
+
+char *
+xcb_glx_set_client_info_arb_gl_extension_string (const xcb_glx_set_client_info_arb_request_t *R);
+
+int
+xcb_glx_set_client_info_arb_gl_extension_string_length (const xcb_glx_set_client_info_arb_request_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_set_client_info_arb_gl_extension_string_end (const xcb_glx_set_client_info_arb_request_t *R);
+
+char *
+xcb_glx_set_client_info_arb_glx_extension_string (const xcb_glx_set_client_info_arb_request_t *R);
+
+int
+xcb_glx_set_client_info_arb_glx_extension_string_length (const xcb_glx_set_client_info_arb_request_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_set_client_info_arb_glx_extension_string_end (const xcb_glx_set_client_info_arb_request_t *R);
+
+int
+xcb_glx_create_context_attribs_arb_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_create_context_attribs_arb_checked (xcb_connection_t   *c,
+                                            xcb_glx_context_t   context,
+                                            xcb_glx_fbconfig_t  fbconfig,
+                                            uint32_t            screen,
+                                            xcb_glx_context_t   share_list,
+                                            uint8_t             is_direct,
+                                            uint32_t            num_attribs,
+                                            const uint32_t     *attribs);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_create_context_attribs_arb (xcb_connection_t   *c,
+                                    xcb_glx_context_t   context,
+                                    xcb_glx_fbconfig_t  fbconfig,
+                                    uint32_t            screen,
+                                    xcb_glx_context_t   share_list,
+                                    uint8_t             is_direct,
+                                    uint32_t            num_attribs,
+                                    const uint32_t     *attribs);
+
+uint32_t *
+xcb_glx_create_context_attribs_arb_attribs (const xcb_glx_create_context_attribs_arb_request_t *R);
+
+int
+xcb_glx_create_context_attribs_arb_attribs_length (const xcb_glx_create_context_attribs_arb_request_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_create_context_attribs_arb_attribs_end (const xcb_glx_create_context_attribs_arb_request_t *R);
+
+int
+xcb_glx_set_client_info_2arb_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_set_client_info_2arb_checked (xcb_connection_t *c,
+                                      uint32_t          major_version,
+                                      uint32_t          minor_version,
+                                      uint32_t          num_versions,
+                                      uint32_t          gl_str_len,
+                                      uint32_t          glx_str_len,
+                                      const uint32_t   *gl_versions,
+                                      const char       *gl_extension_string,
+                                      const char       *glx_extension_string);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_set_client_info_2arb (xcb_connection_t *c,
+                              uint32_t          major_version,
+                              uint32_t          minor_version,
+                              uint32_t          num_versions,
+                              uint32_t          gl_str_len,
+                              uint32_t          glx_str_len,
+                              const uint32_t   *gl_versions,
+                              const char       *gl_extension_string,
+                              const char       *glx_extension_string);
+
+uint32_t *
+xcb_glx_set_client_info_2arb_gl_versions (const xcb_glx_set_client_info_2arb_request_t *R);
+
+int
+xcb_glx_set_client_info_2arb_gl_versions_length (const xcb_glx_set_client_info_2arb_request_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_set_client_info_2arb_gl_versions_end (const xcb_glx_set_client_info_2arb_request_t *R);
+
+char *
+xcb_glx_set_client_info_2arb_gl_extension_string (const xcb_glx_set_client_info_2arb_request_t *R);
+
+int
+xcb_glx_set_client_info_2arb_gl_extension_string_length (const xcb_glx_set_client_info_2arb_request_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_set_client_info_2arb_gl_extension_string_end (const xcb_glx_set_client_info_2arb_request_t *R);
+
+char *
+xcb_glx_set_client_info_2arb_glx_extension_string (const xcb_glx_set_client_info_2arb_request_t *R);
+
+int
+xcb_glx_set_client_info_2arb_glx_extension_string_length (const xcb_glx_set_client_info_2arb_request_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_set_client_info_2arb_glx_extension_string_end (const xcb_glx_set_client_info_2arb_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_new_list_checked (xcb_connection_t      *c,
+                          xcb_glx_context_tag_t  context_tag,
+                          uint32_t               list,
+                          uint32_t               mode);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_new_list (xcb_connection_t      *c,
+                  xcb_glx_context_tag_t  context_tag,
+                  uint32_t               list,
+                  uint32_t               mode);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_end_list_checked (xcb_connection_t      *c,
+                          xcb_glx_context_tag_t  context_tag);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_end_list (xcb_connection_t      *c,
+                  xcb_glx_context_tag_t  context_tag);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_delete_lists_checked (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              uint32_t               list,
+                              int32_t                range);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_delete_lists (xcb_connection_t      *c,
+                      xcb_glx_context_tag_t  context_tag,
+                      uint32_t               list,
+                      int32_t                range);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_gen_lists_cookie_t
+xcb_glx_gen_lists (xcb_connection_t      *c,
+                   xcb_glx_context_tag_t  context_tag,
+                   int32_t                range);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_gen_lists_cookie_t
+xcb_glx_gen_lists_unchecked (xcb_connection_t      *c,
+                             xcb_glx_context_tag_t  context_tag,
+                             int32_t                range);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_gen_lists_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_gen_lists_reply_t *
+xcb_glx_gen_lists_reply (xcb_connection_t            *c,
+                         xcb_glx_gen_lists_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_feedback_buffer_checked (xcb_connection_t      *c,
+                                 xcb_glx_context_tag_t  context_tag,
+                                 int32_t                size,
+                                 int32_t                type);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_feedback_buffer (xcb_connection_t      *c,
+                         xcb_glx_context_tag_t  context_tag,
+                         int32_t                size,
+                         int32_t                type);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_select_buffer_checked (xcb_connection_t      *c,
+                               xcb_glx_context_tag_t  context_tag,
+                               int32_t                size);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_select_buffer (xcb_connection_t      *c,
+                       xcb_glx_context_tag_t  context_tag,
+                       int32_t                size);
+
+int
+xcb_glx_render_mode_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_render_mode_cookie_t
+xcb_glx_render_mode (xcb_connection_t      *c,
+                     xcb_glx_context_tag_t  context_tag,
+                     uint32_t               mode);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_render_mode_cookie_t
+xcb_glx_render_mode_unchecked (xcb_connection_t      *c,
+                               xcb_glx_context_tag_t  context_tag,
+                               uint32_t               mode);
+
+uint32_t *
+xcb_glx_render_mode_data (const xcb_glx_render_mode_reply_t *R);
+
+int
+xcb_glx_render_mode_data_length (const xcb_glx_render_mode_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_render_mode_data_end (const xcb_glx_render_mode_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_render_mode_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_render_mode_reply_t *
+xcb_glx_render_mode_reply (xcb_connection_t              *c,
+                           xcb_glx_render_mode_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_finish_cookie_t
+xcb_glx_finish (xcb_connection_t      *c,
+                xcb_glx_context_tag_t  context_tag);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_finish_cookie_t
+xcb_glx_finish_unchecked (xcb_connection_t      *c,
+                          xcb_glx_context_tag_t  context_tag);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_finish_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_finish_reply_t *
+xcb_glx_finish_reply (xcb_connection_t         *c,
+                      xcb_glx_finish_cookie_t   cookie  /**< */,
+                      xcb_generic_error_t     **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_pixel_storef_checked (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              uint32_t               pname,
+                              xcb_glx_float32_t      datum);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_pixel_storef (xcb_connection_t      *c,
+                      xcb_glx_context_tag_t  context_tag,
+                      uint32_t               pname,
+                      xcb_glx_float32_t      datum);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_pixel_storei_checked (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              uint32_t               pname,
+                              int32_t                datum);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_pixel_storei (xcb_connection_t      *c,
+                      xcb_glx_context_tag_t  context_tag,
+                      uint32_t               pname,
+                      int32_t                datum);
+
+int
+xcb_glx_read_pixels_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_read_pixels_cookie_t
+xcb_glx_read_pixels (xcb_connection_t      *c,
+                     xcb_glx_context_tag_t  context_tag,
+                     int32_t                x,
+                     int32_t                y,
+                     int32_t                width,
+                     int32_t                height,
+                     uint32_t               format,
+                     uint32_t               type,
+                     uint8_t                swap_bytes,
+                     uint8_t                lsb_first);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_read_pixels_cookie_t
+xcb_glx_read_pixels_unchecked (xcb_connection_t      *c,
+                               xcb_glx_context_tag_t  context_tag,
+                               int32_t                x,
+                               int32_t                y,
+                               int32_t                width,
+                               int32_t                height,
+                               uint32_t               format,
+                               uint32_t               type,
+                               uint8_t                swap_bytes,
+                               uint8_t                lsb_first);
+
+uint8_t *
+xcb_glx_read_pixels_data (const xcb_glx_read_pixels_reply_t *R);
+
+int
+xcb_glx_read_pixels_data_length (const xcb_glx_read_pixels_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_read_pixels_data_end (const xcb_glx_read_pixels_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_read_pixels_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_read_pixels_reply_t *
+xcb_glx_read_pixels_reply (xcb_connection_t              *c,
+                           xcb_glx_read_pixels_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e);
+
+int
+xcb_glx_get_booleanv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_booleanv_cookie_t
+xcb_glx_get_booleanv (xcb_connection_t      *c,
+                      xcb_glx_context_tag_t  context_tag,
+                      int32_t                pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_booleanv_cookie_t
+xcb_glx_get_booleanv_unchecked (xcb_connection_t      *c,
+                                xcb_glx_context_tag_t  context_tag,
+                                int32_t                pname);
+
+uint8_t *
+xcb_glx_get_booleanv_data (const xcb_glx_get_booleanv_reply_t *R);
+
+int
+xcb_glx_get_booleanv_data_length (const xcb_glx_get_booleanv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_booleanv_data_end (const xcb_glx_get_booleanv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_booleanv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_booleanv_reply_t *
+xcb_glx_get_booleanv_reply (xcb_connection_t               *c,
+                            xcb_glx_get_booleanv_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e);
+
+int
+xcb_glx_get_clip_plane_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_clip_plane_cookie_t
+xcb_glx_get_clip_plane (xcb_connection_t      *c,
+                        xcb_glx_context_tag_t  context_tag,
+                        int32_t                plane);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_clip_plane_cookie_t
+xcb_glx_get_clip_plane_unchecked (xcb_connection_t      *c,
+                                  xcb_glx_context_tag_t  context_tag,
+                                  int32_t                plane);
+
+xcb_glx_float64_t *
+xcb_glx_get_clip_plane_data (const xcb_glx_get_clip_plane_reply_t *R);
+
+int
+xcb_glx_get_clip_plane_data_length (const xcb_glx_get_clip_plane_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_clip_plane_data_end (const xcb_glx_get_clip_plane_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_clip_plane_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_clip_plane_reply_t *
+xcb_glx_get_clip_plane_reply (xcb_connection_t                 *c,
+                              xcb_glx_get_clip_plane_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+int
+xcb_glx_get_doublev_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_doublev_cookie_t
+xcb_glx_get_doublev (xcb_connection_t      *c,
+                     xcb_glx_context_tag_t  context_tag,
+                     uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_doublev_cookie_t
+xcb_glx_get_doublev_unchecked (xcb_connection_t      *c,
+                               xcb_glx_context_tag_t  context_tag,
+                               uint32_t               pname);
+
+xcb_glx_float64_t *
+xcb_glx_get_doublev_data (const xcb_glx_get_doublev_reply_t *R);
+
+int
+xcb_glx_get_doublev_data_length (const xcb_glx_get_doublev_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_doublev_data_end (const xcb_glx_get_doublev_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_doublev_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_doublev_reply_t *
+xcb_glx_get_doublev_reply (xcb_connection_t              *c,
+                           xcb_glx_get_doublev_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_error_cookie_t
+xcb_glx_get_error (xcb_connection_t      *c,
+                   xcb_glx_context_tag_t  context_tag);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_error_cookie_t
+xcb_glx_get_error_unchecked (xcb_connection_t      *c,
+                             xcb_glx_context_tag_t  context_tag);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_error_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_error_reply_t *
+xcb_glx_get_error_reply (xcb_connection_t            *c,
+                         xcb_glx_get_error_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e);
+
+int
+xcb_glx_get_floatv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_floatv_cookie_t
+xcb_glx_get_floatv (xcb_connection_t      *c,
+                    xcb_glx_context_tag_t  context_tag,
+                    uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_floatv_cookie_t
+xcb_glx_get_floatv_unchecked (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              uint32_t               pname);
+
+xcb_glx_float32_t *
+xcb_glx_get_floatv_data (const xcb_glx_get_floatv_reply_t *R);
+
+int
+xcb_glx_get_floatv_data_length (const xcb_glx_get_floatv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_floatv_data_end (const xcb_glx_get_floatv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_floatv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_floatv_reply_t *
+xcb_glx_get_floatv_reply (xcb_connection_t             *c,
+                          xcb_glx_get_floatv_cookie_t   cookie  /**< */,
+                          xcb_generic_error_t         **e);
+
+int
+xcb_glx_get_integerv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_integerv_cookie_t
+xcb_glx_get_integerv (xcb_connection_t      *c,
+                      xcb_glx_context_tag_t  context_tag,
+                      uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_integerv_cookie_t
+xcb_glx_get_integerv_unchecked (xcb_connection_t      *c,
+                                xcb_glx_context_tag_t  context_tag,
+                                uint32_t               pname);
+
+int32_t *
+xcb_glx_get_integerv_data (const xcb_glx_get_integerv_reply_t *R);
+
+int
+xcb_glx_get_integerv_data_length (const xcb_glx_get_integerv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_integerv_data_end (const xcb_glx_get_integerv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_integerv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_integerv_reply_t *
+xcb_glx_get_integerv_reply (xcb_connection_t               *c,
+                            xcb_glx_get_integerv_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e);
+
+int
+xcb_glx_get_lightfv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_lightfv_cookie_t
+xcb_glx_get_lightfv (xcb_connection_t      *c,
+                     xcb_glx_context_tag_t  context_tag,
+                     uint32_t               light,
+                     uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_lightfv_cookie_t
+xcb_glx_get_lightfv_unchecked (xcb_connection_t      *c,
+                               xcb_glx_context_tag_t  context_tag,
+                               uint32_t               light,
+                               uint32_t               pname);
+
+xcb_glx_float32_t *
+xcb_glx_get_lightfv_data (const xcb_glx_get_lightfv_reply_t *R);
+
+int
+xcb_glx_get_lightfv_data_length (const xcb_glx_get_lightfv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_lightfv_data_end (const xcb_glx_get_lightfv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_lightfv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_lightfv_reply_t *
+xcb_glx_get_lightfv_reply (xcb_connection_t              *c,
+                           xcb_glx_get_lightfv_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e);
+
+int
+xcb_glx_get_lightiv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_lightiv_cookie_t
+xcb_glx_get_lightiv (xcb_connection_t      *c,
+                     xcb_glx_context_tag_t  context_tag,
+                     uint32_t               light,
+                     uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_lightiv_cookie_t
+xcb_glx_get_lightiv_unchecked (xcb_connection_t      *c,
+                               xcb_glx_context_tag_t  context_tag,
+                               uint32_t               light,
+                               uint32_t               pname);
+
+int32_t *
+xcb_glx_get_lightiv_data (const xcb_glx_get_lightiv_reply_t *R);
+
+int
+xcb_glx_get_lightiv_data_length (const xcb_glx_get_lightiv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_lightiv_data_end (const xcb_glx_get_lightiv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_lightiv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_lightiv_reply_t *
+xcb_glx_get_lightiv_reply (xcb_connection_t              *c,
+                           xcb_glx_get_lightiv_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e);
+
+int
+xcb_glx_get_mapdv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_mapdv_cookie_t
+xcb_glx_get_mapdv (xcb_connection_t      *c,
+                   xcb_glx_context_tag_t  context_tag,
+                   uint32_t               target,
+                   uint32_t               query);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_mapdv_cookie_t
+xcb_glx_get_mapdv_unchecked (xcb_connection_t      *c,
+                             xcb_glx_context_tag_t  context_tag,
+                             uint32_t               target,
+                             uint32_t               query);
+
+xcb_glx_float64_t *
+xcb_glx_get_mapdv_data (const xcb_glx_get_mapdv_reply_t *R);
+
+int
+xcb_glx_get_mapdv_data_length (const xcb_glx_get_mapdv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_mapdv_data_end (const xcb_glx_get_mapdv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_mapdv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_mapdv_reply_t *
+xcb_glx_get_mapdv_reply (xcb_connection_t            *c,
+                         xcb_glx_get_mapdv_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e);
+
+int
+xcb_glx_get_mapfv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_mapfv_cookie_t
+xcb_glx_get_mapfv (xcb_connection_t      *c,
+                   xcb_glx_context_tag_t  context_tag,
+                   uint32_t               target,
+                   uint32_t               query);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_mapfv_cookie_t
+xcb_glx_get_mapfv_unchecked (xcb_connection_t      *c,
+                             xcb_glx_context_tag_t  context_tag,
+                             uint32_t               target,
+                             uint32_t               query);
+
+xcb_glx_float32_t *
+xcb_glx_get_mapfv_data (const xcb_glx_get_mapfv_reply_t *R);
+
+int
+xcb_glx_get_mapfv_data_length (const xcb_glx_get_mapfv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_mapfv_data_end (const xcb_glx_get_mapfv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_mapfv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_mapfv_reply_t *
+xcb_glx_get_mapfv_reply (xcb_connection_t            *c,
+                         xcb_glx_get_mapfv_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e);
+
+int
+xcb_glx_get_mapiv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_mapiv_cookie_t
+xcb_glx_get_mapiv (xcb_connection_t      *c,
+                   xcb_glx_context_tag_t  context_tag,
+                   uint32_t               target,
+                   uint32_t               query);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_mapiv_cookie_t
+xcb_glx_get_mapiv_unchecked (xcb_connection_t      *c,
+                             xcb_glx_context_tag_t  context_tag,
+                             uint32_t               target,
+                             uint32_t               query);
+
+int32_t *
+xcb_glx_get_mapiv_data (const xcb_glx_get_mapiv_reply_t *R);
+
+int
+xcb_glx_get_mapiv_data_length (const xcb_glx_get_mapiv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_mapiv_data_end (const xcb_glx_get_mapiv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_mapiv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_mapiv_reply_t *
+xcb_glx_get_mapiv_reply (xcb_connection_t            *c,
+                         xcb_glx_get_mapiv_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e);
+
+int
+xcb_glx_get_materialfv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_materialfv_cookie_t
+xcb_glx_get_materialfv (xcb_connection_t      *c,
+                        xcb_glx_context_tag_t  context_tag,
+                        uint32_t               face,
+                        uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_materialfv_cookie_t
+xcb_glx_get_materialfv_unchecked (xcb_connection_t      *c,
+                                  xcb_glx_context_tag_t  context_tag,
+                                  uint32_t               face,
+                                  uint32_t               pname);
+
+xcb_glx_float32_t *
+xcb_glx_get_materialfv_data (const xcb_glx_get_materialfv_reply_t *R);
+
+int
+xcb_glx_get_materialfv_data_length (const xcb_glx_get_materialfv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_materialfv_data_end (const xcb_glx_get_materialfv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_materialfv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_materialfv_reply_t *
+xcb_glx_get_materialfv_reply (xcb_connection_t                 *c,
+                              xcb_glx_get_materialfv_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+int
+xcb_glx_get_materialiv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_materialiv_cookie_t
+xcb_glx_get_materialiv (xcb_connection_t      *c,
+                        xcb_glx_context_tag_t  context_tag,
+                        uint32_t               face,
+                        uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_materialiv_cookie_t
+xcb_glx_get_materialiv_unchecked (xcb_connection_t      *c,
+                                  xcb_glx_context_tag_t  context_tag,
+                                  uint32_t               face,
+                                  uint32_t               pname);
+
+int32_t *
+xcb_glx_get_materialiv_data (const xcb_glx_get_materialiv_reply_t *R);
+
+int
+xcb_glx_get_materialiv_data_length (const xcb_glx_get_materialiv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_materialiv_data_end (const xcb_glx_get_materialiv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_materialiv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_materialiv_reply_t *
+xcb_glx_get_materialiv_reply (xcb_connection_t                 *c,
+                              xcb_glx_get_materialiv_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+int
+xcb_glx_get_pixel_mapfv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_pixel_mapfv_cookie_t
+xcb_glx_get_pixel_mapfv (xcb_connection_t      *c,
+                         xcb_glx_context_tag_t  context_tag,
+                         uint32_t               map);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_pixel_mapfv_cookie_t
+xcb_glx_get_pixel_mapfv_unchecked (xcb_connection_t      *c,
+                                   xcb_glx_context_tag_t  context_tag,
+                                   uint32_t               map);
+
+xcb_glx_float32_t *
+xcb_glx_get_pixel_mapfv_data (const xcb_glx_get_pixel_mapfv_reply_t *R);
+
+int
+xcb_glx_get_pixel_mapfv_data_length (const xcb_glx_get_pixel_mapfv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_pixel_mapfv_data_end (const xcb_glx_get_pixel_mapfv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_pixel_mapfv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_pixel_mapfv_reply_t *
+xcb_glx_get_pixel_mapfv_reply (xcb_connection_t                  *c,
+                               xcb_glx_get_pixel_mapfv_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+int
+xcb_glx_get_pixel_mapuiv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_pixel_mapuiv_cookie_t
+xcb_glx_get_pixel_mapuiv (xcb_connection_t      *c,
+                          xcb_glx_context_tag_t  context_tag,
+                          uint32_t               map);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_pixel_mapuiv_cookie_t
+xcb_glx_get_pixel_mapuiv_unchecked (xcb_connection_t      *c,
+                                    xcb_glx_context_tag_t  context_tag,
+                                    uint32_t               map);
+
+uint32_t *
+xcb_glx_get_pixel_mapuiv_data (const xcb_glx_get_pixel_mapuiv_reply_t *R);
+
+int
+xcb_glx_get_pixel_mapuiv_data_length (const xcb_glx_get_pixel_mapuiv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_pixel_mapuiv_data_end (const xcb_glx_get_pixel_mapuiv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_pixel_mapuiv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_pixel_mapuiv_reply_t *
+xcb_glx_get_pixel_mapuiv_reply (xcb_connection_t                   *c,
+                                xcb_glx_get_pixel_mapuiv_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e);
+
+int
+xcb_glx_get_pixel_mapusv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_pixel_mapusv_cookie_t
+xcb_glx_get_pixel_mapusv (xcb_connection_t      *c,
+                          xcb_glx_context_tag_t  context_tag,
+                          uint32_t               map);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_pixel_mapusv_cookie_t
+xcb_glx_get_pixel_mapusv_unchecked (xcb_connection_t      *c,
+                                    xcb_glx_context_tag_t  context_tag,
+                                    uint32_t               map);
+
+uint16_t *
+xcb_glx_get_pixel_mapusv_data (const xcb_glx_get_pixel_mapusv_reply_t *R);
+
+int
+xcb_glx_get_pixel_mapusv_data_length (const xcb_glx_get_pixel_mapusv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_pixel_mapusv_data_end (const xcb_glx_get_pixel_mapusv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_pixel_mapusv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_pixel_mapusv_reply_t *
+xcb_glx_get_pixel_mapusv_reply (xcb_connection_t                   *c,
+                                xcb_glx_get_pixel_mapusv_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e);
+
+int
+xcb_glx_get_polygon_stipple_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_polygon_stipple_cookie_t
+xcb_glx_get_polygon_stipple (xcb_connection_t      *c,
+                             xcb_glx_context_tag_t  context_tag,
+                             uint8_t                lsb_first);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_polygon_stipple_cookie_t
+xcb_glx_get_polygon_stipple_unchecked (xcb_connection_t      *c,
+                                       xcb_glx_context_tag_t  context_tag,
+                                       uint8_t                lsb_first);
+
+uint8_t *
+xcb_glx_get_polygon_stipple_data (const xcb_glx_get_polygon_stipple_reply_t *R);
+
+int
+xcb_glx_get_polygon_stipple_data_length (const xcb_glx_get_polygon_stipple_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_polygon_stipple_data_end (const xcb_glx_get_polygon_stipple_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_polygon_stipple_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_polygon_stipple_reply_t *
+xcb_glx_get_polygon_stipple_reply (xcb_connection_t                      *c,
+                                   xcb_glx_get_polygon_stipple_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e);
+
+int
+xcb_glx_get_string_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_string_cookie_t
+xcb_glx_get_string (xcb_connection_t      *c,
+                    xcb_glx_context_tag_t  context_tag,
+                    uint32_t               name);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_string_cookie_t
+xcb_glx_get_string_unchecked (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              uint32_t               name);
+
+char *
+xcb_glx_get_string_string (const xcb_glx_get_string_reply_t *R);
+
+int
+xcb_glx_get_string_string_length (const xcb_glx_get_string_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_string_string_end (const xcb_glx_get_string_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_string_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_string_reply_t *
+xcb_glx_get_string_reply (xcb_connection_t             *c,
+                          xcb_glx_get_string_cookie_t   cookie  /**< */,
+                          xcb_generic_error_t         **e);
+
+int
+xcb_glx_get_tex_envfv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_tex_envfv_cookie_t
+xcb_glx_get_tex_envfv (xcb_connection_t      *c,
+                       xcb_glx_context_tag_t  context_tag,
+                       uint32_t               target,
+                       uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_tex_envfv_cookie_t
+xcb_glx_get_tex_envfv_unchecked (xcb_connection_t      *c,
+                                 xcb_glx_context_tag_t  context_tag,
+                                 uint32_t               target,
+                                 uint32_t               pname);
+
+xcb_glx_float32_t *
+xcb_glx_get_tex_envfv_data (const xcb_glx_get_tex_envfv_reply_t *R);
+
+int
+xcb_glx_get_tex_envfv_data_length (const xcb_glx_get_tex_envfv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_tex_envfv_data_end (const xcb_glx_get_tex_envfv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_tex_envfv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_tex_envfv_reply_t *
+xcb_glx_get_tex_envfv_reply (xcb_connection_t                *c,
+                             xcb_glx_get_tex_envfv_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+int
+xcb_glx_get_tex_enviv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_tex_enviv_cookie_t
+xcb_glx_get_tex_enviv (xcb_connection_t      *c,
+                       xcb_glx_context_tag_t  context_tag,
+                       uint32_t               target,
+                       uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_tex_enviv_cookie_t
+xcb_glx_get_tex_enviv_unchecked (xcb_connection_t      *c,
+                                 xcb_glx_context_tag_t  context_tag,
+                                 uint32_t               target,
+                                 uint32_t               pname);
+
+int32_t *
+xcb_glx_get_tex_enviv_data (const xcb_glx_get_tex_enviv_reply_t *R);
+
+int
+xcb_glx_get_tex_enviv_data_length (const xcb_glx_get_tex_enviv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_tex_enviv_data_end (const xcb_glx_get_tex_enviv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_tex_enviv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_tex_enviv_reply_t *
+xcb_glx_get_tex_enviv_reply (xcb_connection_t                *c,
+                             xcb_glx_get_tex_enviv_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+int
+xcb_glx_get_tex_gendv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_tex_gendv_cookie_t
+xcb_glx_get_tex_gendv (xcb_connection_t      *c,
+                       xcb_glx_context_tag_t  context_tag,
+                       uint32_t               coord,
+                       uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_tex_gendv_cookie_t
+xcb_glx_get_tex_gendv_unchecked (xcb_connection_t      *c,
+                                 xcb_glx_context_tag_t  context_tag,
+                                 uint32_t               coord,
+                                 uint32_t               pname);
+
+xcb_glx_float64_t *
+xcb_glx_get_tex_gendv_data (const xcb_glx_get_tex_gendv_reply_t *R);
+
+int
+xcb_glx_get_tex_gendv_data_length (const xcb_glx_get_tex_gendv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_tex_gendv_data_end (const xcb_glx_get_tex_gendv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_tex_gendv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_tex_gendv_reply_t *
+xcb_glx_get_tex_gendv_reply (xcb_connection_t                *c,
+                             xcb_glx_get_tex_gendv_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+int
+xcb_glx_get_tex_genfv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_tex_genfv_cookie_t
+xcb_glx_get_tex_genfv (xcb_connection_t      *c,
+                       xcb_glx_context_tag_t  context_tag,
+                       uint32_t               coord,
+                       uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_tex_genfv_cookie_t
+xcb_glx_get_tex_genfv_unchecked (xcb_connection_t      *c,
+                                 xcb_glx_context_tag_t  context_tag,
+                                 uint32_t               coord,
+                                 uint32_t               pname);
+
+xcb_glx_float32_t *
+xcb_glx_get_tex_genfv_data (const xcb_glx_get_tex_genfv_reply_t *R);
+
+int
+xcb_glx_get_tex_genfv_data_length (const xcb_glx_get_tex_genfv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_tex_genfv_data_end (const xcb_glx_get_tex_genfv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_tex_genfv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_tex_genfv_reply_t *
+xcb_glx_get_tex_genfv_reply (xcb_connection_t                *c,
+                             xcb_glx_get_tex_genfv_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+int
+xcb_glx_get_tex_geniv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_tex_geniv_cookie_t
+xcb_glx_get_tex_geniv (xcb_connection_t      *c,
+                       xcb_glx_context_tag_t  context_tag,
+                       uint32_t               coord,
+                       uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_tex_geniv_cookie_t
+xcb_glx_get_tex_geniv_unchecked (xcb_connection_t      *c,
+                                 xcb_glx_context_tag_t  context_tag,
+                                 uint32_t               coord,
+                                 uint32_t               pname);
+
+int32_t *
+xcb_glx_get_tex_geniv_data (const xcb_glx_get_tex_geniv_reply_t *R);
+
+int
+xcb_glx_get_tex_geniv_data_length (const xcb_glx_get_tex_geniv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_tex_geniv_data_end (const xcb_glx_get_tex_geniv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_tex_geniv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_tex_geniv_reply_t *
+xcb_glx_get_tex_geniv_reply (xcb_connection_t                *c,
+                             xcb_glx_get_tex_geniv_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+int
+xcb_glx_get_tex_image_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_tex_image_cookie_t
+xcb_glx_get_tex_image (xcb_connection_t      *c,
+                       xcb_glx_context_tag_t  context_tag,
+                       uint32_t               target,
+                       int32_t                level,
+                       uint32_t               format,
+                       uint32_t               type,
+                       uint8_t                swap_bytes);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_tex_image_cookie_t
+xcb_glx_get_tex_image_unchecked (xcb_connection_t      *c,
+                                 xcb_glx_context_tag_t  context_tag,
+                                 uint32_t               target,
+                                 int32_t                level,
+                                 uint32_t               format,
+                                 uint32_t               type,
+                                 uint8_t                swap_bytes);
+
+uint8_t *
+xcb_glx_get_tex_image_data (const xcb_glx_get_tex_image_reply_t *R);
+
+int
+xcb_glx_get_tex_image_data_length (const xcb_glx_get_tex_image_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_tex_image_data_end (const xcb_glx_get_tex_image_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_tex_image_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_tex_image_reply_t *
+xcb_glx_get_tex_image_reply (xcb_connection_t                *c,
+                             xcb_glx_get_tex_image_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+int
+xcb_glx_get_tex_parameterfv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_tex_parameterfv_cookie_t
+xcb_glx_get_tex_parameterfv (xcb_connection_t      *c,
+                             xcb_glx_context_tag_t  context_tag,
+                             uint32_t               target,
+                             uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_tex_parameterfv_cookie_t
+xcb_glx_get_tex_parameterfv_unchecked (xcb_connection_t      *c,
+                                       xcb_glx_context_tag_t  context_tag,
+                                       uint32_t               target,
+                                       uint32_t               pname);
+
+xcb_glx_float32_t *
+xcb_glx_get_tex_parameterfv_data (const xcb_glx_get_tex_parameterfv_reply_t *R);
+
+int
+xcb_glx_get_tex_parameterfv_data_length (const xcb_glx_get_tex_parameterfv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_tex_parameterfv_data_end (const xcb_glx_get_tex_parameterfv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_tex_parameterfv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_tex_parameterfv_reply_t *
+xcb_glx_get_tex_parameterfv_reply (xcb_connection_t                      *c,
+                                   xcb_glx_get_tex_parameterfv_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e);
+
+int
+xcb_glx_get_tex_parameteriv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_tex_parameteriv_cookie_t
+xcb_glx_get_tex_parameteriv (xcb_connection_t      *c,
+                             xcb_glx_context_tag_t  context_tag,
+                             uint32_t               target,
+                             uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_tex_parameteriv_cookie_t
+xcb_glx_get_tex_parameteriv_unchecked (xcb_connection_t      *c,
+                                       xcb_glx_context_tag_t  context_tag,
+                                       uint32_t               target,
+                                       uint32_t               pname);
+
+int32_t *
+xcb_glx_get_tex_parameteriv_data (const xcb_glx_get_tex_parameteriv_reply_t *R);
+
+int
+xcb_glx_get_tex_parameteriv_data_length (const xcb_glx_get_tex_parameteriv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_tex_parameteriv_data_end (const xcb_glx_get_tex_parameteriv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_tex_parameteriv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_tex_parameteriv_reply_t *
+xcb_glx_get_tex_parameteriv_reply (xcb_connection_t                      *c,
+                                   xcb_glx_get_tex_parameteriv_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e);
+
+int
+xcb_glx_get_tex_level_parameterfv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_tex_level_parameterfv_cookie_t
+xcb_glx_get_tex_level_parameterfv (xcb_connection_t      *c,
+                                   xcb_glx_context_tag_t  context_tag,
+                                   uint32_t               target,
+                                   int32_t                level,
+                                   uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_tex_level_parameterfv_cookie_t
+xcb_glx_get_tex_level_parameterfv_unchecked (xcb_connection_t      *c,
+                                             xcb_glx_context_tag_t  context_tag,
+                                             uint32_t               target,
+                                             int32_t                level,
+                                             uint32_t               pname);
+
+xcb_glx_float32_t *
+xcb_glx_get_tex_level_parameterfv_data (const xcb_glx_get_tex_level_parameterfv_reply_t *R);
+
+int
+xcb_glx_get_tex_level_parameterfv_data_length (const xcb_glx_get_tex_level_parameterfv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_tex_level_parameterfv_data_end (const xcb_glx_get_tex_level_parameterfv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_tex_level_parameterfv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_tex_level_parameterfv_reply_t *
+xcb_glx_get_tex_level_parameterfv_reply (xcb_connection_t                            *c,
+                                         xcb_glx_get_tex_level_parameterfv_cookie_t   cookie  /**< */,
+                                         xcb_generic_error_t                        **e);
+
+int
+xcb_glx_get_tex_level_parameteriv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_tex_level_parameteriv_cookie_t
+xcb_glx_get_tex_level_parameteriv (xcb_connection_t      *c,
+                                   xcb_glx_context_tag_t  context_tag,
+                                   uint32_t               target,
+                                   int32_t                level,
+                                   uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_tex_level_parameteriv_cookie_t
+xcb_glx_get_tex_level_parameteriv_unchecked (xcb_connection_t      *c,
+                                             xcb_glx_context_tag_t  context_tag,
+                                             uint32_t               target,
+                                             int32_t                level,
+                                             uint32_t               pname);
+
+int32_t *
+xcb_glx_get_tex_level_parameteriv_data (const xcb_glx_get_tex_level_parameteriv_reply_t *R);
+
+int
+xcb_glx_get_tex_level_parameteriv_data_length (const xcb_glx_get_tex_level_parameteriv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_tex_level_parameteriv_data_end (const xcb_glx_get_tex_level_parameteriv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_tex_level_parameteriv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_tex_level_parameteriv_reply_t *
+xcb_glx_get_tex_level_parameteriv_reply (xcb_connection_t                            *c,
+                                         xcb_glx_get_tex_level_parameteriv_cookie_t   cookie  /**< */,
+                                         xcb_generic_error_t                        **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_is_enabled_cookie_t
+xcb_glx_is_enabled (xcb_connection_t      *c,
+                    xcb_glx_context_tag_t  context_tag,
+                    uint32_t               capability);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_is_enabled_cookie_t
+xcb_glx_is_enabled_unchecked (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              uint32_t               capability);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_is_enabled_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_is_enabled_reply_t *
+xcb_glx_is_enabled_reply (xcb_connection_t             *c,
+                          xcb_glx_is_enabled_cookie_t   cookie  /**< */,
+                          xcb_generic_error_t         **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_is_list_cookie_t
+xcb_glx_is_list (xcb_connection_t      *c,
+                 xcb_glx_context_tag_t  context_tag,
+                 uint32_t               list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_is_list_cookie_t
+xcb_glx_is_list_unchecked (xcb_connection_t      *c,
+                           xcb_glx_context_tag_t  context_tag,
+                           uint32_t               list);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_is_list_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_is_list_reply_t *
+xcb_glx_is_list_reply (xcb_connection_t          *c,
+                       xcb_glx_is_list_cookie_t   cookie  /**< */,
+                       xcb_generic_error_t      **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_flush_checked (xcb_connection_t      *c,
+                       xcb_glx_context_tag_t  context_tag);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_flush (xcb_connection_t      *c,
+               xcb_glx_context_tag_t  context_tag);
+
+int
+xcb_glx_are_textures_resident_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_are_textures_resident_cookie_t
+xcb_glx_are_textures_resident (xcb_connection_t      *c,
+                               xcb_glx_context_tag_t  context_tag,
+                               int32_t                n,
+                               const uint32_t        *textures);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_are_textures_resident_cookie_t
+xcb_glx_are_textures_resident_unchecked (xcb_connection_t      *c,
+                                         xcb_glx_context_tag_t  context_tag,
+                                         int32_t                n,
+                                         const uint32_t        *textures);
+
+uint8_t *
+xcb_glx_are_textures_resident_data (const xcb_glx_are_textures_resident_reply_t *R);
+
+int
+xcb_glx_are_textures_resident_data_length (const xcb_glx_are_textures_resident_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_are_textures_resident_data_end (const xcb_glx_are_textures_resident_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_are_textures_resident_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_are_textures_resident_reply_t *
+xcb_glx_are_textures_resident_reply (xcb_connection_t                        *c,
+                                     xcb_glx_are_textures_resident_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e);
+
+int
+xcb_glx_delete_textures_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_delete_textures_checked (xcb_connection_t      *c,
+                                 xcb_glx_context_tag_t  context_tag,
+                                 int32_t                n,
+                                 const uint32_t        *textures);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_delete_textures (xcb_connection_t      *c,
+                         xcb_glx_context_tag_t  context_tag,
+                         int32_t                n,
+                         const uint32_t        *textures);
+
+uint32_t *
+xcb_glx_delete_textures_textures (const xcb_glx_delete_textures_request_t *R);
+
+int
+xcb_glx_delete_textures_textures_length (const xcb_glx_delete_textures_request_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_delete_textures_textures_end (const xcb_glx_delete_textures_request_t *R);
+
+int
+xcb_glx_gen_textures_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_gen_textures_cookie_t
+xcb_glx_gen_textures (xcb_connection_t      *c,
+                      xcb_glx_context_tag_t  context_tag,
+                      int32_t                n);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_gen_textures_cookie_t
+xcb_glx_gen_textures_unchecked (xcb_connection_t      *c,
+                                xcb_glx_context_tag_t  context_tag,
+                                int32_t                n);
+
+uint32_t *
+xcb_glx_gen_textures_data (const xcb_glx_gen_textures_reply_t *R);
+
+int
+xcb_glx_gen_textures_data_length (const xcb_glx_gen_textures_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_gen_textures_data_end (const xcb_glx_gen_textures_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_gen_textures_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_gen_textures_reply_t *
+xcb_glx_gen_textures_reply (xcb_connection_t               *c,
+                            xcb_glx_gen_textures_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_is_texture_cookie_t
+xcb_glx_is_texture (xcb_connection_t      *c,
+                    xcb_glx_context_tag_t  context_tag,
+                    uint32_t               texture);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_is_texture_cookie_t
+xcb_glx_is_texture_unchecked (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              uint32_t               texture);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_is_texture_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_is_texture_reply_t *
+xcb_glx_is_texture_reply (xcb_connection_t             *c,
+                          xcb_glx_is_texture_cookie_t   cookie  /**< */,
+                          xcb_generic_error_t         **e);
+
+int
+xcb_glx_get_color_table_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_color_table_cookie_t
+xcb_glx_get_color_table (xcb_connection_t      *c,
+                         xcb_glx_context_tag_t  context_tag,
+                         uint32_t               target,
+                         uint32_t               format,
+                         uint32_t               type,
+                         uint8_t                swap_bytes);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_color_table_cookie_t
+xcb_glx_get_color_table_unchecked (xcb_connection_t      *c,
+                                   xcb_glx_context_tag_t  context_tag,
+                                   uint32_t               target,
+                                   uint32_t               format,
+                                   uint32_t               type,
+                                   uint8_t                swap_bytes);
+
+uint8_t *
+xcb_glx_get_color_table_data (const xcb_glx_get_color_table_reply_t *R);
+
+int
+xcb_glx_get_color_table_data_length (const xcb_glx_get_color_table_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_color_table_data_end (const xcb_glx_get_color_table_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_color_table_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_color_table_reply_t *
+xcb_glx_get_color_table_reply (xcb_connection_t                  *c,
+                               xcb_glx_get_color_table_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+int
+xcb_glx_get_color_table_parameterfv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_color_table_parameterfv_cookie_t
+xcb_glx_get_color_table_parameterfv (xcb_connection_t      *c,
+                                     xcb_glx_context_tag_t  context_tag,
+                                     uint32_t               target,
+                                     uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_color_table_parameterfv_cookie_t
+xcb_glx_get_color_table_parameterfv_unchecked (xcb_connection_t      *c,
+                                               xcb_glx_context_tag_t  context_tag,
+                                               uint32_t               target,
+                                               uint32_t               pname);
+
+xcb_glx_float32_t *
+xcb_glx_get_color_table_parameterfv_data (const xcb_glx_get_color_table_parameterfv_reply_t *R);
+
+int
+xcb_glx_get_color_table_parameterfv_data_length (const xcb_glx_get_color_table_parameterfv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_color_table_parameterfv_data_end (const xcb_glx_get_color_table_parameterfv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_color_table_parameterfv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_color_table_parameterfv_reply_t *
+xcb_glx_get_color_table_parameterfv_reply (xcb_connection_t                              *c,
+                                           xcb_glx_get_color_table_parameterfv_cookie_t   cookie  /**< */,
+                                           xcb_generic_error_t                          **e);
+
+int
+xcb_glx_get_color_table_parameteriv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_color_table_parameteriv_cookie_t
+xcb_glx_get_color_table_parameteriv (xcb_connection_t      *c,
+                                     xcb_glx_context_tag_t  context_tag,
+                                     uint32_t               target,
+                                     uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_color_table_parameteriv_cookie_t
+xcb_glx_get_color_table_parameteriv_unchecked (xcb_connection_t      *c,
+                                               xcb_glx_context_tag_t  context_tag,
+                                               uint32_t               target,
+                                               uint32_t               pname);
+
+int32_t *
+xcb_glx_get_color_table_parameteriv_data (const xcb_glx_get_color_table_parameteriv_reply_t *R);
+
+int
+xcb_glx_get_color_table_parameteriv_data_length (const xcb_glx_get_color_table_parameteriv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_color_table_parameteriv_data_end (const xcb_glx_get_color_table_parameteriv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_color_table_parameteriv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_color_table_parameteriv_reply_t *
+xcb_glx_get_color_table_parameteriv_reply (xcb_connection_t                              *c,
+                                           xcb_glx_get_color_table_parameteriv_cookie_t   cookie  /**< */,
+                                           xcb_generic_error_t                          **e);
+
+int
+xcb_glx_get_convolution_filter_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_convolution_filter_cookie_t
+xcb_glx_get_convolution_filter (xcb_connection_t      *c,
+                                xcb_glx_context_tag_t  context_tag,
+                                uint32_t               target,
+                                uint32_t               format,
+                                uint32_t               type,
+                                uint8_t                swap_bytes);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_convolution_filter_cookie_t
+xcb_glx_get_convolution_filter_unchecked (xcb_connection_t      *c,
+                                          xcb_glx_context_tag_t  context_tag,
+                                          uint32_t               target,
+                                          uint32_t               format,
+                                          uint32_t               type,
+                                          uint8_t                swap_bytes);
+
+uint8_t *
+xcb_glx_get_convolution_filter_data (const xcb_glx_get_convolution_filter_reply_t *R);
+
+int
+xcb_glx_get_convolution_filter_data_length (const xcb_glx_get_convolution_filter_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_convolution_filter_data_end (const xcb_glx_get_convolution_filter_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_convolution_filter_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_convolution_filter_reply_t *
+xcb_glx_get_convolution_filter_reply (xcb_connection_t                         *c,
+                                      xcb_glx_get_convolution_filter_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e);
+
+int
+xcb_glx_get_convolution_parameterfv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_convolution_parameterfv_cookie_t
+xcb_glx_get_convolution_parameterfv (xcb_connection_t      *c,
+                                     xcb_glx_context_tag_t  context_tag,
+                                     uint32_t               target,
+                                     uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_convolution_parameterfv_cookie_t
+xcb_glx_get_convolution_parameterfv_unchecked (xcb_connection_t      *c,
+                                               xcb_glx_context_tag_t  context_tag,
+                                               uint32_t               target,
+                                               uint32_t               pname);
+
+xcb_glx_float32_t *
+xcb_glx_get_convolution_parameterfv_data (const xcb_glx_get_convolution_parameterfv_reply_t *R);
+
+int
+xcb_glx_get_convolution_parameterfv_data_length (const xcb_glx_get_convolution_parameterfv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_convolution_parameterfv_data_end (const xcb_glx_get_convolution_parameterfv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_convolution_parameterfv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_convolution_parameterfv_reply_t *
+xcb_glx_get_convolution_parameterfv_reply (xcb_connection_t                              *c,
+                                           xcb_glx_get_convolution_parameterfv_cookie_t   cookie  /**< */,
+                                           xcb_generic_error_t                          **e);
+
+int
+xcb_glx_get_convolution_parameteriv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_convolution_parameteriv_cookie_t
+xcb_glx_get_convolution_parameteriv (xcb_connection_t      *c,
+                                     xcb_glx_context_tag_t  context_tag,
+                                     uint32_t               target,
+                                     uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_convolution_parameteriv_cookie_t
+xcb_glx_get_convolution_parameteriv_unchecked (xcb_connection_t      *c,
+                                               xcb_glx_context_tag_t  context_tag,
+                                               uint32_t               target,
+                                               uint32_t               pname);
+
+int32_t *
+xcb_glx_get_convolution_parameteriv_data (const xcb_glx_get_convolution_parameteriv_reply_t *R);
+
+int
+xcb_glx_get_convolution_parameteriv_data_length (const xcb_glx_get_convolution_parameteriv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_convolution_parameteriv_data_end (const xcb_glx_get_convolution_parameteriv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_convolution_parameteriv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_convolution_parameteriv_reply_t *
+xcb_glx_get_convolution_parameteriv_reply (xcb_connection_t                              *c,
+                                           xcb_glx_get_convolution_parameteriv_cookie_t   cookie  /**< */,
+                                           xcb_generic_error_t                          **e);
+
+int
+xcb_glx_get_separable_filter_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_separable_filter_cookie_t
+xcb_glx_get_separable_filter (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              uint32_t               target,
+                              uint32_t               format,
+                              uint32_t               type,
+                              uint8_t                swap_bytes);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_separable_filter_cookie_t
+xcb_glx_get_separable_filter_unchecked (xcb_connection_t      *c,
+                                        xcb_glx_context_tag_t  context_tag,
+                                        uint32_t               target,
+                                        uint32_t               format,
+                                        uint32_t               type,
+                                        uint8_t                swap_bytes);
+
+uint8_t *
+xcb_glx_get_separable_filter_rows_and_cols (const xcb_glx_get_separable_filter_reply_t *R);
+
+int
+xcb_glx_get_separable_filter_rows_and_cols_length (const xcb_glx_get_separable_filter_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_separable_filter_rows_and_cols_end (const xcb_glx_get_separable_filter_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_separable_filter_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_separable_filter_reply_t *
+xcb_glx_get_separable_filter_reply (xcb_connection_t                       *c,
+                                    xcb_glx_get_separable_filter_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e);
+
+int
+xcb_glx_get_histogram_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_histogram_cookie_t
+xcb_glx_get_histogram (xcb_connection_t      *c,
+                       xcb_glx_context_tag_t  context_tag,
+                       uint32_t               target,
+                       uint32_t               format,
+                       uint32_t               type,
+                       uint8_t                swap_bytes,
+                       uint8_t                reset);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_histogram_cookie_t
+xcb_glx_get_histogram_unchecked (xcb_connection_t      *c,
+                                 xcb_glx_context_tag_t  context_tag,
+                                 uint32_t               target,
+                                 uint32_t               format,
+                                 uint32_t               type,
+                                 uint8_t                swap_bytes,
+                                 uint8_t                reset);
+
+uint8_t *
+xcb_glx_get_histogram_data (const xcb_glx_get_histogram_reply_t *R);
+
+int
+xcb_glx_get_histogram_data_length (const xcb_glx_get_histogram_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_histogram_data_end (const xcb_glx_get_histogram_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_histogram_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_histogram_reply_t *
+xcb_glx_get_histogram_reply (xcb_connection_t                *c,
+                             xcb_glx_get_histogram_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+int
+xcb_glx_get_histogram_parameterfv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_histogram_parameterfv_cookie_t
+xcb_glx_get_histogram_parameterfv (xcb_connection_t      *c,
+                                   xcb_glx_context_tag_t  context_tag,
+                                   uint32_t               target,
+                                   uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_histogram_parameterfv_cookie_t
+xcb_glx_get_histogram_parameterfv_unchecked (xcb_connection_t      *c,
+                                             xcb_glx_context_tag_t  context_tag,
+                                             uint32_t               target,
+                                             uint32_t               pname);
+
+xcb_glx_float32_t *
+xcb_glx_get_histogram_parameterfv_data (const xcb_glx_get_histogram_parameterfv_reply_t *R);
+
+int
+xcb_glx_get_histogram_parameterfv_data_length (const xcb_glx_get_histogram_parameterfv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_histogram_parameterfv_data_end (const xcb_glx_get_histogram_parameterfv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_histogram_parameterfv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_histogram_parameterfv_reply_t *
+xcb_glx_get_histogram_parameterfv_reply (xcb_connection_t                            *c,
+                                         xcb_glx_get_histogram_parameterfv_cookie_t   cookie  /**< */,
+                                         xcb_generic_error_t                        **e);
+
+int
+xcb_glx_get_histogram_parameteriv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_histogram_parameteriv_cookie_t
+xcb_glx_get_histogram_parameteriv (xcb_connection_t      *c,
+                                   xcb_glx_context_tag_t  context_tag,
+                                   uint32_t               target,
+                                   uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_histogram_parameteriv_cookie_t
+xcb_glx_get_histogram_parameteriv_unchecked (xcb_connection_t      *c,
+                                             xcb_glx_context_tag_t  context_tag,
+                                             uint32_t               target,
+                                             uint32_t               pname);
+
+int32_t *
+xcb_glx_get_histogram_parameteriv_data (const xcb_glx_get_histogram_parameteriv_reply_t *R);
+
+int
+xcb_glx_get_histogram_parameteriv_data_length (const xcb_glx_get_histogram_parameteriv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_histogram_parameteriv_data_end (const xcb_glx_get_histogram_parameteriv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_histogram_parameteriv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_histogram_parameteriv_reply_t *
+xcb_glx_get_histogram_parameteriv_reply (xcb_connection_t                            *c,
+                                         xcb_glx_get_histogram_parameteriv_cookie_t   cookie  /**< */,
+                                         xcb_generic_error_t                        **e);
+
+int
+xcb_glx_get_minmax_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_minmax_cookie_t
+xcb_glx_get_minmax (xcb_connection_t      *c,
+                    xcb_glx_context_tag_t  context_tag,
+                    uint32_t               target,
+                    uint32_t               format,
+                    uint32_t               type,
+                    uint8_t                swap_bytes,
+                    uint8_t                reset);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_minmax_cookie_t
+xcb_glx_get_minmax_unchecked (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              uint32_t               target,
+                              uint32_t               format,
+                              uint32_t               type,
+                              uint8_t                swap_bytes,
+                              uint8_t                reset);
+
+uint8_t *
+xcb_glx_get_minmax_data (const xcb_glx_get_minmax_reply_t *R);
+
+int
+xcb_glx_get_minmax_data_length (const xcb_glx_get_minmax_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_minmax_data_end (const xcb_glx_get_minmax_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_minmax_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_minmax_reply_t *
+xcb_glx_get_minmax_reply (xcb_connection_t             *c,
+                          xcb_glx_get_minmax_cookie_t   cookie  /**< */,
+                          xcb_generic_error_t         **e);
+
+int
+xcb_glx_get_minmax_parameterfv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_minmax_parameterfv_cookie_t
+xcb_glx_get_minmax_parameterfv (xcb_connection_t      *c,
+                                xcb_glx_context_tag_t  context_tag,
+                                uint32_t               target,
+                                uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_minmax_parameterfv_cookie_t
+xcb_glx_get_minmax_parameterfv_unchecked (xcb_connection_t      *c,
+                                          xcb_glx_context_tag_t  context_tag,
+                                          uint32_t               target,
+                                          uint32_t               pname);
+
+xcb_glx_float32_t *
+xcb_glx_get_minmax_parameterfv_data (const xcb_glx_get_minmax_parameterfv_reply_t *R);
+
+int
+xcb_glx_get_minmax_parameterfv_data_length (const xcb_glx_get_minmax_parameterfv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_minmax_parameterfv_data_end (const xcb_glx_get_minmax_parameterfv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_minmax_parameterfv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_minmax_parameterfv_reply_t *
+xcb_glx_get_minmax_parameterfv_reply (xcb_connection_t                         *c,
+                                      xcb_glx_get_minmax_parameterfv_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e);
+
+int
+xcb_glx_get_minmax_parameteriv_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_minmax_parameteriv_cookie_t
+xcb_glx_get_minmax_parameteriv (xcb_connection_t      *c,
+                                xcb_glx_context_tag_t  context_tag,
+                                uint32_t               target,
+                                uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_minmax_parameteriv_cookie_t
+xcb_glx_get_minmax_parameteriv_unchecked (xcb_connection_t      *c,
+                                          xcb_glx_context_tag_t  context_tag,
+                                          uint32_t               target,
+                                          uint32_t               pname);
+
+int32_t *
+xcb_glx_get_minmax_parameteriv_data (const xcb_glx_get_minmax_parameteriv_reply_t *R);
+
+int
+xcb_glx_get_minmax_parameteriv_data_length (const xcb_glx_get_minmax_parameteriv_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_minmax_parameteriv_data_end (const xcb_glx_get_minmax_parameteriv_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_minmax_parameteriv_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_minmax_parameteriv_reply_t *
+xcb_glx_get_minmax_parameteriv_reply (xcb_connection_t                         *c,
+                                      xcb_glx_get_minmax_parameteriv_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e);
+
+int
+xcb_glx_get_compressed_tex_image_arb_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_compressed_tex_image_arb_cookie_t
+xcb_glx_get_compressed_tex_image_arb (xcb_connection_t      *c,
+                                      xcb_glx_context_tag_t  context_tag,
+                                      uint32_t               target,
+                                      int32_t                level);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_compressed_tex_image_arb_cookie_t
+xcb_glx_get_compressed_tex_image_arb_unchecked (xcb_connection_t      *c,
+                                                xcb_glx_context_tag_t  context_tag,
+                                                uint32_t               target,
+                                                int32_t                level);
+
+uint8_t *
+xcb_glx_get_compressed_tex_image_arb_data (const xcb_glx_get_compressed_tex_image_arb_reply_t *R);
+
+int
+xcb_glx_get_compressed_tex_image_arb_data_length (const xcb_glx_get_compressed_tex_image_arb_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_compressed_tex_image_arb_data_end (const xcb_glx_get_compressed_tex_image_arb_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_compressed_tex_image_arb_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_compressed_tex_image_arb_reply_t *
+xcb_glx_get_compressed_tex_image_arb_reply (xcb_connection_t                               *c,
+                                            xcb_glx_get_compressed_tex_image_arb_cookie_t   cookie  /**< */,
+                                            xcb_generic_error_t                           **e);
+
+int
+xcb_glx_delete_queries_arb_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_glx_delete_queries_arb_checked (xcb_connection_t      *c,
+                                    xcb_glx_context_tag_t  context_tag,
+                                    int32_t                n,
+                                    const uint32_t        *ids);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_glx_delete_queries_arb (xcb_connection_t      *c,
+                            xcb_glx_context_tag_t  context_tag,
+                            int32_t                n,
+                            const uint32_t        *ids);
+
+uint32_t *
+xcb_glx_delete_queries_arb_ids (const xcb_glx_delete_queries_arb_request_t *R);
+
+int
+xcb_glx_delete_queries_arb_ids_length (const xcb_glx_delete_queries_arb_request_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_delete_queries_arb_ids_end (const xcb_glx_delete_queries_arb_request_t *R);
+
+int
+xcb_glx_gen_queries_arb_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_gen_queries_arb_cookie_t
+xcb_glx_gen_queries_arb (xcb_connection_t      *c,
+                         xcb_glx_context_tag_t  context_tag,
+                         int32_t                n);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_gen_queries_arb_cookie_t
+xcb_glx_gen_queries_arb_unchecked (xcb_connection_t      *c,
+                                   xcb_glx_context_tag_t  context_tag,
+                                   int32_t                n);
+
+uint32_t *
+xcb_glx_gen_queries_arb_data (const xcb_glx_gen_queries_arb_reply_t *R);
+
+int
+xcb_glx_gen_queries_arb_data_length (const xcb_glx_gen_queries_arb_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_gen_queries_arb_data_end (const xcb_glx_gen_queries_arb_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_gen_queries_arb_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_gen_queries_arb_reply_t *
+xcb_glx_gen_queries_arb_reply (xcb_connection_t                  *c,
+                               xcb_glx_gen_queries_arb_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_is_query_arb_cookie_t
+xcb_glx_is_query_arb (xcb_connection_t      *c,
+                      xcb_glx_context_tag_t  context_tag,
+                      uint32_t               id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_is_query_arb_cookie_t
+xcb_glx_is_query_arb_unchecked (xcb_connection_t      *c,
+                                xcb_glx_context_tag_t  context_tag,
+                                uint32_t               id);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_is_query_arb_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_is_query_arb_reply_t *
+xcb_glx_is_query_arb_reply (xcb_connection_t               *c,
+                            xcb_glx_is_query_arb_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e);
+
+int
+xcb_glx_get_queryiv_arb_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_queryiv_arb_cookie_t
+xcb_glx_get_queryiv_arb (xcb_connection_t      *c,
+                         xcb_glx_context_tag_t  context_tag,
+                         uint32_t               target,
+                         uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_queryiv_arb_cookie_t
+xcb_glx_get_queryiv_arb_unchecked (xcb_connection_t      *c,
+                                   xcb_glx_context_tag_t  context_tag,
+                                   uint32_t               target,
+                                   uint32_t               pname);
+
+int32_t *
+xcb_glx_get_queryiv_arb_data (const xcb_glx_get_queryiv_arb_reply_t *R);
+
+int
+xcb_glx_get_queryiv_arb_data_length (const xcb_glx_get_queryiv_arb_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_queryiv_arb_data_end (const xcb_glx_get_queryiv_arb_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_queryiv_arb_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_queryiv_arb_reply_t *
+xcb_glx_get_queryiv_arb_reply (xcb_connection_t                  *c,
+                               xcb_glx_get_queryiv_arb_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+int
+xcb_glx_get_query_objectiv_arb_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_query_objectiv_arb_cookie_t
+xcb_glx_get_query_objectiv_arb (xcb_connection_t      *c,
+                                xcb_glx_context_tag_t  context_tag,
+                                uint32_t               id,
+                                uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_query_objectiv_arb_cookie_t
+xcb_glx_get_query_objectiv_arb_unchecked (xcb_connection_t      *c,
+                                          xcb_glx_context_tag_t  context_tag,
+                                          uint32_t               id,
+                                          uint32_t               pname);
+
+int32_t *
+xcb_glx_get_query_objectiv_arb_data (const xcb_glx_get_query_objectiv_arb_reply_t *R);
+
+int
+xcb_glx_get_query_objectiv_arb_data_length (const xcb_glx_get_query_objectiv_arb_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_query_objectiv_arb_data_end (const xcb_glx_get_query_objectiv_arb_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_query_objectiv_arb_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_query_objectiv_arb_reply_t *
+xcb_glx_get_query_objectiv_arb_reply (xcb_connection_t                         *c,
+                                      xcb_glx_get_query_objectiv_arb_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e);
+
+int
+xcb_glx_get_query_objectuiv_arb_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_glx_get_query_objectuiv_arb_cookie_t
+xcb_glx_get_query_objectuiv_arb (xcb_connection_t      *c,
+                                 xcb_glx_context_tag_t  context_tag,
+                                 uint32_t               id,
+                                 uint32_t               pname);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_glx_get_query_objectuiv_arb_cookie_t
+xcb_glx_get_query_objectuiv_arb_unchecked (xcb_connection_t      *c,
+                                           xcb_glx_context_tag_t  context_tag,
+                                           uint32_t               id,
+                                           uint32_t               pname);
+
+uint32_t *
+xcb_glx_get_query_objectuiv_arb_data (const xcb_glx_get_query_objectuiv_arb_reply_t *R);
+
+int
+xcb_glx_get_query_objectuiv_arb_data_length (const xcb_glx_get_query_objectuiv_arb_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_glx_get_query_objectuiv_arb_data_end (const xcb_glx_get_query_objectuiv_arb_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_glx_get_query_objectuiv_arb_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_glx_get_query_objectuiv_arb_reply_t *
+xcb_glx_get_query_objectuiv_arb_reply (xcb_connection_t                          *c,
+                                       xcb_glx_get_query_objectuiv_arb_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/present.h b/depends/libxcb/include/xcb/present.h
new file mode 100644
index 0000000..e366330
--- /dev/null
+++ b/depends/libxcb/include/xcb/present.h
@@ -0,0 +1,644 @@
+/*
+ * This file generated automatically from present.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_Present_API XCB Present API
+ * @brief Present XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __PRESENT_H
+#define __PRESENT_H
+
+#include "xcb.h"
+#include "xproto.h"
+#include "randr.h"
+#include "xfixes.h"
+#include "sync.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_PRESENT_MAJOR_VERSION 1
+#define XCB_PRESENT_MINOR_VERSION 2
+
+extern xcb_extension_t xcb_present_id;
+
+typedef enum xcb_present_event_enum_t {
+    XCB_PRESENT_EVENT_CONFIGURE_NOTIFY = 0,
+    XCB_PRESENT_EVENT_COMPLETE_NOTIFY = 1,
+    XCB_PRESENT_EVENT_IDLE_NOTIFY = 2,
+    XCB_PRESENT_EVENT_REDIRECT_NOTIFY = 3
+} xcb_present_event_enum_t;
+
+typedef enum xcb_present_event_mask_t {
+    XCB_PRESENT_EVENT_MASK_NO_EVENT = 0,
+    XCB_PRESENT_EVENT_MASK_CONFIGURE_NOTIFY = 1,
+    XCB_PRESENT_EVENT_MASK_COMPLETE_NOTIFY = 2,
+    XCB_PRESENT_EVENT_MASK_IDLE_NOTIFY = 4,
+    XCB_PRESENT_EVENT_MASK_REDIRECT_NOTIFY = 8
+} xcb_present_event_mask_t;
+
+typedef enum xcb_present_option_t {
+    XCB_PRESENT_OPTION_NONE = 0,
+    XCB_PRESENT_OPTION_ASYNC = 1,
+    XCB_PRESENT_OPTION_COPY = 2,
+    XCB_PRESENT_OPTION_UST = 4,
+    XCB_PRESENT_OPTION_SUBOPTIMAL = 8
+} xcb_present_option_t;
+
+typedef enum xcb_present_capability_t {
+    XCB_PRESENT_CAPABILITY_NONE = 0,
+    XCB_PRESENT_CAPABILITY_ASYNC = 1,
+    XCB_PRESENT_CAPABILITY_FENCE = 2,
+    XCB_PRESENT_CAPABILITY_UST = 4
+} xcb_present_capability_t;
+
+typedef enum xcb_present_complete_kind_t {
+    XCB_PRESENT_COMPLETE_KIND_PIXMAP = 0,
+    XCB_PRESENT_COMPLETE_KIND_NOTIFY_MSC = 1
+} xcb_present_complete_kind_t;
+
+typedef enum xcb_present_complete_mode_t {
+    XCB_PRESENT_COMPLETE_MODE_COPY = 0,
+    XCB_PRESENT_COMPLETE_MODE_FLIP = 1,
+    XCB_PRESENT_COMPLETE_MODE_SKIP = 2,
+    XCB_PRESENT_COMPLETE_MODE_SUBOPTIMAL_COPY = 3
+} xcb_present_complete_mode_t;
+
+/**
+ * @brief xcb_present_notify_t
+ **/
+typedef struct xcb_present_notify_t {
+    xcb_window_t window;
+    uint32_t     serial;
+} xcb_present_notify_t;
+
+/**
+ * @brief xcb_present_notify_iterator_t
+ **/
+typedef struct xcb_present_notify_iterator_t {
+    xcb_present_notify_t *data;
+    int                   rem;
+    int                   index;
+} xcb_present_notify_iterator_t;
+
+/**
+ * @brief xcb_present_query_version_cookie_t
+ **/
+typedef struct xcb_present_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_present_query_version_cookie_t;
+
+/** Opcode for xcb_present_query_version. */
+#define XCB_PRESENT_QUERY_VERSION 0
+
+/**
+ * @brief xcb_present_query_version_request_t
+ **/
+typedef struct xcb_present_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t major_version;
+    uint32_t minor_version;
+} xcb_present_query_version_request_t;
+
+/**
+ * @brief xcb_present_query_version_reply_t
+ **/
+typedef struct xcb_present_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t major_version;
+    uint32_t minor_version;
+} xcb_present_query_version_reply_t;
+
+/** Opcode for xcb_present_pixmap. */
+#define XCB_PRESENT_PIXMAP 1
+
+/**
+ * @brief xcb_present_pixmap_request_t
+ **/
+typedef struct xcb_present_pixmap_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_window_t        window;
+    xcb_pixmap_t        pixmap;
+    uint32_t            serial;
+    xcb_xfixes_region_t valid;
+    xcb_xfixes_region_t update;
+    int16_t             x_off;
+    int16_t             y_off;
+    xcb_randr_crtc_t    target_crtc;
+    xcb_sync_fence_t    wait_fence;
+    xcb_sync_fence_t    idle_fence;
+    uint32_t            options;
+    uint8_t             pad0[4];
+    uint64_t            target_msc;
+    uint64_t            divisor;
+    uint64_t            remainder;
+} xcb_present_pixmap_request_t;
+
+/** Opcode for xcb_present_notify_msc. */
+#define XCB_PRESENT_NOTIFY_MSC 2
+
+/**
+ * @brief xcb_present_notify_msc_request_t
+ **/
+typedef struct xcb_present_notify_msc_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    uint32_t     serial;
+    uint8_t      pad0[4];
+    uint64_t     target_msc;
+    uint64_t     divisor;
+    uint64_t     remainder;
+} xcb_present_notify_msc_request_t;
+
+typedef uint32_t xcb_present_event_t;
+
+/**
+ * @brief xcb_present_event_iterator_t
+ **/
+typedef struct xcb_present_event_iterator_t {
+    xcb_present_event_t *data;
+    int                  rem;
+    int                  index;
+} xcb_present_event_iterator_t;
+
+/** Opcode for xcb_present_select_input. */
+#define XCB_PRESENT_SELECT_INPUT 3
+
+/**
+ * @brief xcb_present_select_input_request_t
+ **/
+typedef struct xcb_present_select_input_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_present_event_t eid;
+    xcb_window_t        window;
+    uint32_t            event_mask;
+} xcb_present_select_input_request_t;
+
+/**
+ * @brief xcb_present_query_capabilities_cookie_t
+ **/
+typedef struct xcb_present_query_capabilities_cookie_t {
+    unsigned int sequence;
+} xcb_present_query_capabilities_cookie_t;
+
+/** Opcode for xcb_present_query_capabilities. */
+#define XCB_PRESENT_QUERY_CAPABILITIES 4
+
+/**
+ * @brief xcb_present_query_capabilities_request_t
+ **/
+typedef struct xcb_present_query_capabilities_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t target;
+} xcb_present_query_capabilities_request_t;
+
+/**
+ * @brief xcb_present_query_capabilities_reply_t
+ **/
+typedef struct xcb_present_query_capabilities_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t capabilities;
+} xcb_present_query_capabilities_reply_t;
+
+/** Opcode for xcb_present_generic. */
+#define XCB_PRESENT_GENERIC 0
+
+/**
+ * @brief xcb_present_generic_event_t
+ **/
+typedef struct xcb_present_generic_event_t {
+    uint8_t             response_type;
+    uint8_t             extension;
+    uint16_t            sequence;
+    uint32_t            length;
+    uint16_t            evtype;
+    uint8_t             pad0[2];
+    xcb_present_event_t event;
+} xcb_present_generic_event_t;
+
+/** Opcode for xcb_present_configure_notify. */
+#define XCB_PRESENT_CONFIGURE_NOTIFY 0
+
+/**
+ * @brief xcb_present_configure_notify_event_t
+ **/
+typedef struct xcb_present_configure_notify_event_t {
+    uint8_t             response_type;
+    uint8_t             extension;
+    uint16_t            sequence;
+    uint32_t            length;
+    uint16_t            event_type;
+    uint8_t             pad0[2];
+    xcb_present_event_t event;
+    xcb_window_t        window;
+    int16_t             x;
+    int16_t             y;
+    uint16_t            width;
+    uint16_t            height;
+    int16_t             off_x;
+    int16_t             off_y;
+    uint32_t            full_sequence;
+    uint16_t            pixmap_width;
+    uint16_t            pixmap_height;
+    uint32_t            pixmap_flags;
+} xcb_present_configure_notify_event_t;
+
+/** Opcode for xcb_present_complete_notify. */
+#define XCB_PRESENT_COMPLETE_NOTIFY 1
+
+/**
+ * @brief xcb_present_complete_notify_event_t
+ **/
+typedef struct xcb_present_complete_notify_event_t {
+    uint8_t             response_type;
+    uint8_t             extension;
+    uint16_t            sequence;
+    uint32_t            length;
+    uint16_t            event_type;
+    uint8_t             kind;
+    uint8_t             mode;
+    xcb_present_event_t event;
+    xcb_window_t        window;
+    uint32_t            serial;
+    uint64_t            ust;
+    uint32_t            full_sequence;
+    uint64_t            msc;
+} XCB_PACKED xcb_present_complete_notify_event_t;
+
+/** Opcode for xcb_present_idle_notify. */
+#define XCB_PRESENT_IDLE_NOTIFY 2
+
+/**
+ * @brief xcb_present_idle_notify_event_t
+ **/
+typedef struct xcb_present_idle_notify_event_t {
+    uint8_t             response_type;
+    uint8_t             extension;
+    uint16_t            sequence;
+    uint32_t            length;
+    uint16_t            event_type;
+    uint8_t             pad0[2];
+    xcb_present_event_t event;
+    xcb_window_t        window;
+    uint32_t            serial;
+    xcb_pixmap_t        pixmap;
+    xcb_sync_fence_t    idle_fence;
+    uint32_t            full_sequence;
+} xcb_present_idle_notify_event_t;
+
+/** Opcode for xcb_present_redirect_notify. */
+#define XCB_PRESENT_REDIRECT_NOTIFY 3
+
+/**
+ * @brief xcb_present_redirect_notify_event_t
+ **/
+typedef struct xcb_present_redirect_notify_event_t {
+    uint8_t             response_type;
+    uint8_t             extension;
+    uint16_t            sequence;
+    uint32_t            length;
+    uint16_t            event_type;
+    uint8_t             update_window;
+    uint8_t             pad0;
+    xcb_present_event_t event;
+    xcb_window_t        event_window;
+    xcb_window_t        window;
+    xcb_pixmap_t        pixmap;
+    uint32_t            serial;
+    uint32_t            full_sequence;
+    xcb_xfixes_region_t valid_region;
+    xcb_xfixes_region_t update_region;
+    xcb_rectangle_t     valid_rect;
+    xcb_rectangle_t     update_rect;
+    int16_t             x_off;
+    int16_t             y_off;
+    xcb_randr_crtc_t    target_crtc;
+    xcb_sync_fence_t    wait_fence;
+    xcb_sync_fence_t    idle_fence;
+    uint32_t            options;
+    uint8_t             pad1[4];
+    uint64_t            target_msc;
+    uint64_t            divisor;
+    uint64_t            remainder;
+} XCB_PACKED xcb_present_redirect_notify_event_t;
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_present_notify_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_present_notify_t)
+ */
+void
+xcb_present_notify_next (xcb_present_notify_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_present_notify_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_present_notify_end (xcb_present_notify_iterator_t i);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_present_query_version_cookie_t
+xcb_present_query_version (xcb_connection_t *c,
+                           uint32_t          major_version,
+                           uint32_t          minor_version);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_present_query_version_cookie_t
+xcb_present_query_version_unchecked (xcb_connection_t *c,
+                                     uint32_t          major_version,
+                                     uint32_t          minor_version);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_present_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_present_query_version_reply_t *
+xcb_present_query_version_reply (xcb_connection_t                    *c,
+                                 xcb_present_query_version_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e);
+
+int
+xcb_present_pixmap_sizeof (const void  *_buffer,
+                           uint32_t     notifies_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_present_pixmap_checked (xcb_connection_t           *c,
+                            xcb_window_t                window,
+                            xcb_pixmap_t                pixmap,
+                            uint32_t                    serial,
+                            xcb_xfixes_region_t         valid,
+                            xcb_xfixes_region_t         update,
+                            int16_t                     x_off,
+                            int16_t                     y_off,
+                            xcb_randr_crtc_t            target_crtc,
+                            xcb_sync_fence_t            wait_fence,
+                            xcb_sync_fence_t            idle_fence,
+                            uint32_t                    options,
+                            uint64_t                    target_msc,
+                            uint64_t                    divisor,
+                            uint64_t                    remainder,
+                            uint32_t                    notifies_len,
+                            const xcb_present_notify_t *notifies);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_present_pixmap (xcb_connection_t           *c,
+                    xcb_window_t                window,
+                    xcb_pixmap_t                pixmap,
+                    uint32_t                    serial,
+                    xcb_xfixes_region_t         valid,
+                    xcb_xfixes_region_t         update,
+                    int16_t                     x_off,
+                    int16_t                     y_off,
+                    xcb_randr_crtc_t            target_crtc,
+                    xcb_sync_fence_t            wait_fence,
+                    xcb_sync_fence_t            idle_fence,
+                    uint32_t                    options,
+                    uint64_t                    target_msc,
+                    uint64_t                    divisor,
+                    uint64_t                    remainder,
+                    uint32_t                    notifies_len,
+                    const xcb_present_notify_t *notifies);
+
+xcb_present_notify_t *
+xcb_present_pixmap_notifies (const xcb_present_pixmap_request_t *R);
+
+int
+xcb_present_pixmap_notifies_length (const xcb_present_pixmap_request_t *R);
+
+xcb_present_notify_iterator_t
+xcb_present_pixmap_notifies_iterator (const xcb_present_pixmap_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_present_notify_msc_checked (xcb_connection_t *c,
+                                xcb_window_t      window,
+                                uint32_t          serial,
+                                uint64_t          target_msc,
+                                uint64_t          divisor,
+                                uint64_t          remainder);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_present_notify_msc (xcb_connection_t *c,
+                        xcb_window_t      window,
+                        uint32_t          serial,
+                        uint64_t          target_msc,
+                        uint64_t          divisor,
+                        uint64_t          remainder);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_present_event_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_present_event_t)
+ */
+void
+xcb_present_event_next (xcb_present_event_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_present_event_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_present_event_end (xcb_present_event_iterator_t i);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_present_select_input_checked (xcb_connection_t    *c,
+                                  xcb_present_event_t  eid,
+                                  xcb_window_t         window,
+                                  uint32_t             event_mask);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_present_select_input (xcb_connection_t    *c,
+                          xcb_present_event_t  eid,
+                          xcb_window_t         window,
+                          uint32_t             event_mask);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_present_query_capabilities_cookie_t
+xcb_present_query_capabilities (xcb_connection_t *c,
+                                uint32_t          target);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_present_query_capabilities_cookie_t
+xcb_present_query_capabilities_unchecked (xcb_connection_t *c,
+                                          uint32_t          target);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_present_query_capabilities_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_present_query_capabilities_reply_t *
+xcb_present_query_capabilities_reply (xcb_connection_t                         *c,
+                                      xcb_present_query_capabilities_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e);
+
+int
+xcb_present_redirect_notify_sizeof (const void  *_buffer,
+                                    uint32_t     notifies_len);
+
+xcb_present_notify_t *
+xcb_present_redirect_notify_notifies (const xcb_present_redirect_notify_event_t *R);
+
+int
+xcb_present_redirect_notify_notifies_length (const xcb_present_redirect_notify_event_t *R);
+
+xcb_present_notify_iterator_t
+xcb_present_redirect_notify_notifies_iterator (const xcb_present_redirect_notify_event_t *R);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/randr.h b/depends/libxcb/include/xcb/randr.h
new file mode 100644
index 0000000..cc04c8e
--- /dev/null
+++ b/depends/libxcb/include/xcb/randr.h
@@ -0,0 +1,4588 @@
+/*
+ * This file generated automatically from randr.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_RandR_API XCB RandR API
+ * @brief RandR XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __RANDR_H
+#define __RANDR_H
+
+#include "xcb.h"
+#include "xproto.h"
+#include "render.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_RANDR_MAJOR_VERSION 1
+#define XCB_RANDR_MINOR_VERSION 6
+
+extern xcb_extension_t xcb_randr_id;
+
+typedef uint32_t xcb_randr_mode_t;
+
+/**
+ * @brief xcb_randr_mode_iterator_t
+ **/
+typedef struct xcb_randr_mode_iterator_t {
+    xcb_randr_mode_t *data;
+    int               rem;
+    int               index;
+} xcb_randr_mode_iterator_t;
+
+typedef uint32_t xcb_randr_crtc_t;
+
+/**
+ * @brief xcb_randr_crtc_iterator_t
+ **/
+typedef struct xcb_randr_crtc_iterator_t {
+    xcb_randr_crtc_t *data;
+    int               rem;
+    int               index;
+} xcb_randr_crtc_iterator_t;
+
+typedef uint32_t xcb_randr_output_t;
+
+/**
+ * @brief xcb_randr_output_iterator_t
+ **/
+typedef struct xcb_randr_output_iterator_t {
+    xcb_randr_output_t *data;
+    int                 rem;
+    int                 index;
+} xcb_randr_output_iterator_t;
+
+typedef uint32_t xcb_randr_provider_t;
+
+/**
+ * @brief xcb_randr_provider_iterator_t
+ **/
+typedef struct xcb_randr_provider_iterator_t {
+    xcb_randr_provider_t *data;
+    int                   rem;
+    int                   index;
+} xcb_randr_provider_iterator_t;
+
+typedef uint32_t xcb_randr_lease_t;
+
+/**
+ * @brief xcb_randr_lease_iterator_t
+ **/
+typedef struct xcb_randr_lease_iterator_t {
+    xcb_randr_lease_t *data;
+    int                rem;
+    int                index;
+} xcb_randr_lease_iterator_t;
+
+/** Opcode for xcb_randr_bad_output. */
+#define XCB_RANDR_BAD_OUTPUT 0
+
+/**
+ * @brief xcb_randr_bad_output_error_t
+ **/
+typedef struct xcb_randr_bad_output_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_randr_bad_output_error_t;
+
+/** Opcode for xcb_randr_bad_crtc. */
+#define XCB_RANDR_BAD_CRTC 1
+
+/**
+ * @brief xcb_randr_bad_crtc_error_t
+ **/
+typedef struct xcb_randr_bad_crtc_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_randr_bad_crtc_error_t;
+
+/** Opcode for xcb_randr_bad_mode. */
+#define XCB_RANDR_BAD_MODE 2
+
+/**
+ * @brief xcb_randr_bad_mode_error_t
+ **/
+typedef struct xcb_randr_bad_mode_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_randr_bad_mode_error_t;
+
+/** Opcode for xcb_randr_bad_provider. */
+#define XCB_RANDR_BAD_PROVIDER 3
+
+/**
+ * @brief xcb_randr_bad_provider_error_t
+ **/
+typedef struct xcb_randr_bad_provider_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_randr_bad_provider_error_t;
+
+typedef enum xcb_randr_rotation_t {
+    XCB_RANDR_ROTATION_ROTATE_0 = 1,
+    XCB_RANDR_ROTATION_ROTATE_90 = 2,
+    XCB_RANDR_ROTATION_ROTATE_180 = 4,
+    XCB_RANDR_ROTATION_ROTATE_270 = 8,
+    XCB_RANDR_ROTATION_REFLECT_X = 16,
+    XCB_RANDR_ROTATION_REFLECT_Y = 32
+} xcb_randr_rotation_t;
+
+/**
+ * @brief xcb_randr_screen_size_t
+ **/
+typedef struct xcb_randr_screen_size_t {
+    uint16_t width;
+    uint16_t height;
+    uint16_t mwidth;
+    uint16_t mheight;
+} xcb_randr_screen_size_t;
+
+/**
+ * @brief xcb_randr_screen_size_iterator_t
+ **/
+typedef struct xcb_randr_screen_size_iterator_t {
+    xcb_randr_screen_size_t *data;
+    int                      rem;
+    int                      index;
+} xcb_randr_screen_size_iterator_t;
+
+/**
+ * @brief xcb_randr_refresh_rates_t
+ **/
+typedef struct xcb_randr_refresh_rates_t {
+    uint16_t nRates;
+} xcb_randr_refresh_rates_t;
+
+/**
+ * @brief xcb_randr_refresh_rates_iterator_t
+ **/
+typedef struct xcb_randr_refresh_rates_iterator_t {
+    xcb_randr_refresh_rates_t *data;
+    int                        rem;
+    int                        index;
+} xcb_randr_refresh_rates_iterator_t;
+
+/**
+ * @brief xcb_randr_query_version_cookie_t
+ **/
+typedef struct xcb_randr_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_randr_query_version_cookie_t;
+
+/** Opcode for xcb_randr_query_version. */
+#define XCB_RANDR_QUERY_VERSION 0
+
+/**
+ * @brief xcb_randr_query_version_request_t
+ **/
+typedef struct xcb_randr_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t major_version;
+    uint32_t minor_version;
+} xcb_randr_query_version_request_t;
+
+/**
+ * @brief xcb_randr_query_version_reply_t
+ **/
+typedef struct xcb_randr_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t major_version;
+    uint32_t minor_version;
+    uint8_t  pad1[16];
+} xcb_randr_query_version_reply_t;
+
+typedef enum xcb_randr_set_config_t {
+    XCB_RANDR_SET_CONFIG_SUCCESS = 0,
+    XCB_RANDR_SET_CONFIG_INVALID_CONFIG_TIME = 1,
+    XCB_RANDR_SET_CONFIG_INVALID_TIME = 2,
+    XCB_RANDR_SET_CONFIG_FAILED = 3
+} xcb_randr_set_config_t;
+
+/**
+ * @brief xcb_randr_set_screen_config_cookie_t
+ **/
+typedef struct xcb_randr_set_screen_config_cookie_t {
+    unsigned int sequence;
+} xcb_randr_set_screen_config_cookie_t;
+
+/** Opcode for xcb_randr_set_screen_config. */
+#define XCB_RANDR_SET_SCREEN_CONFIG 2
+
+/**
+ * @brief xcb_randr_set_screen_config_request_t
+ **/
+typedef struct xcb_randr_set_screen_config_request_t {
+    uint8_t         major_opcode;
+    uint8_t         minor_opcode;
+    uint16_t        length;
+    xcb_window_t    window;
+    xcb_timestamp_t timestamp;
+    xcb_timestamp_t config_timestamp;
+    uint16_t        sizeID;
+    uint16_t        rotation;
+    uint16_t        rate;
+    uint8_t         pad0[2];
+} xcb_randr_set_screen_config_request_t;
+
+/**
+ * @brief xcb_randr_set_screen_config_reply_t
+ **/
+typedef struct xcb_randr_set_screen_config_reply_t {
+    uint8_t         response_type;
+    uint8_t         status;
+    uint16_t        sequence;
+    uint32_t        length;
+    xcb_timestamp_t new_timestamp;
+    xcb_timestamp_t config_timestamp;
+    xcb_window_t    root;
+    uint16_t        subpixel_order;
+    uint8_t         pad0[10];
+} xcb_randr_set_screen_config_reply_t;
+
+typedef enum xcb_randr_notify_mask_t {
+    XCB_RANDR_NOTIFY_MASK_SCREEN_CHANGE = 1,
+    XCB_RANDR_NOTIFY_MASK_CRTC_CHANGE = 2,
+    XCB_RANDR_NOTIFY_MASK_OUTPUT_CHANGE = 4,
+    XCB_RANDR_NOTIFY_MASK_OUTPUT_PROPERTY = 8,
+    XCB_RANDR_NOTIFY_MASK_PROVIDER_CHANGE = 16,
+    XCB_RANDR_NOTIFY_MASK_PROVIDER_PROPERTY = 32,
+    XCB_RANDR_NOTIFY_MASK_RESOURCE_CHANGE = 64,
+    XCB_RANDR_NOTIFY_MASK_LEASE = 128
+} xcb_randr_notify_mask_t;
+
+/** Opcode for xcb_randr_select_input. */
+#define XCB_RANDR_SELECT_INPUT 4
+
+/**
+ * @brief xcb_randr_select_input_request_t
+ **/
+typedef struct xcb_randr_select_input_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    uint16_t     enable;
+    uint8_t      pad0[2];
+} xcb_randr_select_input_request_t;
+
+/**
+ * @brief xcb_randr_get_screen_info_cookie_t
+ **/
+typedef struct xcb_randr_get_screen_info_cookie_t {
+    unsigned int sequence;
+} xcb_randr_get_screen_info_cookie_t;
+
+/** Opcode for xcb_randr_get_screen_info. */
+#define XCB_RANDR_GET_SCREEN_INFO 5
+
+/**
+ * @brief xcb_randr_get_screen_info_request_t
+ **/
+typedef struct xcb_randr_get_screen_info_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_randr_get_screen_info_request_t;
+
+/**
+ * @brief xcb_randr_get_screen_info_reply_t
+ **/
+typedef struct xcb_randr_get_screen_info_reply_t {
+    uint8_t         response_type;
+    uint8_t         rotations;
+    uint16_t        sequence;
+    uint32_t        length;
+    xcb_window_t    root;
+    xcb_timestamp_t timestamp;
+    xcb_timestamp_t config_timestamp;
+    uint16_t        nSizes;
+    uint16_t        sizeID;
+    uint16_t        rotation;
+    uint16_t        rate;
+    uint16_t        nInfo;
+    uint8_t         pad0[2];
+} xcb_randr_get_screen_info_reply_t;
+
+/**
+ * @brief xcb_randr_get_screen_size_range_cookie_t
+ **/
+typedef struct xcb_randr_get_screen_size_range_cookie_t {
+    unsigned int sequence;
+} xcb_randr_get_screen_size_range_cookie_t;
+
+/** Opcode for xcb_randr_get_screen_size_range. */
+#define XCB_RANDR_GET_SCREEN_SIZE_RANGE 6
+
+/**
+ * @brief xcb_randr_get_screen_size_range_request_t
+ **/
+typedef struct xcb_randr_get_screen_size_range_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_randr_get_screen_size_range_request_t;
+
+/**
+ * @brief xcb_randr_get_screen_size_range_reply_t
+ **/
+typedef struct xcb_randr_get_screen_size_range_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t min_width;
+    uint16_t min_height;
+    uint16_t max_width;
+    uint16_t max_height;
+    uint8_t  pad1[16];
+} xcb_randr_get_screen_size_range_reply_t;
+
+/** Opcode for xcb_randr_set_screen_size. */
+#define XCB_RANDR_SET_SCREEN_SIZE 7
+
+/**
+ * @brief xcb_randr_set_screen_size_request_t
+ **/
+typedef struct xcb_randr_set_screen_size_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    uint16_t     width;
+    uint16_t     height;
+    uint32_t     mm_width;
+    uint32_t     mm_height;
+} xcb_randr_set_screen_size_request_t;
+
+typedef enum xcb_randr_mode_flag_t {
+    XCB_RANDR_MODE_FLAG_HSYNC_POSITIVE = 1,
+    XCB_RANDR_MODE_FLAG_HSYNC_NEGATIVE = 2,
+    XCB_RANDR_MODE_FLAG_VSYNC_POSITIVE = 4,
+    XCB_RANDR_MODE_FLAG_VSYNC_NEGATIVE = 8,
+    XCB_RANDR_MODE_FLAG_INTERLACE = 16,
+    XCB_RANDR_MODE_FLAG_DOUBLE_SCAN = 32,
+    XCB_RANDR_MODE_FLAG_CSYNC = 64,
+    XCB_RANDR_MODE_FLAG_CSYNC_POSITIVE = 128,
+    XCB_RANDR_MODE_FLAG_CSYNC_NEGATIVE = 256,
+    XCB_RANDR_MODE_FLAG_HSKEW_PRESENT = 512,
+    XCB_RANDR_MODE_FLAG_BCAST = 1024,
+    XCB_RANDR_MODE_FLAG_PIXEL_MULTIPLEX = 2048,
+    XCB_RANDR_MODE_FLAG_DOUBLE_CLOCK = 4096,
+    XCB_RANDR_MODE_FLAG_HALVE_CLOCK = 8192
+} xcb_randr_mode_flag_t;
+
+/**
+ * @brief xcb_randr_mode_info_t
+ **/
+typedef struct xcb_randr_mode_info_t {
+    uint32_t id;
+    uint16_t width;
+    uint16_t height;
+    uint32_t dot_clock;
+    uint16_t hsync_start;
+    uint16_t hsync_end;
+    uint16_t htotal;
+    uint16_t hskew;
+    uint16_t vsync_start;
+    uint16_t vsync_end;
+    uint16_t vtotal;
+    uint16_t name_len;
+    uint32_t mode_flags;
+} xcb_randr_mode_info_t;
+
+/**
+ * @brief xcb_randr_mode_info_iterator_t
+ **/
+typedef struct xcb_randr_mode_info_iterator_t {
+    xcb_randr_mode_info_t *data;
+    int                    rem;
+    int                    index;
+} xcb_randr_mode_info_iterator_t;
+
+/**
+ * @brief xcb_randr_get_screen_resources_cookie_t
+ **/
+typedef struct xcb_randr_get_screen_resources_cookie_t {
+    unsigned int sequence;
+} xcb_randr_get_screen_resources_cookie_t;
+
+/** Opcode for xcb_randr_get_screen_resources. */
+#define XCB_RANDR_GET_SCREEN_RESOURCES 8
+
+/**
+ * @brief xcb_randr_get_screen_resources_request_t
+ **/
+typedef struct xcb_randr_get_screen_resources_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_randr_get_screen_resources_request_t;
+
+/**
+ * @brief xcb_randr_get_screen_resources_reply_t
+ **/
+typedef struct xcb_randr_get_screen_resources_reply_t {
+    uint8_t         response_type;
+    uint8_t         pad0;
+    uint16_t        sequence;
+    uint32_t        length;
+    xcb_timestamp_t timestamp;
+    xcb_timestamp_t config_timestamp;
+    uint16_t        num_crtcs;
+    uint16_t        num_outputs;
+    uint16_t        num_modes;
+    uint16_t        names_len;
+    uint8_t         pad1[8];
+} xcb_randr_get_screen_resources_reply_t;
+
+typedef enum xcb_randr_connection_t {
+    XCB_RANDR_CONNECTION_CONNECTED = 0,
+    XCB_RANDR_CONNECTION_DISCONNECTED = 1,
+    XCB_RANDR_CONNECTION_UNKNOWN = 2
+} xcb_randr_connection_t;
+
+/**
+ * @brief xcb_randr_get_output_info_cookie_t
+ **/
+typedef struct xcb_randr_get_output_info_cookie_t {
+    unsigned int sequence;
+} xcb_randr_get_output_info_cookie_t;
+
+/** Opcode for xcb_randr_get_output_info. */
+#define XCB_RANDR_GET_OUTPUT_INFO 9
+
+/**
+ * @brief xcb_randr_get_output_info_request_t
+ **/
+typedef struct xcb_randr_get_output_info_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_randr_output_t output;
+    xcb_timestamp_t    config_timestamp;
+} xcb_randr_get_output_info_request_t;
+
+/**
+ * @brief xcb_randr_get_output_info_reply_t
+ **/
+typedef struct xcb_randr_get_output_info_reply_t {
+    uint8_t          response_type;
+    uint8_t          status;
+    uint16_t         sequence;
+    uint32_t         length;
+    xcb_timestamp_t  timestamp;
+    xcb_randr_crtc_t crtc;
+    uint32_t         mm_width;
+    uint32_t         mm_height;
+    uint8_t          connection;
+    uint8_t          subpixel_order;
+    uint16_t         num_crtcs;
+    uint16_t         num_modes;
+    uint16_t         num_preferred;
+    uint16_t         num_clones;
+    uint16_t         name_len;
+} xcb_randr_get_output_info_reply_t;
+
+/**
+ * @brief xcb_randr_list_output_properties_cookie_t
+ **/
+typedef struct xcb_randr_list_output_properties_cookie_t {
+    unsigned int sequence;
+} xcb_randr_list_output_properties_cookie_t;
+
+/** Opcode for xcb_randr_list_output_properties. */
+#define XCB_RANDR_LIST_OUTPUT_PROPERTIES 10
+
+/**
+ * @brief xcb_randr_list_output_properties_request_t
+ **/
+typedef struct xcb_randr_list_output_properties_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_randr_output_t output;
+} xcb_randr_list_output_properties_request_t;
+
+/**
+ * @brief xcb_randr_list_output_properties_reply_t
+ **/
+typedef struct xcb_randr_list_output_properties_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t num_atoms;
+    uint8_t  pad1[22];
+} xcb_randr_list_output_properties_reply_t;
+
+/**
+ * @brief xcb_randr_query_output_property_cookie_t
+ **/
+typedef struct xcb_randr_query_output_property_cookie_t {
+    unsigned int sequence;
+} xcb_randr_query_output_property_cookie_t;
+
+/** Opcode for xcb_randr_query_output_property. */
+#define XCB_RANDR_QUERY_OUTPUT_PROPERTY 11
+
+/**
+ * @brief xcb_randr_query_output_property_request_t
+ **/
+typedef struct xcb_randr_query_output_property_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_randr_output_t output;
+    xcb_atom_t         property;
+} xcb_randr_query_output_property_request_t;
+
+/**
+ * @brief xcb_randr_query_output_property_reply_t
+ **/
+typedef struct xcb_randr_query_output_property_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pending;
+    uint8_t  range;
+    uint8_t  immutable;
+    uint8_t  pad1[21];
+} xcb_randr_query_output_property_reply_t;
+
+/** Opcode for xcb_randr_configure_output_property. */
+#define XCB_RANDR_CONFIGURE_OUTPUT_PROPERTY 12
+
+/**
+ * @brief xcb_randr_configure_output_property_request_t
+ **/
+typedef struct xcb_randr_configure_output_property_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_randr_output_t output;
+    xcb_atom_t         property;
+    uint8_t            pending;
+    uint8_t            range;
+    uint8_t            pad0[2];
+} xcb_randr_configure_output_property_request_t;
+
+/** Opcode for xcb_randr_change_output_property. */
+#define XCB_RANDR_CHANGE_OUTPUT_PROPERTY 13
+
+/**
+ * @brief xcb_randr_change_output_property_request_t
+ **/
+typedef struct xcb_randr_change_output_property_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_randr_output_t output;
+    xcb_atom_t         property;
+    xcb_atom_t         type;
+    uint8_t            format;
+    uint8_t            mode;
+    uint8_t            pad0[2];
+    uint32_t           num_units;
+} xcb_randr_change_output_property_request_t;
+
+/** Opcode for xcb_randr_delete_output_property. */
+#define XCB_RANDR_DELETE_OUTPUT_PROPERTY 14
+
+/**
+ * @brief xcb_randr_delete_output_property_request_t
+ **/
+typedef struct xcb_randr_delete_output_property_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_randr_output_t output;
+    xcb_atom_t         property;
+} xcb_randr_delete_output_property_request_t;
+
+/**
+ * @brief xcb_randr_get_output_property_cookie_t
+ **/
+typedef struct xcb_randr_get_output_property_cookie_t {
+    unsigned int sequence;
+} xcb_randr_get_output_property_cookie_t;
+
+/** Opcode for xcb_randr_get_output_property. */
+#define XCB_RANDR_GET_OUTPUT_PROPERTY 15
+
+/**
+ * @brief xcb_randr_get_output_property_request_t
+ **/
+typedef struct xcb_randr_get_output_property_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_randr_output_t output;
+    xcb_atom_t         property;
+    xcb_atom_t         type;
+    uint32_t           long_offset;
+    uint32_t           long_length;
+    uint8_t            _delete;
+    uint8_t            pending;
+    uint8_t            pad0[2];
+} xcb_randr_get_output_property_request_t;
+
+/**
+ * @brief xcb_randr_get_output_property_reply_t
+ **/
+typedef struct xcb_randr_get_output_property_reply_t {
+    uint8_t    response_type;
+    uint8_t    format;
+    uint16_t   sequence;
+    uint32_t   length;
+    xcb_atom_t type;
+    uint32_t   bytes_after;
+    uint32_t   num_items;
+    uint8_t    pad0[12];
+} xcb_randr_get_output_property_reply_t;
+
+/**
+ * @brief xcb_randr_create_mode_cookie_t
+ **/
+typedef struct xcb_randr_create_mode_cookie_t {
+    unsigned int sequence;
+} xcb_randr_create_mode_cookie_t;
+
+/** Opcode for xcb_randr_create_mode. */
+#define XCB_RANDR_CREATE_MODE 16
+
+/**
+ * @brief xcb_randr_create_mode_request_t
+ **/
+typedef struct xcb_randr_create_mode_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_window_t          window;
+    xcb_randr_mode_info_t mode_info;
+} xcb_randr_create_mode_request_t;
+
+/**
+ * @brief xcb_randr_create_mode_reply_t
+ **/
+typedef struct xcb_randr_create_mode_reply_t {
+    uint8_t          response_type;
+    uint8_t          pad0;
+    uint16_t         sequence;
+    uint32_t         length;
+    xcb_randr_mode_t mode;
+    uint8_t          pad1[20];
+} xcb_randr_create_mode_reply_t;
+
+/** Opcode for xcb_randr_destroy_mode. */
+#define XCB_RANDR_DESTROY_MODE 17
+
+/**
+ * @brief xcb_randr_destroy_mode_request_t
+ **/
+typedef struct xcb_randr_destroy_mode_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_randr_mode_t mode;
+} xcb_randr_destroy_mode_request_t;
+
+/** Opcode for xcb_randr_add_output_mode. */
+#define XCB_RANDR_ADD_OUTPUT_MODE 18
+
+/**
+ * @brief xcb_randr_add_output_mode_request_t
+ **/
+typedef struct xcb_randr_add_output_mode_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_randr_output_t output;
+    xcb_randr_mode_t   mode;
+} xcb_randr_add_output_mode_request_t;
+
+/** Opcode for xcb_randr_delete_output_mode. */
+#define XCB_RANDR_DELETE_OUTPUT_MODE 19
+
+/**
+ * @brief xcb_randr_delete_output_mode_request_t
+ **/
+typedef struct xcb_randr_delete_output_mode_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_randr_output_t output;
+    xcb_randr_mode_t   mode;
+} xcb_randr_delete_output_mode_request_t;
+
+/**
+ * @brief xcb_randr_get_crtc_info_cookie_t
+ **/
+typedef struct xcb_randr_get_crtc_info_cookie_t {
+    unsigned int sequence;
+} xcb_randr_get_crtc_info_cookie_t;
+
+/** Opcode for xcb_randr_get_crtc_info. */
+#define XCB_RANDR_GET_CRTC_INFO 20
+
+/**
+ * @brief xcb_randr_get_crtc_info_request_t
+ **/
+typedef struct xcb_randr_get_crtc_info_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_randr_crtc_t crtc;
+    xcb_timestamp_t  config_timestamp;
+} xcb_randr_get_crtc_info_request_t;
+
+/**
+ * @brief xcb_randr_get_crtc_info_reply_t
+ **/
+typedef struct xcb_randr_get_crtc_info_reply_t {
+    uint8_t          response_type;
+    uint8_t          status;
+    uint16_t         sequence;
+    uint32_t         length;
+    xcb_timestamp_t  timestamp;
+    int16_t          x;
+    int16_t          y;
+    uint16_t         width;
+    uint16_t         height;
+    xcb_randr_mode_t mode;
+    uint16_t         rotation;
+    uint16_t         rotations;
+    uint16_t         num_outputs;
+    uint16_t         num_possible_outputs;
+} xcb_randr_get_crtc_info_reply_t;
+
+/**
+ * @brief xcb_randr_set_crtc_config_cookie_t
+ **/
+typedef struct xcb_randr_set_crtc_config_cookie_t {
+    unsigned int sequence;
+} xcb_randr_set_crtc_config_cookie_t;
+
+/** Opcode for xcb_randr_set_crtc_config. */
+#define XCB_RANDR_SET_CRTC_CONFIG 21
+
+/**
+ * @brief xcb_randr_set_crtc_config_request_t
+ **/
+typedef struct xcb_randr_set_crtc_config_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_randr_crtc_t crtc;
+    xcb_timestamp_t  timestamp;
+    xcb_timestamp_t  config_timestamp;
+    int16_t          x;
+    int16_t          y;
+    xcb_randr_mode_t mode;
+    uint16_t         rotation;
+    uint8_t          pad0[2];
+} xcb_randr_set_crtc_config_request_t;
+
+/**
+ * @brief xcb_randr_set_crtc_config_reply_t
+ **/
+typedef struct xcb_randr_set_crtc_config_reply_t {
+    uint8_t         response_type;
+    uint8_t         status;
+    uint16_t        sequence;
+    uint32_t        length;
+    xcb_timestamp_t timestamp;
+    uint8_t         pad0[20];
+} xcb_randr_set_crtc_config_reply_t;
+
+/**
+ * @brief xcb_randr_get_crtc_gamma_size_cookie_t
+ **/
+typedef struct xcb_randr_get_crtc_gamma_size_cookie_t {
+    unsigned int sequence;
+} xcb_randr_get_crtc_gamma_size_cookie_t;
+
+/** Opcode for xcb_randr_get_crtc_gamma_size. */
+#define XCB_RANDR_GET_CRTC_GAMMA_SIZE 22
+
+/**
+ * @brief xcb_randr_get_crtc_gamma_size_request_t
+ **/
+typedef struct xcb_randr_get_crtc_gamma_size_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_randr_crtc_t crtc;
+} xcb_randr_get_crtc_gamma_size_request_t;
+
+/**
+ * @brief xcb_randr_get_crtc_gamma_size_reply_t
+ **/
+typedef struct xcb_randr_get_crtc_gamma_size_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t size;
+    uint8_t  pad1[22];
+} xcb_randr_get_crtc_gamma_size_reply_t;
+
+/**
+ * @brief xcb_randr_get_crtc_gamma_cookie_t
+ **/
+typedef struct xcb_randr_get_crtc_gamma_cookie_t {
+    unsigned int sequence;
+} xcb_randr_get_crtc_gamma_cookie_t;
+
+/** Opcode for xcb_randr_get_crtc_gamma. */
+#define XCB_RANDR_GET_CRTC_GAMMA 23
+
+/**
+ * @brief xcb_randr_get_crtc_gamma_request_t
+ **/
+typedef struct xcb_randr_get_crtc_gamma_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_randr_crtc_t crtc;
+} xcb_randr_get_crtc_gamma_request_t;
+
+/**
+ * @brief xcb_randr_get_crtc_gamma_reply_t
+ **/
+typedef struct xcb_randr_get_crtc_gamma_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t size;
+    uint8_t  pad1[22];
+} xcb_randr_get_crtc_gamma_reply_t;
+
+/** Opcode for xcb_randr_set_crtc_gamma. */
+#define XCB_RANDR_SET_CRTC_GAMMA 24
+
+/**
+ * @brief xcb_randr_set_crtc_gamma_request_t
+ **/
+typedef struct xcb_randr_set_crtc_gamma_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_randr_crtc_t crtc;
+    uint16_t         size;
+    uint8_t          pad0[2];
+} xcb_randr_set_crtc_gamma_request_t;
+
+/**
+ * @brief xcb_randr_get_screen_resources_current_cookie_t
+ **/
+typedef struct xcb_randr_get_screen_resources_current_cookie_t {
+    unsigned int sequence;
+} xcb_randr_get_screen_resources_current_cookie_t;
+
+/** Opcode for xcb_randr_get_screen_resources_current. */
+#define XCB_RANDR_GET_SCREEN_RESOURCES_CURRENT 25
+
+/**
+ * @brief xcb_randr_get_screen_resources_current_request_t
+ **/
+typedef struct xcb_randr_get_screen_resources_current_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_randr_get_screen_resources_current_request_t;
+
+/**
+ * @brief xcb_randr_get_screen_resources_current_reply_t
+ **/
+typedef struct xcb_randr_get_screen_resources_current_reply_t {
+    uint8_t         response_type;
+    uint8_t         pad0;
+    uint16_t        sequence;
+    uint32_t        length;
+    xcb_timestamp_t timestamp;
+    xcb_timestamp_t config_timestamp;
+    uint16_t        num_crtcs;
+    uint16_t        num_outputs;
+    uint16_t        num_modes;
+    uint16_t        names_len;
+    uint8_t         pad1[8];
+} xcb_randr_get_screen_resources_current_reply_t;
+
+typedef enum xcb_randr_transform_t {
+    XCB_RANDR_TRANSFORM_UNIT = 1,
+    XCB_RANDR_TRANSFORM_SCALE_UP = 2,
+    XCB_RANDR_TRANSFORM_SCALE_DOWN = 4,
+    XCB_RANDR_TRANSFORM_PROJECTIVE = 8
+} xcb_randr_transform_t;
+
+/** Opcode for xcb_randr_set_crtc_transform. */
+#define XCB_RANDR_SET_CRTC_TRANSFORM 26
+
+/**
+ * @brief xcb_randr_set_crtc_transform_request_t
+ **/
+typedef struct xcb_randr_set_crtc_transform_request_t {
+    uint8_t                major_opcode;
+    uint8_t                minor_opcode;
+    uint16_t               length;
+    xcb_randr_crtc_t       crtc;
+    xcb_render_transform_t transform;
+    uint16_t               filter_len;
+    uint8_t                pad0[2];
+} xcb_randr_set_crtc_transform_request_t;
+
+/**
+ * @brief xcb_randr_get_crtc_transform_cookie_t
+ **/
+typedef struct xcb_randr_get_crtc_transform_cookie_t {
+    unsigned int sequence;
+} xcb_randr_get_crtc_transform_cookie_t;
+
+/** Opcode for xcb_randr_get_crtc_transform. */
+#define XCB_RANDR_GET_CRTC_TRANSFORM 27
+
+/**
+ * @brief xcb_randr_get_crtc_transform_request_t
+ **/
+typedef struct xcb_randr_get_crtc_transform_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_randr_crtc_t crtc;
+} xcb_randr_get_crtc_transform_request_t;
+
+/**
+ * @brief xcb_randr_get_crtc_transform_reply_t
+ **/
+typedef struct xcb_randr_get_crtc_transform_reply_t {
+    uint8_t                response_type;
+    uint8_t                pad0;
+    uint16_t               sequence;
+    uint32_t               length;
+    xcb_render_transform_t pending_transform;
+    uint8_t                has_transforms;
+    uint8_t                pad1[3];
+    xcb_render_transform_t current_transform;
+    uint8_t                pad2[4];
+    uint16_t               pending_len;
+    uint16_t               pending_nparams;
+    uint16_t               current_len;
+    uint16_t               current_nparams;
+} xcb_randr_get_crtc_transform_reply_t;
+
+/**
+ * @brief xcb_randr_get_panning_cookie_t
+ **/
+typedef struct xcb_randr_get_panning_cookie_t {
+    unsigned int sequence;
+} xcb_randr_get_panning_cookie_t;
+
+/** Opcode for xcb_randr_get_panning. */
+#define XCB_RANDR_GET_PANNING 28
+
+/**
+ * @brief xcb_randr_get_panning_request_t
+ **/
+typedef struct xcb_randr_get_panning_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_randr_crtc_t crtc;
+} xcb_randr_get_panning_request_t;
+
+/**
+ * @brief xcb_randr_get_panning_reply_t
+ **/
+typedef struct xcb_randr_get_panning_reply_t {
+    uint8_t         response_type;
+    uint8_t         status;
+    uint16_t        sequence;
+    uint32_t        length;
+    xcb_timestamp_t timestamp;
+    uint16_t        left;
+    uint16_t        top;
+    uint16_t        width;
+    uint16_t        height;
+    uint16_t        track_left;
+    uint16_t        track_top;
+    uint16_t        track_width;
+    uint16_t        track_height;
+    int16_t         border_left;
+    int16_t         border_top;
+    int16_t         border_right;
+    int16_t         border_bottom;
+} xcb_randr_get_panning_reply_t;
+
+/**
+ * @brief xcb_randr_set_panning_cookie_t
+ **/
+typedef struct xcb_randr_set_panning_cookie_t {
+    unsigned int sequence;
+} xcb_randr_set_panning_cookie_t;
+
+/** Opcode for xcb_randr_set_panning. */
+#define XCB_RANDR_SET_PANNING 29
+
+/**
+ * @brief xcb_randr_set_panning_request_t
+ **/
+typedef struct xcb_randr_set_panning_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_randr_crtc_t crtc;
+    xcb_timestamp_t  timestamp;
+    uint16_t         left;
+    uint16_t         top;
+    uint16_t         width;
+    uint16_t         height;
+    uint16_t         track_left;
+    uint16_t         track_top;
+    uint16_t         track_width;
+    uint16_t         track_height;
+    int16_t          border_left;
+    int16_t          border_top;
+    int16_t          border_right;
+    int16_t          border_bottom;
+} xcb_randr_set_panning_request_t;
+
+/**
+ * @brief xcb_randr_set_panning_reply_t
+ **/
+typedef struct xcb_randr_set_panning_reply_t {
+    uint8_t         response_type;
+    uint8_t         status;
+    uint16_t        sequence;
+    uint32_t        length;
+    xcb_timestamp_t timestamp;
+} xcb_randr_set_panning_reply_t;
+
+/** Opcode for xcb_randr_set_output_primary. */
+#define XCB_RANDR_SET_OUTPUT_PRIMARY 30
+
+/**
+ * @brief xcb_randr_set_output_primary_request_t
+ **/
+typedef struct xcb_randr_set_output_primary_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_window_t       window;
+    xcb_randr_output_t output;
+} xcb_randr_set_output_primary_request_t;
+
+/**
+ * @brief xcb_randr_get_output_primary_cookie_t
+ **/
+typedef struct xcb_randr_get_output_primary_cookie_t {
+    unsigned int sequence;
+} xcb_randr_get_output_primary_cookie_t;
+
+/** Opcode for xcb_randr_get_output_primary. */
+#define XCB_RANDR_GET_OUTPUT_PRIMARY 31
+
+/**
+ * @brief xcb_randr_get_output_primary_request_t
+ **/
+typedef struct xcb_randr_get_output_primary_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_randr_get_output_primary_request_t;
+
+/**
+ * @brief xcb_randr_get_output_primary_reply_t
+ **/
+typedef struct xcb_randr_get_output_primary_reply_t {
+    uint8_t            response_type;
+    uint8_t            pad0;
+    uint16_t           sequence;
+    uint32_t           length;
+    xcb_randr_output_t output;
+} xcb_randr_get_output_primary_reply_t;
+
+/**
+ * @brief xcb_randr_get_providers_cookie_t
+ **/
+typedef struct xcb_randr_get_providers_cookie_t {
+    unsigned int sequence;
+} xcb_randr_get_providers_cookie_t;
+
+/** Opcode for xcb_randr_get_providers. */
+#define XCB_RANDR_GET_PROVIDERS 32
+
+/**
+ * @brief xcb_randr_get_providers_request_t
+ **/
+typedef struct xcb_randr_get_providers_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_randr_get_providers_request_t;
+
+/**
+ * @brief xcb_randr_get_providers_reply_t
+ **/
+typedef struct xcb_randr_get_providers_reply_t {
+    uint8_t         response_type;
+    uint8_t         pad0;
+    uint16_t        sequence;
+    uint32_t        length;
+    xcb_timestamp_t timestamp;
+    uint16_t        num_providers;
+    uint8_t         pad1[18];
+} xcb_randr_get_providers_reply_t;
+
+typedef enum xcb_randr_provider_capability_t {
+    XCB_RANDR_PROVIDER_CAPABILITY_SOURCE_OUTPUT = 1,
+    XCB_RANDR_PROVIDER_CAPABILITY_SINK_OUTPUT = 2,
+    XCB_RANDR_PROVIDER_CAPABILITY_SOURCE_OFFLOAD = 4,
+    XCB_RANDR_PROVIDER_CAPABILITY_SINK_OFFLOAD = 8
+} xcb_randr_provider_capability_t;
+
+/**
+ * @brief xcb_randr_get_provider_info_cookie_t
+ **/
+typedef struct xcb_randr_get_provider_info_cookie_t {
+    unsigned int sequence;
+} xcb_randr_get_provider_info_cookie_t;
+
+/** Opcode for xcb_randr_get_provider_info. */
+#define XCB_RANDR_GET_PROVIDER_INFO 33
+
+/**
+ * @brief xcb_randr_get_provider_info_request_t
+ **/
+typedef struct xcb_randr_get_provider_info_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_randr_provider_t provider;
+    xcb_timestamp_t      config_timestamp;
+} xcb_randr_get_provider_info_request_t;
+
+/**
+ * @brief xcb_randr_get_provider_info_reply_t
+ **/
+typedef struct xcb_randr_get_provider_info_reply_t {
+    uint8_t         response_type;
+    uint8_t         status;
+    uint16_t        sequence;
+    uint32_t        length;
+    xcb_timestamp_t timestamp;
+    uint32_t        capabilities;
+    uint16_t        num_crtcs;
+    uint16_t        num_outputs;
+    uint16_t        num_associated_providers;
+    uint16_t        name_len;
+    uint8_t         pad0[8];
+} xcb_randr_get_provider_info_reply_t;
+
+/** Opcode for xcb_randr_set_provider_offload_sink. */
+#define XCB_RANDR_SET_PROVIDER_OFFLOAD_SINK 34
+
+/**
+ * @brief xcb_randr_set_provider_offload_sink_request_t
+ **/
+typedef struct xcb_randr_set_provider_offload_sink_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_randr_provider_t provider;
+    xcb_randr_provider_t sink_provider;
+    xcb_timestamp_t      config_timestamp;
+} xcb_randr_set_provider_offload_sink_request_t;
+
+/** Opcode for xcb_randr_set_provider_output_source. */
+#define XCB_RANDR_SET_PROVIDER_OUTPUT_SOURCE 35
+
+/**
+ * @brief xcb_randr_set_provider_output_source_request_t
+ **/
+typedef struct xcb_randr_set_provider_output_source_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_randr_provider_t provider;
+    xcb_randr_provider_t source_provider;
+    xcb_timestamp_t      config_timestamp;
+} xcb_randr_set_provider_output_source_request_t;
+
+/**
+ * @brief xcb_randr_list_provider_properties_cookie_t
+ **/
+typedef struct xcb_randr_list_provider_properties_cookie_t {
+    unsigned int sequence;
+} xcb_randr_list_provider_properties_cookie_t;
+
+/** Opcode for xcb_randr_list_provider_properties. */
+#define XCB_RANDR_LIST_PROVIDER_PROPERTIES 36
+
+/**
+ * @brief xcb_randr_list_provider_properties_request_t
+ **/
+typedef struct xcb_randr_list_provider_properties_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_randr_provider_t provider;
+} xcb_randr_list_provider_properties_request_t;
+
+/**
+ * @brief xcb_randr_list_provider_properties_reply_t
+ **/
+typedef struct xcb_randr_list_provider_properties_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t num_atoms;
+    uint8_t  pad1[22];
+} xcb_randr_list_provider_properties_reply_t;
+
+/**
+ * @brief xcb_randr_query_provider_property_cookie_t
+ **/
+typedef struct xcb_randr_query_provider_property_cookie_t {
+    unsigned int sequence;
+} xcb_randr_query_provider_property_cookie_t;
+
+/** Opcode for xcb_randr_query_provider_property. */
+#define XCB_RANDR_QUERY_PROVIDER_PROPERTY 37
+
+/**
+ * @brief xcb_randr_query_provider_property_request_t
+ **/
+typedef struct xcb_randr_query_provider_property_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_randr_provider_t provider;
+    xcb_atom_t           property;
+} xcb_randr_query_provider_property_request_t;
+
+/**
+ * @brief xcb_randr_query_provider_property_reply_t
+ **/
+typedef struct xcb_randr_query_provider_property_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pending;
+    uint8_t  range;
+    uint8_t  immutable;
+    uint8_t  pad1[21];
+} xcb_randr_query_provider_property_reply_t;
+
+/** Opcode for xcb_randr_configure_provider_property. */
+#define XCB_RANDR_CONFIGURE_PROVIDER_PROPERTY 38
+
+/**
+ * @brief xcb_randr_configure_provider_property_request_t
+ **/
+typedef struct xcb_randr_configure_provider_property_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_randr_provider_t provider;
+    xcb_atom_t           property;
+    uint8_t              pending;
+    uint8_t              range;
+    uint8_t              pad0[2];
+} xcb_randr_configure_provider_property_request_t;
+
+/** Opcode for xcb_randr_change_provider_property. */
+#define XCB_RANDR_CHANGE_PROVIDER_PROPERTY 39
+
+/**
+ * @brief xcb_randr_change_provider_property_request_t
+ **/
+typedef struct xcb_randr_change_provider_property_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_randr_provider_t provider;
+    xcb_atom_t           property;
+    xcb_atom_t           type;
+    uint8_t              format;
+    uint8_t              mode;
+    uint8_t              pad0[2];
+    uint32_t             num_items;
+} xcb_randr_change_provider_property_request_t;
+
+/** Opcode for xcb_randr_delete_provider_property. */
+#define XCB_RANDR_DELETE_PROVIDER_PROPERTY 40
+
+/**
+ * @brief xcb_randr_delete_provider_property_request_t
+ **/
+typedef struct xcb_randr_delete_provider_property_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_randr_provider_t provider;
+    xcb_atom_t           property;
+} xcb_randr_delete_provider_property_request_t;
+
+/**
+ * @brief xcb_randr_get_provider_property_cookie_t
+ **/
+typedef struct xcb_randr_get_provider_property_cookie_t {
+    unsigned int sequence;
+} xcb_randr_get_provider_property_cookie_t;
+
+/** Opcode for xcb_randr_get_provider_property. */
+#define XCB_RANDR_GET_PROVIDER_PROPERTY 41
+
+/**
+ * @brief xcb_randr_get_provider_property_request_t
+ **/
+typedef struct xcb_randr_get_provider_property_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_randr_provider_t provider;
+    xcb_atom_t           property;
+    xcb_atom_t           type;
+    uint32_t             long_offset;
+    uint32_t             long_length;
+    uint8_t              _delete;
+    uint8_t              pending;
+    uint8_t              pad0[2];
+} xcb_randr_get_provider_property_request_t;
+
+/**
+ * @brief xcb_randr_get_provider_property_reply_t
+ **/
+typedef struct xcb_randr_get_provider_property_reply_t {
+    uint8_t    response_type;
+    uint8_t    format;
+    uint16_t   sequence;
+    uint32_t   length;
+    xcb_atom_t type;
+    uint32_t   bytes_after;
+    uint32_t   num_items;
+    uint8_t    pad0[12];
+} xcb_randr_get_provider_property_reply_t;
+
+/** Opcode for xcb_randr_screen_change_notify. */
+#define XCB_RANDR_SCREEN_CHANGE_NOTIFY 0
+
+/**
+ * @brief xcb_randr_screen_change_notify_event_t
+ **/
+typedef struct xcb_randr_screen_change_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         rotation;
+    uint16_t        sequence;
+    xcb_timestamp_t timestamp;
+    xcb_timestamp_t config_timestamp;
+    xcb_window_t    root;
+    xcb_window_t    request_window;
+    uint16_t        sizeID;
+    uint16_t        subpixel_order;
+    uint16_t        width;
+    uint16_t        height;
+    uint16_t        mwidth;
+    uint16_t        mheight;
+} xcb_randr_screen_change_notify_event_t;
+
+typedef enum xcb_randr_notify_t {
+    XCB_RANDR_NOTIFY_CRTC_CHANGE = 0,
+    XCB_RANDR_NOTIFY_OUTPUT_CHANGE = 1,
+    XCB_RANDR_NOTIFY_OUTPUT_PROPERTY = 2,
+    XCB_RANDR_NOTIFY_PROVIDER_CHANGE = 3,
+    XCB_RANDR_NOTIFY_PROVIDER_PROPERTY = 4,
+    XCB_RANDR_NOTIFY_RESOURCE_CHANGE = 5,
+    XCB_RANDR_NOTIFY_LEASE = 6
+} xcb_randr_notify_t;
+
+/**
+ * @brief xcb_randr_crtc_change_t
+ **/
+typedef struct xcb_randr_crtc_change_t {
+    xcb_timestamp_t  timestamp;
+    xcb_window_t     window;
+    xcb_randr_crtc_t crtc;
+    xcb_randr_mode_t mode;
+    uint16_t         rotation;
+    uint8_t          pad0[2];
+    int16_t          x;
+    int16_t          y;
+    uint16_t         width;
+    uint16_t         height;
+} xcb_randr_crtc_change_t;
+
+/**
+ * @brief xcb_randr_crtc_change_iterator_t
+ **/
+typedef struct xcb_randr_crtc_change_iterator_t {
+    xcb_randr_crtc_change_t *data;
+    int                      rem;
+    int                      index;
+} xcb_randr_crtc_change_iterator_t;
+
+/**
+ * @brief xcb_randr_output_change_t
+ **/
+typedef struct xcb_randr_output_change_t {
+    xcb_timestamp_t    timestamp;
+    xcb_timestamp_t    config_timestamp;
+    xcb_window_t       window;
+    xcb_randr_output_t output;
+    xcb_randr_crtc_t   crtc;
+    xcb_randr_mode_t   mode;
+    uint16_t           rotation;
+    uint8_t            connection;
+    uint8_t            subpixel_order;
+} xcb_randr_output_change_t;
+
+/**
+ * @brief xcb_randr_output_change_iterator_t
+ **/
+typedef struct xcb_randr_output_change_iterator_t {
+    xcb_randr_output_change_t *data;
+    int                        rem;
+    int                        index;
+} xcb_randr_output_change_iterator_t;
+
+/**
+ * @brief xcb_randr_output_property_t
+ **/
+typedef struct xcb_randr_output_property_t {
+    xcb_window_t       window;
+    xcb_randr_output_t output;
+    xcb_atom_t         atom;
+    xcb_timestamp_t    timestamp;
+    uint8_t            status;
+    uint8_t            pad0[11];
+} xcb_randr_output_property_t;
+
+/**
+ * @brief xcb_randr_output_property_iterator_t
+ **/
+typedef struct xcb_randr_output_property_iterator_t {
+    xcb_randr_output_property_t *data;
+    int                          rem;
+    int                          index;
+} xcb_randr_output_property_iterator_t;
+
+/**
+ * @brief xcb_randr_provider_change_t
+ **/
+typedef struct xcb_randr_provider_change_t {
+    xcb_timestamp_t      timestamp;
+    xcb_window_t         window;
+    xcb_randr_provider_t provider;
+    uint8_t              pad0[16];
+} xcb_randr_provider_change_t;
+
+/**
+ * @brief xcb_randr_provider_change_iterator_t
+ **/
+typedef struct xcb_randr_provider_change_iterator_t {
+    xcb_randr_provider_change_t *data;
+    int                          rem;
+    int                          index;
+} xcb_randr_provider_change_iterator_t;
+
+/**
+ * @brief xcb_randr_provider_property_t
+ **/
+typedef struct xcb_randr_provider_property_t {
+    xcb_window_t         window;
+    xcb_randr_provider_t provider;
+    xcb_atom_t           atom;
+    xcb_timestamp_t      timestamp;
+    uint8_t              state;
+    uint8_t              pad0[11];
+} xcb_randr_provider_property_t;
+
+/**
+ * @brief xcb_randr_provider_property_iterator_t
+ **/
+typedef struct xcb_randr_provider_property_iterator_t {
+    xcb_randr_provider_property_t *data;
+    int                            rem;
+    int                            index;
+} xcb_randr_provider_property_iterator_t;
+
+/**
+ * @brief xcb_randr_resource_change_t
+ **/
+typedef struct xcb_randr_resource_change_t {
+    xcb_timestamp_t timestamp;
+    xcb_window_t    window;
+    uint8_t         pad0[20];
+} xcb_randr_resource_change_t;
+
+/**
+ * @brief xcb_randr_resource_change_iterator_t
+ **/
+typedef struct xcb_randr_resource_change_iterator_t {
+    xcb_randr_resource_change_t *data;
+    int                          rem;
+    int                          index;
+} xcb_randr_resource_change_iterator_t;
+
+/**
+ * @brief xcb_randr_monitor_info_t
+ **/
+typedef struct xcb_randr_monitor_info_t {
+    xcb_atom_t name;
+    uint8_t    primary;
+    uint8_t    automatic;
+    uint16_t   nOutput;
+    int16_t    x;
+    int16_t    y;
+    uint16_t   width;
+    uint16_t   height;
+    uint32_t   width_in_millimeters;
+    uint32_t   height_in_millimeters;
+} xcb_randr_monitor_info_t;
+
+/**
+ * @brief xcb_randr_monitor_info_iterator_t
+ **/
+typedef struct xcb_randr_monitor_info_iterator_t {
+    xcb_randr_monitor_info_t *data;
+    int                       rem;
+    int                       index;
+} xcb_randr_monitor_info_iterator_t;
+
+/**
+ * @brief xcb_randr_get_monitors_cookie_t
+ **/
+typedef struct xcb_randr_get_monitors_cookie_t {
+    unsigned int sequence;
+} xcb_randr_get_monitors_cookie_t;
+
+/** Opcode for xcb_randr_get_monitors. */
+#define XCB_RANDR_GET_MONITORS 42
+
+/**
+ * @brief xcb_randr_get_monitors_request_t
+ **/
+typedef struct xcb_randr_get_monitors_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    uint8_t      get_active;
+} xcb_randr_get_monitors_request_t;
+
+/**
+ * @brief xcb_randr_get_monitors_reply_t
+ **/
+typedef struct xcb_randr_get_monitors_reply_t {
+    uint8_t         response_type;
+    uint8_t         pad0;
+    uint16_t        sequence;
+    uint32_t        length;
+    xcb_timestamp_t timestamp;
+    uint32_t        nMonitors;
+    uint32_t        nOutputs;
+    uint8_t         pad1[12];
+} xcb_randr_get_monitors_reply_t;
+
+/** Opcode for xcb_randr_set_monitor. */
+#define XCB_RANDR_SET_MONITOR 43
+
+/**
+ * @brief xcb_randr_set_monitor_request_t
+ **/
+typedef struct xcb_randr_set_monitor_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_randr_set_monitor_request_t;
+
+/** Opcode for xcb_randr_delete_monitor. */
+#define XCB_RANDR_DELETE_MONITOR 44
+
+/**
+ * @brief xcb_randr_delete_monitor_request_t
+ **/
+typedef struct xcb_randr_delete_monitor_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    xcb_atom_t   name;
+} xcb_randr_delete_monitor_request_t;
+
+/**
+ * @brief xcb_randr_create_lease_cookie_t
+ **/
+typedef struct xcb_randr_create_lease_cookie_t {
+    unsigned int sequence;
+} xcb_randr_create_lease_cookie_t;
+
+/** Opcode for xcb_randr_create_lease. */
+#define XCB_RANDR_CREATE_LEASE 45
+
+/**
+ * @brief xcb_randr_create_lease_request_t
+ **/
+typedef struct xcb_randr_create_lease_request_t {
+    uint8_t           major_opcode;
+    uint8_t           minor_opcode;
+    uint16_t          length;
+    xcb_window_t      window;
+    xcb_randr_lease_t lid;
+    uint16_t          num_crtcs;
+    uint16_t          num_outputs;
+} xcb_randr_create_lease_request_t;
+
+/**
+ * @brief xcb_randr_create_lease_reply_t
+ **/
+typedef struct xcb_randr_create_lease_reply_t {
+    uint8_t  response_type;
+    uint8_t  nfd;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad0[24];
+} xcb_randr_create_lease_reply_t;
+
+/** Opcode for xcb_randr_free_lease. */
+#define XCB_RANDR_FREE_LEASE 46
+
+/**
+ * @brief xcb_randr_free_lease_request_t
+ **/
+typedef struct xcb_randr_free_lease_request_t {
+    uint8_t           major_opcode;
+    uint8_t           minor_opcode;
+    uint16_t          length;
+    xcb_randr_lease_t lid;
+    uint8_t           terminate;
+} xcb_randr_free_lease_request_t;
+
+/**
+ * @brief xcb_randr_lease_notify_t
+ **/
+typedef struct xcb_randr_lease_notify_t {
+    xcb_timestamp_t   timestamp;
+    xcb_window_t      window;
+    xcb_randr_lease_t lease;
+    uint8_t           created;
+    uint8_t           pad0[15];
+} xcb_randr_lease_notify_t;
+
+/**
+ * @brief xcb_randr_lease_notify_iterator_t
+ **/
+typedef struct xcb_randr_lease_notify_iterator_t {
+    xcb_randr_lease_notify_t *data;
+    int                       rem;
+    int                       index;
+} xcb_randr_lease_notify_iterator_t;
+
+/**
+ * @brief xcb_randr_notify_data_t
+ **/
+typedef union xcb_randr_notify_data_t {
+    xcb_randr_crtc_change_t       cc;
+    xcb_randr_output_change_t     oc;
+    xcb_randr_output_property_t   op;
+    xcb_randr_provider_change_t   pc;
+    xcb_randr_provider_property_t pp;
+    xcb_randr_resource_change_t   rc;
+    xcb_randr_lease_notify_t      lc;
+} xcb_randr_notify_data_t;
+
+/**
+ * @brief xcb_randr_notify_data_iterator_t
+ **/
+typedef struct xcb_randr_notify_data_iterator_t {
+    xcb_randr_notify_data_t *data;
+    int                      rem;
+    int                      index;
+} xcb_randr_notify_data_iterator_t;
+
+/** Opcode for xcb_randr_notify. */
+#define XCB_RANDR_NOTIFY 1
+
+/**
+ * @brief xcb_randr_notify_event_t
+ **/
+typedef struct xcb_randr_notify_event_t {
+    uint8_t                 response_type;
+    uint8_t                 subCode;
+    uint16_t                sequence;
+    xcb_randr_notify_data_t u;
+} xcb_randr_notify_event_t;
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_randr_mode_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_randr_mode_t)
+ */
+void
+xcb_randr_mode_next (xcb_randr_mode_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_randr_mode_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_randr_mode_end (xcb_randr_mode_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_randr_crtc_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_randr_crtc_t)
+ */
+void
+xcb_randr_crtc_next (xcb_randr_crtc_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_randr_crtc_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_randr_crtc_end (xcb_randr_crtc_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_randr_output_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_randr_output_t)
+ */
+void
+xcb_randr_output_next (xcb_randr_output_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_randr_output_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_randr_output_end (xcb_randr_output_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_randr_provider_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_randr_provider_t)
+ */
+void
+xcb_randr_provider_next (xcb_randr_provider_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_randr_provider_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_randr_provider_end (xcb_randr_provider_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_randr_lease_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_randr_lease_t)
+ */
+void
+xcb_randr_lease_next (xcb_randr_lease_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_randr_lease_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_randr_lease_end (xcb_randr_lease_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_randr_screen_size_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_randr_screen_size_t)
+ */
+void
+xcb_randr_screen_size_next (xcb_randr_screen_size_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_randr_screen_size_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_randr_screen_size_end (xcb_randr_screen_size_iterator_t i);
+
+int
+xcb_randr_refresh_rates_sizeof (const void  *_buffer);
+
+uint16_t *
+xcb_randr_refresh_rates_rates (const xcb_randr_refresh_rates_t *R);
+
+int
+xcb_randr_refresh_rates_rates_length (const xcb_randr_refresh_rates_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_refresh_rates_rates_end (const xcb_randr_refresh_rates_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_randr_refresh_rates_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_randr_refresh_rates_t)
+ */
+void
+xcb_randr_refresh_rates_next (xcb_randr_refresh_rates_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_randr_refresh_rates_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_randr_refresh_rates_end (xcb_randr_refresh_rates_iterator_t i);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_query_version_cookie_t
+xcb_randr_query_version (xcb_connection_t *c,
+                         uint32_t          major_version,
+                         uint32_t          minor_version);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_query_version_cookie_t
+xcb_randr_query_version_unchecked (xcb_connection_t *c,
+                                   uint32_t          major_version,
+                                   uint32_t          minor_version);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_query_version_reply_t *
+xcb_randr_query_version_reply (xcb_connection_t                  *c,
+                               xcb_randr_query_version_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_set_screen_config_cookie_t
+xcb_randr_set_screen_config (xcb_connection_t *c,
+                             xcb_window_t      window,
+                             xcb_timestamp_t   timestamp,
+                             xcb_timestamp_t   config_timestamp,
+                             uint16_t          sizeID,
+                             uint16_t          rotation,
+                             uint16_t          rate);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_set_screen_config_cookie_t
+xcb_randr_set_screen_config_unchecked (xcb_connection_t *c,
+                                       xcb_window_t      window,
+                                       xcb_timestamp_t   timestamp,
+                                       xcb_timestamp_t   config_timestamp,
+                                       uint16_t          sizeID,
+                                       uint16_t          rotation,
+                                       uint16_t          rate);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_set_screen_config_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_set_screen_config_reply_t *
+xcb_randr_set_screen_config_reply (xcb_connection_t                      *c,
+                                   xcb_randr_set_screen_config_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_randr_select_input_checked (xcb_connection_t *c,
+                                xcb_window_t      window,
+                                uint16_t          enable);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_randr_select_input (xcb_connection_t *c,
+                        xcb_window_t      window,
+                        uint16_t          enable);
+
+int
+xcb_randr_get_screen_info_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_get_screen_info_cookie_t
+xcb_randr_get_screen_info (xcb_connection_t *c,
+                           xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_get_screen_info_cookie_t
+xcb_randr_get_screen_info_unchecked (xcb_connection_t *c,
+                                     xcb_window_t      window);
+
+xcb_randr_screen_size_t *
+xcb_randr_get_screen_info_sizes (const xcb_randr_get_screen_info_reply_t *R);
+
+int
+xcb_randr_get_screen_info_sizes_length (const xcb_randr_get_screen_info_reply_t *R);
+
+xcb_randr_screen_size_iterator_t
+xcb_randr_get_screen_info_sizes_iterator (const xcb_randr_get_screen_info_reply_t *R);
+
+int
+xcb_randr_get_screen_info_rates_length (const xcb_randr_get_screen_info_reply_t *R);
+
+xcb_randr_refresh_rates_iterator_t
+xcb_randr_get_screen_info_rates_iterator (const xcb_randr_get_screen_info_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_get_screen_info_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_get_screen_info_reply_t *
+xcb_randr_get_screen_info_reply (xcb_connection_t                    *c,
+                                 xcb_randr_get_screen_info_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_get_screen_size_range_cookie_t
+xcb_randr_get_screen_size_range (xcb_connection_t *c,
+                                 xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_get_screen_size_range_cookie_t
+xcb_randr_get_screen_size_range_unchecked (xcb_connection_t *c,
+                                           xcb_window_t      window);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_get_screen_size_range_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_get_screen_size_range_reply_t *
+xcb_randr_get_screen_size_range_reply (xcb_connection_t                          *c,
+                                       xcb_randr_get_screen_size_range_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_randr_set_screen_size_checked (xcb_connection_t *c,
+                                   xcb_window_t      window,
+                                   uint16_t          width,
+                                   uint16_t          height,
+                                   uint32_t          mm_width,
+                                   uint32_t          mm_height);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_randr_set_screen_size (xcb_connection_t *c,
+                           xcb_window_t      window,
+                           uint16_t          width,
+                           uint16_t          height,
+                           uint32_t          mm_width,
+                           uint32_t          mm_height);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_randr_mode_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_randr_mode_info_t)
+ */
+void
+xcb_randr_mode_info_next (xcb_randr_mode_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_randr_mode_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_randr_mode_info_end (xcb_randr_mode_info_iterator_t i);
+
+int
+xcb_randr_get_screen_resources_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_get_screen_resources_cookie_t
+xcb_randr_get_screen_resources (xcb_connection_t *c,
+                                xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_get_screen_resources_cookie_t
+xcb_randr_get_screen_resources_unchecked (xcb_connection_t *c,
+                                          xcb_window_t      window);
+
+xcb_randr_crtc_t *
+xcb_randr_get_screen_resources_crtcs (const xcb_randr_get_screen_resources_reply_t *R);
+
+int
+xcb_randr_get_screen_resources_crtcs_length (const xcb_randr_get_screen_resources_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_screen_resources_crtcs_end (const xcb_randr_get_screen_resources_reply_t *R);
+
+xcb_randr_output_t *
+xcb_randr_get_screen_resources_outputs (const xcb_randr_get_screen_resources_reply_t *R);
+
+int
+xcb_randr_get_screen_resources_outputs_length (const xcb_randr_get_screen_resources_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_screen_resources_outputs_end (const xcb_randr_get_screen_resources_reply_t *R);
+
+xcb_randr_mode_info_t *
+xcb_randr_get_screen_resources_modes (const xcb_randr_get_screen_resources_reply_t *R);
+
+int
+xcb_randr_get_screen_resources_modes_length (const xcb_randr_get_screen_resources_reply_t *R);
+
+xcb_randr_mode_info_iterator_t
+xcb_randr_get_screen_resources_modes_iterator (const xcb_randr_get_screen_resources_reply_t *R);
+
+uint8_t *
+xcb_randr_get_screen_resources_names (const xcb_randr_get_screen_resources_reply_t *R);
+
+int
+xcb_randr_get_screen_resources_names_length (const xcb_randr_get_screen_resources_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_screen_resources_names_end (const xcb_randr_get_screen_resources_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_get_screen_resources_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_get_screen_resources_reply_t *
+xcb_randr_get_screen_resources_reply (xcb_connection_t                         *c,
+                                      xcb_randr_get_screen_resources_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e);
+
+int
+xcb_randr_get_output_info_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_get_output_info_cookie_t
+xcb_randr_get_output_info (xcb_connection_t   *c,
+                           xcb_randr_output_t  output,
+                           xcb_timestamp_t     config_timestamp);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_get_output_info_cookie_t
+xcb_randr_get_output_info_unchecked (xcb_connection_t   *c,
+                                     xcb_randr_output_t  output,
+                                     xcb_timestamp_t     config_timestamp);
+
+xcb_randr_crtc_t *
+xcb_randr_get_output_info_crtcs (const xcb_randr_get_output_info_reply_t *R);
+
+int
+xcb_randr_get_output_info_crtcs_length (const xcb_randr_get_output_info_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_output_info_crtcs_end (const xcb_randr_get_output_info_reply_t *R);
+
+xcb_randr_mode_t *
+xcb_randr_get_output_info_modes (const xcb_randr_get_output_info_reply_t *R);
+
+int
+xcb_randr_get_output_info_modes_length (const xcb_randr_get_output_info_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_output_info_modes_end (const xcb_randr_get_output_info_reply_t *R);
+
+xcb_randr_output_t *
+xcb_randr_get_output_info_clones (const xcb_randr_get_output_info_reply_t *R);
+
+int
+xcb_randr_get_output_info_clones_length (const xcb_randr_get_output_info_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_output_info_clones_end (const xcb_randr_get_output_info_reply_t *R);
+
+uint8_t *
+xcb_randr_get_output_info_name (const xcb_randr_get_output_info_reply_t *R);
+
+int
+xcb_randr_get_output_info_name_length (const xcb_randr_get_output_info_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_output_info_name_end (const xcb_randr_get_output_info_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_get_output_info_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_get_output_info_reply_t *
+xcb_randr_get_output_info_reply (xcb_connection_t                    *c,
+                                 xcb_randr_get_output_info_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e);
+
+int
+xcb_randr_list_output_properties_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_list_output_properties_cookie_t
+xcb_randr_list_output_properties (xcb_connection_t   *c,
+                                  xcb_randr_output_t  output);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_list_output_properties_cookie_t
+xcb_randr_list_output_properties_unchecked (xcb_connection_t   *c,
+                                            xcb_randr_output_t  output);
+
+xcb_atom_t *
+xcb_randr_list_output_properties_atoms (const xcb_randr_list_output_properties_reply_t *R);
+
+int
+xcb_randr_list_output_properties_atoms_length (const xcb_randr_list_output_properties_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_list_output_properties_atoms_end (const xcb_randr_list_output_properties_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_list_output_properties_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_list_output_properties_reply_t *
+xcb_randr_list_output_properties_reply (xcb_connection_t                           *c,
+                                        xcb_randr_list_output_properties_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e);
+
+int
+xcb_randr_query_output_property_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_query_output_property_cookie_t
+xcb_randr_query_output_property (xcb_connection_t   *c,
+                                 xcb_randr_output_t  output,
+                                 xcb_atom_t          property);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_query_output_property_cookie_t
+xcb_randr_query_output_property_unchecked (xcb_connection_t   *c,
+                                           xcb_randr_output_t  output,
+                                           xcb_atom_t          property);
+
+int32_t *
+xcb_randr_query_output_property_valid_values (const xcb_randr_query_output_property_reply_t *R);
+
+int
+xcb_randr_query_output_property_valid_values_length (const xcb_randr_query_output_property_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_query_output_property_valid_values_end (const xcb_randr_query_output_property_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_query_output_property_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_query_output_property_reply_t *
+xcb_randr_query_output_property_reply (xcb_connection_t                          *c,
+                                       xcb_randr_query_output_property_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e);
+
+int
+xcb_randr_configure_output_property_sizeof (const void  *_buffer,
+                                            uint32_t     values_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_randr_configure_output_property_checked (xcb_connection_t   *c,
+                                             xcb_randr_output_t  output,
+                                             xcb_atom_t          property,
+                                             uint8_t             pending,
+                                             uint8_t             range,
+                                             uint32_t            values_len,
+                                             const int32_t      *values);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_randr_configure_output_property (xcb_connection_t   *c,
+                                     xcb_randr_output_t  output,
+                                     xcb_atom_t          property,
+                                     uint8_t             pending,
+                                     uint8_t             range,
+                                     uint32_t            values_len,
+                                     const int32_t      *values);
+
+int32_t *
+xcb_randr_configure_output_property_values (const xcb_randr_configure_output_property_request_t *R);
+
+int
+xcb_randr_configure_output_property_values_length (const xcb_randr_configure_output_property_request_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_configure_output_property_values_end (const xcb_randr_configure_output_property_request_t *R);
+
+int
+xcb_randr_change_output_property_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_randr_change_output_property_checked (xcb_connection_t   *c,
+                                          xcb_randr_output_t  output,
+                                          xcb_atom_t          property,
+                                          xcb_atom_t          type,
+                                          uint8_t             format,
+                                          uint8_t             mode,
+                                          uint32_t            num_units,
+                                          const void         *data);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_randr_change_output_property (xcb_connection_t   *c,
+                                  xcb_randr_output_t  output,
+                                  xcb_atom_t          property,
+                                  xcb_atom_t          type,
+                                  uint8_t             format,
+                                  uint8_t             mode,
+                                  uint32_t            num_units,
+                                  const void         *data);
+
+void *
+xcb_randr_change_output_property_data (const xcb_randr_change_output_property_request_t *R);
+
+int
+xcb_randr_change_output_property_data_length (const xcb_randr_change_output_property_request_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_change_output_property_data_end (const xcb_randr_change_output_property_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_randr_delete_output_property_checked (xcb_connection_t   *c,
+                                          xcb_randr_output_t  output,
+                                          xcb_atom_t          property);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_randr_delete_output_property (xcb_connection_t   *c,
+                                  xcb_randr_output_t  output,
+                                  xcb_atom_t          property);
+
+int
+xcb_randr_get_output_property_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_get_output_property_cookie_t
+xcb_randr_get_output_property (xcb_connection_t   *c,
+                               xcb_randr_output_t  output,
+                               xcb_atom_t          property,
+                               xcb_atom_t          type,
+                               uint32_t            long_offset,
+                               uint32_t            long_length,
+                               uint8_t             _delete,
+                               uint8_t             pending);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_get_output_property_cookie_t
+xcb_randr_get_output_property_unchecked (xcb_connection_t   *c,
+                                         xcb_randr_output_t  output,
+                                         xcb_atom_t          property,
+                                         xcb_atom_t          type,
+                                         uint32_t            long_offset,
+                                         uint32_t            long_length,
+                                         uint8_t             _delete,
+                                         uint8_t             pending);
+
+uint8_t *
+xcb_randr_get_output_property_data (const xcb_randr_get_output_property_reply_t *R);
+
+int
+xcb_randr_get_output_property_data_length (const xcb_randr_get_output_property_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_output_property_data_end (const xcb_randr_get_output_property_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_get_output_property_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_get_output_property_reply_t *
+xcb_randr_get_output_property_reply (xcb_connection_t                        *c,
+                                     xcb_randr_get_output_property_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e);
+
+int
+xcb_randr_create_mode_sizeof (const void  *_buffer,
+                              uint32_t     name_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_create_mode_cookie_t
+xcb_randr_create_mode (xcb_connection_t      *c,
+                       xcb_window_t           window,
+                       xcb_randr_mode_info_t  mode_info,
+                       uint32_t               name_len,
+                       const char            *name);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_create_mode_cookie_t
+xcb_randr_create_mode_unchecked (xcb_connection_t      *c,
+                                 xcb_window_t           window,
+                                 xcb_randr_mode_info_t  mode_info,
+                                 uint32_t               name_len,
+                                 const char            *name);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_create_mode_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_create_mode_reply_t *
+xcb_randr_create_mode_reply (xcb_connection_t                *c,
+                             xcb_randr_create_mode_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_randr_destroy_mode_checked (xcb_connection_t *c,
+                                xcb_randr_mode_t  mode);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_randr_destroy_mode (xcb_connection_t *c,
+                        xcb_randr_mode_t  mode);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_randr_add_output_mode_checked (xcb_connection_t   *c,
+                                   xcb_randr_output_t  output,
+                                   xcb_randr_mode_t    mode);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_randr_add_output_mode (xcb_connection_t   *c,
+                           xcb_randr_output_t  output,
+                           xcb_randr_mode_t    mode);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_randr_delete_output_mode_checked (xcb_connection_t   *c,
+                                      xcb_randr_output_t  output,
+                                      xcb_randr_mode_t    mode);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_randr_delete_output_mode (xcb_connection_t   *c,
+                              xcb_randr_output_t  output,
+                              xcb_randr_mode_t    mode);
+
+int
+xcb_randr_get_crtc_info_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_get_crtc_info_cookie_t
+xcb_randr_get_crtc_info (xcb_connection_t *c,
+                         xcb_randr_crtc_t  crtc,
+                         xcb_timestamp_t   config_timestamp);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_get_crtc_info_cookie_t
+xcb_randr_get_crtc_info_unchecked (xcb_connection_t *c,
+                                   xcb_randr_crtc_t  crtc,
+                                   xcb_timestamp_t   config_timestamp);
+
+xcb_randr_output_t *
+xcb_randr_get_crtc_info_outputs (const xcb_randr_get_crtc_info_reply_t *R);
+
+int
+xcb_randr_get_crtc_info_outputs_length (const xcb_randr_get_crtc_info_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_crtc_info_outputs_end (const xcb_randr_get_crtc_info_reply_t *R);
+
+xcb_randr_output_t *
+xcb_randr_get_crtc_info_possible (const xcb_randr_get_crtc_info_reply_t *R);
+
+int
+xcb_randr_get_crtc_info_possible_length (const xcb_randr_get_crtc_info_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_crtc_info_possible_end (const xcb_randr_get_crtc_info_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_get_crtc_info_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_get_crtc_info_reply_t *
+xcb_randr_get_crtc_info_reply (xcb_connection_t                  *c,
+                               xcb_randr_get_crtc_info_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+int
+xcb_randr_set_crtc_config_sizeof (const void  *_buffer,
+                                  uint32_t     outputs_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_set_crtc_config_cookie_t
+xcb_randr_set_crtc_config (xcb_connection_t         *c,
+                           xcb_randr_crtc_t          crtc,
+                           xcb_timestamp_t           timestamp,
+                           xcb_timestamp_t           config_timestamp,
+                           int16_t                   x,
+                           int16_t                   y,
+                           xcb_randr_mode_t          mode,
+                           uint16_t                  rotation,
+                           uint32_t                  outputs_len,
+                           const xcb_randr_output_t *outputs);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_set_crtc_config_cookie_t
+xcb_randr_set_crtc_config_unchecked (xcb_connection_t         *c,
+                                     xcb_randr_crtc_t          crtc,
+                                     xcb_timestamp_t           timestamp,
+                                     xcb_timestamp_t           config_timestamp,
+                                     int16_t                   x,
+                                     int16_t                   y,
+                                     xcb_randr_mode_t          mode,
+                                     uint16_t                  rotation,
+                                     uint32_t                  outputs_len,
+                                     const xcb_randr_output_t *outputs);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_set_crtc_config_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_set_crtc_config_reply_t *
+xcb_randr_set_crtc_config_reply (xcb_connection_t                    *c,
+                                 xcb_randr_set_crtc_config_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_get_crtc_gamma_size_cookie_t
+xcb_randr_get_crtc_gamma_size (xcb_connection_t *c,
+                               xcb_randr_crtc_t  crtc);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_get_crtc_gamma_size_cookie_t
+xcb_randr_get_crtc_gamma_size_unchecked (xcb_connection_t *c,
+                                         xcb_randr_crtc_t  crtc);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_get_crtc_gamma_size_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_get_crtc_gamma_size_reply_t *
+xcb_randr_get_crtc_gamma_size_reply (xcb_connection_t                        *c,
+                                     xcb_randr_get_crtc_gamma_size_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e);
+
+int
+xcb_randr_get_crtc_gamma_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_get_crtc_gamma_cookie_t
+xcb_randr_get_crtc_gamma (xcb_connection_t *c,
+                          xcb_randr_crtc_t  crtc);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_get_crtc_gamma_cookie_t
+xcb_randr_get_crtc_gamma_unchecked (xcb_connection_t *c,
+                                    xcb_randr_crtc_t  crtc);
+
+uint16_t *
+xcb_randr_get_crtc_gamma_red (const xcb_randr_get_crtc_gamma_reply_t *R);
+
+int
+xcb_randr_get_crtc_gamma_red_length (const xcb_randr_get_crtc_gamma_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_crtc_gamma_red_end (const xcb_randr_get_crtc_gamma_reply_t *R);
+
+uint16_t *
+xcb_randr_get_crtc_gamma_green (const xcb_randr_get_crtc_gamma_reply_t *R);
+
+int
+xcb_randr_get_crtc_gamma_green_length (const xcb_randr_get_crtc_gamma_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_crtc_gamma_green_end (const xcb_randr_get_crtc_gamma_reply_t *R);
+
+uint16_t *
+xcb_randr_get_crtc_gamma_blue (const xcb_randr_get_crtc_gamma_reply_t *R);
+
+int
+xcb_randr_get_crtc_gamma_blue_length (const xcb_randr_get_crtc_gamma_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_crtc_gamma_blue_end (const xcb_randr_get_crtc_gamma_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_get_crtc_gamma_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_get_crtc_gamma_reply_t *
+xcb_randr_get_crtc_gamma_reply (xcb_connection_t                   *c,
+                                xcb_randr_get_crtc_gamma_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e);
+
+int
+xcb_randr_set_crtc_gamma_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_randr_set_crtc_gamma_checked (xcb_connection_t *c,
+                                  xcb_randr_crtc_t  crtc,
+                                  uint16_t          size,
+                                  const uint16_t   *red,
+                                  const uint16_t   *green,
+                                  const uint16_t   *blue);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_randr_set_crtc_gamma (xcb_connection_t *c,
+                          xcb_randr_crtc_t  crtc,
+                          uint16_t          size,
+                          const uint16_t   *red,
+                          const uint16_t   *green,
+                          const uint16_t   *blue);
+
+uint16_t *
+xcb_randr_set_crtc_gamma_red (const xcb_randr_set_crtc_gamma_request_t *R);
+
+int
+xcb_randr_set_crtc_gamma_red_length (const xcb_randr_set_crtc_gamma_request_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_set_crtc_gamma_red_end (const xcb_randr_set_crtc_gamma_request_t *R);
+
+uint16_t *
+xcb_randr_set_crtc_gamma_green (const xcb_randr_set_crtc_gamma_request_t *R);
+
+int
+xcb_randr_set_crtc_gamma_green_length (const xcb_randr_set_crtc_gamma_request_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_set_crtc_gamma_green_end (const xcb_randr_set_crtc_gamma_request_t *R);
+
+uint16_t *
+xcb_randr_set_crtc_gamma_blue (const xcb_randr_set_crtc_gamma_request_t *R);
+
+int
+xcb_randr_set_crtc_gamma_blue_length (const xcb_randr_set_crtc_gamma_request_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_set_crtc_gamma_blue_end (const xcb_randr_set_crtc_gamma_request_t *R);
+
+int
+xcb_randr_get_screen_resources_current_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_get_screen_resources_current_cookie_t
+xcb_randr_get_screen_resources_current (xcb_connection_t *c,
+                                        xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_get_screen_resources_current_cookie_t
+xcb_randr_get_screen_resources_current_unchecked (xcb_connection_t *c,
+                                                  xcb_window_t      window);
+
+xcb_randr_crtc_t *
+xcb_randr_get_screen_resources_current_crtcs (const xcb_randr_get_screen_resources_current_reply_t *R);
+
+int
+xcb_randr_get_screen_resources_current_crtcs_length (const xcb_randr_get_screen_resources_current_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_screen_resources_current_crtcs_end (const xcb_randr_get_screen_resources_current_reply_t *R);
+
+xcb_randr_output_t *
+xcb_randr_get_screen_resources_current_outputs (const xcb_randr_get_screen_resources_current_reply_t *R);
+
+int
+xcb_randr_get_screen_resources_current_outputs_length (const xcb_randr_get_screen_resources_current_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_screen_resources_current_outputs_end (const xcb_randr_get_screen_resources_current_reply_t *R);
+
+xcb_randr_mode_info_t *
+xcb_randr_get_screen_resources_current_modes (const xcb_randr_get_screen_resources_current_reply_t *R);
+
+int
+xcb_randr_get_screen_resources_current_modes_length (const xcb_randr_get_screen_resources_current_reply_t *R);
+
+xcb_randr_mode_info_iterator_t
+xcb_randr_get_screen_resources_current_modes_iterator (const xcb_randr_get_screen_resources_current_reply_t *R);
+
+uint8_t *
+xcb_randr_get_screen_resources_current_names (const xcb_randr_get_screen_resources_current_reply_t *R);
+
+int
+xcb_randr_get_screen_resources_current_names_length (const xcb_randr_get_screen_resources_current_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_screen_resources_current_names_end (const xcb_randr_get_screen_resources_current_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_get_screen_resources_current_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_get_screen_resources_current_reply_t *
+xcb_randr_get_screen_resources_current_reply (xcb_connection_t                                 *c,
+                                              xcb_randr_get_screen_resources_current_cookie_t   cookie  /**< */,
+                                              xcb_generic_error_t                             **e);
+
+int
+xcb_randr_set_crtc_transform_sizeof (const void  *_buffer,
+                                     uint32_t     filter_params_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_randr_set_crtc_transform_checked (xcb_connection_t         *c,
+                                      xcb_randr_crtc_t          crtc,
+                                      xcb_render_transform_t    transform,
+                                      uint16_t                  filter_len,
+                                      const char               *filter_name,
+                                      uint32_t                  filter_params_len,
+                                      const xcb_render_fixed_t *filter_params);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_randr_set_crtc_transform (xcb_connection_t         *c,
+                              xcb_randr_crtc_t          crtc,
+                              xcb_render_transform_t    transform,
+                              uint16_t                  filter_len,
+                              const char               *filter_name,
+                              uint32_t                  filter_params_len,
+                              const xcb_render_fixed_t *filter_params);
+
+char *
+xcb_randr_set_crtc_transform_filter_name (const xcb_randr_set_crtc_transform_request_t *R);
+
+int
+xcb_randr_set_crtc_transform_filter_name_length (const xcb_randr_set_crtc_transform_request_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_set_crtc_transform_filter_name_end (const xcb_randr_set_crtc_transform_request_t *R);
+
+xcb_render_fixed_t *
+xcb_randr_set_crtc_transform_filter_params (const xcb_randr_set_crtc_transform_request_t *R);
+
+int
+xcb_randr_set_crtc_transform_filter_params_length (const xcb_randr_set_crtc_transform_request_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_set_crtc_transform_filter_params_end (const xcb_randr_set_crtc_transform_request_t *R);
+
+int
+xcb_randr_get_crtc_transform_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_get_crtc_transform_cookie_t
+xcb_randr_get_crtc_transform (xcb_connection_t *c,
+                              xcb_randr_crtc_t  crtc);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_get_crtc_transform_cookie_t
+xcb_randr_get_crtc_transform_unchecked (xcb_connection_t *c,
+                                        xcb_randr_crtc_t  crtc);
+
+char *
+xcb_randr_get_crtc_transform_pending_filter_name (const xcb_randr_get_crtc_transform_reply_t *R);
+
+int
+xcb_randr_get_crtc_transform_pending_filter_name_length (const xcb_randr_get_crtc_transform_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_crtc_transform_pending_filter_name_end (const xcb_randr_get_crtc_transform_reply_t *R);
+
+xcb_render_fixed_t *
+xcb_randr_get_crtc_transform_pending_params (const xcb_randr_get_crtc_transform_reply_t *R);
+
+int
+xcb_randr_get_crtc_transform_pending_params_length (const xcb_randr_get_crtc_transform_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_crtc_transform_pending_params_end (const xcb_randr_get_crtc_transform_reply_t *R);
+
+char *
+xcb_randr_get_crtc_transform_current_filter_name (const xcb_randr_get_crtc_transform_reply_t *R);
+
+int
+xcb_randr_get_crtc_transform_current_filter_name_length (const xcb_randr_get_crtc_transform_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_crtc_transform_current_filter_name_end (const xcb_randr_get_crtc_transform_reply_t *R);
+
+xcb_render_fixed_t *
+xcb_randr_get_crtc_transform_current_params (const xcb_randr_get_crtc_transform_reply_t *R);
+
+int
+xcb_randr_get_crtc_transform_current_params_length (const xcb_randr_get_crtc_transform_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_crtc_transform_current_params_end (const xcb_randr_get_crtc_transform_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_get_crtc_transform_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_get_crtc_transform_reply_t *
+xcb_randr_get_crtc_transform_reply (xcb_connection_t                       *c,
+                                    xcb_randr_get_crtc_transform_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_get_panning_cookie_t
+xcb_randr_get_panning (xcb_connection_t *c,
+                       xcb_randr_crtc_t  crtc);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_get_panning_cookie_t
+xcb_randr_get_panning_unchecked (xcb_connection_t *c,
+                                 xcb_randr_crtc_t  crtc);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_get_panning_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_get_panning_reply_t *
+xcb_randr_get_panning_reply (xcb_connection_t                *c,
+                             xcb_randr_get_panning_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_set_panning_cookie_t
+xcb_randr_set_panning (xcb_connection_t *c,
+                       xcb_randr_crtc_t  crtc,
+                       xcb_timestamp_t   timestamp,
+                       uint16_t          left,
+                       uint16_t          top,
+                       uint16_t          width,
+                       uint16_t          height,
+                       uint16_t          track_left,
+                       uint16_t          track_top,
+                       uint16_t          track_width,
+                       uint16_t          track_height,
+                       int16_t           border_left,
+                       int16_t           border_top,
+                       int16_t           border_right,
+                       int16_t           border_bottom);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_set_panning_cookie_t
+xcb_randr_set_panning_unchecked (xcb_connection_t *c,
+                                 xcb_randr_crtc_t  crtc,
+                                 xcb_timestamp_t   timestamp,
+                                 uint16_t          left,
+                                 uint16_t          top,
+                                 uint16_t          width,
+                                 uint16_t          height,
+                                 uint16_t          track_left,
+                                 uint16_t          track_top,
+                                 uint16_t          track_width,
+                                 uint16_t          track_height,
+                                 int16_t           border_left,
+                                 int16_t           border_top,
+                                 int16_t           border_right,
+                                 int16_t           border_bottom);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_set_panning_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_set_panning_reply_t *
+xcb_randr_set_panning_reply (xcb_connection_t                *c,
+                             xcb_randr_set_panning_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_randr_set_output_primary_checked (xcb_connection_t   *c,
+                                      xcb_window_t        window,
+                                      xcb_randr_output_t  output);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_randr_set_output_primary (xcb_connection_t   *c,
+                              xcb_window_t        window,
+                              xcb_randr_output_t  output);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_get_output_primary_cookie_t
+xcb_randr_get_output_primary (xcb_connection_t *c,
+                              xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_get_output_primary_cookie_t
+xcb_randr_get_output_primary_unchecked (xcb_connection_t *c,
+                                        xcb_window_t      window);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_get_output_primary_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_get_output_primary_reply_t *
+xcb_randr_get_output_primary_reply (xcb_connection_t                       *c,
+                                    xcb_randr_get_output_primary_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e);
+
+int
+xcb_randr_get_providers_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_get_providers_cookie_t
+xcb_randr_get_providers (xcb_connection_t *c,
+                         xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_get_providers_cookie_t
+xcb_randr_get_providers_unchecked (xcb_connection_t *c,
+                                   xcb_window_t      window);
+
+xcb_randr_provider_t *
+xcb_randr_get_providers_providers (const xcb_randr_get_providers_reply_t *R);
+
+int
+xcb_randr_get_providers_providers_length (const xcb_randr_get_providers_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_providers_providers_end (const xcb_randr_get_providers_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_get_providers_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_get_providers_reply_t *
+xcb_randr_get_providers_reply (xcb_connection_t                  *c,
+                               xcb_randr_get_providers_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+int
+xcb_randr_get_provider_info_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_get_provider_info_cookie_t
+xcb_randr_get_provider_info (xcb_connection_t     *c,
+                             xcb_randr_provider_t  provider,
+                             xcb_timestamp_t       config_timestamp);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_get_provider_info_cookie_t
+xcb_randr_get_provider_info_unchecked (xcb_connection_t     *c,
+                                       xcb_randr_provider_t  provider,
+                                       xcb_timestamp_t       config_timestamp);
+
+xcb_randr_crtc_t *
+xcb_randr_get_provider_info_crtcs (const xcb_randr_get_provider_info_reply_t *R);
+
+int
+xcb_randr_get_provider_info_crtcs_length (const xcb_randr_get_provider_info_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_provider_info_crtcs_end (const xcb_randr_get_provider_info_reply_t *R);
+
+xcb_randr_output_t *
+xcb_randr_get_provider_info_outputs (const xcb_randr_get_provider_info_reply_t *R);
+
+int
+xcb_randr_get_provider_info_outputs_length (const xcb_randr_get_provider_info_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_provider_info_outputs_end (const xcb_randr_get_provider_info_reply_t *R);
+
+xcb_randr_provider_t *
+xcb_randr_get_provider_info_associated_providers (const xcb_randr_get_provider_info_reply_t *R);
+
+int
+xcb_randr_get_provider_info_associated_providers_length (const xcb_randr_get_provider_info_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_provider_info_associated_providers_end (const xcb_randr_get_provider_info_reply_t *R);
+
+uint32_t *
+xcb_randr_get_provider_info_associated_capability (const xcb_randr_get_provider_info_reply_t *R);
+
+int
+xcb_randr_get_provider_info_associated_capability_length (const xcb_randr_get_provider_info_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_provider_info_associated_capability_end (const xcb_randr_get_provider_info_reply_t *R);
+
+char *
+xcb_randr_get_provider_info_name (const xcb_randr_get_provider_info_reply_t *R);
+
+int
+xcb_randr_get_provider_info_name_length (const xcb_randr_get_provider_info_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_provider_info_name_end (const xcb_randr_get_provider_info_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_get_provider_info_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_get_provider_info_reply_t *
+xcb_randr_get_provider_info_reply (xcb_connection_t                      *c,
+                                   xcb_randr_get_provider_info_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_randr_set_provider_offload_sink_checked (xcb_connection_t     *c,
+                                             xcb_randr_provider_t  provider,
+                                             xcb_randr_provider_t  sink_provider,
+                                             xcb_timestamp_t       config_timestamp);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_randr_set_provider_offload_sink (xcb_connection_t     *c,
+                                     xcb_randr_provider_t  provider,
+                                     xcb_randr_provider_t  sink_provider,
+                                     xcb_timestamp_t       config_timestamp);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_randr_set_provider_output_source_checked (xcb_connection_t     *c,
+                                              xcb_randr_provider_t  provider,
+                                              xcb_randr_provider_t  source_provider,
+                                              xcb_timestamp_t       config_timestamp);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_randr_set_provider_output_source (xcb_connection_t     *c,
+                                      xcb_randr_provider_t  provider,
+                                      xcb_randr_provider_t  source_provider,
+                                      xcb_timestamp_t       config_timestamp);
+
+int
+xcb_randr_list_provider_properties_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_list_provider_properties_cookie_t
+xcb_randr_list_provider_properties (xcb_connection_t     *c,
+                                    xcb_randr_provider_t  provider);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_list_provider_properties_cookie_t
+xcb_randr_list_provider_properties_unchecked (xcb_connection_t     *c,
+                                              xcb_randr_provider_t  provider);
+
+xcb_atom_t *
+xcb_randr_list_provider_properties_atoms (const xcb_randr_list_provider_properties_reply_t *R);
+
+int
+xcb_randr_list_provider_properties_atoms_length (const xcb_randr_list_provider_properties_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_list_provider_properties_atoms_end (const xcb_randr_list_provider_properties_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_list_provider_properties_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_list_provider_properties_reply_t *
+xcb_randr_list_provider_properties_reply (xcb_connection_t                             *c,
+                                          xcb_randr_list_provider_properties_cookie_t   cookie  /**< */,
+                                          xcb_generic_error_t                         **e);
+
+int
+xcb_randr_query_provider_property_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_query_provider_property_cookie_t
+xcb_randr_query_provider_property (xcb_connection_t     *c,
+                                   xcb_randr_provider_t  provider,
+                                   xcb_atom_t            property);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_query_provider_property_cookie_t
+xcb_randr_query_provider_property_unchecked (xcb_connection_t     *c,
+                                             xcb_randr_provider_t  provider,
+                                             xcb_atom_t            property);
+
+int32_t *
+xcb_randr_query_provider_property_valid_values (const xcb_randr_query_provider_property_reply_t *R);
+
+int
+xcb_randr_query_provider_property_valid_values_length (const xcb_randr_query_provider_property_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_query_provider_property_valid_values_end (const xcb_randr_query_provider_property_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_query_provider_property_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_query_provider_property_reply_t *
+xcb_randr_query_provider_property_reply (xcb_connection_t                            *c,
+                                         xcb_randr_query_provider_property_cookie_t   cookie  /**< */,
+                                         xcb_generic_error_t                        **e);
+
+int
+xcb_randr_configure_provider_property_sizeof (const void  *_buffer,
+                                              uint32_t     values_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_randr_configure_provider_property_checked (xcb_connection_t     *c,
+                                               xcb_randr_provider_t  provider,
+                                               xcb_atom_t            property,
+                                               uint8_t               pending,
+                                               uint8_t               range,
+                                               uint32_t              values_len,
+                                               const int32_t        *values);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_randr_configure_provider_property (xcb_connection_t     *c,
+                                       xcb_randr_provider_t  provider,
+                                       xcb_atom_t            property,
+                                       uint8_t               pending,
+                                       uint8_t               range,
+                                       uint32_t              values_len,
+                                       const int32_t        *values);
+
+int32_t *
+xcb_randr_configure_provider_property_values (const xcb_randr_configure_provider_property_request_t *R);
+
+int
+xcb_randr_configure_provider_property_values_length (const xcb_randr_configure_provider_property_request_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_configure_provider_property_values_end (const xcb_randr_configure_provider_property_request_t *R);
+
+int
+xcb_randr_change_provider_property_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_randr_change_provider_property_checked (xcb_connection_t     *c,
+                                            xcb_randr_provider_t  provider,
+                                            xcb_atom_t            property,
+                                            xcb_atom_t            type,
+                                            uint8_t               format,
+                                            uint8_t               mode,
+                                            uint32_t              num_items,
+                                            const void           *data);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_randr_change_provider_property (xcb_connection_t     *c,
+                                    xcb_randr_provider_t  provider,
+                                    xcb_atom_t            property,
+                                    xcb_atom_t            type,
+                                    uint8_t               format,
+                                    uint8_t               mode,
+                                    uint32_t              num_items,
+                                    const void           *data);
+
+void *
+xcb_randr_change_provider_property_data (const xcb_randr_change_provider_property_request_t *R);
+
+int
+xcb_randr_change_provider_property_data_length (const xcb_randr_change_provider_property_request_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_change_provider_property_data_end (const xcb_randr_change_provider_property_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_randr_delete_provider_property_checked (xcb_connection_t     *c,
+                                            xcb_randr_provider_t  provider,
+                                            xcb_atom_t            property);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_randr_delete_provider_property (xcb_connection_t     *c,
+                                    xcb_randr_provider_t  provider,
+                                    xcb_atom_t            property);
+
+int
+xcb_randr_get_provider_property_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_get_provider_property_cookie_t
+xcb_randr_get_provider_property (xcb_connection_t     *c,
+                                 xcb_randr_provider_t  provider,
+                                 xcb_atom_t            property,
+                                 xcb_atom_t            type,
+                                 uint32_t              long_offset,
+                                 uint32_t              long_length,
+                                 uint8_t               _delete,
+                                 uint8_t               pending);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_get_provider_property_cookie_t
+xcb_randr_get_provider_property_unchecked (xcb_connection_t     *c,
+                                           xcb_randr_provider_t  provider,
+                                           xcb_atom_t            property,
+                                           xcb_atom_t            type,
+                                           uint32_t              long_offset,
+                                           uint32_t              long_length,
+                                           uint8_t               _delete,
+                                           uint8_t               pending);
+
+void *
+xcb_randr_get_provider_property_data (const xcb_randr_get_provider_property_reply_t *R);
+
+int
+xcb_randr_get_provider_property_data_length (const xcb_randr_get_provider_property_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_get_provider_property_data_end (const xcb_randr_get_provider_property_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_get_provider_property_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_get_provider_property_reply_t *
+xcb_randr_get_provider_property_reply (xcb_connection_t                          *c,
+                                       xcb_randr_get_provider_property_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_randr_crtc_change_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_randr_crtc_change_t)
+ */
+void
+xcb_randr_crtc_change_next (xcb_randr_crtc_change_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_randr_crtc_change_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_randr_crtc_change_end (xcb_randr_crtc_change_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_randr_output_change_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_randr_output_change_t)
+ */
+void
+xcb_randr_output_change_next (xcb_randr_output_change_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_randr_output_change_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_randr_output_change_end (xcb_randr_output_change_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_randr_output_property_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_randr_output_property_t)
+ */
+void
+xcb_randr_output_property_next (xcb_randr_output_property_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_randr_output_property_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_randr_output_property_end (xcb_randr_output_property_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_randr_provider_change_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_randr_provider_change_t)
+ */
+void
+xcb_randr_provider_change_next (xcb_randr_provider_change_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_randr_provider_change_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_randr_provider_change_end (xcb_randr_provider_change_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_randr_provider_property_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_randr_provider_property_t)
+ */
+void
+xcb_randr_provider_property_next (xcb_randr_provider_property_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_randr_provider_property_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_randr_provider_property_end (xcb_randr_provider_property_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_randr_resource_change_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_randr_resource_change_t)
+ */
+void
+xcb_randr_resource_change_next (xcb_randr_resource_change_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_randr_resource_change_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_randr_resource_change_end (xcb_randr_resource_change_iterator_t i);
+
+int
+xcb_randr_monitor_info_sizeof (const void  *_buffer);
+
+xcb_randr_output_t *
+xcb_randr_monitor_info_outputs (const xcb_randr_monitor_info_t *R);
+
+int
+xcb_randr_monitor_info_outputs_length (const xcb_randr_monitor_info_t *R);
+
+xcb_generic_iterator_t
+xcb_randr_monitor_info_outputs_end (const xcb_randr_monitor_info_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_randr_monitor_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_randr_monitor_info_t)
+ */
+void
+xcb_randr_monitor_info_next (xcb_randr_monitor_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_randr_monitor_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_randr_monitor_info_end (xcb_randr_monitor_info_iterator_t i);
+
+int
+xcb_randr_get_monitors_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_get_monitors_cookie_t
+xcb_randr_get_monitors (xcb_connection_t *c,
+                        xcb_window_t      window,
+                        uint8_t           get_active);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_get_monitors_cookie_t
+xcb_randr_get_monitors_unchecked (xcb_connection_t *c,
+                                  xcb_window_t      window,
+                                  uint8_t           get_active);
+
+int
+xcb_randr_get_monitors_monitors_length (const xcb_randr_get_monitors_reply_t *R);
+
+xcb_randr_monitor_info_iterator_t
+xcb_randr_get_monitors_monitors_iterator (const xcb_randr_get_monitors_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_get_monitors_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_get_monitors_reply_t *
+xcb_randr_get_monitors_reply (xcb_connection_t                 *c,
+                              xcb_randr_get_monitors_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+int
+xcb_randr_set_monitor_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_randr_set_monitor_checked (xcb_connection_t         *c,
+                               xcb_window_t              window,
+                               xcb_randr_monitor_info_t *monitorinfo);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_randr_set_monitor (xcb_connection_t         *c,
+                       xcb_window_t              window,
+                       xcb_randr_monitor_info_t *monitorinfo);
+
+xcb_randr_monitor_info_t *
+xcb_randr_set_monitor_monitorinfo (const xcb_randr_set_monitor_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_randr_delete_monitor_checked (xcb_connection_t *c,
+                                  xcb_window_t      window,
+                                  xcb_atom_t        name);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_randr_delete_monitor (xcb_connection_t *c,
+                          xcb_window_t      window,
+                          xcb_atom_t        name);
+
+int
+xcb_randr_create_lease_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_randr_create_lease_cookie_t
+xcb_randr_create_lease (xcb_connection_t         *c,
+                        xcb_window_t              window,
+                        xcb_randr_lease_t         lid,
+                        uint16_t                  num_crtcs,
+                        uint16_t                  num_outputs,
+                        const xcb_randr_crtc_t   *crtcs,
+                        const xcb_randr_output_t *outputs);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_randr_create_lease_cookie_t
+xcb_randr_create_lease_unchecked (xcb_connection_t         *c,
+                                  xcb_window_t              window,
+                                  xcb_randr_lease_t         lid,
+                                  uint16_t                  num_crtcs,
+                                  uint16_t                  num_outputs,
+                                  const xcb_randr_crtc_t   *crtcs,
+                                  const xcb_randr_output_t *outputs);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_randr_create_lease_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_randr_create_lease_reply_t *
+xcb_randr_create_lease_reply (xcb_connection_t                 *c,
+                              xcb_randr_create_lease_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+/**
+ * Return the reply fds
+ * @param c      The connection
+ * @param reply  The reply
+ *
+ * Returns a pointer to the array of reply fds of the reply.
+ *
+ * The returned value points into the reply and must not be free().
+ * The fds are not managed by xcb. You must close() them before freeing the reply.
+ */
+int *
+xcb_randr_create_lease_reply_fds (xcb_connection_t                *c  /**< */,
+                                  xcb_randr_create_lease_reply_t  *reply);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_randr_free_lease_checked (xcb_connection_t  *c,
+                              xcb_randr_lease_t  lid,
+                              uint8_t            terminate);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_randr_free_lease (xcb_connection_t  *c,
+                      xcb_randr_lease_t  lid,
+                      uint8_t            terminate);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_randr_lease_notify_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_randr_lease_notify_t)
+ */
+void
+xcb_randr_lease_notify_next (xcb_randr_lease_notify_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_randr_lease_notify_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_randr_lease_notify_end (xcb_randr_lease_notify_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_randr_notify_data_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_randr_notify_data_t)
+ */
+void
+xcb_randr_notify_data_next (xcb_randr_notify_data_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_randr_notify_data_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_randr_notify_data_end (xcb_randr_notify_data_iterator_t i);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/record.h b/depends/libxcb/include/xcb/record.h
new file mode 100644
index 0000000..cfd33f3
--- /dev/null
+++ b/depends/libxcb/include/xcb/record.h
@@ -0,0 +1,935 @@
+/*
+ * This file generated automatically from record.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_Record_API XCB Record API
+ * @brief Record XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __RECORD_H
+#define __RECORD_H
+
+#include "xcb.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_RECORD_MAJOR_VERSION 1
+#define XCB_RECORD_MINOR_VERSION 13
+
+extern xcb_extension_t xcb_record_id;
+
+typedef uint32_t xcb_record_context_t;
+
+/**
+ * @brief xcb_record_context_iterator_t
+ **/
+typedef struct xcb_record_context_iterator_t {
+    xcb_record_context_t *data;
+    int                   rem;
+    int                   index;
+} xcb_record_context_iterator_t;
+
+/**
+ * @brief xcb_record_range_8_t
+ **/
+typedef struct xcb_record_range_8_t {
+    uint8_t first;
+    uint8_t last;
+} xcb_record_range_8_t;
+
+/**
+ * @brief xcb_record_range_8_iterator_t
+ **/
+typedef struct xcb_record_range_8_iterator_t {
+    xcb_record_range_8_t *data;
+    int                   rem;
+    int                   index;
+} xcb_record_range_8_iterator_t;
+
+/**
+ * @brief xcb_record_range_16_t
+ **/
+typedef struct xcb_record_range_16_t {
+    uint16_t first;
+    uint16_t last;
+} xcb_record_range_16_t;
+
+/**
+ * @brief xcb_record_range_16_iterator_t
+ **/
+typedef struct xcb_record_range_16_iterator_t {
+    xcb_record_range_16_t *data;
+    int                    rem;
+    int                    index;
+} xcb_record_range_16_iterator_t;
+
+/**
+ * @brief xcb_record_ext_range_t
+ **/
+typedef struct xcb_record_ext_range_t {
+    xcb_record_range_8_t  major;
+    xcb_record_range_16_t minor;
+} xcb_record_ext_range_t;
+
+/**
+ * @brief xcb_record_ext_range_iterator_t
+ **/
+typedef struct xcb_record_ext_range_iterator_t {
+    xcb_record_ext_range_t *data;
+    int                     rem;
+    int                     index;
+} xcb_record_ext_range_iterator_t;
+
+/**
+ * @brief xcb_record_range_t
+ **/
+typedef struct xcb_record_range_t {
+    xcb_record_range_8_t   core_requests;
+    xcb_record_range_8_t   core_replies;
+    xcb_record_ext_range_t ext_requests;
+    xcb_record_ext_range_t ext_replies;
+    xcb_record_range_8_t   delivered_events;
+    xcb_record_range_8_t   device_events;
+    xcb_record_range_8_t   errors;
+    uint8_t                client_started;
+    uint8_t                client_died;
+} xcb_record_range_t;
+
+/**
+ * @brief xcb_record_range_iterator_t
+ **/
+typedef struct xcb_record_range_iterator_t {
+    xcb_record_range_t *data;
+    int                 rem;
+    int                 index;
+} xcb_record_range_iterator_t;
+
+typedef uint8_t xcb_record_element_header_t;
+
+/**
+ * @brief xcb_record_element_header_iterator_t
+ **/
+typedef struct xcb_record_element_header_iterator_t {
+    xcb_record_element_header_t *data;
+    int                          rem;
+    int                          index;
+} xcb_record_element_header_iterator_t;
+
+typedef enum xcb_record_h_type_t {
+    XCB_RECORD_H_TYPE_FROM_SERVER_TIME = 1,
+    XCB_RECORD_H_TYPE_FROM_CLIENT_TIME = 2,
+    XCB_RECORD_H_TYPE_FROM_CLIENT_SEQUENCE = 4
+} xcb_record_h_type_t;
+
+typedef uint32_t xcb_record_client_spec_t;
+
+/**
+ * @brief xcb_record_client_spec_iterator_t
+ **/
+typedef struct xcb_record_client_spec_iterator_t {
+    xcb_record_client_spec_t *data;
+    int                       rem;
+    int                       index;
+} xcb_record_client_spec_iterator_t;
+
+typedef enum xcb_record_cs_t {
+    XCB_RECORD_CS_CURRENT_CLIENTS = 1,
+    XCB_RECORD_CS_FUTURE_CLIENTS = 2,
+    XCB_RECORD_CS_ALL_CLIENTS = 3
+} xcb_record_cs_t;
+
+/**
+ * @brief xcb_record_client_info_t
+ **/
+typedef struct xcb_record_client_info_t {
+    xcb_record_client_spec_t client_resource;
+    uint32_t                 num_ranges;
+} xcb_record_client_info_t;
+
+/**
+ * @brief xcb_record_client_info_iterator_t
+ **/
+typedef struct xcb_record_client_info_iterator_t {
+    xcb_record_client_info_t *data;
+    int                       rem;
+    int                       index;
+} xcb_record_client_info_iterator_t;
+
+/** Opcode for xcb_record_bad_context. */
+#define XCB_RECORD_BAD_CONTEXT 0
+
+/**
+ * @brief xcb_record_bad_context_error_t
+ **/
+typedef struct xcb_record_bad_context_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t invalid_record;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_record_bad_context_error_t;
+
+/**
+ * @brief xcb_record_query_version_cookie_t
+ **/
+typedef struct xcb_record_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_record_query_version_cookie_t;
+
+/** Opcode for xcb_record_query_version. */
+#define XCB_RECORD_QUERY_VERSION 0
+
+/**
+ * @brief xcb_record_query_version_request_t
+ **/
+typedef struct xcb_record_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint16_t major_version;
+    uint16_t minor_version;
+} xcb_record_query_version_request_t;
+
+/**
+ * @brief xcb_record_query_version_reply_t
+ **/
+typedef struct xcb_record_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t major_version;
+    uint16_t minor_version;
+} xcb_record_query_version_reply_t;
+
+/** Opcode for xcb_record_create_context. */
+#define XCB_RECORD_CREATE_CONTEXT 1
+
+/**
+ * @brief xcb_record_create_context_request_t
+ **/
+typedef struct xcb_record_create_context_request_t {
+    uint8_t                     major_opcode;
+    uint8_t                     minor_opcode;
+    uint16_t                    length;
+    xcb_record_context_t        context;
+    xcb_record_element_header_t element_header;
+    uint8_t                     pad0[3];
+    uint32_t                    num_client_specs;
+    uint32_t                    num_ranges;
+} xcb_record_create_context_request_t;
+
+/** Opcode for xcb_record_register_clients. */
+#define XCB_RECORD_REGISTER_CLIENTS 2
+
+/**
+ * @brief xcb_record_register_clients_request_t
+ **/
+typedef struct xcb_record_register_clients_request_t {
+    uint8_t                     major_opcode;
+    uint8_t                     minor_opcode;
+    uint16_t                    length;
+    xcb_record_context_t        context;
+    xcb_record_element_header_t element_header;
+    uint8_t                     pad0[3];
+    uint32_t                    num_client_specs;
+    uint32_t                    num_ranges;
+} xcb_record_register_clients_request_t;
+
+/** Opcode for xcb_record_unregister_clients. */
+#define XCB_RECORD_UNREGISTER_CLIENTS 3
+
+/**
+ * @brief xcb_record_unregister_clients_request_t
+ **/
+typedef struct xcb_record_unregister_clients_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_record_context_t context;
+    uint32_t             num_client_specs;
+} xcb_record_unregister_clients_request_t;
+
+/**
+ * @brief xcb_record_get_context_cookie_t
+ **/
+typedef struct xcb_record_get_context_cookie_t {
+    unsigned int sequence;
+} xcb_record_get_context_cookie_t;
+
+/** Opcode for xcb_record_get_context. */
+#define XCB_RECORD_GET_CONTEXT 4
+
+/**
+ * @brief xcb_record_get_context_request_t
+ **/
+typedef struct xcb_record_get_context_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_record_context_t context;
+} xcb_record_get_context_request_t;
+
+/**
+ * @brief xcb_record_get_context_reply_t
+ **/
+typedef struct xcb_record_get_context_reply_t {
+    uint8_t                     response_type;
+    uint8_t                     enabled;
+    uint16_t                    sequence;
+    uint32_t                    length;
+    xcb_record_element_header_t element_header;
+    uint8_t                     pad0[3];
+    uint32_t                    num_intercepted_clients;
+    uint8_t                     pad1[16];
+} xcb_record_get_context_reply_t;
+
+/**
+ * @brief xcb_record_enable_context_cookie_t
+ **/
+typedef struct xcb_record_enable_context_cookie_t {
+    unsigned int sequence;
+} xcb_record_enable_context_cookie_t;
+
+/** Opcode for xcb_record_enable_context. */
+#define XCB_RECORD_ENABLE_CONTEXT 5
+
+/**
+ * @brief xcb_record_enable_context_request_t
+ **/
+typedef struct xcb_record_enable_context_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_record_context_t context;
+} xcb_record_enable_context_request_t;
+
+/**
+ * @brief xcb_record_enable_context_reply_t
+ **/
+typedef struct xcb_record_enable_context_reply_t {
+    uint8_t                     response_type;
+    uint8_t                     category;
+    uint16_t                    sequence;
+    uint32_t                    length;
+    xcb_record_element_header_t element_header;
+    uint8_t                     client_swapped;
+    uint8_t                     pad0[2];
+    uint32_t                    xid_base;
+    uint32_t                    server_time;
+    uint32_t                    rec_sequence_num;
+    uint8_t                     pad1[8];
+} xcb_record_enable_context_reply_t;
+
+/** Opcode for xcb_record_disable_context. */
+#define XCB_RECORD_DISABLE_CONTEXT 6
+
+/**
+ * @brief xcb_record_disable_context_request_t
+ **/
+typedef struct xcb_record_disable_context_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_record_context_t context;
+} xcb_record_disable_context_request_t;
+
+/** Opcode for xcb_record_free_context. */
+#define XCB_RECORD_FREE_CONTEXT 7
+
+/**
+ * @brief xcb_record_free_context_request_t
+ **/
+typedef struct xcb_record_free_context_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_record_context_t context;
+} xcb_record_free_context_request_t;
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_record_context_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_record_context_t)
+ */
+void
+xcb_record_context_next (xcb_record_context_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_record_context_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_record_context_end (xcb_record_context_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_record_range_8_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_record_range_8_t)
+ */
+void
+xcb_record_range_8_next (xcb_record_range_8_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_record_range_8_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_record_range_8_end (xcb_record_range_8_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_record_range_16_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_record_range_16_t)
+ */
+void
+xcb_record_range_16_next (xcb_record_range_16_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_record_range_16_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_record_range_16_end (xcb_record_range_16_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_record_ext_range_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_record_ext_range_t)
+ */
+void
+xcb_record_ext_range_next (xcb_record_ext_range_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_record_ext_range_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_record_ext_range_end (xcb_record_ext_range_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_record_range_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_record_range_t)
+ */
+void
+xcb_record_range_next (xcb_record_range_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_record_range_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_record_range_end (xcb_record_range_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_record_element_header_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_record_element_header_t)
+ */
+void
+xcb_record_element_header_next (xcb_record_element_header_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_record_element_header_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_record_element_header_end (xcb_record_element_header_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_record_client_spec_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_record_client_spec_t)
+ */
+void
+xcb_record_client_spec_next (xcb_record_client_spec_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_record_client_spec_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_record_client_spec_end (xcb_record_client_spec_iterator_t i);
+
+int
+xcb_record_client_info_sizeof (const void  *_buffer);
+
+xcb_record_range_t *
+xcb_record_client_info_ranges (const xcb_record_client_info_t *R);
+
+int
+xcb_record_client_info_ranges_length (const xcb_record_client_info_t *R);
+
+xcb_record_range_iterator_t
+xcb_record_client_info_ranges_iterator (const xcb_record_client_info_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_record_client_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_record_client_info_t)
+ */
+void
+xcb_record_client_info_next (xcb_record_client_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_record_client_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_record_client_info_end (xcb_record_client_info_iterator_t i);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_record_query_version_cookie_t
+xcb_record_query_version (xcb_connection_t *c,
+                          uint16_t          major_version,
+                          uint16_t          minor_version);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_record_query_version_cookie_t
+xcb_record_query_version_unchecked (xcb_connection_t *c,
+                                    uint16_t          major_version,
+                                    uint16_t          minor_version);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_record_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_record_query_version_reply_t *
+xcb_record_query_version_reply (xcb_connection_t                   *c,
+                                xcb_record_query_version_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e);
+
+int
+xcb_record_create_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_record_create_context_checked (xcb_connection_t               *c,
+                                   xcb_record_context_t            context,
+                                   xcb_record_element_header_t     element_header,
+                                   uint32_t                        num_client_specs,
+                                   uint32_t                        num_ranges,
+                                   const xcb_record_client_spec_t *client_specs,
+                                   const xcb_record_range_t       *ranges);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_record_create_context (xcb_connection_t               *c,
+                           xcb_record_context_t            context,
+                           xcb_record_element_header_t     element_header,
+                           uint32_t                        num_client_specs,
+                           uint32_t                        num_ranges,
+                           const xcb_record_client_spec_t *client_specs,
+                           const xcb_record_range_t       *ranges);
+
+xcb_record_client_spec_t *
+xcb_record_create_context_client_specs (const xcb_record_create_context_request_t *R);
+
+int
+xcb_record_create_context_client_specs_length (const xcb_record_create_context_request_t *R);
+
+xcb_generic_iterator_t
+xcb_record_create_context_client_specs_end (const xcb_record_create_context_request_t *R);
+
+xcb_record_range_t *
+xcb_record_create_context_ranges (const xcb_record_create_context_request_t *R);
+
+int
+xcb_record_create_context_ranges_length (const xcb_record_create_context_request_t *R);
+
+xcb_record_range_iterator_t
+xcb_record_create_context_ranges_iterator (const xcb_record_create_context_request_t *R);
+
+int
+xcb_record_register_clients_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_record_register_clients_checked (xcb_connection_t               *c,
+                                     xcb_record_context_t            context,
+                                     xcb_record_element_header_t     element_header,
+                                     uint32_t                        num_client_specs,
+                                     uint32_t                        num_ranges,
+                                     const xcb_record_client_spec_t *client_specs,
+                                     const xcb_record_range_t       *ranges);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_record_register_clients (xcb_connection_t               *c,
+                             xcb_record_context_t            context,
+                             xcb_record_element_header_t     element_header,
+                             uint32_t                        num_client_specs,
+                             uint32_t                        num_ranges,
+                             const xcb_record_client_spec_t *client_specs,
+                             const xcb_record_range_t       *ranges);
+
+xcb_record_client_spec_t *
+xcb_record_register_clients_client_specs (const xcb_record_register_clients_request_t *R);
+
+int
+xcb_record_register_clients_client_specs_length (const xcb_record_register_clients_request_t *R);
+
+xcb_generic_iterator_t
+xcb_record_register_clients_client_specs_end (const xcb_record_register_clients_request_t *R);
+
+xcb_record_range_t *
+xcb_record_register_clients_ranges (const xcb_record_register_clients_request_t *R);
+
+int
+xcb_record_register_clients_ranges_length (const xcb_record_register_clients_request_t *R);
+
+xcb_record_range_iterator_t
+xcb_record_register_clients_ranges_iterator (const xcb_record_register_clients_request_t *R);
+
+int
+xcb_record_unregister_clients_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_record_unregister_clients_checked (xcb_connection_t               *c,
+                                       xcb_record_context_t            context,
+                                       uint32_t                        num_client_specs,
+                                       const xcb_record_client_spec_t *client_specs);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_record_unregister_clients (xcb_connection_t               *c,
+                               xcb_record_context_t            context,
+                               uint32_t                        num_client_specs,
+                               const xcb_record_client_spec_t *client_specs);
+
+xcb_record_client_spec_t *
+xcb_record_unregister_clients_client_specs (const xcb_record_unregister_clients_request_t *R);
+
+int
+xcb_record_unregister_clients_client_specs_length (const xcb_record_unregister_clients_request_t *R);
+
+xcb_generic_iterator_t
+xcb_record_unregister_clients_client_specs_end (const xcb_record_unregister_clients_request_t *R);
+
+int
+xcb_record_get_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_record_get_context_cookie_t
+xcb_record_get_context (xcb_connection_t     *c,
+                        xcb_record_context_t  context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_record_get_context_cookie_t
+xcb_record_get_context_unchecked (xcb_connection_t     *c,
+                                  xcb_record_context_t  context);
+
+int
+xcb_record_get_context_intercepted_clients_length (const xcb_record_get_context_reply_t *R);
+
+xcb_record_client_info_iterator_t
+xcb_record_get_context_intercepted_clients_iterator (const xcb_record_get_context_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_record_get_context_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_record_get_context_reply_t *
+xcb_record_get_context_reply (xcb_connection_t                 *c,
+                              xcb_record_get_context_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+int
+xcb_record_enable_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_record_enable_context_cookie_t
+xcb_record_enable_context (xcb_connection_t     *c,
+                           xcb_record_context_t  context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_record_enable_context_cookie_t
+xcb_record_enable_context_unchecked (xcb_connection_t     *c,
+                                     xcb_record_context_t  context);
+
+uint8_t *
+xcb_record_enable_context_data (const xcb_record_enable_context_reply_t *R);
+
+int
+xcb_record_enable_context_data_length (const xcb_record_enable_context_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_record_enable_context_data_end (const xcb_record_enable_context_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_record_enable_context_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_record_enable_context_reply_t *
+xcb_record_enable_context_reply (xcb_connection_t                    *c,
+                                 xcb_record_enable_context_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_record_disable_context_checked (xcb_connection_t     *c,
+                                    xcb_record_context_t  context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_record_disable_context (xcb_connection_t     *c,
+                            xcb_record_context_t  context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_record_free_context_checked (xcb_connection_t     *c,
+                                 xcb_record_context_t  context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_record_free_context (xcb_connection_t     *c,
+                         xcb_record_context_t  context);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/render.h b/depends/libxcb/include/xcb/render.h
new file mode 100644
index 0000000..d6f84d5
--- /dev/null
+++ b/depends/libxcb/include/xcb/render.h
@@ -0,0 +1,3277 @@
+/*
+ * This file generated automatically from render.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_Render_API XCB Render API
+ * @brief Render XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __RENDER_H
+#define __RENDER_H
+
+#include "xcb.h"
+#include "xproto.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_RENDER_MAJOR_VERSION 0
+#define XCB_RENDER_MINOR_VERSION 11
+
+extern xcb_extension_t xcb_render_id;
+
+typedef enum xcb_render_pict_type_t {
+    XCB_RENDER_PICT_TYPE_INDEXED = 0,
+    XCB_RENDER_PICT_TYPE_DIRECT = 1
+} xcb_render_pict_type_t;
+
+typedef enum xcb_render_picture_enum_t {
+    XCB_RENDER_PICTURE_NONE = 0
+} xcb_render_picture_enum_t;
+
+typedef enum xcb_render_pict_op_t {
+    XCB_RENDER_PICT_OP_CLEAR = 0,
+    XCB_RENDER_PICT_OP_SRC = 1,
+    XCB_RENDER_PICT_OP_DST = 2,
+    XCB_RENDER_PICT_OP_OVER = 3,
+    XCB_RENDER_PICT_OP_OVER_REVERSE = 4,
+    XCB_RENDER_PICT_OP_IN = 5,
+    XCB_RENDER_PICT_OP_IN_REVERSE = 6,
+    XCB_RENDER_PICT_OP_OUT = 7,
+    XCB_RENDER_PICT_OP_OUT_REVERSE = 8,
+    XCB_RENDER_PICT_OP_ATOP = 9,
+    XCB_RENDER_PICT_OP_ATOP_REVERSE = 10,
+    XCB_RENDER_PICT_OP_XOR = 11,
+    XCB_RENDER_PICT_OP_ADD = 12,
+    XCB_RENDER_PICT_OP_SATURATE = 13,
+    XCB_RENDER_PICT_OP_DISJOINT_CLEAR = 16,
+    XCB_RENDER_PICT_OP_DISJOINT_SRC = 17,
+    XCB_RENDER_PICT_OP_DISJOINT_DST = 18,
+    XCB_RENDER_PICT_OP_DISJOINT_OVER = 19,
+    XCB_RENDER_PICT_OP_DISJOINT_OVER_REVERSE = 20,
+    XCB_RENDER_PICT_OP_DISJOINT_IN = 21,
+    XCB_RENDER_PICT_OP_DISJOINT_IN_REVERSE = 22,
+    XCB_RENDER_PICT_OP_DISJOINT_OUT = 23,
+    XCB_RENDER_PICT_OP_DISJOINT_OUT_REVERSE = 24,
+    XCB_RENDER_PICT_OP_DISJOINT_ATOP = 25,
+    XCB_RENDER_PICT_OP_DISJOINT_ATOP_REVERSE = 26,
+    XCB_RENDER_PICT_OP_DISJOINT_XOR = 27,
+    XCB_RENDER_PICT_OP_CONJOINT_CLEAR = 32,
+    XCB_RENDER_PICT_OP_CONJOINT_SRC = 33,
+    XCB_RENDER_PICT_OP_CONJOINT_DST = 34,
+    XCB_RENDER_PICT_OP_CONJOINT_OVER = 35,
+    XCB_RENDER_PICT_OP_CONJOINT_OVER_REVERSE = 36,
+    XCB_RENDER_PICT_OP_CONJOINT_IN = 37,
+    XCB_RENDER_PICT_OP_CONJOINT_IN_REVERSE = 38,
+    XCB_RENDER_PICT_OP_CONJOINT_OUT = 39,
+    XCB_RENDER_PICT_OP_CONJOINT_OUT_REVERSE = 40,
+    XCB_RENDER_PICT_OP_CONJOINT_ATOP = 41,
+    XCB_RENDER_PICT_OP_CONJOINT_ATOP_REVERSE = 42,
+    XCB_RENDER_PICT_OP_CONJOINT_XOR = 43,
+    XCB_RENDER_PICT_OP_MULTIPLY = 48,
+    XCB_RENDER_PICT_OP_SCREEN = 49,
+    XCB_RENDER_PICT_OP_OVERLAY = 50,
+    XCB_RENDER_PICT_OP_DARKEN = 51,
+    XCB_RENDER_PICT_OP_LIGHTEN = 52,
+    XCB_RENDER_PICT_OP_COLOR_DODGE = 53,
+    XCB_RENDER_PICT_OP_COLOR_BURN = 54,
+    XCB_RENDER_PICT_OP_HARD_LIGHT = 55,
+    XCB_RENDER_PICT_OP_SOFT_LIGHT = 56,
+    XCB_RENDER_PICT_OP_DIFFERENCE = 57,
+    XCB_RENDER_PICT_OP_EXCLUSION = 58,
+    XCB_RENDER_PICT_OP_HSL_HUE = 59,
+    XCB_RENDER_PICT_OP_HSL_SATURATION = 60,
+    XCB_RENDER_PICT_OP_HSL_COLOR = 61,
+    XCB_RENDER_PICT_OP_HSL_LUMINOSITY = 62
+} xcb_render_pict_op_t;
+
+typedef enum xcb_render_poly_edge_t {
+    XCB_RENDER_POLY_EDGE_SHARP = 0,
+    XCB_RENDER_POLY_EDGE_SMOOTH = 1
+} xcb_render_poly_edge_t;
+
+typedef enum xcb_render_poly_mode_t {
+    XCB_RENDER_POLY_MODE_PRECISE = 0,
+    XCB_RENDER_POLY_MODE_IMPRECISE = 1
+} xcb_render_poly_mode_t;
+
+typedef enum xcb_render_cp_t {
+    XCB_RENDER_CP_REPEAT = 1,
+    XCB_RENDER_CP_ALPHA_MAP = 2,
+    XCB_RENDER_CP_ALPHA_X_ORIGIN = 4,
+    XCB_RENDER_CP_ALPHA_Y_ORIGIN = 8,
+    XCB_RENDER_CP_CLIP_X_ORIGIN = 16,
+    XCB_RENDER_CP_CLIP_Y_ORIGIN = 32,
+    XCB_RENDER_CP_CLIP_MASK = 64,
+    XCB_RENDER_CP_GRAPHICS_EXPOSURE = 128,
+    XCB_RENDER_CP_SUBWINDOW_MODE = 256,
+    XCB_RENDER_CP_POLY_EDGE = 512,
+    XCB_RENDER_CP_POLY_MODE = 1024,
+    XCB_RENDER_CP_DITHER = 2048,
+    XCB_RENDER_CP_COMPONENT_ALPHA = 4096
+} xcb_render_cp_t;
+
+typedef enum xcb_render_sub_pixel_t {
+    XCB_RENDER_SUB_PIXEL_UNKNOWN = 0,
+    XCB_RENDER_SUB_PIXEL_HORIZONTAL_RGB = 1,
+    XCB_RENDER_SUB_PIXEL_HORIZONTAL_BGR = 2,
+    XCB_RENDER_SUB_PIXEL_VERTICAL_RGB = 3,
+    XCB_RENDER_SUB_PIXEL_VERTICAL_BGR = 4,
+    XCB_RENDER_SUB_PIXEL_NONE = 5
+} xcb_render_sub_pixel_t;
+
+typedef enum xcb_render_repeat_t {
+    XCB_RENDER_REPEAT_NONE = 0,
+    XCB_RENDER_REPEAT_NORMAL = 1,
+    XCB_RENDER_REPEAT_PAD = 2,
+    XCB_RENDER_REPEAT_REFLECT = 3
+} xcb_render_repeat_t;
+
+typedef uint32_t xcb_render_glyph_t;
+
+/**
+ * @brief xcb_render_glyph_iterator_t
+ **/
+typedef struct xcb_render_glyph_iterator_t {
+    xcb_render_glyph_t *data;
+    int                 rem;
+    int                 index;
+} xcb_render_glyph_iterator_t;
+
+typedef uint32_t xcb_render_glyphset_t;
+
+/**
+ * @brief xcb_render_glyphset_iterator_t
+ **/
+typedef struct xcb_render_glyphset_iterator_t {
+    xcb_render_glyphset_t *data;
+    int                    rem;
+    int                    index;
+} xcb_render_glyphset_iterator_t;
+
+typedef uint32_t xcb_render_picture_t;
+
+/**
+ * @brief xcb_render_picture_iterator_t
+ **/
+typedef struct xcb_render_picture_iterator_t {
+    xcb_render_picture_t *data;
+    int                   rem;
+    int                   index;
+} xcb_render_picture_iterator_t;
+
+typedef uint32_t xcb_render_pictformat_t;
+
+/**
+ * @brief xcb_render_pictformat_iterator_t
+ **/
+typedef struct xcb_render_pictformat_iterator_t {
+    xcb_render_pictformat_t *data;
+    int                      rem;
+    int                      index;
+} xcb_render_pictformat_iterator_t;
+
+typedef int32_t xcb_render_fixed_t;
+
+/**
+ * @brief xcb_render_fixed_iterator_t
+ **/
+typedef struct xcb_render_fixed_iterator_t {
+    xcb_render_fixed_t *data;
+    int                 rem;
+    int                 index;
+} xcb_render_fixed_iterator_t;
+
+/** Opcode for xcb_render_pict_format. */
+#define XCB_RENDER_PICT_FORMAT 0
+
+/**
+ * @brief xcb_render_pict_format_error_t
+ **/
+typedef struct xcb_render_pict_format_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_render_pict_format_error_t;
+
+/** Opcode for xcb_render_picture. */
+#define XCB_RENDER_PICTURE 1
+
+/**
+ * @brief xcb_render_picture_error_t
+ **/
+typedef struct xcb_render_picture_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_render_picture_error_t;
+
+/** Opcode for xcb_render_pict_op. */
+#define XCB_RENDER_PICT_OP 2
+
+/**
+ * @brief xcb_render_pict_op_error_t
+ **/
+typedef struct xcb_render_pict_op_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_render_pict_op_error_t;
+
+/** Opcode for xcb_render_glyph_set. */
+#define XCB_RENDER_GLYPH_SET 3
+
+/**
+ * @brief xcb_render_glyph_set_error_t
+ **/
+typedef struct xcb_render_glyph_set_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_render_glyph_set_error_t;
+
+/** Opcode for xcb_render_glyph. */
+#define XCB_RENDER_GLYPH 4
+
+/**
+ * @brief xcb_render_glyph_error_t
+ **/
+typedef struct xcb_render_glyph_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_render_glyph_error_t;
+
+/**
+ * @brief xcb_render_directformat_t
+ **/
+typedef struct xcb_render_directformat_t {
+    uint16_t red_shift;
+    uint16_t red_mask;
+    uint16_t green_shift;
+    uint16_t green_mask;
+    uint16_t blue_shift;
+    uint16_t blue_mask;
+    uint16_t alpha_shift;
+    uint16_t alpha_mask;
+} xcb_render_directformat_t;
+
+/**
+ * @brief xcb_render_directformat_iterator_t
+ **/
+typedef struct xcb_render_directformat_iterator_t {
+    xcb_render_directformat_t *data;
+    int                        rem;
+    int                        index;
+} xcb_render_directformat_iterator_t;
+
+/**
+ * @brief xcb_render_pictforminfo_t
+ **/
+typedef struct xcb_render_pictforminfo_t {
+    xcb_render_pictformat_t   id;
+    uint8_t                   type;
+    uint8_t                   depth;
+    uint8_t                   pad0[2];
+    xcb_render_directformat_t direct;
+    xcb_colormap_t            colormap;
+} xcb_render_pictforminfo_t;
+
+/**
+ * @brief xcb_render_pictforminfo_iterator_t
+ **/
+typedef struct xcb_render_pictforminfo_iterator_t {
+    xcb_render_pictforminfo_t *data;
+    int                        rem;
+    int                        index;
+} xcb_render_pictforminfo_iterator_t;
+
+/**
+ * @brief xcb_render_pictvisual_t
+ **/
+typedef struct xcb_render_pictvisual_t {
+    xcb_visualid_t          visual;
+    xcb_render_pictformat_t format;
+} xcb_render_pictvisual_t;
+
+/**
+ * @brief xcb_render_pictvisual_iterator_t
+ **/
+typedef struct xcb_render_pictvisual_iterator_t {
+    xcb_render_pictvisual_t *data;
+    int                      rem;
+    int                      index;
+} xcb_render_pictvisual_iterator_t;
+
+/**
+ * @brief xcb_render_pictdepth_t
+ **/
+typedef struct xcb_render_pictdepth_t {
+    uint8_t  depth;
+    uint8_t  pad0;
+    uint16_t num_visuals;
+    uint8_t  pad1[4];
+} xcb_render_pictdepth_t;
+
+/**
+ * @brief xcb_render_pictdepth_iterator_t
+ **/
+typedef struct xcb_render_pictdepth_iterator_t {
+    xcb_render_pictdepth_t *data;
+    int                     rem;
+    int                     index;
+} xcb_render_pictdepth_iterator_t;
+
+/**
+ * @brief xcb_render_pictscreen_t
+ **/
+typedef struct xcb_render_pictscreen_t {
+    uint32_t                num_depths;
+    xcb_render_pictformat_t fallback;
+} xcb_render_pictscreen_t;
+
+/**
+ * @brief xcb_render_pictscreen_iterator_t
+ **/
+typedef struct xcb_render_pictscreen_iterator_t {
+    xcb_render_pictscreen_t *data;
+    int                      rem;
+    int                      index;
+} xcb_render_pictscreen_iterator_t;
+
+/**
+ * @brief xcb_render_indexvalue_t
+ **/
+typedef struct xcb_render_indexvalue_t {
+    uint32_t pixel;
+    uint16_t red;
+    uint16_t green;
+    uint16_t blue;
+    uint16_t alpha;
+} xcb_render_indexvalue_t;
+
+/**
+ * @brief xcb_render_indexvalue_iterator_t
+ **/
+typedef struct xcb_render_indexvalue_iterator_t {
+    xcb_render_indexvalue_t *data;
+    int                      rem;
+    int                      index;
+} xcb_render_indexvalue_iterator_t;
+
+/**
+ * @brief xcb_render_color_t
+ **/
+typedef struct xcb_render_color_t {
+    uint16_t red;
+    uint16_t green;
+    uint16_t blue;
+    uint16_t alpha;
+} xcb_render_color_t;
+
+/**
+ * @brief xcb_render_color_iterator_t
+ **/
+typedef struct xcb_render_color_iterator_t {
+    xcb_render_color_t *data;
+    int                 rem;
+    int                 index;
+} xcb_render_color_iterator_t;
+
+/**
+ * @brief xcb_render_pointfix_t
+ **/
+typedef struct xcb_render_pointfix_t {
+    xcb_render_fixed_t x;
+    xcb_render_fixed_t y;
+} xcb_render_pointfix_t;
+
+/**
+ * @brief xcb_render_pointfix_iterator_t
+ **/
+typedef struct xcb_render_pointfix_iterator_t {
+    xcb_render_pointfix_t *data;
+    int                    rem;
+    int                    index;
+} xcb_render_pointfix_iterator_t;
+
+/**
+ * @brief xcb_render_linefix_t
+ **/
+typedef struct xcb_render_linefix_t {
+    xcb_render_pointfix_t p1;
+    xcb_render_pointfix_t p2;
+} xcb_render_linefix_t;
+
+/**
+ * @brief xcb_render_linefix_iterator_t
+ **/
+typedef struct xcb_render_linefix_iterator_t {
+    xcb_render_linefix_t *data;
+    int                   rem;
+    int                   index;
+} xcb_render_linefix_iterator_t;
+
+/**
+ * @brief xcb_render_triangle_t
+ **/
+typedef struct xcb_render_triangle_t {
+    xcb_render_pointfix_t p1;
+    xcb_render_pointfix_t p2;
+    xcb_render_pointfix_t p3;
+} xcb_render_triangle_t;
+
+/**
+ * @brief xcb_render_triangle_iterator_t
+ **/
+typedef struct xcb_render_triangle_iterator_t {
+    xcb_render_triangle_t *data;
+    int                    rem;
+    int                    index;
+} xcb_render_triangle_iterator_t;
+
+/**
+ * @brief xcb_render_trapezoid_t
+ **/
+typedef struct xcb_render_trapezoid_t {
+    xcb_render_fixed_t   top;
+    xcb_render_fixed_t   bottom;
+    xcb_render_linefix_t left;
+    xcb_render_linefix_t right;
+} xcb_render_trapezoid_t;
+
+/**
+ * @brief xcb_render_trapezoid_iterator_t
+ **/
+typedef struct xcb_render_trapezoid_iterator_t {
+    xcb_render_trapezoid_t *data;
+    int                     rem;
+    int                     index;
+} xcb_render_trapezoid_iterator_t;
+
+/**
+ * @brief xcb_render_glyphinfo_t
+ **/
+typedef struct xcb_render_glyphinfo_t {
+    uint16_t width;
+    uint16_t height;
+    int16_t  x;
+    int16_t  y;
+    int16_t  x_off;
+    int16_t  y_off;
+} xcb_render_glyphinfo_t;
+
+/**
+ * @brief xcb_render_glyphinfo_iterator_t
+ **/
+typedef struct xcb_render_glyphinfo_iterator_t {
+    xcb_render_glyphinfo_t *data;
+    int                     rem;
+    int                     index;
+} xcb_render_glyphinfo_iterator_t;
+
+/**
+ * @brief xcb_render_query_version_cookie_t
+ **/
+typedef struct xcb_render_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_render_query_version_cookie_t;
+
+/** Opcode for xcb_render_query_version. */
+#define XCB_RENDER_QUERY_VERSION 0
+
+/**
+ * @brief xcb_render_query_version_request_t
+ **/
+typedef struct xcb_render_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t client_major_version;
+    uint32_t client_minor_version;
+} xcb_render_query_version_request_t;
+
+/**
+ * @brief xcb_render_query_version_reply_t
+ **/
+typedef struct xcb_render_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t major_version;
+    uint32_t minor_version;
+    uint8_t  pad1[16];
+} xcb_render_query_version_reply_t;
+
+/**
+ * @brief xcb_render_query_pict_formats_cookie_t
+ **/
+typedef struct xcb_render_query_pict_formats_cookie_t {
+    unsigned int sequence;
+} xcb_render_query_pict_formats_cookie_t;
+
+/** Opcode for xcb_render_query_pict_formats. */
+#define XCB_RENDER_QUERY_PICT_FORMATS 1
+
+/**
+ * @brief xcb_render_query_pict_formats_request_t
+ **/
+typedef struct xcb_render_query_pict_formats_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_render_query_pict_formats_request_t;
+
+/**
+ * @brief xcb_render_query_pict_formats_reply_t
+ **/
+typedef struct xcb_render_query_pict_formats_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t num_formats;
+    uint32_t num_screens;
+    uint32_t num_depths;
+    uint32_t num_visuals;
+    uint32_t num_subpixel;
+    uint8_t  pad1[4];
+} xcb_render_query_pict_formats_reply_t;
+
+/**
+ * @brief xcb_render_query_pict_index_values_cookie_t
+ **/
+typedef struct xcb_render_query_pict_index_values_cookie_t {
+    unsigned int sequence;
+} xcb_render_query_pict_index_values_cookie_t;
+
+/** Opcode for xcb_render_query_pict_index_values. */
+#define XCB_RENDER_QUERY_PICT_INDEX_VALUES 2
+
+/**
+ * @brief xcb_render_query_pict_index_values_request_t
+ **/
+typedef struct xcb_render_query_pict_index_values_request_t {
+    uint8_t                 major_opcode;
+    uint8_t                 minor_opcode;
+    uint16_t                length;
+    xcb_render_pictformat_t format;
+} xcb_render_query_pict_index_values_request_t;
+
+/**
+ * @brief xcb_render_query_pict_index_values_reply_t
+ **/
+typedef struct xcb_render_query_pict_index_values_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t num_values;
+    uint8_t  pad1[20];
+} xcb_render_query_pict_index_values_reply_t;
+
+/**
+ * @brief xcb_render_create_picture_value_list_t
+ **/
+typedef struct xcb_render_create_picture_value_list_t {
+    uint32_t             repeat;
+    xcb_render_picture_t alphamap;
+    int32_t              alphaxorigin;
+    int32_t              alphayorigin;
+    int32_t              clipxorigin;
+    int32_t              clipyorigin;
+    xcb_pixmap_t         clipmask;
+    uint32_t             graphicsexposure;
+    uint32_t             subwindowmode;
+    uint32_t             polyedge;
+    uint32_t             polymode;
+    xcb_atom_t           dither;
+    uint32_t             componentalpha;
+} xcb_render_create_picture_value_list_t;
+
+/** Opcode for xcb_render_create_picture. */
+#define XCB_RENDER_CREATE_PICTURE 4
+
+/**
+ * @brief xcb_render_create_picture_request_t
+ **/
+typedef struct xcb_render_create_picture_request_t {
+    uint8_t                 major_opcode;
+    uint8_t                 minor_opcode;
+    uint16_t                length;
+    xcb_render_picture_t    pid;
+    xcb_drawable_t          drawable;
+    xcb_render_pictformat_t format;
+    uint32_t                value_mask;
+} xcb_render_create_picture_request_t;
+
+/**
+ * @brief xcb_render_change_picture_value_list_t
+ **/
+typedef struct xcb_render_change_picture_value_list_t {
+    uint32_t             repeat;
+    xcb_render_picture_t alphamap;
+    int32_t              alphaxorigin;
+    int32_t              alphayorigin;
+    int32_t              clipxorigin;
+    int32_t              clipyorigin;
+    xcb_pixmap_t         clipmask;
+    uint32_t             graphicsexposure;
+    uint32_t             subwindowmode;
+    uint32_t             polyedge;
+    uint32_t             polymode;
+    xcb_atom_t           dither;
+    uint32_t             componentalpha;
+} xcb_render_change_picture_value_list_t;
+
+/** Opcode for xcb_render_change_picture. */
+#define XCB_RENDER_CHANGE_PICTURE 5
+
+/**
+ * @brief xcb_render_change_picture_request_t
+ **/
+typedef struct xcb_render_change_picture_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_render_picture_t picture;
+    uint32_t             value_mask;
+} xcb_render_change_picture_request_t;
+
+/** Opcode for xcb_render_set_picture_clip_rectangles. */
+#define XCB_RENDER_SET_PICTURE_CLIP_RECTANGLES 6
+
+/**
+ * @brief xcb_render_set_picture_clip_rectangles_request_t
+ **/
+typedef struct xcb_render_set_picture_clip_rectangles_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_render_picture_t picture;
+    int16_t              clip_x_origin;
+    int16_t              clip_y_origin;
+} xcb_render_set_picture_clip_rectangles_request_t;
+
+/** Opcode for xcb_render_free_picture. */
+#define XCB_RENDER_FREE_PICTURE 7
+
+/**
+ * @brief xcb_render_free_picture_request_t
+ **/
+typedef struct xcb_render_free_picture_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_render_picture_t picture;
+} xcb_render_free_picture_request_t;
+
+/** Opcode for xcb_render_composite. */
+#define XCB_RENDER_COMPOSITE 8
+
+/**
+ * @brief xcb_render_composite_request_t
+ **/
+typedef struct xcb_render_composite_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    uint8_t              op;
+    uint8_t              pad0[3];
+    xcb_render_picture_t src;
+    xcb_render_picture_t mask;
+    xcb_render_picture_t dst;
+    int16_t              src_x;
+    int16_t              src_y;
+    int16_t              mask_x;
+    int16_t              mask_y;
+    int16_t              dst_x;
+    int16_t              dst_y;
+    uint16_t             width;
+    uint16_t             height;
+} xcb_render_composite_request_t;
+
+/** Opcode for xcb_render_trapezoids. */
+#define XCB_RENDER_TRAPEZOIDS 10
+
+/**
+ * @brief xcb_render_trapezoids_request_t
+ **/
+typedef struct xcb_render_trapezoids_request_t {
+    uint8_t                 major_opcode;
+    uint8_t                 minor_opcode;
+    uint16_t                length;
+    uint8_t                 op;
+    uint8_t                 pad0[3];
+    xcb_render_picture_t    src;
+    xcb_render_picture_t    dst;
+    xcb_render_pictformat_t mask_format;
+    int16_t                 src_x;
+    int16_t                 src_y;
+} xcb_render_trapezoids_request_t;
+
+/** Opcode for xcb_render_triangles. */
+#define XCB_RENDER_TRIANGLES 11
+
+/**
+ * @brief xcb_render_triangles_request_t
+ **/
+typedef struct xcb_render_triangles_request_t {
+    uint8_t                 major_opcode;
+    uint8_t                 minor_opcode;
+    uint16_t                length;
+    uint8_t                 op;
+    uint8_t                 pad0[3];
+    xcb_render_picture_t    src;
+    xcb_render_picture_t    dst;
+    xcb_render_pictformat_t mask_format;
+    int16_t                 src_x;
+    int16_t                 src_y;
+} xcb_render_triangles_request_t;
+
+/** Opcode for xcb_render_tri_strip. */
+#define XCB_RENDER_TRI_STRIP 12
+
+/**
+ * @brief xcb_render_tri_strip_request_t
+ **/
+typedef struct xcb_render_tri_strip_request_t {
+    uint8_t                 major_opcode;
+    uint8_t                 minor_opcode;
+    uint16_t                length;
+    uint8_t                 op;
+    uint8_t                 pad0[3];
+    xcb_render_picture_t    src;
+    xcb_render_picture_t    dst;
+    xcb_render_pictformat_t mask_format;
+    int16_t                 src_x;
+    int16_t                 src_y;
+} xcb_render_tri_strip_request_t;
+
+/** Opcode for xcb_render_tri_fan. */
+#define XCB_RENDER_TRI_FAN 13
+
+/**
+ * @brief xcb_render_tri_fan_request_t
+ **/
+typedef struct xcb_render_tri_fan_request_t {
+    uint8_t                 major_opcode;
+    uint8_t                 minor_opcode;
+    uint16_t                length;
+    uint8_t                 op;
+    uint8_t                 pad0[3];
+    xcb_render_picture_t    src;
+    xcb_render_picture_t    dst;
+    xcb_render_pictformat_t mask_format;
+    int16_t                 src_x;
+    int16_t                 src_y;
+} xcb_render_tri_fan_request_t;
+
+/** Opcode for xcb_render_create_glyph_set. */
+#define XCB_RENDER_CREATE_GLYPH_SET 17
+
+/**
+ * @brief xcb_render_create_glyph_set_request_t
+ **/
+typedef struct xcb_render_create_glyph_set_request_t {
+    uint8_t                 major_opcode;
+    uint8_t                 minor_opcode;
+    uint16_t                length;
+    xcb_render_glyphset_t   gsid;
+    xcb_render_pictformat_t format;
+} xcb_render_create_glyph_set_request_t;
+
+/** Opcode for xcb_render_reference_glyph_set. */
+#define XCB_RENDER_REFERENCE_GLYPH_SET 18
+
+/**
+ * @brief xcb_render_reference_glyph_set_request_t
+ **/
+typedef struct xcb_render_reference_glyph_set_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_render_glyphset_t gsid;
+    xcb_render_glyphset_t existing;
+} xcb_render_reference_glyph_set_request_t;
+
+/** Opcode for xcb_render_free_glyph_set. */
+#define XCB_RENDER_FREE_GLYPH_SET 19
+
+/**
+ * @brief xcb_render_free_glyph_set_request_t
+ **/
+typedef struct xcb_render_free_glyph_set_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_render_glyphset_t glyphset;
+} xcb_render_free_glyph_set_request_t;
+
+/** Opcode for xcb_render_add_glyphs. */
+#define XCB_RENDER_ADD_GLYPHS 20
+
+/**
+ * @brief xcb_render_add_glyphs_request_t
+ **/
+typedef struct xcb_render_add_glyphs_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_render_glyphset_t glyphset;
+    uint32_t              glyphs_len;
+} xcb_render_add_glyphs_request_t;
+
+/** Opcode for xcb_render_free_glyphs. */
+#define XCB_RENDER_FREE_GLYPHS 22
+
+/**
+ * @brief xcb_render_free_glyphs_request_t
+ **/
+typedef struct xcb_render_free_glyphs_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_render_glyphset_t glyphset;
+} xcb_render_free_glyphs_request_t;
+
+/** Opcode for xcb_render_composite_glyphs_8. */
+#define XCB_RENDER_COMPOSITE_GLYPHS_8 23
+
+/**
+ * @brief xcb_render_composite_glyphs_8_request_t
+ **/
+typedef struct xcb_render_composite_glyphs_8_request_t {
+    uint8_t                 major_opcode;
+    uint8_t                 minor_opcode;
+    uint16_t                length;
+    uint8_t                 op;
+    uint8_t                 pad0[3];
+    xcb_render_picture_t    src;
+    xcb_render_picture_t    dst;
+    xcb_render_pictformat_t mask_format;
+    xcb_render_glyphset_t   glyphset;
+    int16_t                 src_x;
+    int16_t                 src_y;
+} xcb_render_composite_glyphs_8_request_t;
+
+/** Opcode for xcb_render_composite_glyphs_16. */
+#define XCB_RENDER_COMPOSITE_GLYPHS_16 24
+
+/**
+ * @brief xcb_render_composite_glyphs_16_request_t
+ **/
+typedef struct xcb_render_composite_glyphs_16_request_t {
+    uint8_t                 major_opcode;
+    uint8_t                 minor_opcode;
+    uint16_t                length;
+    uint8_t                 op;
+    uint8_t                 pad0[3];
+    xcb_render_picture_t    src;
+    xcb_render_picture_t    dst;
+    xcb_render_pictformat_t mask_format;
+    xcb_render_glyphset_t   glyphset;
+    int16_t                 src_x;
+    int16_t                 src_y;
+} xcb_render_composite_glyphs_16_request_t;
+
+/** Opcode for xcb_render_composite_glyphs_32. */
+#define XCB_RENDER_COMPOSITE_GLYPHS_32 25
+
+/**
+ * @brief xcb_render_composite_glyphs_32_request_t
+ **/
+typedef struct xcb_render_composite_glyphs_32_request_t {
+    uint8_t                 major_opcode;
+    uint8_t                 minor_opcode;
+    uint16_t                length;
+    uint8_t                 op;
+    uint8_t                 pad0[3];
+    xcb_render_picture_t    src;
+    xcb_render_picture_t    dst;
+    xcb_render_pictformat_t mask_format;
+    xcb_render_glyphset_t   glyphset;
+    int16_t                 src_x;
+    int16_t                 src_y;
+} xcb_render_composite_glyphs_32_request_t;
+
+/** Opcode for xcb_render_fill_rectangles. */
+#define XCB_RENDER_FILL_RECTANGLES 26
+
+/**
+ * @brief xcb_render_fill_rectangles_request_t
+ **/
+typedef struct xcb_render_fill_rectangles_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    uint8_t              op;
+    uint8_t              pad0[3];
+    xcb_render_picture_t dst;
+    xcb_render_color_t   color;
+} xcb_render_fill_rectangles_request_t;
+
+/** Opcode for xcb_render_create_cursor. */
+#define XCB_RENDER_CREATE_CURSOR 27
+
+/**
+ * @brief xcb_render_create_cursor_request_t
+ **/
+typedef struct xcb_render_create_cursor_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_cursor_t         cid;
+    xcb_render_picture_t source;
+    uint16_t             x;
+    uint16_t             y;
+} xcb_render_create_cursor_request_t;
+
+/**
+ * @brief xcb_render_transform_t
+ **/
+typedef struct xcb_render_transform_t {
+    xcb_render_fixed_t matrix11;
+    xcb_render_fixed_t matrix12;
+    xcb_render_fixed_t matrix13;
+    xcb_render_fixed_t matrix21;
+    xcb_render_fixed_t matrix22;
+    xcb_render_fixed_t matrix23;
+    xcb_render_fixed_t matrix31;
+    xcb_render_fixed_t matrix32;
+    xcb_render_fixed_t matrix33;
+} xcb_render_transform_t;
+
+/**
+ * @brief xcb_render_transform_iterator_t
+ **/
+typedef struct xcb_render_transform_iterator_t {
+    xcb_render_transform_t *data;
+    int                     rem;
+    int                     index;
+} xcb_render_transform_iterator_t;
+
+/** Opcode for xcb_render_set_picture_transform. */
+#define XCB_RENDER_SET_PICTURE_TRANSFORM 28
+
+/**
+ * @brief xcb_render_set_picture_transform_request_t
+ **/
+typedef struct xcb_render_set_picture_transform_request_t {
+    uint8_t                major_opcode;
+    uint8_t                minor_opcode;
+    uint16_t               length;
+    xcb_render_picture_t   picture;
+    xcb_render_transform_t transform;
+} xcb_render_set_picture_transform_request_t;
+
+/**
+ * @brief xcb_render_query_filters_cookie_t
+ **/
+typedef struct xcb_render_query_filters_cookie_t {
+    unsigned int sequence;
+} xcb_render_query_filters_cookie_t;
+
+/** Opcode for xcb_render_query_filters. */
+#define XCB_RENDER_QUERY_FILTERS 29
+
+/**
+ * @brief xcb_render_query_filters_request_t
+ **/
+typedef struct xcb_render_query_filters_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+} xcb_render_query_filters_request_t;
+
+/**
+ * @brief xcb_render_query_filters_reply_t
+ **/
+typedef struct xcb_render_query_filters_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t num_aliases;
+    uint32_t num_filters;
+    uint8_t  pad1[16];
+} xcb_render_query_filters_reply_t;
+
+/** Opcode for xcb_render_set_picture_filter. */
+#define XCB_RENDER_SET_PICTURE_FILTER 30
+
+/**
+ * @brief xcb_render_set_picture_filter_request_t
+ **/
+typedef struct xcb_render_set_picture_filter_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_render_picture_t picture;
+    uint16_t             filter_len;
+    uint8_t              pad0[2];
+} xcb_render_set_picture_filter_request_t;
+
+/**
+ * @brief xcb_render_animcursorelt_t
+ **/
+typedef struct xcb_render_animcursorelt_t {
+    xcb_cursor_t cursor;
+    uint32_t     delay;
+} xcb_render_animcursorelt_t;
+
+/**
+ * @brief xcb_render_animcursorelt_iterator_t
+ **/
+typedef struct xcb_render_animcursorelt_iterator_t {
+    xcb_render_animcursorelt_t *data;
+    int                         rem;
+    int                         index;
+} xcb_render_animcursorelt_iterator_t;
+
+/** Opcode for xcb_render_create_anim_cursor. */
+#define XCB_RENDER_CREATE_ANIM_CURSOR 31
+
+/**
+ * @brief xcb_render_create_anim_cursor_request_t
+ **/
+typedef struct xcb_render_create_anim_cursor_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_cursor_t cid;
+} xcb_render_create_anim_cursor_request_t;
+
+/**
+ * @brief xcb_render_spanfix_t
+ **/
+typedef struct xcb_render_spanfix_t {
+    xcb_render_fixed_t l;
+    xcb_render_fixed_t r;
+    xcb_render_fixed_t y;
+} xcb_render_spanfix_t;
+
+/**
+ * @brief xcb_render_spanfix_iterator_t
+ **/
+typedef struct xcb_render_spanfix_iterator_t {
+    xcb_render_spanfix_t *data;
+    int                   rem;
+    int                   index;
+} xcb_render_spanfix_iterator_t;
+
+/**
+ * @brief xcb_render_trap_t
+ **/
+typedef struct xcb_render_trap_t {
+    xcb_render_spanfix_t top;
+    xcb_render_spanfix_t bot;
+} xcb_render_trap_t;
+
+/**
+ * @brief xcb_render_trap_iterator_t
+ **/
+typedef struct xcb_render_trap_iterator_t {
+    xcb_render_trap_t *data;
+    int                rem;
+    int                index;
+} xcb_render_trap_iterator_t;
+
+/** Opcode for xcb_render_add_traps. */
+#define XCB_RENDER_ADD_TRAPS 32
+
+/**
+ * @brief xcb_render_add_traps_request_t
+ **/
+typedef struct xcb_render_add_traps_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_render_picture_t picture;
+    int16_t              x_off;
+    int16_t              y_off;
+} xcb_render_add_traps_request_t;
+
+/** Opcode for xcb_render_create_solid_fill. */
+#define XCB_RENDER_CREATE_SOLID_FILL 33
+
+/**
+ * @brief xcb_render_create_solid_fill_request_t
+ **/
+typedef struct xcb_render_create_solid_fill_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_render_picture_t picture;
+    xcb_render_color_t   color;
+} xcb_render_create_solid_fill_request_t;
+
+/** Opcode for xcb_render_create_linear_gradient. */
+#define XCB_RENDER_CREATE_LINEAR_GRADIENT 34
+
+/**
+ * @brief xcb_render_create_linear_gradient_request_t
+ **/
+typedef struct xcb_render_create_linear_gradient_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_render_picture_t  picture;
+    xcb_render_pointfix_t p1;
+    xcb_render_pointfix_t p2;
+    uint32_t              num_stops;
+} xcb_render_create_linear_gradient_request_t;
+
+/** Opcode for xcb_render_create_radial_gradient. */
+#define XCB_RENDER_CREATE_RADIAL_GRADIENT 35
+
+/**
+ * @brief xcb_render_create_radial_gradient_request_t
+ **/
+typedef struct xcb_render_create_radial_gradient_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_render_picture_t  picture;
+    xcb_render_pointfix_t inner;
+    xcb_render_pointfix_t outer;
+    xcb_render_fixed_t    inner_radius;
+    xcb_render_fixed_t    outer_radius;
+    uint32_t              num_stops;
+} xcb_render_create_radial_gradient_request_t;
+
+/** Opcode for xcb_render_create_conical_gradient. */
+#define XCB_RENDER_CREATE_CONICAL_GRADIENT 36
+
+/**
+ * @brief xcb_render_create_conical_gradient_request_t
+ **/
+typedef struct xcb_render_create_conical_gradient_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_render_picture_t  picture;
+    xcb_render_pointfix_t center;
+    xcb_render_fixed_t    angle;
+    uint32_t              num_stops;
+} xcb_render_create_conical_gradient_request_t;
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_glyph_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_glyph_t)
+ */
+void
+xcb_render_glyph_next (xcb_render_glyph_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_glyph_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_glyph_end (xcb_render_glyph_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_glyphset_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_glyphset_t)
+ */
+void
+xcb_render_glyphset_next (xcb_render_glyphset_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_glyphset_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_glyphset_end (xcb_render_glyphset_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_picture_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_picture_t)
+ */
+void
+xcb_render_picture_next (xcb_render_picture_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_picture_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_picture_end (xcb_render_picture_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_pictformat_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_pictformat_t)
+ */
+void
+xcb_render_pictformat_next (xcb_render_pictformat_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_pictformat_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_pictformat_end (xcb_render_pictformat_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_fixed_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_fixed_t)
+ */
+void
+xcb_render_fixed_next (xcb_render_fixed_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_fixed_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_fixed_end (xcb_render_fixed_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_directformat_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_directformat_t)
+ */
+void
+xcb_render_directformat_next (xcb_render_directformat_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_directformat_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_directformat_end (xcb_render_directformat_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_pictforminfo_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_pictforminfo_t)
+ */
+void
+xcb_render_pictforminfo_next (xcb_render_pictforminfo_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_pictforminfo_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_pictforminfo_end (xcb_render_pictforminfo_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_pictvisual_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_pictvisual_t)
+ */
+void
+xcb_render_pictvisual_next (xcb_render_pictvisual_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_pictvisual_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_pictvisual_end (xcb_render_pictvisual_iterator_t i);
+
+int
+xcb_render_pictdepth_sizeof (const void  *_buffer);
+
+xcb_render_pictvisual_t *
+xcb_render_pictdepth_visuals (const xcb_render_pictdepth_t *R);
+
+int
+xcb_render_pictdepth_visuals_length (const xcb_render_pictdepth_t *R);
+
+xcb_render_pictvisual_iterator_t
+xcb_render_pictdepth_visuals_iterator (const xcb_render_pictdepth_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_pictdepth_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_pictdepth_t)
+ */
+void
+xcb_render_pictdepth_next (xcb_render_pictdepth_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_pictdepth_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_pictdepth_end (xcb_render_pictdepth_iterator_t i);
+
+int
+xcb_render_pictscreen_sizeof (const void  *_buffer);
+
+int
+xcb_render_pictscreen_depths_length (const xcb_render_pictscreen_t *R);
+
+xcb_render_pictdepth_iterator_t
+xcb_render_pictscreen_depths_iterator (const xcb_render_pictscreen_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_pictscreen_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_pictscreen_t)
+ */
+void
+xcb_render_pictscreen_next (xcb_render_pictscreen_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_pictscreen_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_pictscreen_end (xcb_render_pictscreen_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_indexvalue_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_indexvalue_t)
+ */
+void
+xcb_render_indexvalue_next (xcb_render_indexvalue_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_indexvalue_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_indexvalue_end (xcb_render_indexvalue_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_color_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_color_t)
+ */
+void
+xcb_render_color_next (xcb_render_color_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_color_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_color_end (xcb_render_color_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_pointfix_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_pointfix_t)
+ */
+void
+xcb_render_pointfix_next (xcb_render_pointfix_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_pointfix_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_pointfix_end (xcb_render_pointfix_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_linefix_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_linefix_t)
+ */
+void
+xcb_render_linefix_next (xcb_render_linefix_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_linefix_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_linefix_end (xcb_render_linefix_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_triangle_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_triangle_t)
+ */
+void
+xcb_render_triangle_next (xcb_render_triangle_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_triangle_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_triangle_end (xcb_render_triangle_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_trapezoid_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_trapezoid_t)
+ */
+void
+xcb_render_trapezoid_next (xcb_render_trapezoid_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_trapezoid_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_trapezoid_end (xcb_render_trapezoid_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_glyphinfo_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_glyphinfo_t)
+ */
+void
+xcb_render_glyphinfo_next (xcb_render_glyphinfo_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_glyphinfo_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_glyphinfo_end (xcb_render_glyphinfo_iterator_t i);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_render_query_version_cookie_t
+xcb_render_query_version (xcb_connection_t *c,
+                          uint32_t          client_major_version,
+                          uint32_t          client_minor_version);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_render_query_version_cookie_t
+xcb_render_query_version_unchecked (xcb_connection_t *c,
+                                    uint32_t          client_major_version,
+                                    uint32_t          client_minor_version);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_render_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_render_query_version_reply_t *
+xcb_render_query_version_reply (xcb_connection_t                   *c,
+                                xcb_render_query_version_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e);
+
+int
+xcb_render_query_pict_formats_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_render_query_pict_formats_cookie_t
+xcb_render_query_pict_formats (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_render_query_pict_formats_cookie_t
+xcb_render_query_pict_formats_unchecked (xcb_connection_t *c);
+
+xcb_render_pictforminfo_t *
+xcb_render_query_pict_formats_formats (const xcb_render_query_pict_formats_reply_t *R);
+
+int
+xcb_render_query_pict_formats_formats_length (const xcb_render_query_pict_formats_reply_t *R);
+
+xcb_render_pictforminfo_iterator_t
+xcb_render_query_pict_formats_formats_iterator (const xcb_render_query_pict_formats_reply_t *R);
+
+int
+xcb_render_query_pict_formats_screens_length (const xcb_render_query_pict_formats_reply_t *R);
+
+xcb_render_pictscreen_iterator_t
+xcb_render_query_pict_formats_screens_iterator (const xcb_render_query_pict_formats_reply_t *R);
+
+uint32_t *
+xcb_render_query_pict_formats_subpixels (const xcb_render_query_pict_formats_reply_t *R);
+
+int
+xcb_render_query_pict_formats_subpixels_length (const xcb_render_query_pict_formats_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_render_query_pict_formats_subpixels_end (const xcb_render_query_pict_formats_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_render_query_pict_formats_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_render_query_pict_formats_reply_t *
+xcb_render_query_pict_formats_reply (xcb_connection_t                        *c,
+                                     xcb_render_query_pict_formats_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e);
+
+int
+xcb_render_query_pict_index_values_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_render_query_pict_index_values_cookie_t
+xcb_render_query_pict_index_values (xcb_connection_t        *c,
+                                    xcb_render_pictformat_t  format);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_render_query_pict_index_values_cookie_t
+xcb_render_query_pict_index_values_unchecked (xcb_connection_t        *c,
+                                              xcb_render_pictformat_t  format);
+
+xcb_render_indexvalue_t *
+xcb_render_query_pict_index_values_values (const xcb_render_query_pict_index_values_reply_t *R);
+
+int
+xcb_render_query_pict_index_values_values_length (const xcb_render_query_pict_index_values_reply_t *R);
+
+xcb_render_indexvalue_iterator_t
+xcb_render_query_pict_index_values_values_iterator (const xcb_render_query_pict_index_values_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_render_query_pict_index_values_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_render_query_pict_index_values_reply_t *
+xcb_render_query_pict_index_values_reply (xcb_connection_t                             *c,
+                                          xcb_render_query_pict_index_values_cookie_t   cookie  /**< */,
+                                          xcb_generic_error_t                         **e);
+
+int
+xcb_render_create_picture_value_list_serialize (void                                         **_buffer,
+                                                uint32_t                                       value_mask,
+                                                const xcb_render_create_picture_value_list_t  *_aux);
+
+int
+xcb_render_create_picture_value_list_unpack (const void                              *_buffer,
+                                             uint32_t                                 value_mask,
+                                             xcb_render_create_picture_value_list_t  *_aux);
+
+int
+xcb_render_create_picture_value_list_sizeof (const void  *_buffer,
+                                             uint32_t     value_mask);
+
+int
+xcb_render_create_picture_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_create_picture_checked (xcb_connection_t        *c,
+                                   xcb_render_picture_t     pid,
+                                   xcb_drawable_t           drawable,
+                                   xcb_render_pictformat_t  format,
+                                   uint32_t                 value_mask,
+                                   const void              *value_list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_create_picture (xcb_connection_t        *c,
+                           xcb_render_picture_t     pid,
+                           xcb_drawable_t           drawable,
+                           xcb_render_pictformat_t  format,
+                           uint32_t                 value_mask,
+                           const void              *value_list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_create_picture_aux_checked (xcb_connection_t                             *c,
+                                       xcb_render_picture_t                          pid,
+                                       xcb_drawable_t                                drawable,
+                                       xcb_render_pictformat_t                       format,
+                                       uint32_t                                      value_mask,
+                                       const xcb_render_create_picture_value_list_t *value_list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_create_picture_aux (xcb_connection_t                             *c,
+                               xcb_render_picture_t                          pid,
+                               xcb_drawable_t                                drawable,
+                               xcb_render_pictformat_t                       format,
+                               uint32_t                                      value_mask,
+                               const xcb_render_create_picture_value_list_t *value_list);
+
+void *
+xcb_render_create_picture_value_list (const xcb_render_create_picture_request_t *R);
+
+int
+xcb_render_change_picture_value_list_serialize (void                                         **_buffer,
+                                                uint32_t                                       value_mask,
+                                                const xcb_render_change_picture_value_list_t  *_aux);
+
+int
+xcb_render_change_picture_value_list_unpack (const void                              *_buffer,
+                                             uint32_t                                 value_mask,
+                                             xcb_render_change_picture_value_list_t  *_aux);
+
+int
+xcb_render_change_picture_value_list_sizeof (const void  *_buffer,
+                                             uint32_t     value_mask);
+
+int
+xcb_render_change_picture_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_change_picture_checked (xcb_connection_t     *c,
+                                   xcb_render_picture_t  picture,
+                                   uint32_t              value_mask,
+                                   const void           *value_list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_change_picture (xcb_connection_t     *c,
+                           xcb_render_picture_t  picture,
+                           uint32_t              value_mask,
+                           const void           *value_list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_change_picture_aux_checked (xcb_connection_t                             *c,
+                                       xcb_render_picture_t                          picture,
+                                       uint32_t                                      value_mask,
+                                       const xcb_render_change_picture_value_list_t *value_list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_change_picture_aux (xcb_connection_t                             *c,
+                               xcb_render_picture_t                          picture,
+                               uint32_t                                      value_mask,
+                               const xcb_render_change_picture_value_list_t *value_list);
+
+void *
+xcb_render_change_picture_value_list (const xcb_render_change_picture_request_t *R);
+
+int
+xcb_render_set_picture_clip_rectangles_sizeof (const void  *_buffer,
+                                               uint32_t     rectangles_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_set_picture_clip_rectangles_checked (xcb_connection_t      *c,
+                                                xcb_render_picture_t   picture,
+                                                int16_t                clip_x_origin,
+                                                int16_t                clip_y_origin,
+                                                uint32_t               rectangles_len,
+                                                const xcb_rectangle_t *rectangles);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_set_picture_clip_rectangles (xcb_connection_t      *c,
+                                        xcb_render_picture_t   picture,
+                                        int16_t                clip_x_origin,
+                                        int16_t                clip_y_origin,
+                                        uint32_t               rectangles_len,
+                                        const xcb_rectangle_t *rectangles);
+
+xcb_rectangle_t *
+xcb_render_set_picture_clip_rectangles_rectangles (const xcb_render_set_picture_clip_rectangles_request_t *R);
+
+int
+xcb_render_set_picture_clip_rectangles_rectangles_length (const xcb_render_set_picture_clip_rectangles_request_t *R);
+
+xcb_rectangle_iterator_t
+xcb_render_set_picture_clip_rectangles_rectangles_iterator (const xcb_render_set_picture_clip_rectangles_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_free_picture_checked (xcb_connection_t     *c,
+                                 xcb_render_picture_t  picture);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_free_picture (xcb_connection_t     *c,
+                         xcb_render_picture_t  picture);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_composite_checked (xcb_connection_t     *c,
+                              uint8_t               op,
+                              xcb_render_picture_t  src,
+                              xcb_render_picture_t  mask,
+                              xcb_render_picture_t  dst,
+                              int16_t               src_x,
+                              int16_t               src_y,
+                              int16_t               mask_x,
+                              int16_t               mask_y,
+                              int16_t               dst_x,
+                              int16_t               dst_y,
+                              uint16_t              width,
+                              uint16_t              height);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_composite (xcb_connection_t     *c,
+                      uint8_t               op,
+                      xcb_render_picture_t  src,
+                      xcb_render_picture_t  mask,
+                      xcb_render_picture_t  dst,
+                      int16_t               src_x,
+                      int16_t               src_y,
+                      int16_t               mask_x,
+                      int16_t               mask_y,
+                      int16_t               dst_x,
+                      int16_t               dst_y,
+                      uint16_t              width,
+                      uint16_t              height);
+
+int
+xcb_render_trapezoids_sizeof (const void  *_buffer,
+                              uint32_t     traps_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_trapezoids_checked (xcb_connection_t             *c,
+                               uint8_t                       op,
+                               xcb_render_picture_t          src,
+                               xcb_render_picture_t          dst,
+                               xcb_render_pictformat_t       mask_format,
+                               int16_t                       src_x,
+                               int16_t                       src_y,
+                               uint32_t                      traps_len,
+                               const xcb_render_trapezoid_t *traps);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_trapezoids (xcb_connection_t             *c,
+                       uint8_t                       op,
+                       xcb_render_picture_t          src,
+                       xcb_render_picture_t          dst,
+                       xcb_render_pictformat_t       mask_format,
+                       int16_t                       src_x,
+                       int16_t                       src_y,
+                       uint32_t                      traps_len,
+                       const xcb_render_trapezoid_t *traps);
+
+xcb_render_trapezoid_t *
+xcb_render_trapezoids_traps (const xcb_render_trapezoids_request_t *R);
+
+int
+xcb_render_trapezoids_traps_length (const xcb_render_trapezoids_request_t *R);
+
+xcb_render_trapezoid_iterator_t
+xcb_render_trapezoids_traps_iterator (const xcb_render_trapezoids_request_t *R);
+
+int
+xcb_render_triangles_sizeof (const void  *_buffer,
+                             uint32_t     triangles_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_triangles_checked (xcb_connection_t            *c,
+                              uint8_t                      op,
+                              xcb_render_picture_t         src,
+                              xcb_render_picture_t         dst,
+                              xcb_render_pictformat_t      mask_format,
+                              int16_t                      src_x,
+                              int16_t                      src_y,
+                              uint32_t                     triangles_len,
+                              const xcb_render_triangle_t *triangles);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_triangles (xcb_connection_t            *c,
+                      uint8_t                      op,
+                      xcb_render_picture_t         src,
+                      xcb_render_picture_t         dst,
+                      xcb_render_pictformat_t      mask_format,
+                      int16_t                      src_x,
+                      int16_t                      src_y,
+                      uint32_t                     triangles_len,
+                      const xcb_render_triangle_t *triangles);
+
+xcb_render_triangle_t *
+xcb_render_triangles_triangles (const xcb_render_triangles_request_t *R);
+
+int
+xcb_render_triangles_triangles_length (const xcb_render_triangles_request_t *R);
+
+xcb_render_triangle_iterator_t
+xcb_render_triangles_triangles_iterator (const xcb_render_triangles_request_t *R);
+
+int
+xcb_render_tri_strip_sizeof (const void  *_buffer,
+                             uint32_t     points_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_tri_strip_checked (xcb_connection_t            *c,
+                              uint8_t                      op,
+                              xcb_render_picture_t         src,
+                              xcb_render_picture_t         dst,
+                              xcb_render_pictformat_t      mask_format,
+                              int16_t                      src_x,
+                              int16_t                      src_y,
+                              uint32_t                     points_len,
+                              const xcb_render_pointfix_t *points);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_tri_strip (xcb_connection_t            *c,
+                      uint8_t                      op,
+                      xcb_render_picture_t         src,
+                      xcb_render_picture_t         dst,
+                      xcb_render_pictformat_t      mask_format,
+                      int16_t                      src_x,
+                      int16_t                      src_y,
+                      uint32_t                     points_len,
+                      const xcb_render_pointfix_t *points);
+
+xcb_render_pointfix_t *
+xcb_render_tri_strip_points (const xcb_render_tri_strip_request_t *R);
+
+int
+xcb_render_tri_strip_points_length (const xcb_render_tri_strip_request_t *R);
+
+xcb_render_pointfix_iterator_t
+xcb_render_tri_strip_points_iterator (const xcb_render_tri_strip_request_t *R);
+
+int
+xcb_render_tri_fan_sizeof (const void  *_buffer,
+                           uint32_t     points_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_tri_fan_checked (xcb_connection_t            *c,
+                            uint8_t                      op,
+                            xcb_render_picture_t         src,
+                            xcb_render_picture_t         dst,
+                            xcb_render_pictformat_t      mask_format,
+                            int16_t                      src_x,
+                            int16_t                      src_y,
+                            uint32_t                     points_len,
+                            const xcb_render_pointfix_t *points);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_tri_fan (xcb_connection_t            *c,
+                    uint8_t                      op,
+                    xcb_render_picture_t         src,
+                    xcb_render_picture_t         dst,
+                    xcb_render_pictformat_t      mask_format,
+                    int16_t                      src_x,
+                    int16_t                      src_y,
+                    uint32_t                     points_len,
+                    const xcb_render_pointfix_t *points);
+
+xcb_render_pointfix_t *
+xcb_render_tri_fan_points (const xcb_render_tri_fan_request_t *R);
+
+int
+xcb_render_tri_fan_points_length (const xcb_render_tri_fan_request_t *R);
+
+xcb_render_pointfix_iterator_t
+xcb_render_tri_fan_points_iterator (const xcb_render_tri_fan_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_create_glyph_set_checked (xcb_connection_t        *c,
+                                     xcb_render_glyphset_t    gsid,
+                                     xcb_render_pictformat_t  format);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_create_glyph_set (xcb_connection_t        *c,
+                             xcb_render_glyphset_t    gsid,
+                             xcb_render_pictformat_t  format);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_reference_glyph_set_checked (xcb_connection_t      *c,
+                                        xcb_render_glyphset_t  gsid,
+                                        xcb_render_glyphset_t  existing);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_reference_glyph_set (xcb_connection_t      *c,
+                                xcb_render_glyphset_t  gsid,
+                                xcb_render_glyphset_t  existing);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_free_glyph_set_checked (xcb_connection_t      *c,
+                                   xcb_render_glyphset_t  glyphset);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_free_glyph_set (xcb_connection_t      *c,
+                           xcb_render_glyphset_t  glyphset);
+
+int
+xcb_render_add_glyphs_sizeof (const void  *_buffer,
+                              uint32_t     data_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_add_glyphs_checked (xcb_connection_t             *c,
+                               xcb_render_glyphset_t         glyphset,
+                               uint32_t                      glyphs_len,
+                               const uint32_t               *glyphids,
+                               const xcb_render_glyphinfo_t *glyphs,
+                               uint32_t                      data_len,
+                               const uint8_t                *data);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_add_glyphs (xcb_connection_t             *c,
+                       xcb_render_glyphset_t         glyphset,
+                       uint32_t                      glyphs_len,
+                       const uint32_t               *glyphids,
+                       const xcb_render_glyphinfo_t *glyphs,
+                       uint32_t                      data_len,
+                       const uint8_t                *data);
+
+uint32_t *
+xcb_render_add_glyphs_glyphids (const xcb_render_add_glyphs_request_t *R);
+
+int
+xcb_render_add_glyphs_glyphids_length (const xcb_render_add_glyphs_request_t *R);
+
+xcb_generic_iterator_t
+xcb_render_add_glyphs_glyphids_end (const xcb_render_add_glyphs_request_t *R);
+
+xcb_render_glyphinfo_t *
+xcb_render_add_glyphs_glyphs (const xcb_render_add_glyphs_request_t *R);
+
+int
+xcb_render_add_glyphs_glyphs_length (const xcb_render_add_glyphs_request_t *R);
+
+xcb_render_glyphinfo_iterator_t
+xcb_render_add_glyphs_glyphs_iterator (const xcb_render_add_glyphs_request_t *R);
+
+uint8_t *
+xcb_render_add_glyphs_data (const xcb_render_add_glyphs_request_t *R);
+
+int
+xcb_render_add_glyphs_data_length (const xcb_render_add_glyphs_request_t *R);
+
+xcb_generic_iterator_t
+xcb_render_add_glyphs_data_end (const xcb_render_add_glyphs_request_t *R);
+
+int
+xcb_render_free_glyphs_sizeof (const void  *_buffer,
+                               uint32_t     glyphs_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_free_glyphs_checked (xcb_connection_t         *c,
+                                xcb_render_glyphset_t     glyphset,
+                                uint32_t                  glyphs_len,
+                                const xcb_render_glyph_t *glyphs);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_free_glyphs (xcb_connection_t         *c,
+                        xcb_render_glyphset_t     glyphset,
+                        uint32_t                  glyphs_len,
+                        const xcb_render_glyph_t *glyphs);
+
+xcb_render_glyph_t *
+xcb_render_free_glyphs_glyphs (const xcb_render_free_glyphs_request_t *R);
+
+int
+xcb_render_free_glyphs_glyphs_length (const xcb_render_free_glyphs_request_t *R);
+
+xcb_generic_iterator_t
+xcb_render_free_glyphs_glyphs_end (const xcb_render_free_glyphs_request_t *R);
+
+int
+xcb_render_composite_glyphs_8_sizeof (const void  *_buffer,
+                                      uint32_t     glyphcmds_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_composite_glyphs_8_checked (xcb_connection_t        *c,
+                                       uint8_t                  op,
+                                       xcb_render_picture_t     src,
+                                       xcb_render_picture_t     dst,
+                                       xcb_render_pictformat_t  mask_format,
+                                       xcb_render_glyphset_t    glyphset,
+                                       int16_t                  src_x,
+                                       int16_t                  src_y,
+                                       uint32_t                 glyphcmds_len,
+                                       const uint8_t           *glyphcmds);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_composite_glyphs_8 (xcb_connection_t        *c,
+                               uint8_t                  op,
+                               xcb_render_picture_t     src,
+                               xcb_render_picture_t     dst,
+                               xcb_render_pictformat_t  mask_format,
+                               xcb_render_glyphset_t    glyphset,
+                               int16_t                  src_x,
+                               int16_t                  src_y,
+                               uint32_t                 glyphcmds_len,
+                               const uint8_t           *glyphcmds);
+
+uint8_t *
+xcb_render_composite_glyphs_8_glyphcmds (const xcb_render_composite_glyphs_8_request_t *R);
+
+int
+xcb_render_composite_glyphs_8_glyphcmds_length (const xcb_render_composite_glyphs_8_request_t *R);
+
+xcb_generic_iterator_t
+xcb_render_composite_glyphs_8_glyphcmds_end (const xcb_render_composite_glyphs_8_request_t *R);
+
+int
+xcb_render_composite_glyphs_16_sizeof (const void  *_buffer,
+                                       uint32_t     glyphcmds_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_composite_glyphs_16_checked (xcb_connection_t        *c,
+                                        uint8_t                  op,
+                                        xcb_render_picture_t     src,
+                                        xcb_render_picture_t     dst,
+                                        xcb_render_pictformat_t  mask_format,
+                                        xcb_render_glyphset_t    glyphset,
+                                        int16_t                  src_x,
+                                        int16_t                  src_y,
+                                        uint32_t                 glyphcmds_len,
+                                        const uint8_t           *glyphcmds);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_composite_glyphs_16 (xcb_connection_t        *c,
+                                uint8_t                  op,
+                                xcb_render_picture_t     src,
+                                xcb_render_picture_t     dst,
+                                xcb_render_pictformat_t  mask_format,
+                                xcb_render_glyphset_t    glyphset,
+                                int16_t                  src_x,
+                                int16_t                  src_y,
+                                uint32_t                 glyphcmds_len,
+                                const uint8_t           *glyphcmds);
+
+uint8_t *
+xcb_render_composite_glyphs_16_glyphcmds (const xcb_render_composite_glyphs_16_request_t *R);
+
+int
+xcb_render_composite_glyphs_16_glyphcmds_length (const xcb_render_composite_glyphs_16_request_t *R);
+
+xcb_generic_iterator_t
+xcb_render_composite_glyphs_16_glyphcmds_end (const xcb_render_composite_glyphs_16_request_t *R);
+
+int
+xcb_render_composite_glyphs_32_sizeof (const void  *_buffer,
+                                       uint32_t     glyphcmds_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_composite_glyphs_32_checked (xcb_connection_t        *c,
+                                        uint8_t                  op,
+                                        xcb_render_picture_t     src,
+                                        xcb_render_picture_t     dst,
+                                        xcb_render_pictformat_t  mask_format,
+                                        xcb_render_glyphset_t    glyphset,
+                                        int16_t                  src_x,
+                                        int16_t                  src_y,
+                                        uint32_t                 glyphcmds_len,
+                                        const uint8_t           *glyphcmds);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_composite_glyphs_32 (xcb_connection_t        *c,
+                                uint8_t                  op,
+                                xcb_render_picture_t     src,
+                                xcb_render_picture_t     dst,
+                                xcb_render_pictformat_t  mask_format,
+                                xcb_render_glyphset_t    glyphset,
+                                int16_t                  src_x,
+                                int16_t                  src_y,
+                                uint32_t                 glyphcmds_len,
+                                const uint8_t           *glyphcmds);
+
+uint8_t *
+xcb_render_composite_glyphs_32_glyphcmds (const xcb_render_composite_glyphs_32_request_t *R);
+
+int
+xcb_render_composite_glyphs_32_glyphcmds_length (const xcb_render_composite_glyphs_32_request_t *R);
+
+xcb_generic_iterator_t
+xcb_render_composite_glyphs_32_glyphcmds_end (const xcb_render_composite_glyphs_32_request_t *R);
+
+int
+xcb_render_fill_rectangles_sizeof (const void  *_buffer,
+                                   uint32_t     rects_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_fill_rectangles_checked (xcb_connection_t      *c,
+                                    uint8_t                op,
+                                    xcb_render_picture_t   dst,
+                                    xcb_render_color_t     color,
+                                    uint32_t               rects_len,
+                                    const xcb_rectangle_t *rects);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_fill_rectangles (xcb_connection_t      *c,
+                            uint8_t                op,
+                            xcb_render_picture_t   dst,
+                            xcb_render_color_t     color,
+                            uint32_t               rects_len,
+                            const xcb_rectangle_t *rects);
+
+xcb_rectangle_t *
+xcb_render_fill_rectangles_rects (const xcb_render_fill_rectangles_request_t *R);
+
+int
+xcb_render_fill_rectangles_rects_length (const xcb_render_fill_rectangles_request_t *R);
+
+xcb_rectangle_iterator_t
+xcb_render_fill_rectangles_rects_iterator (const xcb_render_fill_rectangles_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_create_cursor_checked (xcb_connection_t     *c,
+                                  xcb_cursor_t          cid,
+                                  xcb_render_picture_t  source,
+                                  uint16_t              x,
+                                  uint16_t              y);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_create_cursor (xcb_connection_t     *c,
+                          xcb_cursor_t          cid,
+                          xcb_render_picture_t  source,
+                          uint16_t              x,
+                          uint16_t              y);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_transform_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_transform_t)
+ */
+void
+xcb_render_transform_next (xcb_render_transform_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_transform_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_transform_end (xcb_render_transform_iterator_t i);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_set_picture_transform_checked (xcb_connection_t       *c,
+                                          xcb_render_picture_t    picture,
+                                          xcb_render_transform_t  transform);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_set_picture_transform (xcb_connection_t       *c,
+                                  xcb_render_picture_t    picture,
+                                  xcb_render_transform_t  transform);
+
+int
+xcb_render_query_filters_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_render_query_filters_cookie_t
+xcb_render_query_filters (xcb_connection_t *c,
+                          xcb_drawable_t    drawable);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_render_query_filters_cookie_t
+xcb_render_query_filters_unchecked (xcb_connection_t *c,
+                                    xcb_drawable_t    drawable);
+
+uint16_t *
+xcb_render_query_filters_aliases (const xcb_render_query_filters_reply_t *R);
+
+int
+xcb_render_query_filters_aliases_length (const xcb_render_query_filters_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_render_query_filters_aliases_end (const xcb_render_query_filters_reply_t *R);
+
+int
+xcb_render_query_filters_filters_length (const xcb_render_query_filters_reply_t *R);
+
+xcb_str_iterator_t
+xcb_render_query_filters_filters_iterator (const xcb_render_query_filters_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_render_query_filters_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_render_query_filters_reply_t *
+xcb_render_query_filters_reply (xcb_connection_t                   *c,
+                                xcb_render_query_filters_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e);
+
+int
+xcb_render_set_picture_filter_sizeof (const void  *_buffer,
+                                      uint32_t     values_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_set_picture_filter_checked (xcb_connection_t         *c,
+                                       xcb_render_picture_t      picture,
+                                       uint16_t                  filter_len,
+                                       const char               *filter,
+                                       uint32_t                  values_len,
+                                       const xcb_render_fixed_t *values);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_set_picture_filter (xcb_connection_t         *c,
+                               xcb_render_picture_t      picture,
+                               uint16_t                  filter_len,
+                               const char               *filter,
+                               uint32_t                  values_len,
+                               const xcb_render_fixed_t *values);
+
+char *
+xcb_render_set_picture_filter_filter (const xcb_render_set_picture_filter_request_t *R);
+
+int
+xcb_render_set_picture_filter_filter_length (const xcb_render_set_picture_filter_request_t *R);
+
+xcb_generic_iterator_t
+xcb_render_set_picture_filter_filter_end (const xcb_render_set_picture_filter_request_t *R);
+
+xcb_render_fixed_t *
+xcb_render_set_picture_filter_values (const xcb_render_set_picture_filter_request_t *R);
+
+int
+xcb_render_set_picture_filter_values_length (const xcb_render_set_picture_filter_request_t *R);
+
+xcb_generic_iterator_t
+xcb_render_set_picture_filter_values_end (const xcb_render_set_picture_filter_request_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_animcursorelt_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_animcursorelt_t)
+ */
+void
+xcb_render_animcursorelt_next (xcb_render_animcursorelt_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_animcursorelt_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_animcursorelt_end (xcb_render_animcursorelt_iterator_t i);
+
+int
+xcb_render_create_anim_cursor_sizeof (const void  *_buffer,
+                                      uint32_t     cursors_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_create_anim_cursor_checked (xcb_connection_t                 *c,
+                                       xcb_cursor_t                      cid,
+                                       uint32_t                          cursors_len,
+                                       const xcb_render_animcursorelt_t *cursors);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_create_anim_cursor (xcb_connection_t                 *c,
+                               xcb_cursor_t                      cid,
+                               uint32_t                          cursors_len,
+                               const xcb_render_animcursorelt_t *cursors);
+
+xcb_render_animcursorelt_t *
+xcb_render_create_anim_cursor_cursors (const xcb_render_create_anim_cursor_request_t *R);
+
+int
+xcb_render_create_anim_cursor_cursors_length (const xcb_render_create_anim_cursor_request_t *R);
+
+xcb_render_animcursorelt_iterator_t
+xcb_render_create_anim_cursor_cursors_iterator (const xcb_render_create_anim_cursor_request_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_spanfix_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_spanfix_t)
+ */
+void
+xcb_render_spanfix_next (xcb_render_spanfix_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_spanfix_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_spanfix_end (xcb_render_spanfix_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_render_trap_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_render_trap_t)
+ */
+void
+xcb_render_trap_next (xcb_render_trap_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_render_trap_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_render_trap_end (xcb_render_trap_iterator_t i);
+
+int
+xcb_render_add_traps_sizeof (const void  *_buffer,
+                             uint32_t     traps_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_add_traps_checked (xcb_connection_t        *c,
+                              xcb_render_picture_t     picture,
+                              int16_t                  x_off,
+                              int16_t                  y_off,
+                              uint32_t                 traps_len,
+                              const xcb_render_trap_t *traps);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_add_traps (xcb_connection_t        *c,
+                      xcb_render_picture_t     picture,
+                      int16_t                  x_off,
+                      int16_t                  y_off,
+                      uint32_t                 traps_len,
+                      const xcb_render_trap_t *traps);
+
+xcb_render_trap_t *
+xcb_render_add_traps_traps (const xcb_render_add_traps_request_t *R);
+
+int
+xcb_render_add_traps_traps_length (const xcb_render_add_traps_request_t *R);
+
+xcb_render_trap_iterator_t
+xcb_render_add_traps_traps_iterator (const xcb_render_add_traps_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_create_solid_fill_checked (xcb_connection_t     *c,
+                                      xcb_render_picture_t  picture,
+                                      xcb_render_color_t    color);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_create_solid_fill (xcb_connection_t     *c,
+                              xcb_render_picture_t  picture,
+                              xcb_render_color_t    color);
+
+int
+xcb_render_create_linear_gradient_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_create_linear_gradient_checked (xcb_connection_t         *c,
+                                           xcb_render_picture_t      picture,
+                                           xcb_render_pointfix_t     p1,
+                                           xcb_render_pointfix_t     p2,
+                                           uint32_t                  num_stops,
+                                           const xcb_render_fixed_t *stops,
+                                           const xcb_render_color_t *colors);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_create_linear_gradient (xcb_connection_t         *c,
+                                   xcb_render_picture_t      picture,
+                                   xcb_render_pointfix_t     p1,
+                                   xcb_render_pointfix_t     p2,
+                                   uint32_t                  num_stops,
+                                   const xcb_render_fixed_t *stops,
+                                   const xcb_render_color_t *colors);
+
+xcb_render_fixed_t *
+xcb_render_create_linear_gradient_stops (const xcb_render_create_linear_gradient_request_t *R);
+
+int
+xcb_render_create_linear_gradient_stops_length (const xcb_render_create_linear_gradient_request_t *R);
+
+xcb_generic_iterator_t
+xcb_render_create_linear_gradient_stops_end (const xcb_render_create_linear_gradient_request_t *R);
+
+xcb_render_color_t *
+xcb_render_create_linear_gradient_colors (const xcb_render_create_linear_gradient_request_t *R);
+
+int
+xcb_render_create_linear_gradient_colors_length (const xcb_render_create_linear_gradient_request_t *R);
+
+xcb_render_color_iterator_t
+xcb_render_create_linear_gradient_colors_iterator (const xcb_render_create_linear_gradient_request_t *R);
+
+int
+xcb_render_create_radial_gradient_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_create_radial_gradient_checked (xcb_connection_t         *c,
+                                           xcb_render_picture_t      picture,
+                                           xcb_render_pointfix_t     inner,
+                                           xcb_render_pointfix_t     outer,
+                                           xcb_render_fixed_t        inner_radius,
+                                           xcb_render_fixed_t        outer_radius,
+                                           uint32_t                  num_stops,
+                                           const xcb_render_fixed_t *stops,
+                                           const xcb_render_color_t *colors);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_create_radial_gradient (xcb_connection_t         *c,
+                                   xcb_render_picture_t      picture,
+                                   xcb_render_pointfix_t     inner,
+                                   xcb_render_pointfix_t     outer,
+                                   xcb_render_fixed_t        inner_radius,
+                                   xcb_render_fixed_t        outer_radius,
+                                   uint32_t                  num_stops,
+                                   const xcb_render_fixed_t *stops,
+                                   const xcb_render_color_t *colors);
+
+xcb_render_fixed_t *
+xcb_render_create_radial_gradient_stops (const xcb_render_create_radial_gradient_request_t *R);
+
+int
+xcb_render_create_radial_gradient_stops_length (const xcb_render_create_radial_gradient_request_t *R);
+
+xcb_generic_iterator_t
+xcb_render_create_radial_gradient_stops_end (const xcb_render_create_radial_gradient_request_t *R);
+
+xcb_render_color_t *
+xcb_render_create_radial_gradient_colors (const xcb_render_create_radial_gradient_request_t *R);
+
+int
+xcb_render_create_radial_gradient_colors_length (const xcb_render_create_radial_gradient_request_t *R);
+
+xcb_render_color_iterator_t
+xcb_render_create_radial_gradient_colors_iterator (const xcb_render_create_radial_gradient_request_t *R);
+
+int
+xcb_render_create_conical_gradient_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_render_create_conical_gradient_checked (xcb_connection_t         *c,
+                                            xcb_render_picture_t      picture,
+                                            xcb_render_pointfix_t     center,
+                                            xcb_render_fixed_t        angle,
+                                            uint32_t                  num_stops,
+                                            const xcb_render_fixed_t *stops,
+                                            const xcb_render_color_t *colors);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_render_create_conical_gradient (xcb_connection_t         *c,
+                                    xcb_render_picture_t      picture,
+                                    xcb_render_pointfix_t     center,
+                                    xcb_render_fixed_t        angle,
+                                    uint32_t                  num_stops,
+                                    const xcb_render_fixed_t *stops,
+                                    const xcb_render_color_t *colors);
+
+xcb_render_fixed_t *
+xcb_render_create_conical_gradient_stops (const xcb_render_create_conical_gradient_request_t *R);
+
+int
+xcb_render_create_conical_gradient_stops_length (const xcb_render_create_conical_gradient_request_t *R);
+
+xcb_generic_iterator_t
+xcb_render_create_conical_gradient_stops_end (const xcb_render_create_conical_gradient_request_t *R);
+
+xcb_render_color_t *
+xcb_render_create_conical_gradient_colors (const xcb_render_create_conical_gradient_request_t *R);
+
+int
+xcb_render_create_conical_gradient_colors_length (const xcb_render_create_conical_gradient_request_t *R);
+
+xcb_render_color_iterator_t
+xcb_render_create_conical_gradient_colors_iterator (const xcb_render_create_conical_gradient_request_t *R);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/res.h b/depends/libxcb/include/xcb/res.h
new file mode 100644
index 0000000..40afb63
--- /dev/null
+++ b/depends/libxcb/include/xcb/res.h
@@ -0,0 +1,864 @@
+/*
+ * This file generated automatically from res.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_Res_API XCB Res API
+ * @brief Res XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __RES_H
+#define __RES_H
+
+#include "xcb.h"
+#include "xproto.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_RES_MAJOR_VERSION 1
+#define XCB_RES_MINOR_VERSION 2
+
+extern xcb_extension_t xcb_res_id;
+
+/**
+ * @brief xcb_res_client_t
+ **/
+typedef struct xcb_res_client_t {
+    uint32_t resource_base;
+    uint32_t resource_mask;
+} xcb_res_client_t;
+
+/**
+ * @brief xcb_res_client_iterator_t
+ **/
+typedef struct xcb_res_client_iterator_t {
+    xcb_res_client_t *data;
+    int               rem;
+    int               index;
+} xcb_res_client_iterator_t;
+
+/**
+ * @brief xcb_res_type_t
+ **/
+typedef struct xcb_res_type_t {
+    xcb_atom_t resource_type;
+    uint32_t   count;
+} xcb_res_type_t;
+
+/**
+ * @brief xcb_res_type_iterator_t
+ **/
+typedef struct xcb_res_type_iterator_t {
+    xcb_res_type_t *data;
+    int             rem;
+    int             index;
+} xcb_res_type_iterator_t;
+
+typedef enum xcb_res_client_id_mask_t {
+    XCB_RES_CLIENT_ID_MASK_CLIENT_XID = 1,
+    XCB_RES_CLIENT_ID_MASK_LOCAL_CLIENT_PID = 2
+} xcb_res_client_id_mask_t;
+
+/**
+ * @brief xcb_res_client_id_spec_t
+ **/
+typedef struct xcb_res_client_id_spec_t {
+    uint32_t client;
+    uint32_t mask;
+} xcb_res_client_id_spec_t;
+
+/**
+ * @brief xcb_res_client_id_spec_iterator_t
+ **/
+typedef struct xcb_res_client_id_spec_iterator_t {
+    xcb_res_client_id_spec_t *data;
+    int                       rem;
+    int                       index;
+} xcb_res_client_id_spec_iterator_t;
+
+/**
+ * @brief xcb_res_client_id_value_t
+ **/
+typedef struct xcb_res_client_id_value_t {
+    xcb_res_client_id_spec_t spec;
+    uint32_t                 length;
+} xcb_res_client_id_value_t;
+
+/**
+ * @brief xcb_res_client_id_value_iterator_t
+ **/
+typedef struct xcb_res_client_id_value_iterator_t {
+    xcb_res_client_id_value_t *data;
+    int                        rem;
+    int                        index;
+} xcb_res_client_id_value_iterator_t;
+
+/**
+ * @brief xcb_res_resource_id_spec_t
+ **/
+typedef struct xcb_res_resource_id_spec_t {
+    uint32_t resource;
+    uint32_t type;
+} xcb_res_resource_id_spec_t;
+
+/**
+ * @brief xcb_res_resource_id_spec_iterator_t
+ **/
+typedef struct xcb_res_resource_id_spec_iterator_t {
+    xcb_res_resource_id_spec_t *data;
+    int                         rem;
+    int                         index;
+} xcb_res_resource_id_spec_iterator_t;
+
+/**
+ * @brief xcb_res_resource_size_spec_t
+ **/
+typedef struct xcb_res_resource_size_spec_t {
+    xcb_res_resource_id_spec_t spec;
+    uint32_t                   bytes;
+    uint32_t                   ref_count;
+    uint32_t                   use_count;
+} xcb_res_resource_size_spec_t;
+
+/**
+ * @brief xcb_res_resource_size_spec_iterator_t
+ **/
+typedef struct xcb_res_resource_size_spec_iterator_t {
+    xcb_res_resource_size_spec_t *data;
+    int                           rem;
+    int                           index;
+} xcb_res_resource_size_spec_iterator_t;
+
+/**
+ * @brief xcb_res_resource_size_value_t
+ **/
+typedef struct xcb_res_resource_size_value_t {
+    xcb_res_resource_size_spec_t size;
+    uint32_t                     num_cross_references;
+} xcb_res_resource_size_value_t;
+
+/**
+ * @brief xcb_res_resource_size_value_iterator_t
+ **/
+typedef struct xcb_res_resource_size_value_iterator_t {
+    xcb_res_resource_size_value_t *data;
+    int                            rem;
+    int                            index;
+} xcb_res_resource_size_value_iterator_t;
+
+/**
+ * @brief xcb_res_query_version_cookie_t
+ **/
+typedef struct xcb_res_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_res_query_version_cookie_t;
+
+/** Opcode for xcb_res_query_version. */
+#define XCB_RES_QUERY_VERSION 0
+
+/**
+ * @brief xcb_res_query_version_request_t
+ **/
+typedef struct xcb_res_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  client_major;
+    uint8_t  client_minor;
+} xcb_res_query_version_request_t;
+
+/**
+ * @brief xcb_res_query_version_reply_t
+ **/
+typedef struct xcb_res_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t server_major;
+    uint16_t server_minor;
+} xcb_res_query_version_reply_t;
+
+/**
+ * @brief xcb_res_query_clients_cookie_t
+ **/
+typedef struct xcb_res_query_clients_cookie_t {
+    unsigned int sequence;
+} xcb_res_query_clients_cookie_t;
+
+/** Opcode for xcb_res_query_clients. */
+#define XCB_RES_QUERY_CLIENTS 1
+
+/**
+ * @brief xcb_res_query_clients_request_t
+ **/
+typedef struct xcb_res_query_clients_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_res_query_clients_request_t;
+
+/**
+ * @brief xcb_res_query_clients_reply_t
+ **/
+typedef struct xcb_res_query_clients_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t num_clients;
+    uint8_t  pad1[20];
+} xcb_res_query_clients_reply_t;
+
+/**
+ * @brief xcb_res_query_client_resources_cookie_t
+ **/
+typedef struct xcb_res_query_client_resources_cookie_t {
+    unsigned int sequence;
+} xcb_res_query_client_resources_cookie_t;
+
+/** Opcode for xcb_res_query_client_resources. */
+#define XCB_RES_QUERY_CLIENT_RESOURCES 2
+
+/**
+ * @brief xcb_res_query_client_resources_request_t
+ **/
+typedef struct xcb_res_query_client_resources_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t xid;
+} xcb_res_query_client_resources_request_t;
+
+/**
+ * @brief xcb_res_query_client_resources_reply_t
+ **/
+typedef struct xcb_res_query_client_resources_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t num_types;
+    uint8_t  pad1[20];
+} xcb_res_query_client_resources_reply_t;
+
+/**
+ * @brief xcb_res_query_client_pixmap_bytes_cookie_t
+ **/
+typedef struct xcb_res_query_client_pixmap_bytes_cookie_t {
+    unsigned int sequence;
+} xcb_res_query_client_pixmap_bytes_cookie_t;
+
+/** Opcode for xcb_res_query_client_pixmap_bytes. */
+#define XCB_RES_QUERY_CLIENT_PIXMAP_BYTES 3
+
+/**
+ * @brief xcb_res_query_client_pixmap_bytes_request_t
+ **/
+typedef struct xcb_res_query_client_pixmap_bytes_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t xid;
+} xcb_res_query_client_pixmap_bytes_request_t;
+
+/**
+ * @brief xcb_res_query_client_pixmap_bytes_reply_t
+ **/
+typedef struct xcb_res_query_client_pixmap_bytes_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t bytes;
+    uint32_t bytes_overflow;
+} xcb_res_query_client_pixmap_bytes_reply_t;
+
+/**
+ * @brief xcb_res_query_client_ids_cookie_t
+ **/
+typedef struct xcb_res_query_client_ids_cookie_t {
+    unsigned int sequence;
+} xcb_res_query_client_ids_cookie_t;
+
+/** Opcode for xcb_res_query_client_ids. */
+#define XCB_RES_QUERY_CLIENT_IDS 4
+
+/**
+ * @brief xcb_res_query_client_ids_request_t
+ **/
+typedef struct xcb_res_query_client_ids_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t num_specs;
+} xcb_res_query_client_ids_request_t;
+
+/**
+ * @brief xcb_res_query_client_ids_reply_t
+ **/
+typedef struct xcb_res_query_client_ids_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t num_ids;
+    uint8_t  pad1[20];
+} xcb_res_query_client_ids_reply_t;
+
+/**
+ * @brief xcb_res_query_resource_bytes_cookie_t
+ **/
+typedef struct xcb_res_query_resource_bytes_cookie_t {
+    unsigned int sequence;
+} xcb_res_query_resource_bytes_cookie_t;
+
+/** Opcode for xcb_res_query_resource_bytes. */
+#define XCB_RES_QUERY_RESOURCE_BYTES 5
+
+/**
+ * @brief xcb_res_query_resource_bytes_request_t
+ **/
+typedef struct xcb_res_query_resource_bytes_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t client;
+    uint32_t num_specs;
+} xcb_res_query_resource_bytes_request_t;
+
+/**
+ * @brief xcb_res_query_resource_bytes_reply_t
+ **/
+typedef struct xcb_res_query_resource_bytes_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t num_sizes;
+    uint8_t  pad1[20];
+} xcb_res_query_resource_bytes_reply_t;
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_res_client_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_res_client_t)
+ */
+void
+xcb_res_client_next (xcb_res_client_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_res_client_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_res_client_end (xcb_res_client_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_res_type_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_res_type_t)
+ */
+void
+xcb_res_type_next (xcb_res_type_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_res_type_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_res_type_end (xcb_res_type_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_res_client_id_spec_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_res_client_id_spec_t)
+ */
+void
+xcb_res_client_id_spec_next (xcb_res_client_id_spec_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_res_client_id_spec_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_res_client_id_spec_end (xcb_res_client_id_spec_iterator_t i);
+
+int
+xcb_res_client_id_value_sizeof (const void  *_buffer);
+
+uint32_t *
+xcb_res_client_id_value_value (const xcb_res_client_id_value_t *R);
+
+int
+xcb_res_client_id_value_value_length (const xcb_res_client_id_value_t *R);
+
+xcb_generic_iterator_t
+xcb_res_client_id_value_value_end (const xcb_res_client_id_value_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_res_client_id_value_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_res_client_id_value_t)
+ */
+void
+xcb_res_client_id_value_next (xcb_res_client_id_value_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_res_client_id_value_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_res_client_id_value_end (xcb_res_client_id_value_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_res_resource_id_spec_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_res_resource_id_spec_t)
+ */
+void
+xcb_res_resource_id_spec_next (xcb_res_resource_id_spec_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_res_resource_id_spec_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_res_resource_id_spec_end (xcb_res_resource_id_spec_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_res_resource_size_spec_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_res_resource_size_spec_t)
+ */
+void
+xcb_res_resource_size_spec_next (xcb_res_resource_size_spec_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_res_resource_size_spec_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_res_resource_size_spec_end (xcb_res_resource_size_spec_iterator_t i);
+
+int
+xcb_res_resource_size_value_sizeof (const void  *_buffer);
+
+xcb_res_resource_size_spec_t *
+xcb_res_resource_size_value_cross_references (const xcb_res_resource_size_value_t *R);
+
+int
+xcb_res_resource_size_value_cross_references_length (const xcb_res_resource_size_value_t *R);
+
+xcb_res_resource_size_spec_iterator_t
+xcb_res_resource_size_value_cross_references_iterator (const xcb_res_resource_size_value_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_res_resource_size_value_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_res_resource_size_value_t)
+ */
+void
+xcb_res_resource_size_value_next (xcb_res_resource_size_value_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_res_resource_size_value_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_res_resource_size_value_end (xcb_res_resource_size_value_iterator_t i);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_res_query_version_cookie_t
+xcb_res_query_version (xcb_connection_t *c,
+                       uint8_t           client_major,
+                       uint8_t           client_minor);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_res_query_version_cookie_t
+xcb_res_query_version_unchecked (xcb_connection_t *c,
+                                 uint8_t           client_major,
+                                 uint8_t           client_minor);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_res_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_res_query_version_reply_t *
+xcb_res_query_version_reply (xcb_connection_t                *c,
+                             xcb_res_query_version_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+int
+xcb_res_query_clients_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_res_query_clients_cookie_t
+xcb_res_query_clients (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_res_query_clients_cookie_t
+xcb_res_query_clients_unchecked (xcb_connection_t *c);
+
+xcb_res_client_t *
+xcb_res_query_clients_clients (const xcb_res_query_clients_reply_t *R);
+
+int
+xcb_res_query_clients_clients_length (const xcb_res_query_clients_reply_t *R);
+
+xcb_res_client_iterator_t
+xcb_res_query_clients_clients_iterator (const xcb_res_query_clients_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_res_query_clients_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_res_query_clients_reply_t *
+xcb_res_query_clients_reply (xcb_connection_t                *c,
+                             xcb_res_query_clients_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+int
+xcb_res_query_client_resources_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_res_query_client_resources_cookie_t
+xcb_res_query_client_resources (xcb_connection_t *c,
+                                uint32_t          xid);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_res_query_client_resources_cookie_t
+xcb_res_query_client_resources_unchecked (xcb_connection_t *c,
+                                          uint32_t          xid);
+
+xcb_res_type_t *
+xcb_res_query_client_resources_types (const xcb_res_query_client_resources_reply_t *R);
+
+int
+xcb_res_query_client_resources_types_length (const xcb_res_query_client_resources_reply_t *R);
+
+xcb_res_type_iterator_t
+xcb_res_query_client_resources_types_iterator (const xcb_res_query_client_resources_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_res_query_client_resources_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_res_query_client_resources_reply_t *
+xcb_res_query_client_resources_reply (xcb_connection_t                         *c,
+                                      xcb_res_query_client_resources_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_res_query_client_pixmap_bytes_cookie_t
+xcb_res_query_client_pixmap_bytes (xcb_connection_t *c,
+                                   uint32_t          xid);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_res_query_client_pixmap_bytes_cookie_t
+xcb_res_query_client_pixmap_bytes_unchecked (xcb_connection_t *c,
+                                             uint32_t          xid);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_res_query_client_pixmap_bytes_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_res_query_client_pixmap_bytes_reply_t *
+xcb_res_query_client_pixmap_bytes_reply (xcb_connection_t                            *c,
+                                         xcb_res_query_client_pixmap_bytes_cookie_t   cookie  /**< */,
+                                         xcb_generic_error_t                        **e);
+
+int
+xcb_res_query_client_ids_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_res_query_client_ids_cookie_t
+xcb_res_query_client_ids (xcb_connection_t               *c,
+                          uint32_t                        num_specs,
+                          const xcb_res_client_id_spec_t *specs);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_res_query_client_ids_cookie_t
+xcb_res_query_client_ids_unchecked (xcb_connection_t               *c,
+                                    uint32_t                        num_specs,
+                                    const xcb_res_client_id_spec_t *specs);
+
+int
+xcb_res_query_client_ids_ids_length (const xcb_res_query_client_ids_reply_t *R);
+
+xcb_res_client_id_value_iterator_t
+xcb_res_query_client_ids_ids_iterator (const xcb_res_query_client_ids_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_res_query_client_ids_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_res_query_client_ids_reply_t *
+xcb_res_query_client_ids_reply (xcb_connection_t                   *c,
+                                xcb_res_query_client_ids_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e);
+
+int
+xcb_res_query_resource_bytes_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_res_query_resource_bytes_cookie_t
+xcb_res_query_resource_bytes (xcb_connection_t                 *c,
+                              uint32_t                          client,
+                              uint32_t                          num_specs,
+                              const xcb_res_resource_id_spec_t *specs);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_res_query_resource_bytes_cookie_t
+xcb_res_query_resource_bytes_unchecked (xcb_connection_t                 *c,
+                                        uint32_t                          client,
+                                        uint32_t                          num_specs,
+                                        const xcb_res_resource_id_spec_t *specs);
+
+int
+xcb_res_query_resource_bytes_sizes_length (const xcb_res_query_resource_bytes_reply_t *R);
+
+xcb_res_resource_size_value_iterator_t
+xcb_res_query_resource_bytes_sizes_iterator (const xcb_res_query_resource_bytes_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_res_query_resource_bytes_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_res_query_resource_bytes_reply_t *
+xcb_res_query_resource_bytes_reply (xcb_connection_t                       *c,
+                                    xcb_res_query_resource_bytes_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/screensaver.h b/depends/libxcb/include/xcb/screensaver.h
new file mode 100644
index 0000000..f6982ea
--- /dev/null
+++ b/depends/libxcb/include/xcb/screensaver.h
@@ -0,0 +1,517 @@
+/*
+ * This file generated automatically from screensaver.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_ScreenSaver_API XCB ScreenSaver API
+ * @brief ScreenSaver XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __SCREENSAVER_H
+#define __SCREENSAVER_H
+
+#include "xcb.h"
+#include "xproto.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_SCREENSAVER_MAJOR_VERSION 1
+#define XCB_SCREENSAVER_MINOR_VERSION 1
+
+extern xcb_extension_t xcb_screensaver_id;
+
+typedef enum xcb_screensaver_kind_t {
+    XCB_SCREENSAVER_KIND_BLANKED = 0,
+    XCB_SCREENSAVER_KIND_INTERNAL = 1,
+    XCB_SCREENSAVER_KIND_EXTERNAL = 2
+} xcb_screensaver_kind_t;
+
+typedef enum xcb_screensaver_event_t {
+    XCB_SCREENSAVER_EVENT_NOTIFY_MASK = 1,
+    XCB_SCREENSAVER_EVENT_CYCLE_MASK = 2
+} xcb_screensaver_event_t;
+
+typedef enum xcb_screensaver_state_t {
+    XCB_SCREENSAVER_STATE_OFF = 0,
+    XCB_SCREENSAVER_STATE_ON = 1,
+    XCB_SCREENSAVER_STATE_CYCLE = 2,
+    XCB_SCREENSAVER_STATE_DISABLED = 3
+} xcb_screensaver_state_t;
+
+/**
+ * @brief xcb_screensaver_query_version_cookie_t
+ **/
+typedef struct xcb_screensaver_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_screensaver_query_version_cookie_t;
+
+/** Opcode for xcb_screensaver_query_version. */
+#define XCB_SCREENSAVER_QUERY_VERSION 0
+
+/**
+ * @brief xcb_screensaver_query_version_request_t
+ **/
+typedef struct xcb_screensaver_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  client_major_version;
+    uint8_t  client_minor_version;
+    uint8_t  pad0[2];
+} xcb_screensaver_query_version_request_t;
+
+/**
+ * @brief xcb_screensaver_query_version_reply_t
+ **/
+typedef struct xcb_screensaver_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t server_major_version;
+    uint16_t server_minor_version;
+    uint8_t  pad1[20];
+} xcb_screensaver_query_version_reply_t;
+
+/**
+ * @brief xcb_screensaver_query_info_cookie_t
+ **/
+typedef struct xcb_screensaver_query_info_cookie_t {
+    unsigned int sequence;
+} xcb_screensaver_query_info_cookie_t;
+
+/** Opcode for xcb_screensaver_query_info. */
+#define XCB_SCREENSAVER_QUERY_INFO 1
+
+/**
+ * @brief xcb_screensaver_query_info_request_t
+ **/
+typedef struct xcb_screensaver_query_info_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+} xcb_screensaver_query_info_request_t;
+
+/**
+ * @brief xcb_screensaver_query_info_reply_t
+ **/
+typedef struct xcb_screensaver_query_info_reply_t {
+    uint8_t      response_type;
+    uint8_t      state;
+    uint16_t     sequence;
+    uint32_t     length;
+    xcb_window_t saver_window;
+    uint32_t     ms_until_server;
+    uint32_t     ms_since_user_input;
+    uint32_t     event_mask;
+    uint8_t      kind;
+    uint8_t      pad0[7];
+} xcb_screensaver_query_info_reply_t;
+
+/** Opcode for xcb_screensaver_select_input. */
+#define XCB_SCREENSAVER_SELECT_INPUT 2
+
+/**
+ * @brief xcb_screensaver_select_input_request_t
+ **/
+typedef struct xcb_screensaver_select_input_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    uint32_t       event_mask;
+} xcb_screensaver_select_input_request_t;
+
+/**
+ * @brief xcb_screensaver_set_attributes_value_list_t
+ **/
+typedef struct xcb_screensaver_set_attributes_value_list_t {
+    xcb_pixmap_t   background_pixmap;
+    uint32_t       background_pixel;
+    xcb_pixmap_t   border_pixmap;
+    uint32_t       border_pixel;
+    uint32_t       bit_gravity;
+    uint32_t       win_gravity;
+    uint32_t       backing_store;
+    uint32_t       backing_planes;
+    uint32_t       backing_pixel;
+    xcb_bool32_t   override_redirect;
+    xcb_bool32_t   save_under;
+    uint32_t       event_mask;
+    uint32_t       do_not_propogate_mask;
+    xcb_colormap_t colormap;
+    xcb_cursor_t   cursor;
+} xcb_screensaver_set_attributes_value_list_t;
+
+/** Opcode for xcb_screensaver_set_attributes. */
+#define XCB_SCREENSAVER_SET_ATTRIBUTES 3
+
+/**
+ * @brief xcb_screensaver_set_attributes_request_t
+ **/
+typedef struct xcb_screensaver_set_attributes_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    int16_t        x;
+    int16_t        y;
+    uint16_t       width;
+    uint16_t       height;
+    uint16_t       border_width;
+    uint8_t        _class;
+    uint8_t        depth;
+    xcb_visualid_t visual;
+    uint32_t       value_mask;
+} xcb_screensaver_set_attributes_request_t;
+
+/** Opcode for xcb_screensaver_unset_attributes. */
+#define XCB_SCREENSAVER_UNSET_ATTRIBUTES 4
+
+/**
+ * @brief xcb_screensaver_unset_attributes_request_t
+ **/
+typedef struct xcb_screensaver_unset_attributes_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+} xcb_screensaver_unset_attributes_request_t;
+
+/** Opcode for xcb_screensaver_suspend. */
+#define XCB_SCREENSAVER_SUSPEND 5
+
+/**
+ * @brief xcb_screensaver_suspend_request_t
+ **/
+typedef struct xcb_screensaver_suspend_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t suspend;
+} xcb_screensaver_suspend_request_t;
+
+/** Opcode for xcb_screensaver_notify. */
+#define XCB_SCREENSAVER_NOTIFY 0
+
+/**
+ * @brief xcb_screensaver_notify_event_t
+ **/
+typedef struct xcb_screensaver_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         state;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    xcb_window_t    root;
+    xcb_window_t    window;
+    uint8_t         kind;
+    uint8_t         forced;
+    uint8_t         pad0[14];
+} xcb_screensaver_notify_event_t;
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_screensaver_query_version_cookie_t
+xcb_screensaver_query_version (xcb_connection_t *c,
+                               uint8_t           client_major_version,
+                               uint8_t           client_minor_version);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_screensaver_query_version_cookie_t
+xcb_screensaver_query_version_unchecked (xcb_connection_t *c,
+                                         uint8_t           client_major_version,
+                                         uint8_t           client_minor_version);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_screensaver_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_screensaver_query_version_reply_t *
+xcb_screensaver_query_version_reply (xcb_connection_t                        *c,
+                                     xcb_screensaver_query_version_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_screensaver_query_info_cookie_t
+xcb_screensaver_query_info (xcb_connection_t *c,
+                            xcb_drawable_t    drawable);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_screensaver_query_info_cookie_t
+xcb_screensaver_query_info_unchecked (xcb_connection_t *c,
+                                      xcb_drawable_t    drawable);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_screensaver_query_info_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_screensaver_query_info_reply_t *
+xcb_screensaver_query_info_reply (xcb_connection_t                     *c,
+                                  xcb_screensaver_query_info_cookie_t   cookie  /**< */,
+                                  xcb_generic_error_t                 **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_screensaver_select_input_checked (xcb_connection_t *c,
+                                      xcb_drawable_t    drawable,
+                                      uint32_t          event_mask);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_screensaver_select_input (xcb_connection_t *c,
+                              xcb_drawable_t    drawable,
+                              uint32_t          event_mask);
+
+int
+xcb_screensaver_set_attributes_value_list_serialize (void                                              **_buffer,
+                                                     uint32_t                                            value_mask,
+                                                     const xcb_screensaver_set_attributes_value_list_t  *_aux);
+
+int
+xcb_screensaver_set_attributes_value_list_unpack (const void                                   *_buffer,
+                                                  uint32_t                                      value_mask,
+                                                  xcb_screensaver_set_attributes_value_list_t  *_aux);
+
+int
+xcb_screensaver_set_attributes_value_list_sizeof (const void  *_buffer,
+                                                  uint32_t     value_mask);
+
+int
+xcb_screensaver_set_attributes_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_screensaver_set_attributes_checked (xcb_connection_t *c,
+                                        xcb_drawable_t    drawable,
+                                        int16_t           x,
+                                        int16_t           y,
+                                        uint16_t          width,
+                                        uint16_t          height,
+                                        uint16_t          border_width,
+                                        uint8_t           _class,
+                                        uint8_t           depth,
+                                        xcb_visualid_t    visual,
+                                        uint32_t          value_mask,
+                                        const void       *value_list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_screensaver_set_attributes (xcb_connection_t *c,
+                                xcb_drawable_t    drawable,
+                                int16_t           x,
+                                int16_t           y,
+                                uint16_t          width,
+                                uint16_t          height,
+                                uint16_t          border_width,
+                                uint8_t           _class,
+                                uint8_t           depth,
+                                xcb_visualid_t    visual,
+                                uint32_t          value_mask,
+                                const void       *value_list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_screensaver_set_attributes_aux_checked (xcb_connection_t                                  *c,
+                                            xcb_drawable_t                                     drawable,
+                                            int16_t                                            x,
+                                            int16_t                                            y,
+                                            uint16_t                                           width,
+                                            uint16_t                                           height,
+                                            uint16_t                                           border_width,
+                                            uint8_t                                            _class,
+                                            uint8_t                                            depth,
+                                            xcb_visualid_t                                     visual,
+                                            uint32_t                                           value_mask,
+                                            const xcb_screensaver_set_attributes_value_list_t *value_list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_screensaver_set_attributes_aux (xcb_connection_t                                  *c,
+                                    xcb_drawable_t                                     drawable,
+                                    int16_t                                            x,
+                                    int16_t                                            y,
+                                    uint16_t                                           width,
+                                    uint16_t                                           height,
+                                    uint16_t                                           border_width,
+                                    uint8_t                                            _class,
+                                    uint8_t                                            depth,
+                                    xcb_visualid_t                                     visual,
+                                    uint32_t                                           value_mask,
+                                    const xcb_screensaver_set_attributes_value_list_t *value_list);
+
+void *
+xcb_screensaver_set_attributes_value_list (const xcb_screensaver_set_attributes_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_screensaver_unset_attributes_checked (xcb_connection_t *c,
+                                          xcb_drawable_t    drawable);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_screensaver_unset_attributes (xcb_connection_t *c,
+                                  xcb_drawable_t    drawable);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_screensaver_suspend_checked (xcb_connection_t *c,
+                                 uint32_t          suspend);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_screensaver_suspend (xcb_connection_t *c,
+                         uint32_t          suspend);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/shape.h b/depends/libxcb/include/xcb/shape.h
new file mode 100644
index 0000000..0b3b759
--- /dev/null
+++ b/depends/libxcb/include/xcb/shape.h
@@ -0,0 +1,752 @@
+/*
+ * This file generated automatically from shape.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_Shape_API XCB Shape API
+ * @brief Shape XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __SHAPE_H
+#define __SHAPE_H
+
+#include "xcb.h"
+#include "xproto.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_SHAPE_MAJOR_VERSION 1
+#define XCB_SHAPE_MINOR_VERSION 1
+
+extern xcb_extension_t xcb_shape_id;
+
+typedef uint8_t xcb_shape_op_t;
+
+/**
+ * @brief xcb_shape_op_iterator_t
+ **/
+typedef struct xcb_shape_op_iterator_t {
+    xcb_shape_op_t *data;
+    int             rem;
+    int             index;
+} xcb_shape_op_iterator_t;
+
+typedef uint8_t xcb_shape_kind_t;
+
+/**
+ * @brief xcb_shape_kind_iterator_t
+ **/
+typedef struct xcb_shape_kind_iterator_t {
+    xcb_shape_kind_t *data;
+    int               rem;
+    int               index;
+} xcb_shape_kind_iterator_t;
+
+typedef enum xcb_shape_so_t {
+    XCB_SHAPE_SO_SET = 0,
+    XCB_SHAPE_SO_UNION = 1,
+    XCB_SHAPE_SO_INTERSECT = 2,
+    XCB_SHAPE_SO_SUBTRACT = 3,
+    XCB_SHAPE_SO_INVERT = 4
+} xcb_shape_so_t;
+
+typedef enum xcb_shape_sk_t {
+    XCB_SHAPE_SK_BOUNDING = 0,
+    XCB_SHAPE_SK_CLIP = 1,
+    XCB_SHAPE_SK_INPUT = 2
+} xcb_shape_sk_t;
+
+/** Opcode for xcb_shape_notify. */
+#define XCB_SHAPE_NOTIFY 0
+
+/**
+ * @brief xcb_shape_notify_event_t
+ **/
+typedef struct xcb_shape_notify_event_t {
+    uint8_t          response_type;
+    xcb_shape_kind_t shape_kind;
+    uint16_t         sequence;
+    xcb_window_t     affected_window;
+    int16_t          extents_x;
+    int16_t          extents_y;
+    uint16_t         extents_width;
+    uint16_t         extents_height;
+    xcb_timestamp_t  server_time;
+    uint8_t          shaped;
+    uint8_t          pad0[11];
+} xcb_shape_notify_event_t;
+
+/**
+ * @brief xcb_shape_query_version_cookie_t
+ **/
+typedef struct xcb_shape_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_shape_query_version_cookie_t;
+
+/** Opcode for xcb_shape_query_version. */
+#define XCB_SHAPE_QUERY_VERSION 0
+
+/**
+ * @brief xcb_shape_query_version_request_t
+ **/
+typedef struct xcb_shape_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_shape_query_version_request_t;
+
+/**
+ * @brief xcb_shape_query_version_reply_t
+ **/
+typedef struct xcb_shape_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t major_version;
+    uint16_t minor_version;
+} xcb_shape_query_version_reply_t;
+
+/** Opcode for xcb_shape_rectangles. */
+#define XCB_SHAPE_RECTANGLES 1
+
+/**
+ * @brief xcb_shape_rectangles_request_t
+ **/
+typedef struct xcb_shape_rectangles_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_shape_op_t   operation;
+    xcb_shape_kind_t destination_kind;
+    uint8_t          ordering;
+    uint8_t          pad0;
+    xcb_window_t     destination_window;
+    int16_t          x_offset;
+    int16_t          y_offset;
+} xcb_shape_rectangles_request_t;
+
+/** Opcode for xcb_shape_mask. */
+#define XCB_SHAPE_MASK 2
+
+/**
+ * @brief xcb_shape_mask_request_t
+ **/
+typedef struct xcb_shape_mask_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_shape_op_t   operation;
+    xcb_shape_kind_t destination_kind;
+    uint8_t          pad0[2];
+    xcb_window_t     destination_window;
+    int16_t          x_offset;
+    int16_t          y_offset;
+    xcb_pixmap_t     source_bitmap;
+} xcb_shape_mask_request_t;
+
+/** Opcode for xcb_shape_combine. */
+#define XCB_SHAPE_COMBINE 3
+
+/**
+ * @brief xcb_shape_combine_request_t
+ **/
+typedef struct xcb_shape_combine_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_shape_op_t   operation;
+    xcb_shape_kind_t destination_kind;
+    xcb_shape_kind_t source_kind;
+    uint8_t          pad0;
+    xcb_window_t     destination_window;
+    int16_t          x_offset;
+    int16_t          y_offset;
+    xcb_window_t     source_window;
+} xcb_shape_combine_request_t;
+
+/** Opcode for xcb_shape_offset. */
+#define XCB_SHAPE_OFFSET 4
+
+/**
+ * @brief xcb_shape_offset_request_t
+ **/
+typedef struct xcb_shape_offset_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_shape_kind_t destination_kind;
+    uint8_t          pad0[3];
+    xcb_window_t     destination_window;
+    int16_t          x_offset;
+    int16_t          y_offset;
+} xcb_shape_offset_request_t;
+
+/**
+ * @brief xcb_shape_query_extents_cookie_t
+ **/
+typedef struct xcb_shape_query_extents_cookie_t {
+    unsigned int sequence;
+} xcb_shape_query_extents_cookie_t;
+
+/** Opcode for xcb_shape_query_extents. */
+#define XCB_SHAPE_QUERY_EXTENTS 5
+
+/**
+ * @brief xcb_shape_query_extents_request_t
+ **/
+typedef struct xcb_shape_query_extents_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t destination_window;
+} xcb_shape_query_extents_request_t;
+
+/**
+ * @brief xcb_shape_query_extents_reply_t
+ **/
+typedef struct xcb_shape_query_extents_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  bounding_shaped;
+    uint8_t  clip_shaped;
+    uint8_t  pad1[2];
+    int16_t  bounding_shape_extents_x;
+    int16_t  bounding_shape_extents_y;
+    uint16_t bounding_shape_extents_width;
+    uint16_t bounding_shape_extents_height;
+    int16_t  clip_shape_extents_x;
+    int16_t  clip_shape_extents_y;
+    uint16_t clip_shape_extents_width;
+    uint16_t clip_shape_extents_height;
+} xcb_shape_query_extents_reply_t;
+
+/** Opcode for xcb_shape_select_input. */
+#define XCB_SHAPE_SELECT_INPUT 6
+
+/**
+ * @brief xcb_shape_select_input_request_t
+ **/
+typedef struct xcb_shape_select_input_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t destination_window;
+    uint8_t      enable;
+    uint8_t      pad0[3];
+} xcb_shape_select_input_request_t;
+
+/**
+ * @brief xcb_shape_input_selected_cookie_t
+ **/
+typedef struct xcb_shape_input_selected_cookie_t {
+    unsigned int sequence;
+} xcb_shape_input_selected_cookie_t;
+
+/** Opcode for xcb_shape_input_selected. */
+#define XCB_SHAPE_INPUT_SELECTED 7
+
+/**
+ * @brief xcb_shape_input_selected_request_t
+ **/
+typedef struct xcb_shape_input_selected_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t destination_window;
+} xcb_shape_input_selected_request_t;
+
+/**
+ * @brief xcb_shape_input_selected_reply_t
+ **/
+typedef struct xcb_shape_input_selected_reply_t {
+    uint8_t  response_type;
+    uint8_t  enabled;
+    uint16_t sequence;
+    uint32_t length;
+} xcb_shape_input_selected_reply_t;
+
+/**
+ * @brief xcb_shape_get_rectangles_cookie_t
+ **/
+typedef struct xcb_shape_get_rectangles_cookie_t {
+    unsigned int sequence;
+} xcb_shape_get_rectangles_cookie_t;
+
+/** Opcode for xcb_shape_get_rectangles. */
+#define XCB_SHAPE_GET_RECTANGLES 8
+
+/**
+ * @brief xcb_shape_get_rectangles_request_t
+ **/
+typedef struct xcb_shape_get_rectangles_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_window_t     window;
+    xcb_shape_kind_t source_kind;
+    uint8_t          pad0[3];
+} xcb_shape_get_rectangles_request_t;
+
+/**
+ * @brief xcb_shape_get_rectangles_reply_t
+ **/
+typedef struct xcb_shape_get_rectangles_reply_t {
+    uint8_t  response_type;
+    uint8_t  ordering;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t rectangles_len;
+    uint8_t  pad0[20];
+} xcb_shape_get_rectangles_reply_t;
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_shape_op_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_shape_op_t)
+ */
+void
+xcb_shape_op_next (xcb_shape_op_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_shape_op_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_shape_op_end (xcb_shape_op_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_shape_kind_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_shape_kind_t)
+ */
+void
+xcb_shape_kind_next (xcb_shape_kind_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_shape_kind_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_shape_kind_end (xcb_shape_kind_iterator_t i);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_shape_query_version_cookie_t
+xcb_shape_query_version (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_shape_query_version_cookie_t
+xcb_shape_query_version_unchecked (xcb_connection_t *c);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_shape_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_shape_query_version_reply_t *
+xcb_shape_query_version_reply (xcb_connection_t                  *c,
+                               xcb_shape_query_version_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+int
+xcb_shape_rectangles_sizeof (const void  *_buffer,
+                             uint32_t     rectangles_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_shape_rectangles_checked (xcb_connection_t      *c,
+                              xcb_shape_op_t         operation,
+                              xcb_shape_kind_t       destination_kind,
+                              uint8_t                ordering,
+                              xcb_window_t           destination_window,
+                              int16_t                x_offset,
+                              int16_t                y_offset,
+                              uint32_t               rectangles_len,
+                              const xcb_rectangle_t *rectangles);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_shape_rectangles (xcb_connection_t      *c,
+                      xcb_shape_op_t         operation,
+                      xcb_shape_kind_t       destination_kind,
+                      uint8_t                ordering,
+                      xcb_window_t           destination_window,
+                      int16_t                x_offset,
+                      int16_t                y_offset,
+                      uint32_t               rectangles_len,
+                      const xcb_rectangle_t *rectangles);
+
+xcb_rectangle_t *
+xcb_shape_rectangles_rectangles (const xcb_shape_rectangles_request_t *R);
+
+int
+xcb_shape_rectangles_rectangles_length (const xcb_shape_rectangles_request_t *R);
+
+xcb_rectangle_iterator_t
+xcb_shape_rectangles_rectangles_iterator (const xcb_shape_rectangles_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_shape_mask_checked (xcb_connection_t *c,
+                        xcb_shape_op_t    operation,
+                        xcb_shape_kind_t  destination_kind,
+                        xcb_window_t      destination_window,
+                        int16_t           x_offset,
+                        int16_t           y_offset,
+                        xcb_pixmap_t      source_bitmap);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_shape_mask (xcb_connection_t *c,
+                xcb_shape_op_t    operation,
+                xcb_shape_kind_t  destination_kind,
+                xcb_window_t      destination_window,
+                int16_t           x_offset,
+                int16_t           y_offset,
+                xcb_pixmap_t      source_bitmap);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_shape_combine_checked (xcb_connection_t *c,
+                           xcb_shape_op_t    operation,
+                           xcb_shape_kind_t  destination_kind,
+                           xcb_shape_kind_t  source_kind,
+                           xcb_window_t      destination_window,
+                           int16_t           x_offset,
+                           int16_t           y_offset,
+                           xcb_window_t      source_window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_shape_combine (xcb_connection_t *c,
+                   xcb_shape_op_t    operation,
+                   xcb_shape_kind_t  destination_kind,
+                   xcb_shape_kind_t  source_kind,
+                   xcb_window_t      destination_window,
+                   int16_t           x_offset,
+                   int16_t           y_offset,
+                   xcb_window_t      source_window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_shape_offset_checked (xcb_connection_t *c,
+                          xcb_shape_kind_t  destination_kind,
+                          xcb_window_t      destination_window,
+                          int16_t           x_offset,
+                          int16_t           y_offset);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_shape_offset (xcb_connection_t *c,
+                  xcb_shape_kind_t  destination_kind,
+                  xcb_window_t      destination_window,
+                  int16_t           x_offset,
+                  int16_t           y_offset);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_shape_query_extents_cookie_t
+xcb_shape_query_extents (xcb_connection_t *c,
+                         xcb_window_t      destination_window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_shape_query_extents_cookie_t
+xcb_shape_query_extents_unchecked (xcb_connection_t *c,
+                                   xcb_window_t      destination_window);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_shape_query_extents_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_shape_query_extents_reply_t *
+xcb_shape_query_extents_reply (xcb_connection_t                  *c,
+                               xcb_shape_query_extents_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_shape_select_input_checked (xcb_connection_t *c,
+                                xcb_window_t      destination_window,
+                                uint8_t           enable);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_shape_select_input (xcb_connection_t *c,
+                        xcb_window_t      destination_window,
+                        uint8_t           enable);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_shape_input_selected_cookie_t
+xcb_shape_input_selected (xcb_connection_t *c,
+                          xcb_window_t      destination_window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_shape_input_selected_cookie_t
+xcb_shape_input_selected_unchecked (xcb_connection_t *c,
+                                    xcb_window_t      destination_window);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_shape_input_selected_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_shape_input_selected_reply_t *
+xcb_shape_input_selected_reply (xcb_connection_t                   *c,
+                                xcb_shape_input_selected_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e);
+
+int
+xcb_shape_get_rectangles_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_shape_get_rectangles_cookie_t
+xcb_shape_get_rectangles (xcb_connection_t *c,
+                          xcb_window_t      window,
+                          xcb_shape_kind_t  source_kind);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_shape_get_rectangles_cookie_t
+xcb_shape_get_rectangles_unchecked (xcb_connection_t *c,
+                                    xcb_window_t      window,
+                                    xcb_shape_kind_t  source_kind);
+
+xcb_rectangle_t *
+xcb_shape_get_rectangles_rectangles (const xcb_shape_get_rectangles_reply_t *R);
+
+int
+xcb_shape_get_rectangles_rectangles_length (const xcb_shape_get_rectangles_reply_t *R);
+
+xcb_rectangle_iterator_t
+xcb_shape_get_rectangles_rectangles_iterator (const xcb_shape_get_rectangles_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_shape_get_rectangles_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_shape_get_rectangles_reply_t *
+xcb_shape_get_rectangles_reply (xcb_connection_t                   *c,
+                                xcb_shape_get_rectangles_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/shm.h b/depends/libxcb/include/xcb/shm.h
new file mode 100644
index 0000000..248e0f4
--- /dev/null
+++ b/depends/libxcb/include/xcb/shm.h
@@ -0,0 +1,648 @@
+/*
+ * This file generated automatically from shm.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_Shm_API XCB Shm API
+ * @brief Shm XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __SHM_H
+#define __SHM_H
+
+#include "xcb.h"
+#include "xproto.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_SHM_MAJOR_VERSION 1
+#define XCB_SHM_MINOR_VERSION 2
+
+extern xcb_extension_t xcb_shm_id;
+
+typedef uint32_t xcb_shm_seg_t;
+
+/**
+ * @brief xcb_shm_seg_iterator_t
+ **/
+typedef struct xcb_shm_seg_iterator_t {
+    xcb_shm_seg_t *data;
+    int            rem;
+    int            index;
+} xcb_shm_seg_iterator_t;
+
+/** Opcode for xcb_shm_completion. */
+#define XCB_SHM_COMPLETION 0
+
+/**
+ * @brief xcb_shm_completion_event_t
+ **/
+typedef struct xcb_shm_completion_event_t {
+    uint8_t        response_type;
+    uint8_t        pad0;
+    uint16_t       sequence;
+    xcb_drawable_t drawable;
+    uint16_t       minor_event;
+    uint8_t        major_event;
+    uint8_t        pad1;
+    xcb_shm_seg_t  shmseg;
+    uint32_t       offset;
+} xcb_shm_completion_event_t;
+
+/** Opcode for xcb_shm_bad_seg. */
+#define XCB_SHM_BAD_SEG 0
+
+typedef xcb_value_error_t xcb_shm_bad_seg_error_t;
+
+/**
+ * @brief xcb_shm_query_version_cookie_t
+ **/
+typedef struct xcb_shm_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_shm_query_version_cookie_t;
+
+/** Opcode for xcb_shm_query_version. */
+#define XCB_SHM_QUERY_VERSION 0
+
+/**
+ * @brief xcb_shm_query_version_request_t
+ **/
+typedef struct xcb_shm_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_shm_query_version_request_t;
+
+/**
+ * @brief xcb_shm_query_version_reply_t
+ **/
+typedef struct xcb_shm_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  shared_pixmaps;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t major_version;
+    uint16_t minor_version;
+    uint16_t uid;
+    uint16_t gid;
+    uint8_t  pixmap_format;
+    uint8_t  pad0[15];
+} xcb_shm_query_version_reply_t;
+
+/** Opcode for xcb_shm_attach. */
+#define XCB_SHM_ATTACH 1
+
+/**
+ * @brief xcb_shm_attach_request_t
+ **/
+typedef struct xcb_shm_attach_request_t {
+    uint8_t       major_opcode;
+    uint8_t       minor_opcode;
+    uint16_t      length;
+    xcb_shm_seg_t shmseg;
+    uint32_t      shmid;
+    uint8_t       read_only;
+    uint8_t       pad0[3];
+} xcb_shm_attach_request_t;
+
+/** Opcode for xcb_shm_detach. */
+#define XCB_SHM_DETACH 2
+
+/**
+ * @brief xcb_shm_detach_request_t
+ **/
+typedef struct xcb_shm_detach_request_t {
+    uint8_t       major_opcode;
+    uint8_t       minor_opcode;
+    uint16_t      length;
+    xcb_shm_seg_t shmseg;
+} xcb_shm_detach_request_t;
+
+/** Opcode for xcb_shm_put_image. */
+#define XCB_SHM_PUT_IMAGE 3
+
+/**
+ * @brief xcb_shm_put_image_request_t
+ **/
+typedef struct xcb_shm_put_image_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    xcb_gcontext_t gc;
+    uint16_t       total_width;
+    uint16_t       total_height;
+    uint16_t       src_x;
+    uint16_t       src_y;
+    uint16_t       src_width;
+    uint16_t       src_height;
+    int16_t        dst_x;
+    int16_t        dst_y;
+    uint8_t        depth;
+    uint8_t        format;
+    uint8_t        send_event;
+    uint8_t        pad0;
+    xcb_shm_seg_t  shmseg;
+    uint32_t       offset;
+} xcb_shm_put_image_request_t;
+
+/**
+ * @brief xcb_shm_get_image_cookie_t
+ **/
+typedef struct xcb_shm_get_image_cookie_t {
+    unsigned int sequence;
+} xcb_shm_get_image_cookie_t;
+
+/** Opcode for xcb_shm_get_image. */
+#define XCB_SHM_GET_IMAGE 4
+
+/**
+ * @brief xcb_shm_get_image_request_t
+ **/
+typedef struct xcb_shm_get_image_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    int16_t        x;
+    int16_t        y;
+    uint16_t       width;
+    uint16_t       height;
+    uint32_t       plane_mask;
+    uint8_t        format;
+    uint8_t        pad0[3];
+    xcb_shm_seg_t  shmseg;
+    uint32_t       offset;
+} xcb_shm_get_image_request_t;
+
+/**
+ * @brief xcb_shm_get_image_reply_t
+ **/
+typedef struct xcb_shm_get_image_reply_t {
+    uint8_t        response_type;
+    uint8_t        depth;
+    uint16_t       sequence;
+    uint32_t       length;
+    xcb_visualid_t visual;
+    uint32_t       size;
+} xcb_shm_get_image_reply_t;
+
+/** Opcode for xcb_shm_create_pixmap. */
+#define XCB_SHM_CREATE_PIXMAP 5
+
+/**
+ * @brief xcb_shm_create_pixmap_request_t
+ **/
+typedef struct xcb_shm_create_pixmap_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_pixmap_t   pid;
+    xcb_drawable_t drawable;
+    uint16_t       width;
+    uint16_t       height;
+    uint8_t        depth;
+    uint8_t        pad0[3];
+    xcb_shm_seg_t  shmseg;
+    uint32_t       offset;
+} xcb_shm_create_pixmap_request_t;
+
+/** Opcode for xcb_shm_attach_fd. */
+#define XCB_SHM_ATTACH_FD 6
+
+/**
+ * @brief xcb_shm_attach_fd_request_t
+ **/
+typedef struct xcb_shm_attach_fd_request_t {
+    uint8_t       major_opcode;
+    uint8_t       minor_opcode;
+    uint16_t      length;
+    xcb_shm_seg_t shmseg;
+    uint8_t       read_only;
+    uint8_t       pad0[3];
+} xcb_shm_attach_fd_request_t;
+
+/**
+ * @brief xcb_shm_create_segment_cookie_t
+ **/
+typedef struct xcb_shm_create_segment_cookie_t {
+    unsigned int sequence;
+} xcb_shm_create_segment_cookie_t;
+
+/** Opcode for xcb_shm_create_segment. */
+#define XCB_SHM_CREATE_SEGMENT 7
+
+/**
+ * @brief xcb_shm_create_segment_request_t
+ **/
+typedef struct xcb_shm_create_segment_request_t {
+    uint8_t       major_opcode;
+    uint8_t       minor_opcode;
+    uint16_t      length;
+    xcb_shm_seg_t shmseg;
+    uint32_t      size;
+    uint8_t       read_only;
+    uint8_t       pad0[3];
+} xcb_shm_create_segment_request_t;
+
+/**
+ * @brief xcb_shm_create_segment_reply_t
+ **/
+typedef struct xcb_shm_create_segment_reply_t {
+    uint8_t  response_type;
+    uint8_t  nfd;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad0[24];
+} xcb_shm_create_segment_reply_t;
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_shm_seg_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_shm_seg_t)
+ */
+void
+xcb_shm_seg_next (xcb_shm_seg_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_shm_seg_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_shm_seg_end (xcb_shm_seg_iterator_t i);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_shm_query_version_cookie_t
+xcb_shm_query_version (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_shm_query_version_cookie_t
+xcb_shm_query_version_unchecked (xcb_connection_t *c);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_shm_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_shm_query_version_reply_t *
+xcb_shm_query_version_reply (xcb_connection_t                *c,
+                             xcb_shm_query_version_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_shm_attach_checked (xcb_connection_t *c,
+                        xcb_shm_seg_t     shmseg,
+                        uint32_t          shmid,
+                        uint8_t           read_only);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_shm_attach (xcb_connection_t *c,
+                xcb_shm_seg_t     shmseg,
+                uint32_t          shmid,
+                uint8_t           read_only);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_shm_detach_checked (xcb_connection_t *c,
+                        xcb_shm_seg_t     shmseg);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_shm_detach (xcb_connection_t *c,
+                xcb_shm_seg_t     shmseg);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_shm_put_image_checked (xcb_connection_t *c,
+                           xcb_drawable_t    drawable,
+                           xcb_gcontext_t    gc,
+                           uint16_t          total_width,
+                           uint16_t          total_height,
+                           uint16_t          src_x,
+                           uint16_t          src_y,
+                           uint16_t          src_width,
+                           uint16_t          src_height,
+                           int16_t           dst_x,
+                           int16_t           dst_y,
+                           uint8_t           depth,
+                           uint8_t           format,
+                           uint8_t           send_event,
+                           xcb_shm_seg_t     shmseg,
+                           uint32_t          offset);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_shm_put_image (xcb_connection_t *c,
+                   xcb_drawable_t    drawable,
+                   xcb_gcontext_t    gc,
+                   uint16_t          total_width,
+                   uint16_t          total_height,
+                   uint16_t          src_x,
+                   uint16_t          src_y,
+                   uint16_t          src_width,
+                   uint16_t          src_height,
+                   int16_t           dst_x,
+                   int16_t           dst_y,
+                   uint8_t           depth,
+                   uint8_t           format,
+                   uint8_t           send_event,
+                   xcb_shm_seg_t     shmseg,
+                   uint32_t          offset);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_shm_get_image_cookie_t
+xcb_shm_get_image (xcb_connection_t *c,
+                   xcb_drawable_t    drawable,
+                   int16_t           x,
+                   int16_t           y,
+                   uint16_t          width,
+                   uint16_t          height,
+                   uint32_t          plane_mask,
+                   uint8_t           format,
+                   xcb_shm_seg_t     shmseg,
+                   uint32_t          offset);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_shm_get_image_cookie_t
+xcb_shm_get_image_unchecked (xcb_connection_t *c,
+                             xcb_drawable_t    drawable,
+                             int16_t           x,
+                             int16_t           y,
+                             uint16_t          width,
+                             uint16_t          height,
+                             uint32_t          plane_mask,
+                             uint8_t           format,
+                             xcb_shm_seg_t     shmseg,
+                             uint32_t          offset);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_shm_get_image_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_shm_get_image_reply_t *
+xcb_shm_get_image_reply (xcb_connection_t            *c,
+                         xcb_shm_get_image_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_shm_create_pixmap_checked (xcb_connection_t *c,
+                               xcb_pixmap_t      pid,
+                               xcb_drawable_t    drawable,
+                               uint16_t          width,
+                               uint16_t          height,
+                               uint8_t           depth,
+                               xcb_shm_seg_t     shmseg,
+                               uint32_t          offset);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_shm_create_pixmap (xcb_connection_t *c,
+                       xcb_pixmap_t      pid,
+                       xcb_drawable_t    drawable,
+                       uint16_t          width,
+                       uint16_t          height,
+                       uint8_t           depth,
+                       xcb_shm_seg_t     shmseg,
+                       uint32_t          offset);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_shm_attach_fd_checked (xcb_connection_t *c,
+                           xcb_shm_seg_t     shmseg,
+                           int32_t           shm_fd,
+                           uint8_t           read_only);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_shm_attach_fd (xcb_connection_t *c,
+                   xcb_shm_seg_t     shmseg,
+                   int32_t           shm_fd,
+                   uint8_t           read_only);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_shm_create_segment_cookie_t
+xcb_shm_create_segment (xcb_connection_t *c,
+                        xcb_shm_seg_t     shmseg,
+                        uint32_t          size,
+                        uint8_t           read_only);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_shm_create_segment_cookie_t
+xcb_shm_create_segment_unchecked (xcb_connection_t *c,
+                                  xcb_shm_seg_t     shmseg,
+                                  uint32_t          size,
+                                  uint8_t           read_only);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_shm_create_segment_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_shm_create_segment_reply_t *
+xcb_shm_create_segment_reply (xcb_connection_t                 *c,
+                              xcb_shm_create_segment_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+/**
+ * Return the reply fds
+ * @param c      The connection
+ * @param reply  The reply
+ *
+ * Returns a pointer to the array of reply fds of the reply.
+ *
+ * The returned value points into the reply and must not be free().
+ * The fds are not managed by xcb. You must close() them before freeing the reply.
+ */
+int *
+xcb_shm_create_segment_reply_fds (xcb_connection_t                *c  /**< */,
+                                  xcb_shm_create_segment_reply_t  *reply);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/sync.h b/depends/libxcb/include/xcb/sync.h
new file mode 100644
index 0000000..47796e9
--- /dev/null
+++ b/depends/libxcb/include/xcb/sync.h
@@ -0,0 +1,1628 @@
+/*
+ * This file generated automatically from sync.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_Sync_API XCB Sync API
+ * @brief Sync XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __SYNC_H
+#define __SYNC_H
+
+#include "xcb.h"
+#include "xproto.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_SYNC_MAJOR_VERSION 3
+#define XCB_SYNC_MINOR_VERSION 1
+
+extern xcb_extension_t xcb_sync_id;
+
+typedef uint32_t xcb_sync_alarm_t;
+
+/**
+ * @brief xcb_sync_alarm_iterator_t
+ **/
+typedef struct xcb_sync_alarm_iterator_t {
+    xcb_sync_alarm_t *data;
+    int               rem;
+    int               index;
+} xcb_sync_alarm_iterator_t;
+
+typedef enum xcb_sync_alarmstate_t {
+    XCB_SYNC_ALARMSTATE_ACTIVE = 0,
+    XCB_SYNC_ALARMSTATE_INACTIVE = 1,
+    XCB_SYNC_ALARMSTATE_DESTROYED = 2
+} xcb_sync_alarmstate_t;
+
+typedef uint32_t xcb_sync_counter_t;
+
+/**
+ * @brief xcb_sync_counter_iterator_t
+ **/
+typedef struct xcb_sync_counter_iterator_t {
+    xcb_sync_counter_t *data;
+    int                 rem;
+    int                 index;
+} xcb_sync_counter_iterator_t;
+
+typedef uint32_t xcb_sync_fence_t;
+
+/**
+ * @brief xcb_sync_fence_iterator_t
+ **/
+typedef struct xcb_sync_fence_iterator_t {
+    xcb_sync_fence_t *data;
+    int               rem;
+    int               index;
+} xcb_sync_fence_iterator_t;
+
+typedef enum xcb_sync_testtype_t {
+    XCB_SYNC_TESTTYPE_POSITIVE_TRANSITION = 0,
+    XCB_SYNC_TESTTYPE_NEGATIVE_TRANSITION = 1,
+    XCB_SYNC_TESTTYPE_POSITIVE_COMPARISON = 2,
+    XCB_SYNC_TESTTYPE_NEGATIVE_COMPARISON = 3
+} xcb_sync_testtype_t;
+
+typedef enum xcb_sync_valuetype_t {
+    XCB_SYNC_VALUETYPE_ABSOLUTE = 0,
+    XCB_SYNC_VALUETYPE_RELATIVE = 1
+} xcb_sync_valuetype_t;
+
+typedef enum xcb_sync_ca_t {
+    XCB_SYNC_CA_COUNTER = 1,
+    XCB_SYNC_CA_VALUE_TYPE = 2,
+    XCB_SYNC_CA_VALUE = 4,
+    XCB_SYNC_CA_TEST_TYPE = 8,
+    XCB_SYNC_CA_DELTA = 16,
+    XCB_SYNC_CA_EVENTS = 32
+} xcb_sync_ca_t;
+
+/**
+ * @brief xcb_sync_int64_t
+ **/
+typedef struct xcb_sync_int64_t {
+    int32_t  hi;
+    uint32_t lo;
+} xcb_sync_int64_t;
+
+/**
+ * @brief xcb_sync_int64_iterator_t
+ **/
+typedef struct xcb_sync_int64_iterator_t {
+    xcb_sync_int64_t *data;
+    int               rem;
+    int               index;
+} xcb_sync_int64_iterator_t;
+
+/**
+ * @brief xcb_sync_systemcounter_t
+ **/
+typedef struct xcb_sync_systemcounter_t {
+    xcb_sync_counter_t counter;
+    xcb_sync_int64_t   resolution;
+    uint16_t           name_len;
+} xcb_sync_systemcounter_t;
+
+/**
+ * @brief xcb_sync_systemcounter_iterator_t
+ **/
+typedef struct xcb_sync_systemcounter_iterator_t {
+    xcb_sync_systemcounter_t *data;
+    int                       rem;
+    int                       index;
+} xcb_sync_systemcounter_iterator_t;
+
+/**
+ * @brief xcb_sync_trigger_t
+ **/
+typedef struct xcb_sync_trigger_t {
+    xcb_sync_counter_t counter;
+    uint32_t           wait_type;
+    xcb_sync_int64_t   wait_value;
+    uint32_t           test_type;
+} xcb_sync_trigger_t;
+
+/**
+ * @brief xcb_sync_trigger_iterator_t
+ **/
+typedef struct xcb_sync_trigger_iterator_t {
+    xcb_sync_trigger_t *data;
+    int                 rem;
+    int                 index;
+} xcb_sync_trigger_iterator_t;
+
+/**
+ * @brief xcb_sync_waitcondition_t
+ **/
+typedef struct xcb_sync_waitcondition_t {
+    xcb_sync_trigger_t trigger;
+    xcb_sync_int64_t   event_threshold;
+} xcb_sync_waitcondition_t;
+
+/**
+ * @brief xcb_sync_waitcondition_iterator_t
+ **/
+typedef struct xcb_sync_waitcondition_iterator_t {
+    xcb_sync_waitcondition_t *data;
+    int                       rem;
+    int                       index;
+} xcb_sync_waitcondition_iterator_t;
+
+/** Opcode for xcb_sync_counter. */
+#define XCB_SYNC_COUNTER 0
+
+/**
+ * @brief xcb_sync_counter_error_t
+ **/
+typedef struct xcb_sync_counter_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_counter;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_sync_counter_error_t;
+
+/** Opcode for xcb_sync_alarm. */
+#define XCB_SYNC_ALARM 1
+
+/**
+ * @brief xcb_sync_alarm_error_t
+ **/
+typedef struct xcb_sync_alarm_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_alarm;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_sync_alarm_error_t;
+
+/**
+ * @brief xcb_sync_initialize_cookie_t
+ **/
+typedef struct xcb_sync_initialize_cookie_t {
+    unsigned int sequence;
+} xcb_sync_initialize_cookie_t;
+
+/** Opcode for xcb_sync_initialize. */
+#define XCB_SYNC_INITIALIZE 0
+
+/**
+ * @brief xcb_sync_initialize_request_t
+ **/
+typedef struct xcb_sync_initialize_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  desired_major_version;
+    uint8_t  desired_minor_version;
+} xcb_sync_initialize_request_t;
+
+/**
+ * @brief xcb_sync_initialize_reply_t
+ **/
+typedef struct xcb_sync_initialize_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  major_version;
+    uint8_t  minor_version;
+    uint8_t  pad1[22];
+} xcb_sync_initialize_reply_t;
+
+/**
+ * @brief xcb_sync_list_system_counters_cookie_t
+ **/
+typedef struct xcb_sync_list_system_counters_cookie_t {
+    unsigned int sequence;
+} xcb_sync_list_system_counters_cookie_t;
+
+/** Opcode for xcb_sync_list_system_counters. */
+#define XCB_SYNC_LIST_SYSTEM_COUNTERS 1
+
+/**
+ * @brief xcb_sync_list_system_counters_request_t
+ **/
+typedef struct xcb_sync_list_system_counters_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_sync_list_system_counters_request_t;
+
+/**
+ * @brief xcb_sync_list_system_counters_reply_t
+ **/
+typedef struct xcb_sync_list_system_counters_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t counters_len;
+    uint8_t  pad1[20];
+} xcb_sync_list_system_counters_reply_t;
+
+/** Opcode for xcb_sync_create_counter. */
+#define XCB_SYNC_CREATE_COUNTER 2
+
+/**
+ * @brief xcb_sync_create_counter_request_t
+ **/
+typedef struct xcb_sync_create_counter_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_sync_counter_t id;
+    xcb_sync_int64_t   initial_value;
+} xcb_sync_create_counter_request_t;
+
+/** Opcode for xcb_sync_destroy_counter. */
+#define XCB_SYNC_DESTROY_COUNTER 6
+
+/**
+ * @brief xcb_sync_destroy_counter_request_t
+ **/
+typedef struct xcb_sync_destroy_counter_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_sync_counter_t counter;
+} xcb_sync_destroy_counter_request_t;
+
+/**
+ * @brief xcb_sync_query_counter_cookie_t
+ **/
+typedef struct xcb_sync_query_counter_cookie_t {
+    unsigned int sequence;
+} xcb_sync_query_counter_cookie_t;
+
+/** Opcode for xcb_sync_query_counter. */
+#define XCB_SYNC_QUERY_COUNTER 5
+
+/**
+ * @brief xcb_sync_query_counter_request_t
+ **/
+typedef struct xcb_sync_query_counter_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_sync_counter_t counter;
+} xcb_sync_query_counter_request_t;
+
+/**
+ * @brief xcb_sync_query_counter_reply_t
+ **/
+typedef struct xcb_sync_query_counter_reply_t {
+    uint8_t          response_type;
+    uint8_t          pad0;
+    uint16_t         sequence;
+    uint32_t         length;
+    xcb_sync_int64_t counter_value;
+} xcb_sync_query_counter_reply_t;
+
+/** Opcode for xcb_sync_await. */
+#define XCB_SYNC_AWAIT 7
+
+/**
+ * @brief xcb_sync_await_request_t
+ **/
+typedef struct xcb_sync_await_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_sync_await_request_t;
+
+/** Opcode for xcb_sync_change_counter. */
+#define XCB_SYNC_CHANGE_COUNTER 4
+
+/**
+ * @brief xcb_sync_change_counter_request_t
+ **/
+typedef struct xcb_sync_change_counter_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_sync_counter_t counter;
+    xcb_sync_int64_t   amount;
+} xcb_sync_change_counter_request_t;
+
+/** Opcode for xcb_sync_set_counter. */
+#define XCB_SYNC_SET_COUNTER 3
+
+/**
+ * @brief xcb_sync_set_counter_request_t
+ **/
+typedef struct xcb_sync_set_counter_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_sync_counter_t counter;
+    xcb_sync_int64_t   value;
+} xcb_sync_set_counter_request_t;
+
+/**
+ * @brief xcb_sync_create_alarm_value_list_t
+ **/
+typedef struct xcb_sync_create_alarm_value_list_t {
+    xcb_sync_counter_t counter;
+    uint32_t           valueType;
+    xcb_sync_int64_t   value;
+    uint32_t           testType;
+    xcb_sync_int64_t   delta;
+    uint32_t           events;
+} xcb_sync_create_alarm_value_list_t;
+
+/** Opcode for xcb_sync_create_alarm. */
+#define XCB_SYNC_CREATE_ALARM 8
+
+/**
+ * @brief xcb_sync_create_alarm_request_t
+ **/
+typedef struct xcb_sync_create_alarm_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_sync_alarm_t id;
+    uint32_t         value_mask;
+} xcb_sync_create_alarm_request_t;
+
+/**
+ * @brief xcb_sync_change_alarm_value_list_t
+ **/
+typedef struct xcb_sync_change_alarm_value_list_t {
+    xcb_sync_counter_t counter;
+    uint32_t           valueType;
+    xcb_sync_int64_t   value;
+    uint32_t           testType;
+    xcb_sync_int64_t   delta;
+    uint32_t           events;
+} xcb_sync_change_alarm_value_list_t;
+
+/** Opcode for xcb_sync_change_alarm. */
+#define XCB_SYNC_CHANGE_ALARM 9
+
+/**
+ * @brief xcb_sync_change_alarm_request_t
+ **/
+typedef struct xcb_sync_change_alarm_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_sync_alarm_t id;
+    uint32_t         value_mask;
+} xcb_sync_change_alarm_request_t;
+
+/** Opcode for xcb_sync_destroy_alarm. */
+#define XCB_SYNC_DESTROY_ALARM 11
+
+/**
+ * @brief xcb_sync_destroy_alarm_request_t
+ **/
+typedef struct xcb_sync_destroy_alarm_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_sync_alarm_t alarm;
+} xcb_sync_destroy_alarm_request_t;
+
+/**
+ * @brief xcb_sync_query_alarm_cookie_t
+ **/
+typedef struct xcb_sync_query_alarm_cookie_t {
+    unsigned int sequence;
+} xcb_sync_query_alarm_cookie_t;
+
+/** Opcode for xcb_sync_query_alarm. */
+#define XCB_SYNC_QUERY_ALARM 10
+
+/**
+ * @brief xcb_sync_query_alarm_request_t
+ **/
+typedef struct xcb_sync_query_alarm_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_sync_alarm_t alarm;
+} xcb_sync_query_alarm_request_t;
+
+/**
+ * @brief xcb_sync_query_alarm_reply_t
+ **/
+typedef struct xcb_sync_query_alarm_reply_t {
+    uint8_t            response_type;
+    uint8_t            pad0;
+    uint16_t           sequence;
+    uint32_t           length;
+    xcb_sync_trigger_t trigger;
+    xcb_sync_int64_t   delta;
+    uint8_t            events;
+    uint8_t            state;
+    uint8_t            pad1[2];
+} xcb_sync_query_alarm_reply_t;
+
+/** Opcode for xcb_sync_set_priority. */
+#define XCB_SYNC_SET_PRIORITY 12
+
+/**
+ * @brief xcb_sync_set_priority_request_t
+ **/
+typedef struct xcb_sync_set_priority_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t id;
+    int32_t  priority;
+} xcb_sync_set_priority_request_t;
+
+/**
+ * @brief xcb_sync_get_priority_cookie_t
+ **/
+typedef struct xcb_sync_get_priority_cookie_t {
+    unsigned int sequence;
+} xcb_sync_get_priority_cookie_t;
+
+/** Opcode for xcb_sync_get_priority. */
+#define XCB_SYNC_GET_PRIORITY 13
+
+/**
+ * @brief xcb_sync_get_priority_request_t
+ **/
+typedef struct xcb_sync_get_priority_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t id;
+} xcb_sync_get_priority_request_t;
+
+/**
+ * @brief xcb_sync_get_priority_reply_t
+ **/
+typedef struct xcb_sync_get_priority_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    int32_t  priority;
+} xcb_sync_get_priority_reply_t;
+
+/** Opcode for xcb_sync_create_fence. */
+#define XCB_SYNC_CREATE_FENCE 14
+
+/**
+ * @brief xcb_sync_create_fence_request_t
+ **/
+typedef struct xcb_sync_create_fence_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_drawable_t   drawable;
+    xcb_sync_fence_t fence;
+    uint8_t          initially_triggered;
+} xcb_sync_create_fence_request_t;
+
+/** Opcode for xcb_sync_trigger_fence. */
+#define XCB_SYNC_TRIGGER_FENCE 15
+
+/**
+ * @brief xcb_sync_trigger_fence_request_t
+ **/
+typedef struct xcb_sync_trigger_fence_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_sync_fence_t fence;
+} xcb_sync_trigger_fence_request_t;
+
+/** Opcode for xcb_sync_reset_fence. */
+#define XCB_SYNC_RESET_FENCE 16
+
+/**
+ * @brief xcb_sync_reset_fence_request_t
+ **/
+typedef struct xcb_sync_reset_fence_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_sync_fence_t fence;
+} xcb_sync_reset_fence_request_t;
+
+/** Opcode for xcb_sync_destroy_fence. */
+#define XCB_SYNC_DESTROY_FENCE 17
+
+/**
+ * @brief xcb_sync_destroy_fence_request_t
+ **/
+typedef struct xcb_sync_destroy_fence_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_sync_fence_t fence;
+} xcb_sync_destroy_fence_request_t;
+
+/**
+ * @brief xcb_sync_query_fence_cookie_t
+ **/
+typedef struct xcb_sync_query_fence_cookie_t {
+    unsigned int sequence;
+} xcb_sync_query_fence_cookie_t;
+
+/** Opcode for xcb_sync_query_fence. */
+#define XCB_SYNC_QUERY_FENCE 18
+
+/**
+ * @brief xcb_sync_query_fence_request_t
+ **/
+typedef struct xcb_sync_query_fence_request_t {
+    uint8_t          major_opcode;
+    uint8_t          minor_opcode;
+    uint16_t         length;
+    xcb_sync_fence_t fence;
+} xcb_sync_query_fence_request_t;
+
+/**
+ * @brief xcb_sync_query_fence_reply_t
+ **/
+typedef struct xcb_sync_query_fence_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  triggered;
+    uint8_t  pad1[23];
+} xcb_sync_query_fence_reply_t;
+
+/** Opcode for xcb_sync_await_fence. */
+#define XCB_SYNC_AWAIT_FENCE 19
+
+/**
+ * @brief xcb_sync_await_fence_request_t
+ **/
+typedef struct xcb_sync_await_fence_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_sync_await_fence_request_t;
+
+/** Opcode for xcb_sync_counter_notify. */
+#define XCB_SYNC_COUNTER_NOTIFY 0
+
+/**
+ * @brief xcb_sync_counter_notify_event_t
+ **/
+typedef struct xcb_sync_counter_notify_event_t {
+    uint8_t            response_type;
+    uint8_t            kind;
+    uint16_t           sequence;
+    xcb_sync_counter_t counter;
+    xcb_sync_int64_t   wait_value;
+    xcb_sync_int64_t   counter_value;
+    xcb_timestamp_t    timestamp;
+    uint16_t           count;
+    uint8_t            destroyed;
+    uint8_t            pad0;
+} xcb_sync_counter_notify_event_t;
+
+/** Opcode for xcb_sync_alarm_notify. */
+#define XCB_SYNC_ALARM_NOTIFY 1
+
+/**
+ * @brief xcb_sync_alarm_notify_event_t
+ **/
+typedef struct xcb_sync_alarm_notify_event_t {
+    uint8_t          response_type;
+    uint8_t          kind;
+    uint16_t         sequence;
+    xcb_sync_alarm_t alarm;
+    xcb_sync_int64_t counter_value;
+    xcb_sync_int64_t alarm_value;
+    xcb_timestamp_t  timestamp;
+    uint8_t          state;
+    uint8_t          pad0[3];
+} xcb_sync_alarm_notify_event_t;
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_sync_alarm_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_sync_alarm_t)
+ */
+void
+xcb_sync_alarm_next (xcb_sync_alarm_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_sync_alarm_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_sync_alarm_end (xcb_sync_alarm_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_sync_counter_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_sync_counter_t)
+ */
+void
+xcb_sync_counter_next (xcb_sync_counter_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_sync_counter_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_sync_counter_end (xcb_sync_counter_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_sync_fence_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_sync_fence_t)
+ */
+void
+xcb_sync_fence_next (xcb_sync_fence_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_sync_fence_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_sync_fence_end (xcb_sync_fence_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_sync_int64_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_sync_int64_t)
+ */
+void
+xcb_sync_int64_next (xcb_sync_int64_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_sync_int64_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_sync_int64_end (xcb_sync_int64_iterator_t i);
+
+int
+xcb_sync_systemcounter_sizeof (const void  *_buffer);
+
+char *
+xcb_sync_systemcounter_name (const xcb_sync_systemcounter_t *R);
+
+int
+xcb_sync_systemcounter_name_length (const xcb_sync_systemcounter_t *R);
+
+xcb_generic_iterator_t
+xcb_sync_systemcounter_name_end (const xcb_sync_systemcounter_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_sync_systemcounter_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_sync_systemcounter_t)
+ */
+void
+xcb_sync_systemcounter_next (xcb_sync_systemcounter_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_sync_systemcounter_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_sync_systemcounter_end (xcb_sync_systemcounter_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_sync_trigger_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_sync_trigger_t)
+ */
+void
+xcb_sync_trigger_next (xcb_sync_trigger_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_sync_trigger_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_sync_trigger_end (xcb_sync_trigger_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_sync_waitcondition_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_sync_waitcondition_t)
+ */
+void
+xcb_sync_waitcondition_next (xcb_sync_waitcondition_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_sync_waitcondition_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_sync_waitcondition_end (xcb_sync_waitcondition_iterator_t i);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_sync_initialize_cookie_t
+xcb_sync_initialize (xcb_connection_t *c,
+                     uint8_t           desired_major_version,
+                     uint8_t           desired_minor_version);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_sync_initialize_cookie_t
+xcb_sync_initialize_unchecked (xcb_connection_t *c,
+                               uint8_t           desired_major_version,
+                               uint8_t           desired_minor_version);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_sync_initialize_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_sync_initialize_reply_t *
+xcb_sync_initialize_reply (xcb_connection_t              *c,
+                           xcb_sync_initialize_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e);
+
+int
+xcb_sync_list_system_counters_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_sync_list_system_counters_cookie_t
+xcb_sync_list_system_counters (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_sync_list_system_counters_cookie_t
+xcb_sync_list_system_counters_unchecked (xcb_connection_t *c);
+
+int
+xcb_sync_list_system_counters_counters_length (const xcb_sync_list_system_counters_reply_t *R);
+
+xcb_sync_systemcounter_iterator_t
+xcb_sync_list_system_counters_counters_iterator (const xcb_sync_list_system_counters_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_sync_list_system_counters_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_sync_list_system_counters_reply_t *
+xcb_sync_list_system_counters_reply (xcb_connection_t                        *c,
+                                     xcb_sync_list_system_counters_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_sync_create_counter_checked (xcb_connection_t   *c,
+                                 xcb_sync_counter_t  id,
+                                 xcb_sync_int64_t    initial_value);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_sync_create_counter (xcb_connection_t   *c,
+                         xcb_sync_counter_t  id,
+                         xcb_sync_int64_t    initial_value);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_sync_destroy_counter_checked (xcb_connection_t   *c,
+                                  xcb_sync_counter_t  counter);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_sync_destroy_counter (xcb_connection_t   *c,
+                          xcb_sync_counter_t  counter);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_sync_query_counter_cookie_t
+xcb_sync_query_counter (xcb_connection_t   *c,
+                        xcb_sync_counter_t  counter);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_sync_query_counter_cookie_t
+xcb_sync_query_counter_unchecked (xcb_connection_t   *c,
+                                  xcb_sync_counter_t  counter);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_sync_query_counter_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_sync_query_counter_reply_t *
+xcb_sync_query_counter_reply (xcb_connection_t                 *c,
+                              xcb_sync_query_counter_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+int
+xcb_sync_await_sizeof (const void  *_buffer,
+                       uint32_t     wait_list_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_sync_await_checked (xcb_connection_t               *c,
+                        uint32_t                        wait_list_len,
+                        const xcb_sync_waitcondition_t *wait_list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_sync_await (xcb_connection_t               *c,
+                uint32_t                        wait_list_len,
+                const xcb_sync_waitcondition_t *wait_list);
+
+xcb_sync_waitcondition_t *
+xcb_sync_await_wait_list (const xcb_sync_await_request_t *R);
+
+int
+xcb_sync_await_wait_list_length (const xcb_sync_await_request_t *R);
+
+xcb_sync_waitcondition_iterator_t
+xcb_sync_await_wait_list_iterator (const xcb_sync_await_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_sync_change_counter_checked (xcb_connection_t   *c,
+                                 xcb_sync_counter_t  counter,
+                                 xcb_sync_int64_t    amount);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_sync_change_counter (xcb_connection_t   *c,
+                         xcb_sync_counter_t  counter,
+                         xcb_sync_int64_t    amount);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_sync_set_counter_checked (xcb_connection_t   *c,
+                              xcb_sync_counter_t  counter,
+                              xcb_sync_int64_t    value);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_sync_set_counter (xcb_connection_t   *c,
+                      xcb_sync_counter_t  counter,
+                      xcb_sync_int64_t    value);
+
+int
+xcb_sync_create_alarm_value_list_serialize (void                                     **_buffer,
+                                            uint32_t                                   value_mask,
+                                            const xcb_sync_create_alarm_value_list_t  *_aux);
+
+int
+xcb_sync_create_alarm_value_list_unpack (const void                          *_buffer,
+                                         uint32_t                             value_mask,
+                                         xcb_sync_create_alarm_value_list_t  *_aux);
+
+int
+xcb_sync_create_alarm_value_list_sizeof (const void  *_buffer,
+                                         uint32_t     value_mask);
+
+int
+xcb_sync_create_alarm_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_sync_create_alarm_checked (xcb_connection_t *c,
+                               xcb_sync_alarm_t  id,
+                               uint32_t          value_mask,
+                               const void       *value_list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_sync_create_alarm (xcb_connection_t *c,
+                       xcb_sync_alarm_t  id,
+                       uint32_t          value_mask,
+                       const void       *value_list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_sync_create_alarm_aux_checked (xcb_connection_t                         *c,
+                                   xcb_sync_alarm_t                          id,
+                                   uint32_t                                  value_mask,
+                                   const xcb_sync_create_alarm_value_list_t *value_list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_sync_create_alarm_aux (xcb_connection_t                         *c,
+                           xcb_sync_alarm_t                          id,
+                           uint32_t                                  value_mask,
+                           const xcb_sync_create_alarm_value_list_t *value_list);
+
+void *
+xcb_sync_create_alarm_value_list (const xcb_sync_create_alarm_request_t *R);
+
+int
+xcb_sync_change_alarm_value_list_serialize (void                                     **_buffer,
+                                            uint32_t                                   value_mask,
+                                            const xcb_sync_change_alarm_value_list_t  *_aux);
+
+int
+xcb_sync_change_alarm_value_list_unpack (const void                          *_buffer,
+                                         uint32_t                             value_mask,
+                                         xcb_sync_change_alarm_value_list_t  *_aux);
+
+int
+xcb_sync_change_alarm_value_list_sizeof (const void  *_buffer,
+                                         uint32_t     value_mask);
+
+int
+xcb_sync_change_alarm_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_sync_change_alarm_checked (xcb_connection_t *c,
+                               xcb_sync_alarm_t  id,
+                               uint32_t          value_mask,
+                               const void       *value_list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_sync_change_alarm (xcb_connection_t *c,
+                       xcb_sync_alarm_t  id,
+                       uint32_t          value_mask,
+                       const void       *value_list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_sync_change_alarm_aux_checked (xcb_connection_t                         *c,
+                                   xcb_sync_alarm_t                          id,
+                                   uint32_t                                  value_mask,
+                                   const xcb_sync_change_alarm_value_list_t *value_list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_sync_change_alarm_aux (xcb_connection_t                         *c,
+                           xcb_sync_alarm_t                          id,
+                           uint32_t                                  value_mask,
+                           const xcb_sync_change_alarm_value_list_t *value_list);
+
+void *
+xcb_sync_change_alarm_value_list (const xcb_sync_change_alarm_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_sync_destroy_alarm_checked (xcb_connection_t *c,
+                                xcb_sync_alarm_t  alarm);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_sync_destroy_alarm (xcb_connection_t *c,
+                        xcb_sync_alarm_t  alarm);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_sync_query_alarm_cookie_t
+xcb_sync_query_alarm (xcb_connection_t *c,
+                      xcb_sync_alarm_t  alarm);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_sync_query_alarm_cookie_t
+xcb_sync_query_alarm_unchecked (xcb_connection_t *c,
+                                xcb_sync_alarm_t  alarm);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_sync_query_alarm_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_sync_query_alarm_reply_t *
+xcb_sync_query_alarm_reply (xcb_connection_t               *c,
+                            xcb_sync_query_alarm_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_sync_set_priority_checked (xcb_connection_t *c,
+                               uint32_t          id,
+                               int32_t           priority);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_sync_set_priority (xcb_connection_t *c,
+                       uint32_t          id,
+                       int32_t           priority);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_sync_get_priority_cookie_t
+xcb_sync_get_priority (xcb_connection_t *c,
+                       uint32_t          id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_sync_get_priority_cookie_t
+xcb_sync_get_priority_unchecked (xcb_connection_t *c,
+                                 uint32_t          id);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_sync_get_priority_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_sync_get_priority_reply_t *
+xcb_sync_get_priority_reply (xcb_connection_t                *c,
+                             xcb_sync_get_priority_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_sync_create_fence_checked (xcb_connection_t *c,
+                               xcb_drawable_t    drawable,
+                               xcb_sync_fence_t  fence,
+                               uint8_t           initially_triggered);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_sync_create_fence (xcb_connection_t *c,
+                       xcb_drawable_t    drawable,
+                       xcb_sync_fence_t  fence,
+                       uint8_t           initially_triggered);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_sync_trigger_fence_checked (xcb_connection_t *c,
+                                xcb_sync_fence_t  fence);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_sync_trigger_fence (xcb_connection_t *c,
+                        xcb_sync_fence_t  fence);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_sync_reset_fence_checked (xcb_connection_t *c,
+                              xcb_sync_fence_t  fence);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_sync_reset_fence (xcb_connection_t *c,
+                      xcb_sync_fence_t  fence);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_sync_destroy_fence_checked (xcb_connection_t *c,
+                                xcb_sync_fence_t  fence);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_sync_destroy_fence (xcb_connection_t *c,
+                        xcb_sync_fence_t  fence);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_sync_query_fence_cookie_t
+xcb_sync_query_fence (xcb_connection_t *c,
+                      xcb_sync_fence_t  fence);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_sync_query_fence_cookie_t
+xcb_sync_query_fence_unchecked (xcb_connection_t *c,
+                                xcb_sync_fence_t  fence);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_sync_query_fence_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_sync_query_fence_reply_t *
+xcb_sync_query_fence_reply (xcb_connection_t               *c,
+                            xcb_sync_query_fence_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e);
+
+int
+xcb_sync_await_fence_sizeof (const void  *_buffer,
+                             uint32_t     fence_list_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_sync_await_fence_checked (xcb_connection_t       *c,
+                              uint32_t                fence_list_len,
+                              const xcb_sync_fence_t *fence_list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_sync_await_fence (xcb_connection_t       *c,
+                      uint32_t                fence_list_len,
+                      const xcb_sync_fence_t *fence_list);
+
+xcb_sync_fence_t *
+xcb_sync_await_fence_fence_list (const xcb_sync_await_fence_request_t *R);
+
+int
+xcb_sync_await_fence_fence_list_length (const xcb_sync_await_fence_request_t *R);
+
+xcb_generic_iterator_t
+xcb_sync_await_fence_fence_list_end (const xcb_sync_await_fence_request_t *R);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/xc_misc.h b/depends/libxcb/include/xcb/xc_misc.h
new file mode 100644
index 0000000..866c879
--- /dev/null
+++ b/depends/libxcb/include/xcb/xc_misc.h
@@ -0,0 +1,281 @@
+/*
+ * This file generated automatically from xc_misc.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_XCMisc_API XCB XCMisc API
+ * @brief XCMisc XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __XC_MISC_H
+#define __XC_MISC_H
+
+#include "xcb.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_XCMISC_MAJOR_VERSION 1
+#define XCB_XCMISC_MINOR_VERSION 1
+
+extern xcb_extension_t xcb_xc_misc_id;
+
+/**
+ * @brief xcb_xc_misc_get_version_cookie_t
+ **/
+typedef struct xcb_xc_misc_get_version_cookie_t {
+    unsigned int sequence;
+} xcb_xc_misc_get_version_cookie_t;
+
+/** Opcode for xcb_xc_misc_get_version. */
+#define XCB_XC_MISC_GET_VERSION 0
+
+/**
+ * @brief xcb_xc_misc_get_version_request_t
+ **/
+typedef struct xcb_xc_misc_get_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint16_t client_major_version;
+    uint16_t client_minor_version;
+} xcb_xc_misc_get_version_request_t;
+
+/**
+ * @brief xcb_xc_misc_get_version_reply_t
+ **/
+typedef struct xcb_xc_misc_get_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t server_major_version;
+    uint16_t server_minor_version;
+} xcb_xc_misc_get_version_reply_t;
+
+/**
+ * @brief xcb_xc_misc_get_xid_range_cookie_t
+ **/
+typedef struct xcb_xc_misc_get_xid_range_cookie_t {
+    unsigned int sequence;
+} xcb_xc_misc_get_xid_range_cookie_t;
+
+/** Opcode for xcb_xc_misc_get_xid_range. */
+#define XCB_XC_MISC_GET_XID_RANGE 1
+
+/**
+ * @brief xcb_xc_misc_get_xid_range_request_t
+ **/
+typedef struct xcb_xc_misc_get_xid_range_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_xc_misc_get_xid_range_request_t;
+
+/**
+ * @brief xcb_xc_misc_get_xid_range_reply_t
+ **/
+typedef struct xcb_xc_misc_get_xid_range_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t start_id;
+    uint32_t count;
+} xcb_xc_misc_get_xid_range_reply_t;
+
+/**
+ * @brief xcb_xc_misc_get_xid_list_cookie_t
+ **/
+typedef struct xcb_xc_misc_get_xid_list_cookie_t {
+    unsigned int sequence;
+} xcb_xc_misc_get_xid_list_cookie_t;
+
+/** Opcode for xcb_xc_misc_get_xid_list. */
+#define XCB_XC_MISC_GET_XID_LIST 2
+
+/**
+ * @brief xcb_xc_misc_get_xid_list_request_t
+ **/
+typedef struct xcb_xc_misc_get_xid_list_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t count;
+} xcb_xc_misc_get_xid_list_request_t;
+
+/**
+ * @brief xcb_xc_misc_get_xid_list_reply_t
+ **/
+typedef struct xcb_xc_misc_get_xid_list_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t ids_len;
+    uint8_t  pad1[20];
+} xcb_xc_misc_get_xid_list_reply_t;
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xc_misc_get_version_cookie_t
+xcb_xc_misc_get_version (xcb_connection_t *c,
+                         uint16_t          client_major_version,
+                         uint16_t          client_minor_version);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xc_misc_get_version_cookie_t
+xcb_xc_misc_get_version_unchecked (xcb_connection_t *c,
+                                   uint16_t          client_major_version,
+                                   uint16_t          client_minor_version);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xc_misc_get_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xc_misc_get_version_reply_t *
+xcb_xc_misc_get_version_reply (xcb_connection_t                  *c,
+                               xcb_xc_misc_get_version_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xc_misc_get_xid_range_cookie_t
+xcb_xc_misc_get_xid_range (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xc_misc_get_xid_range_cookie_t
+xcb_xc_misc_get_xid_range_unchecked (xcb_connection_t *c);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xc_misc_get_xid_range_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xc_misc_get_xid_range_reply_t *
+xcb_xc_misc_get_xid_range_reply (xcb_connection_t                    *c,
+                                 xcb_xc_misc_get_xid_range_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e);
+
+int
+xcb_xc_misc_get_xid_list_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xc_misc_get_xid_list_cookie_t
+xcb_xc_misc_get_xid_list (xcb_connection_t *c,
+                          uint32_t          count);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xc_misc_get_xid_list_cookie_t
+xcb_xc_misc_get_xid_list_unchecked (xcb_connection_t *c,
+                                    uint32_t          count);
+
+uint32_t *
+xcb_xc_misc_get_xid_list_ids (const xcb_xc_misc_get_xid_list_reply_t *R);
+
+int
+xcb_xc_misc_get_xid_list_ids_length (const xcb_xc_misc_get_xid_list_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_xc_misc_get_xid_list_ids_end (const xcb_xc_misc_get_xid_list_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xc_misc_get_xid_list_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xc_misc_get_xid_list_reply_t *
+xcb_xc_misc_get_xid_list_reply (xcb_connection_t                   *c,
+                                xcb_xc_misc_get_xid_list_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/xcb.h b/depends/libxcb/include/xcb/xcb.h
new file mode 100644
index 0000000..3f39bb4
--- /dev/null
+++ b/depends/libxcb/include/xcb/xcb.h
@@ -0,0 +1,644 @@
+/*
+ * Copyright (C) 2001-2006 Bart Massey, Jamey Sharp, and Josh Triplett.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Except as contained in this notice, the names of the authors or their
+ * institutions shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the authors.
+ */
+
+#ifndef __XCB_H__
+#define __XCB_H__
+#include <sys/types.h>
+
+#if defined(__solaris__)
+#include <inttypes.h>
+#else
+#include <stdint.h>
+#endif
+
+#ifndef _WIN32
+#include <sys/uio.h>
+#else
+#include "xcb_windefs.h"
+#endif
+#include <pthread.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @file xcb.h
+ */
+
+#ifdef __GNUC__
+#define XCB_PACKED __attribute__((__packed__))
+#else
+#define XCB_PACKED
+#endif
+
+/**
+ * @defgroup XCB_Core_API XCB Core API
+ * @brief Core API of the XCB library.
+ *
+ * @{
+ */
+
+/* Pre-defined constants */
+
+/** Current protocol version */
+#define X_PROTOCOL 11
+
+/** Current minor version */
+#define X_PROTOCOL_REVISION 0
+
+/** X_TCP_PORT + display number = server port for TCP transport */
+#define X_TCP_PORT 6000
+
+/** xcb connection errors because of socket, pipe and other stream errors. */
+#define XCB_CONN_ERROR 1
+
+/** xcb connection shutdown because of extension not supported */
+#define XCB_CONN_CLOSED_EXT_NOTSUPPORTED 2
+
+/** malloc(), calloc() and realloc() error upon failure, for eg ENOMEM */
+#define XCB_CONN_CLOSED_MEM_INSUFFICIENT 3
+
+/** Connection closed, exceeding request length that server accepts. */
+#define XCB_CONN_CLOSED_REQ_LEN_EXCEED 4
+
+/** Connection closed, error during parsing display string. */
+#define XCB_CONN_CLOSED_PARSE_ERR 5
+
+/** Connection closed because the server does not have a screen matching the display. */
+#define XCB_CONN_CLOSED_INVALID_SCREEN 6
+
+/** Connection closed because some FD passing operation failed */
+#define XCB_CONN_CLOSED_FDPASSING_FAILED 7
+
+#define XCB_TYPE_PAD(T,I) (-(I) & (sizeof(T) > 4 ? 3 : sizeof(T) - 1))
+
+/* Opaque structures */
+
+/**
+ * @brief XCB Connection structure.
+ *
+ * A structure that contain all data that  XCB needs to communicate with an X server.
+ */
+typedef struct xcb_connection_t xcb_connection_t;  /**< Opaque structure containing all data that  XCB needs to communicate with an X server. */
+
+
+/* Other types */
+
+/**
+ * @brief Generic iterator.
+ *
+ * A generic iterator structure.
+ */
+typedef struct {
+    void *data;   /**< Data of the current iterator */
+    int rem;    /**< remaining elements */
+    int index;  /**< index of the current iterator */
+} xcb_generic_iterator_t;
+
+/**
+ * @brief Generic reply.
+ *
+ * A generic reply structure.
+ */
+typedef struct {
+    uint8_t   response_type;  /**< Type of the response */
+    uint8_t  pad0;           /**< Padding */
+    uint16_t sequence;       /**< Sequence number */
+    uint32_t length;         /**< Length of the response */
+} xcb_generic_reply_t;
+
+/**
+ * @brief Generic event.
+ *
+ * A generic event structure.
+ */
+typedef struct {
+    uint8_t   response_type;  /**< Type of the response */
+    uint8_t  pad0;           /**< Padding */
+    uint16_t sequence;       /**< Sequence number */
+    uint32_t pad[7];         /**< Padding */
+    uint32_t full_sequence;  /**< full sequence */
+} xcb_generic_event_t;
+
+/**
+ * @brief Raw Generic event.
+ *
+ * A generic event structure as used on the wire, i.e., without the full_sequence field
+ */
+typedef struct {
+    uint8_t   response_type;  /**< Type of the response */
+    uint8_t  pad0;           /**< Padding */
+    uint16_t sequence;       /**< Sequence number */
+    uint32_t pad[7];         /**< Padding */
+} xcb_raw_generic_event_t;
+
+/**
+ * @brief GE event
+ *
+ * An event as sent by the XGE extension. The length field specifies the
+ * number of 4-byte blocks trailing the struct.
+ *
+ * @deprecated Since some fields in this struct have unfortunate names, it is
+ * recommended to use xcb_ge_generic_event_t instead.
+ */
+typedef struct {
+    uint8_t  response_type;  /**< Type of the response */
+    uint8_t  pad0;           /**< Padding */
+    uint16_t sequence;       /**< Sequence number */
+    uint32_t length;
+    uint16_t event_type;
+    uint16_t pad1;
+    uint32_t pad[5];         /**< Padding */
+    uint32_t full_sequence;  /**< full sequence */
+} xcb_ge_event_t;
+
+/**
+ * @brief Generic error.
+ *
+ * A generic error structure.
+ */
+typedef struct {
+    uint8_t   response_type;  /**< Type of the response */
+    uint8_t   error_code;     /**< Error code */
+    uint16_t sequence;       /**< Sequence number */
+    uint32_t resource_id;     /** < Resource ID for requests with side effects only */
+    uint16_t minor_code;      /** < Minor opcode of the failed request */
+    uint8_t major_code;       /** < Major opcode of the failed request */
+    uint8_t pad0;
+    uint32_t pad[5];         /**< Padding */
+    uint32_t full_sequence;  /**< full sequence */
+} xcb_generic_error_t;
+
+/**
+ * @brief Generic cookie.
+ *
+ * A generic cookie structure.
+ */
+typedef struct {
+    unsigned int sequence;  /**< Sequence number */
+} xcb_void_cookie_t;
+
+
+/* Include the generated xproto header. */
+#include "xproto.h"
+
+
+/** XCB_NONE is the universal null resource or null atom parameter value for many core X requests */
+#define XCB_NONE 0L
+
+/** XCB_COPY_FROM_PARENT can be used for many xcb_create_window parameters */
+#define XCB_COPY_FROM_PARENT 0L
+
+/** XCB_CURRENT_TIME can be used in most requests that take an xcb_timestamp_t */
+#define XCB_CURRENT_TIME 0L
+
+/** XCB_NO_SYMBOL fills in unused entries in xcb_keysym_t tables */
+#define XCB_NO_SYMBOL 0L
+
+
+/* xcb_auth.c */
+
+/**
+ * @brief Container for authorization information.
+ *
+ * A container for authorization information to be sent to the X server.
+ */
+typedef struct xcb_auth_info_t {
+    int   namelen;  /**< Length of the string name (as returned by strlen). */
+    char *name;     /**< String containing the authentication protocol name, such as "MIT-MAGIC-COOKIE-1" or "XDM-AUTHORIZATION-1". */
+    int   datalen;  /**< Length of the data member. */
+    char *data;   /**< Data interpreted in a protocol-specific manner. */
+} xcb_auth_info_t;
+
+
+/* xcb_out.c */
+
+/**
+ * @brief Forces any buffered output to be written to the server.
+ * @param c The connection to the X server.
+ * @return > @c 0 on success, <= @c 0 otherwise.
+ *
+ * Forces any buffered output to be written to the server. Blocks
+ * until the write is complete.
+ */
+int xcb_flush(xcb_connection_t *c);
+
+/**
+ * @brief Returns the maximum request length that this server accepts.
+ * @param c The connection to the X server.
+ * @return The maximum request length field.
+ *
+ * In the absence of the BIG-REQUESTS extension, returns the
+ * maximum request length field from the connection setup data, which
+ * may be as much as 65535. If the server supports BIG-REQUESTS, then
+ * the maximum request length field from the reply to the
+ * BigRequestsEnable request will be returned instead.
+ *
+ * Note that this length is measured in four-byte units, making the
+ * theoretical maximum lengths roughly 256kB without BIG-REQUESTS and
+ * 16GB with.
+ */
+uint32_t xcb_get_maximum_request_length(xcb_connection_t *c);
+
+/**
+ * @brief Prefetch the maximum request length without blocking.
+ * @param c The connection to the X server.
+ *
+ * Without blocking, does as much work as possible toward computing
+ * the maximum request length accepted by the X server.
+ *
+ * Invoking this function may cause a call to xcb_big_requests_enable,
+ * but will not block waiting for the reply.
+ * xcb_get_maximum_request_length will return the prefetched data
+ * after possibly blocking while the reply is retrieved.
+ *
+ * Note that in order for this function to be fully non-blocking, the
+ * application must previously have called
+ * xcb_prefetch_extension_data(c, &xcb_big_requests_id) and the reply
+ * must have already arrived.
+ */
+void xcb_prefetch_maximum_request_length(xcb_connection_t *c);
+
+
+/* xcb_in.c */
+
+/**
+ * @brief Returns the next event or error from the server.
+ * @param c The connection to the X server.
+ * @return The next event from the server.
+ *
+ * Returns the next event or error from the server, or returns null in
+ * the event of an I/O error. Blocks until either an event or error
+ * arrive, or an I/O error occurs.
+ */
+xcb_generic_event_t *xcb_wait_for_event(xcb_connection_t *c);
+
+/**
+ * @brief Returns the next event or error from the server.
+ * @param c The connection to the X server.
+ * @return The next event from the server.
+ *
+ * Returns the next event or error from the server, if one is
+ * available, or returns @c NULL otherwise. If no event is available, that
+ * might be because an I/O error like connection close occurred while
+ * attempting to read the next event, in which case the connection is
+ * shut down when this function returns.
+ */
+xcb_generic_event_t *xcb_poll_for_event(xcb_connection_t *c);
+
+/**
+ * @brief Returns the next event without reading from the connection.
+ * @param c The connection to the X server.
+ * @return The next already queued event from the server.
+ *
+ * This is a version of xcb_poll_for_event that only examines the
+ * event queue for new events. The function doesn't try to read new
+ * events from the connection if no queued events are found.
+ *
+ * This function is useful for callers that know in advance that all
+ * interesting events have already been read from the connection. For
+ * example, callers might use xcb_wait_for_reply and be interested
+ * only of events that preceded a specific reply.
+ */
+xcb_generic_event_t *xcb_poll_for_queued_event(xcb_connection_t *c);
+
+typedef struct xcb_special_event xcb_special_event_t;
+
+/**
+ * @brief Returns the next event from a special queue
+ */
+xcb_generic_event_t *xcb_poll_for_special_event(xcb_connection_t *c,
+                                                xcb_special_event_t *se);
+
+/**
+ * @brief Returns the next event from a special queue, blocking until one arrives
+ */
+xcb_generic_event_t *xcb_wait_for_special_event(xcb_connection_t *c,
+                                                xcb_special_event_t *se);
+/**
+ * @typedef typedef struct xcb_extension_t xcb_extension_t
+ */
+typedef struct xcb_extension_t xcb_extension_t;  /**< Opaque structure used as key for xcb_get_extension_data_t. */
+
+/**
+ * @brief Listen for a special event
+ */
+xcb_special_event_t *xcb_register_for_special_xge(xcb_connection_t *c,
+                                                  xcb_extension_t *ext,
+                                                  uint32_t eid,
+                                                  uint32_t *stamp);
+
+/**
+ * @brief Stop listening for a special event
+ */
+void xcb_unregister_for_special_event(xcb_connection_t *c,
+                                      xcb_special_event_t *se);
+
+/**
+ * @brief Return the error for a request, or NULL if none can ever arrive.
+ * @param c The connection to the X server.
+ * @param cookie The request cookie.
+ * @return The error for the request, or NULL if none can ever arrive.
+ *
+ * The xcb_void_cookie_t cookie supplied to this function must have resulted
+ * from a call to xcb_[request_name]_checked().  This function will block
+ * until one of two conditions happens.  If an error is received, it will be
+ * returned.  If a reply to a subsequent request has already arrived, no error
+ * can arrive for this request, so this function will return NULL.
+ *
+ * Note that this function will perform a sync if needed to ensure that the
+ * sequence number will advance beyond that provided in cookie; this is a
+ * convenience to avoid races in determining whether the sync is needed.
+ */
+xcb_generic_error_t *xcb_request_check(xcb_connection_t *c, xcb_void_cookie_t cookie);
+
+/**
+ * @brief Discards the reply for a request.
+ * @param c The connection to the X server.
+ * @param sequence The request sequence number from a cookie.
+ *
+ * Discards the reply for a request. Additionally, any error generated
+ * by the request is also discarded (unless it was an _unchecked request
+ * and the error has already arrived).
+ *
+ * This function will not block even if the reply is not yet available.
+ *
+ * Note that the sequence really does have to come from an xcb cookie;
+ * this function is not designed to operate on socket-handoff replies.
+ */
+void xcb_discard_reply(xcb_connection_t *c, unsigned int sequence);
+
+/**
+ * @brief Discards the reply for a request, given by a 64bit sequence number
+ * @param c The connection to the X server.
+ * @param sequence 64-bit sequence number as returned by xcb_send_request64().
+ *
+ * Discards the reply for a request. Additionally, any error generated
+ * by the request is also discarded (unless it was an _unchecked request
+ * and the error has already arrived).
+ *
+ * This function will not block even if the reply is not yet available.
+ *
+ * Note that the sequence really does have to come from xcb_send_request64();
+ * the cookie sequence number is defined as "unsigned" int and therefore
+ * not 64-bit on all platforms.
+ * This function is not designed to operate on socket-handoff replies.
+ *
+ * Unlike its xcb_discard_reply() counterpart, the given sequence number is not
+ * automatically "widened" to 64-bit.
+ */
+void xcb_discard_reply64(xcb_connection_t *c, uint64_t sequence);
+
+/* xcb_ext.c */
+
+/**
+ * @brief Caches reply information from QueryExtension requests.
+ * @param c The connection.
+ * @param ext The extension data.
+ * @return A pointer to the xcb_query_extension_reply_t for the extension.
+ *
+ * This function is the primary interface to the "extension cache",
+ * which caches reply information from QueryExtension
+ * requests. Invoking this function may cause a call to
+ * xcb_query_extension to retrieve extension information from the
+ * server, and may block until extension data is received from the
+ * server.
+ *
+ * The result must not be freed. This storage is managed by the cache
+ * itself.
+ */
+const struct xcb_query_extension_reply_t *xcb_get_extension_data(xcb_connection_t *c, xcb_extension_t *ext);
+
+/**
+ * @brief Prefetch of extension data into the extension cache
+ * @param c The connection.
+ * @param ext The extension data.
+ *
+ * This function allows a "prefetch" of extension data into the
+ * extension cache. Invoking the function may cause a call to
+ * xcb_query_extension, but will not block waiting for the
+ * reply. xcb_get_extension_data will return the prefetched data after
+ * possibly blocking while it is retrieved.
+ */
+void xcb_prefetch_extension_data(xcb_connection_t *c, xcb_extension_t *ext);
+
+
+/* xcb_conn.c */
+
+/**
+ * @brief Access the data returned by the server.
+ * @param c The connection.
+ * @return A pointer to an xcb_setup_t structure.
+ *
+ * Accessor for the data returned by the server when the xcb_connection_t
+ * was initialized. This data includes
+ * - the server's required format for images,
+ * - a list of available visuals,
+ * - a list of available screens,
+ * - the server's maximum request length (in the absence of the
+ * BIG-REQUESTS extension),
+ * - and other assorted information.
+ *
+ * See the X protocol specification for more details.
+ *
+ * The result must not be freed.
+ */
+const struct xcb_setup_t *xcb_get_setup(xcb_connection_t *c);
+
+/**
+ * @brief Access the file descriptor of the connection.
+ * @param c The connection.
+ * @return The file descriptor.
+ *
+ * Accessor for the file descriptor that was passed to the
+ * xcb_connect_to_fd call that returned @p c.
+ */
+int xcb_get_file_descriptor(xcb_connection_t *c);
+
+/**
+ * @brief Test whether the connection has shut down due to a fatal error.
+ * @param c The connection.
+ * @return > 0 if the connection is in an error state; 0 otherwise.
+ *
+ * Some errors that occur in the context of an xcb_connection_t
+ * are unrecoverable. When such an error occurs, the
+ * connection is shut down and further operations on the
+ * xcb_connection_t have no effect, but memory will not be freed until
+ * xcb_disconnect() is called on the xcb_connection_t.
+ *
+ * @return XCB_CONN_ERROR, because of socket errors, pipe errors or other stream errors.
+ * @return XCB_CONN_CLOSED_EXT_NOTSUPPORTED, when extension not supported.
+ * @return XCB_CONN_CLOSED_MEM_INSUFFICIENT, when memory not available.
+ * @return XCB_CONN_CLOSED_REQ_LEN_EXCEED, exceeding request length that server accepts.
+ * @return XCB_CONN_CLOSED_PARSE_ERR, error during parsing display string.
+ * @return XCB_CONN_CLOSED_INVALID_SCREEN, because the server does not have a screen matching the display.
+ */
+int xcb_connection_has_error(xcb_connection_t *c);
+
+/**
+ * @brief Connects to the X server.
+ * @param fd The file descriptor.
+ * @param auth_info Authentication data.
+ * @return A newly allocated xcb_connection_t structure.
+ *
+ * Connects to an X server, given the open socket @p fd and the
+ * xcb_auth_info_t @p auth_info. The file descriptor @p fd is
+ * bidirectionally connected to an X server. If the connection
+ * should be unauthenticated, @p auth_info must be @c
+ * NULL.
+ *
+ * Always returns a non-NULL pointer to a xcb_connection_t, even on failure.
+ * Callers need to use xcb_connection_has_error() to check for failure.
+ * When finished, use xcb_disconnect() to close the connection and free
+ * the structure.
+ */
+xcb_connection_t *xcb_connect_to_fd(int fd, xcb_auth_info_t *auth_info);
+
+/**
+ * @brief Closes the connection.
+ * @param c The connection.
+ *
+ * Closes the file descriptor and frees all memory associated with the
+ * connection @c c. If @p c is @c NULL, nothing is done.
+ */
+void xcb_disconnect(xcb_connection_t *c);
+
+
+/* xcb_util.c */
+
+/**
+ * @brief Parses a display string name in the form documented by X(7x).
+ * @param name The name of the display.
+ * @param host A pointer to a malloc'd copy of the hostname.
+ * @param display A pointer to the display number.
+ * @param screen A pointer to the screen number.
+ * @return 0 on failure, non 0 otherwise.
+ *
+ * Parses the display string name @p display_name in the form
+ * documented by X(7x). Has no side effects on failure. If
+ * @p displayname is @c NULL or empty, it uses the environment
+ * variable DISPLAY. @p hostp is a pointer to a newly allocated string
+ * that contain the host name. @p displayp is set to the display
+ * number and @p screenp to the preferred screen number. @p screenp
+ * can be @c NULL. If @p displayname does not contain a screen number,
+ * it is set to @c 0.
+ */
+int xcb_parse_display(const char *name, char **host, int *display, int *screen);
+
+/**
+ * @brief Connects to the X server.
+ * @param displayname The name of the display.
+ * @param screenp A pointer to a preferred screen number.
+ * @return A newly allocated xcb_connection_t structure.
+ *
+ * Connects to the X server specified by @p displayname. If @p
+ * displayname is @c NULL, uses the value of the DISPLAY environment
+ * variable. If a particular screen on that server is preferred, the
+ * int pointed to by @p screenp (if not @c NULL) will be set to that
+ * screen; otherwise the screen will be set to 0.
+ *
+ * Always returns a non-NULL pointer to a xcb_connection_t, even on failure.
+ * Callers need to use xcb_connection_has_error() to check for failure.
+ * When finished, use xcb_disconnect() to close the connection and free
+ * the structure.
+ */
+xcb_connection_t *xcb_connect(const char *displayname, int *screenp);
+
+/**
+ * @brief Connects to the X server, using an authorization information.
+ * @param display The name of the display.
+ * @param auth The authorization information.
+ * @param screen A pointer to a preferred screen number.
+ * @return A newly allocated xcb_connection_t structure.
+ *
+ * Connects to the X server specified by @p displayname, using the
+ * authorization @p auth. If a particular screen on that server is
+ * preferred, the int pointed to by @p screenp (if not @c NULL) will
+ * be set to that screen; otherwise @p screenp will be set to 0.
+ *
+ * Always returns a non-NULL pointer to a xcb_connection_t, even on failure.
+ * Callers need to use xcb_connection_has_error() to check for failure.
+ * When finished, use xcb_disconnect() to close the connection and free
+ * the structure.
+ */
+xcb_connection_t *xcb_connect_to_display_with_auth_info(const char *display, xcb_auth_info_t *auth, int *screen);
+
+
+/* xcb_xid.c */
+
+/**
+ * @brief Allocates an XID for a new object.
+ * @param c The connection.
+ * @return A newly allocated XID, or -1 on failure.
+ *
+ * Allocates an XID for a new object. Typically used just prior to
+ * various object creation functions, such as xcb_create_window.
+ */
+uint32_t xcb_generate_id(xcb_connection_t *c);
+
+
+/**
+ * @brief Obtain number of bytes read from the connection.
+ * @param c The connection
+ * @return Number of bytes read from the server.
+ *
+ * Returns cumulative number of bytes received from the connection.
+ *
+ * This retrieves the total number of bytes read from this connection,
+ * to be used for diagnostic/monitoring/informative purposes.
+ */
+
+uint64_t
+xcb_total_read(xcb_connection_t *c);
+
+/**
+ *
+ * @brief Obtain number of bytes written to the connection.
+ * @param c The connection
+ * @return Number of bytes written to the server.
+ *
+ * Returns cumulative number of bytes sent to the connection.
+ *
+ * This retrieves the total number of bytes written to this connection,
+ * to be used for diagnostic/monitoring/informative purposes.
+ */
+
+uint64_t
+xcb_total_written(xcb_connection_t *c);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* __XCB_H__ */
diff --git a/depends/libxcb/include/xcb/xcb_windefs.h b/depends/libxcb/include/xcb/xcb_windefs.h
new file mode 100644
index 0000000..df6026d
--- /dev/null
+++ b/depends/libxcb/include/xcb/xcb_windefs.h
@@ -0,0 +1,45 @@
+/* Copyright (C) 2009 Jatin Golani.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the names of the authors or their
+ * institutions shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the authors.
+ */
+
+
+#ifndef _XCB_WINDEFS_H
+#define _XCB_WINDEFS_H
+
+#ifndef WINVER
+#define WINVER 0x0501 /* required for getaddrinfo/freeaddrinfo defined only for WinXP and above */
+#endif
+
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windef.h>
+
+struct iovec  {
+    void *iov_base;    /* Pointer to data.  */
+    int iov_len;       /* Length of data.  */
+};
+
+typedef unsigned int in_addr_t;
+
+#endif /* xcb_windefs.h */
diff --git a/depends/libxcb/include/xcb/xcbext.h b/depends/libxcb/include/xcb/xcbext.h
new file mode 100644
index 0000000..90f9d58
--- /dev/null
+++ b/depends/libxcb/include/xcb/xcbext.h
@@ -0,0 +1,322 @@
+/*
+ * Copyright (C) 2001-2004 Bart Massey and Jamey Sharp.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the names of the authors or their
+ * institutions shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the authors.
+ */
+
+#ifndef __XCBEXT_H
+#define __XCBEXT_H
+
+#include "xcb.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* xcb_ext.c */
+
+struct xcb_extension_t {
+    const char *name;
+    int global_id;
+};
+
+
+/* xcb_out.c */
+
+typedef struct {
+    size_t count;
+    xcb_extension_t *ext;
+    uint8_t opcode;
+    uint8_t isvoid;
+} xcb_protocol_request_t;
+
+enum xcb_send_request_flags_t {
+    XCB_REQUEST_CHECKED = 1 << 0,
+    XCB_REQUEST_RAW = 1 << 1,
+    XCB_REQUEST_DISCARD_REPLY = 1 << 2,
+    XCB_REQUEST_REPLY_FDS = 1 << 3
+};
+
+/**
+ * @brief Send a request to the server.
+ * @param c The connection to the X server.
+ * @param flags A combination of flags from the xcb_send_request_flags_t enumeration.
+ * @param vector Data to send; must have two iovecs before start for internal use.
+ * @param request Information about the request to be sent.
+ * @return The request's sequence number on success, 0 otherwise.
+ *
+ * This function sends a new request to the X server. The data of the request is
+ * given as an array of @c iovecs in the @p vector argument. The length of that
+ * array and the necessary management information are given in the @p request
+ * argument.
+ *
+ * When this function returns, the request might or might not be sent already.
+ * Use xcb_flush() to make sure that it really was sent.
+ *
+ * Please note that this function is not the preferred way for sending requests.
+ * It's better to use the generated wrapper functions.
+ *
+ * Please note that xcb might use index -1 and -2 of the @p vector array internally,
+ * so they must be valid!
+ */
+unsigned int xcb_send_request(xcb_connection_t *c, int flags, struct iovec *vector, const xcb_protocol_request_t *request);
+
+/**
+ * @brief Send a request to the server.
+ * @param c The connection to the X server.
+ * @param flags A combination of flags from the xcb_send_request_flags_t enumeration.
+ * @param vector Data to send; must have two iovecs before start for internal use.
+ * @param request Information about the request to be sent.
+ * @param num_fds Number of additional file descriptors to send to the server
+ * @param fds Additional file descriptors that should be send to the server.
+ * @return The request's sequence number on success, 0 otherwise.
+ *
+ * This function sends a new request to the X server. The data of the request is
+ * given as an array of @c iovecs in the @p vector argument. The length of that
+ * array and the necessary management information are given in the @p request
+ * argument.
+ *
+ * If @p num_fds is non-zero, @p fds points to an array of file descriptors that
+ * will be sent to the X server along with this request. After this function
+ * returns, all file descriptors sent are owned by xcb and will be closed
+ * eventually.
+ *
+ * When this function returns, the request might or might not be sent already.
+ * Use xcb_flush() to make sure that it really was sent.
+ *
+ * Please note that this function is not the preferred way for sending requests.
+ *
+ * Please note that xcb might use index -1 and -2 of the @p vector array internally,
+ * so they must be valid!
+ */
+unsigned int xcb_send_request_with_fds(xcb_connection_t *c, int flags, struct iovec *vector,
+                const xcb_protocol_request_t *request, unsigned int num_fds, int *fds);
+
+/**
+ * @brief Send a request to the server, with 64-bit sequence number returned.
+ * @param c The connection to the X server.
+ * @param flags A combination of flags from the xcb_send_request_flags_t enumeration.
+ * @param vector Data to send; must have two iovecs before start for internal use.
+ * @param request Information about the request to be sent.
+ * @return The request's sequence number on success, 0 otherwise.
+ *
+ * This function sends a new request to the X server. The data of the request is
+ * given as an array of @c iovecs in the @p vector argument. The length of that
+ * array and the necessary management information are given in the @p request
+ * argument.
+ *
+ * When this function returns, the request might or might not be sent already.
+ * Use xcb_flush() to make sure that it really was sent.
+ *
+ * Please note that this function is not the preferred way for sending requests.
+ * It's better to use the generated wrapper functions.
+ *
+ * Please note that xcb might use index -1 and -2 of the @p vector array internally,
+ * so they must be valid!
+ */
+uint64_t xcb_send_request64(xcb_connection_t *c, int flags, struct iovec *vector, const xcb_protocol_request_t *request);
+
+/**
+ * @brief Send a request to the server, with 64-bit sequence number returned.
+ * @param c The connection to the X server.
+ * @param flags A combination of flags from the xcb_send_request_flags_t enumeration.
+ * @param vector Data to send; must have two iovecs before start for internal use.
+ * @param request Information about the request to be sent.
+ * @param num_fds Number of additional file descriptors to send to the server
+ * @param fds Additional file descriptors that should be send to the server.
+ * @return The request's sequence number on success, 0 otherwise.
+ *
+ * This function sends a new request to the X server. The data of the request is
+ * given as an array of @c iovecs in the @p vector argument. The length of that
+ * array and the necessary management information are given in the @p request
+ * argument.
+ *
+ * If @p num_fds is non-zero, @p fds points to an array of file descriptors that
+ * will be sent to the X server along with this request. After this function
+ * returns, all file descriptors sent are owned by xcb and will be closed
+ * eventually.
+ *
+ * When this function returns, the request might or might not be sent already.
+ * Use xcb_flush() to make sure that it really was sent.
+ *
+ * Please note that this function is not the preferred way for sending requests.
+ * It's better to use the generated wrapper functions.
+ *
+ * Please note that xcb might use index -1 and -2 of the @p vector array internally,
+ * so they must be valid!
+ */
+uint64_t xcb_send_request_with_fds64(xcb_connection_t *c, int flags, struct iovec *vector,
+                const xcb_protocol_request_t *request, unsigned int num_fds, int *fds);
+
+/**
+ * @brief Send a file descriptor to the server in the next call to xcb_send_request.
+ * @param c The connection to the X server.
+ * @param fd The file descriptor to send.
+ *
+ * After this function returns, the file descriptor given is owned by xcb and
+ * will be closed eventually.
+ *
+ * @deprecated This function cannot be used in a thread-safe way. Two threads
+ * that run xcb_send_fd(); xcb_send_request(); could mix up their file
+ * descriptors. Instead, xcb_send_request_with_fds() should be used.
+ */
+void xcb_send_fd(xcb_connection_t *c, int fd);
+
+/**
+ * @brief Take over the write side of the socket
+ * @param c The connection to the X server.
+ * @param return_socket Callback function that will be called when xcb wants
+ *                        to use the socket again.
+ * @param closure Argument to the callback function.
+ * @param flags A combination of flags from the xcb_send_request_flags_t enumeration.
+ * @param sent Location to the sequence number of the last sequence request.
+ *              Must not be NULL.
+ * @return 1 on success, else 0.
+ *
+ * xcb_take_socket allows external code to ask XCB for permission to
+ * take over the write side of the socket and send raw data with
+ * xcb_writev. xcb_take_socket provides the sequence number of the last
+ * request XCB sent. The caller of xcb_take_socket must supply a
+ * callback which XCB can call when it wants the write side of the
+ * socket back to make a request. This callback synchronizes with the
+ * external socket owner and flushes any output queues if appropriate.
+ * If you are sending requests which won't cause a reply, please note the
+ * comment for xcb_writev which explains some sequence number wrap issues.
+ *
+ * All replies that are generated while the socket is owned externally have
+ * @p flags applied to them. For example, use XCB_REQUEST_CHECK if you don't
+ * want errors to go to xcb's normal error handling, but instead having to be
+ * picked up via xcb_wait_for_reply(), xcb_poll_for_reply() or
+ * xcb_request_check().
+ */
+int xcb_take_socket(xcb_connection_t *c, void (*return_socket)(void *closure), void *closure, int flags, uint64_t *sent);
+
+/**
+ * @brief Send raw data to the X server.
+ * @param c The connection to the X server.
+ * @param vector Array of data to be sent.
+ * @param count Number of entries in @p vector.
+ * @param requests Number of requests that are being sent.
+ * @return 1 on success, else 0.
+ *
+ * You must own the write-side of the socket (you've called
+ * xcb_take_socket, and haven't returned from return_socket yet) to call
+ * xcb_writev. Also, the iovec must have at least 1 byte of data in it.
+ * You have to make sure that xcb can detect sequence number wraps correctly.
+ * This means that the first request you send after xcb_take_socket must cause a
+ * reply (e.g. just insert a GetInputFocus request). After every (1 << 16) - 1
+ * requests without a reply, you have to insert a request which will cause a
+ * reply. You can again use GetInputFocus for this. You do not have to wait for
+ * any of the GetInputFocus replies, but can instead handle them via
+ * xcb_discard_reply().
+ */
+int xcb_writev(xcb_connection_t *c, struct iovec *vector, int count, uint64_t requests);
+
+
+/* xcb_in.c */
+
+/**
+ * @brief Wait for the reply of a given request.
+ * @param c The connection to the X server.
+ * @param request Sequence number of the request as returned by xcb_send_request().
+ * @param e Location to store errors in, or NULL. Ignored for unchecked requests.
+ *
+ * Returns the reply to the given request or returns null in the event of
+ * errors. Blocks until the reply or error for the request arrives, or an I/O
+ * error occurs.
+ */
+void *xcb_wait_for_reply(xcb_connection_t *c, unsigned int request, xcb_generic_error_t **e);
+
+/**
+ * @brief Wait for the reply of a given request, with 64-bit sequence number
+ * @param c The connection to the X server.
+ * @param request 64-bit sequence number of the request as returned by xcb_send_request64().
+ * @param e Location to store errors in, or NULL. Ignored for unchecked requests.
+ *
+ * Returns the reply to the given request or returns null in the event of
+ * errors. Blocks until the reply or error for the request arrives, or an I/O
+ * error occurs.
+ *
+ * Unlike its xcb_wait_for_reply() counterpart, the given sequence number is not
+ * automatically "widened" to 64-bit.
+ */
+void *xcb_wait_for_reply64(xcb_connection_t *c, uint64_t request, xcb_generic_error_t **e);
+
+/**
+ * @brief Poll for the reply of a given request.
+ * @param c The connection to the X server.
+ * @param request Sequence number of the request as returned by xcb_send_request().
+ * @param reply Location to store the reply in, must not be NULL.
+ * @param error Location to store errors in, or NULL. Ignored for unchecked requests.
+ * @return 1 when the reply to the request was returned, else 0.
+ *
+ * Checks if the reply to the given request already received. Does not block.
+ */
+int xcb_poll_for_reply(xcb_connection_t *c, unsigned int request, void **reply, xcb_generic_error_t **error);
+
+/**
+ * @brief Poll for the reply of a given request, with 64-bit sequence number.
+ * @param c The connection to the X server.
+ * @param request 64-bit sequence number of the request as returned by xcb_send_request().
+ * @param reply Location to store the reply in, must not be NULL.
+ * @param error Location to store errors in, or NULL. Ignored for unchecked requests.
+ * @return 1 when the reply to the request was returned, else 0.
+ *
+ * Checks if the reply to the given request already received. Does not block.
+ *
+ * Unlike its xcb_poll_for_reply() counterpart, the given sequence number is not
+ * automatically "widened" to 64-bit.
+ */
+int xcb_poll_for_reply64(xcb_connection_t *c, uint64_t request, void **reply, xcb_generic_error_t **error);
+
+/**
+ * @brief Don't use this, only needed by the generated code.
+ * @param c The connection to the X server.
+ * @param reply A reply that was received from the server
+ * @param replylen The size of the reply.
+ * @return Pointer to the location where received file descriptors are stored.
+ */
+int *xcb_get_reply_fds(xcb_connection_t *c, void *reply, size_t replylen);
+
+
+/* xcb_util.c */
+
+/**
+ * @param mask The mask to check
+ * @return The number of set bits in the mask
+ */
+int xcb_popcount(uint32_t mask);
+
+/**
+ * @param list The base of an array
+ * @param len The length of the array
+ * @return The sum of all entries in the array.
+ */
+int xcb_sumof(uint8_t *list, int len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/depends/libxcb/include/xcb/xcbint.h b/depends/libxcb/include/xcb/xcbint.h
new file mode 100644
index 0000000..235c848
--- /dev/null
+++ b/depends/libxcb/include/xcb/xcbint.h
@@ -0,0 +1,241 @@
+/*
+ * Copyright (C) 2001-2004 Bart Massey and Jamey Sharp.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the names of the authors or their
+ * institutions shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the authors.
+ */
+
+#ifndef __XCBINT_H
+#define __XCBINT_H
+
+#include "bigreq.h"
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef GCC_HAS_VISIBILITY
+#pragma GCC visibility push(hidden)
+#endif
+
+#ifndef __has_attribute
+# define __has_attribute(x) 0  /* Compatibility with older compilers. */
+#endif
+
+#if __has_attribute(fallthrough)
+# define XCB_ALLOW_FALLTHRU __attribute__ ((fallthrough));
+#else
+# define XCB_ALLOW_FALLTHRU /* FALLTHRU */
+#endif
+
+enum workarounds {
+    WORKAROUND_NONE,
+    WORKAROUND_GLX_GET_FB_CONFIGS_BUG,
+    WORKAROUND_EXTERNAL_SOCKET_OWNER
+};
+
+enum lazy_reply_tag
+{
+    LAZY_NONE = 0,
+    LAZY_COOKIE,
+    LAZY_FORCED
+};
+
+#define XCB_PAD(i) (-(i) & 3)
+
+#define XCB_SEQUENCE_COMPARE(a,op,b)    ((int64_t) ((a) - (b)) op 0)
+
+#ifndef offsetof
+#define offsetof(type,member) ((size_t) &((type *)0)->member)
+#endif
+
+#ifndef MIN
+#define MIN(x,y) ((x) < (y) ? (x) : (y))
+#endif
+
+#define container_of(pointer,type,member) ((type *)(((char *)(pointer)) - offsetof(type, member)))
+
+/* xcb_list.c */
+
+typedef void (*xcb_list_free_func_t)(void *);
+
+typedef struct _xcb_map _xcb_map;
+
+_xcb_map *_xcb_map_new(void);
+void _xcb_map_delete(_xcb_map *q, xcb_list_free_func_t do_free);
+int _xcb_map_put(_xcb_map *q, uint64_t key, void *data);
+void *_xcb_map_remove(_xcb_map *q, uint64_t key);
+
+
+/* xcb_out.c */
+
+#if HAVE_SENDMSG
+#define XCB_MAX_PASS_FD 16
+
+typedef struct _xcb_fd {
+    int fd[XCB_MAX_PASS_FD];
+    int nfd;
+    int ifd;
+} _xcb_fd;
+#endif
+
+typedef struct _xcb_out {
+    pthread_cond_t cond;
+    int writing;
+
+    pthread_cond_t socket_cond;
+    void (*return_socket)(void *closure);
+    void *socket_closure;
+    int socket_moving;
+
+    char queue[XCB_QUEUE_BUFFER_SIZE];
+    int queue_len;
+
+    uint64_t request;
+    uint64_t request_written;
+    uint64_t request_expected_written;
+    uint64_t total_written;
+
+    pthread_mutex_t reqlenlock;
+    enum lazy_reply_tag maximum_request_length_tag;
+    union {
+        xcb_big_requests_enable_cookie_t cookie;
+        uint32_t value;
+    } maximum_request_length;
+#if HAVE_SENDMSG
+    _xcb_fd out_fd;
+#endif
+} _xcb_out;
+
+int _xcb_out_init(_xcb_out *out);
+void _xcb_out_destroy(_xcb_out *out);
+
+int _xcb_out_send(xcb_connection_t *c, struct iovec *vector, int count);
+void _xcb_out_send_sync(xcb_connection_t *c);
+int _xcb_out_flush_to(xcb_connection_t *c, uint64_t request);
+
+
+/* xcb_in.c */
+
+typedef struct _xcb_in {
+    pthread_cond_t event_cond;
+    int reading;
+
+    char queue[4096];
+    int queue_len;
+
+    uint64_t request_expected;
+    uint64_t request_read;
+    uint64_t request_completed;
+    uint64_t total_read;
+    struct reply_list *current_reply;
+    struct reply_list **current_reply_tail;
+
+    _xcb_map *replies;
+    struct event_list *events;
+    struct event_list **events_tail;
+    struct reader_list *readers;
+    struct special_list *special_waiters;
+
+    struct pending_reply *pending_replies;
+    struct pending_reply **pending_replies_tail;
+#if HAVE_SENDMSG
+    _xcb_fd in_fd;
+#endif
+    struct xcb_special_event *special_events;
+} _xcb_in;
+
+int _xcb_in_init(_xcb_in *in);
+void _xcb_in_destroy(_xcb_in *in);
+
+void _xcb_in_wake_up_next_reader(xcb_connection_t *c);
+
+int _xcb_in_expect_reply(xcb_connection_t *c, uint64_t request, enum workarounds workaround, int flags);
+void _xcb_in_replies_done(xcb_connection_t *c);
+
+int _xcb_in_read(xcb_connection_t *c);
+int _xcb_in_read_block(xcb_connection_t *c, void *buf, int nread);
+
+
+/* xcb_xid.c */
+
+typedef struct _xcb_xid {
+    pthread_mutex_t lock;
+    uint32_t last;
+    uint32_t base;
+    uint32_t max;
+    uint32_t inc;
+} _xcb_xid;
+
+int _xcb_xid_init(xcb_connection_t *c);
+void _xcb_xid_destroy(xcb_connection_t *c);
+
+
+/* xcb_ext.c */
+
+typedef struct _xcb_ext {
+    pthread_mutex_t lock;
+    struct lazyreply *extensions;
+    int extensions_size;
+} _xcb_ext;
+
+int _xcb_ext_init(xcb_connection_t *c);
+void _xcb_ext_destroy(xcb_connection_t *c);
+
+
+/* xcb_conn.c */
+
+struct xcb_connection_t {
+    /* This must be the first field; see _xcb_conn_ret_error(). */
+    int has_error;
+
+    /* constant data */
+    xcb_setup_t *setup;
+    int fd;
+
+    /* I/O data */
+    pthread_mutex_t iolock;
+    _xcb_in in;
+    _xcb_out out;
+
+    /* misc data */
+    _xcb_ext ext;
+    _xcb_xid xid;
+};
+
+void _xcb_conn_shutdown(xcb_connection_t *c, int err);
+
+xcb_connection_t *_xcb_conn_ret_error(int err);
+
+int _xcb_conn_wait(xcb_connection_t *c, pthread_cond_t *cond, struct iovec **vector, int *count);
+
+
+/* xcb_auth.c */
+
+int _xcb_get_auth_info(int fd, xcb_auth_info_t *info, int display);
+
+#ifdef GCC_HAS_VISIBILITY
+#pragma GCC visibility pop
+#endif
+
+#endif
diff --git a/depends/libxcb/include/xcb/xevie.h b/depends/libxcb/include/xcb/xevie.h
new file mode 100644
index 0000000..d6b7825
--- /dev/null
+++ b/depends/libxcb/include/xcb/xevie.h
@@ -0,0 +1,473 @@
+/*
+ * This file generated automatically from xevie.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_Xevie_API XCB Xevie API
+ * @brief Xevie XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __XEVIE_H
+#define __XEVIE_H
+
+#include "xcb.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_XEVIE_MAJOR_VERSION 1
+#define XCB_XEVIE_MINOR_VERSION 0
+
+extern xcb_extension_t xcb_xevie_id;
+
+/**
+ * @brief xcb_xevie_query_version_cookie_t
+ **/
+typedef struct xcb_xevie_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_xevie_query_version_cookie_t;
+
+/** Opcode for xcb_xevie_query_version. */
+#define XCB_XEVIE_QUERY_VERSION 0
+
+/**
+ * @brief xcb_xevie_query_version_request_t
+ **/
+typedef struct xcb_xevie_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint16_t client_major_version;
+    uint16_t client_minor_version;
+} xcb_xevie_query_version_request_t;
+
+/**
+ * @brief xcb_xevie_query_version_reply_t
+ **/
+typedef struct xcb_xevie_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t server_major_version;
+    uint16_t server_minor_version;
+    uint8_t  pad1[20];
+} xcb_xevie_query_version_reply_t;
+
+/**
+ * @brief xcb_xevie_start_cookie_t
+ **/
+typedef struct xcb_xevie_start_cookie_t {
+    unsigned int sequence;
+} xcb_xevie_start_cookie_t;
+
+/** Opcode for xcb_xevie_start. */
+#define XCB_XEVIE_START 1
+
+/**
+ * @brief xcb_xevie_start_request_t
+ **/
+typedef struct xcb_xevie_start_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t screen;
+} xcb_xevie_start_request_t;
+
+/**
+ * @brief xcb_xevie_start_reply_t
+ **/
+typedef struct xcb_xevie_start_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[24];
+} xcb_xevie_start_reply_t;
+
+/**
+ * @brief xcb_xevie_end_cookie_t
+ **/
+typedef struct xcb_xevie_end_cookie_t {
+    unsigned int sequence;
+} xcb_xevie_end_cookie_t;
+
+/** Opcode for xcb_xevie_end. */
+#define XCB_XEVIE_END 2
+
+/**
+ * @brief xcb_xevie_end_request_t
+ **/
+typedef struct xcb_xevie_end_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t cmap;
+} xcb_xevie_end_request_t;
+
+/**
+ * @brief xcb_xevie_end_reply_t
+ **/
+typedef struct xcb_xevie_end_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[24];
+} xcb_xevie_end_reply_t;
+
+typedef enum xcb_xevie_datatype_t {
+    XCB_XEVIE_DATATYPE_UNMODIFIED = 0,
+    XCB_XEVIE_DATATYPE_MODIFIED = 1
+} xcb_xevie_datatype_t;
+
+/**
+ * @brief xcb_xevie_event_t
+ **/
+typedef struct xcb_xevie_event_t {
+    uint8_t pad0[32];
+} xcb_xevie_event_t;
+
+/**
+ * @brief xcb_xevie_event_iterator_t
+ **/
+typedef struct xcb_xevie_event_iterator_t {
+    xcb_xevie_event_t *data;
+    int                rem;
+    int                index;
+} xcb_xevie_event_iterator_t;
+
+/**
+ * @brief xcb_xevie_send_cookie_t
+ **/
+typedef struct xcb_xevie_send_cookie_t {
+    unsigned int sequence;
+} xcb_xevie_send_cookie_t;
+
+/** Opcode for xcb_xevie_send. */
+#define XCB_XEVIE_SEND 3
+
+/**
+ * @brief xcb_xevie_send_request_t
+ **/
+typedef struct xcb_xevie_send_request_t {
+    uint8_t           major_opcode;
+    uint8_t           minor_opcode;
+    uint16_t          length;
+    xcb_xevie_event_t event;
+    uint32_t          data_type;
+    uint8_t           pad0[64];
+} xcb_xevie_send_request_t;
+
+/**
+ * @brief xcb_xevie_send_reply_t
+ **/
+typedef struct xcb_xevie_send_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[24];
+} xcb_xevie_send_reply_t;
+
+/**
+ * @brief xcb_xevie_select_input_cookie_t
+ **/
+typedef struct xcb_xevie_select_input_cookie_t {
+    unsigned int sequence;
+} xcb_xevie_select_input_cookie_t;
+
+/** Opcode for xcb_xevie_select_input. */
+#define XCB_XEVIE_SELECT_INPUT 4
+
+/**
+ * @brief xcb_xevie_select_input_request_t
+ **/
+typedef struct xcb_xevie_select_input_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t event_mask;
+} xcb_xevie_select_input_request_t;
+
+/**
+ * @brief xcb_xevie_select_input_reply_t
+ **/
+typedef struct xcb_xevie_select_input_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[24];
+} xcb_xevie_select_input_reply_t;
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xevie_query_version_cookie_t
+xcb_xevie_query_version (xcb_connection_t *c,
+                         uint16_t          client_major_version,
+                         uint16_t          client_minor_version);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xevie_query_version_cookie_t
+xcb_xevie_query_version_unchecked (xcb_connection_t *c,
+                                   uint16_t          client_major_version,
+                                   uint16_t          client_minor_version);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xevie_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xevie_query_version_reply_t *
+xcb_xevie_query_version_reply (xcb_connection_t                  *c,
+                               xcb_xevie_query_version_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xevie_start_cookie_t
+xcb_xevie_start (xcb_connection_t *c,
+                 uint32_t          screen);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xevie_start_cookie_t
+xcb_xevie_start_unchecked (xcb_connection_t *c,
+                           uint32_t          screen);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xevie_start_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xevie_start_reply_t *
+xcb_xevie_start_reply (xcb_connection_t          *c,
+                       xcb_xevie_start_cookie_t   cookie  /**< */,
+                       xcb_generic_error_t      **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xevie_end_cookie_t
+xcb_xevie_end (xcb_connection_t *c,
+               uint32_t          cmap);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xevie_end_cookie_t
+xcb_xevie_end_unchecked (xcb_connection_t *c,
+                         uint32_t          cmap);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xevie_end_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xevie_end_reply_t *
+xcb_xevie_end_reply (xcb_connection_t        *c,
+                     xcb_xevie_end_cookie_t   cookie  /**< */,
+                     xcb_generic_error_t    **e);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xevie_event_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xevie_event_t)
+ */
+void
+xcb_xevie_event_next (xcb_xevie_event_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xevie_event_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xevie_event_end (xcb_xevie_event_iterator_t i);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xevie_send_cookie_t
+xcb_xevie_send (xcb_connection_t  *c,
+                xcb_xevie_event_t  event,
+                uint32_t           data_type);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xevie_send_cookie_t
+xcb_xevie_send_unchecked (xcb_connection_t  *c,
+                          xcb_xevie_event_t  event,
+                          uint32_t           data_type);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xevie_send_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xevie_send_reply_t *
+xcb_xevie_send_reply (xcb_connection_t         *c,
+                      xcb_xevie_send_cookie_t   cookie  /**< */,
+                      xcb_generic_error_t     **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xevie_select_input_cookie_t
+xcb_xevie_select_input (xcb_connection_t *c,
+                        uint32_t          event_mask);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xevie_select_input_cookie_t
+xcb_xevie_select_input_unchecked (xcb_connection_t *c,
+                                  uint32_t          event_mask);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xevie_select_input_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xevie_select_input_reply_t *
+xcb_xevie_select_input_reply (xcb_connection_t                 *c,
+                              xcb_xevie_select_input_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/xf86dri.h b/depends/libxcb/include/xcb/xf86dri.h
new file mode 100644
index 0000000..fbe1b0e
--- /dev/null
+++ b/depends/libxcb/include/xcb/xf86dri.h
@@ -0,0 +1,988 @@
+/*
+ * This file generated automatically from xf86dri.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_XF86Dri_API XCB XF86Dri API
+ * @brief XF86Dri XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __XF86DRI_H
+#define __XF86DRI_H
+
+#include "xcb.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_XF86DRI_MAJOR_VERSION 4
+#define XCB_XF86DRI_MINOR_VERSION 1
+
+extern xcb_extension_t xcb_xf86dri_id;
+
+/**
+ * @brief xcb_xf86dri_drm_clip_rect_t
+ **/
+typedef struct xcb_xf86dri_drm_clip_rect_t {
+    int16_t x1;
+    int16_t y1;
+    int16_t x2;
+    int16_t x3;
+} xcb_xf86dri_drm_clip_rect_t;
+
+/**
+ * @brief xcb_xf86dri_drm_clip_rect_iterator_t
+ **/
+typedef struct xcb_xf86dri_drm_clip_rect_iterator_t {
+    xcb_xf86dri_drm_clip_rect_t *data;
+    int                          rem;
+    int                          index;
+} xcb_xf86dri_drm_clip_rect_iterator_t;
+
+/**
+ * @brief xcb_xf86dri_query_version_cookie_t
+ **/
+typedef struct xcb_xf86dri_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_xf86dri_query_version_cookie_t;
+
+/** Opcode for xcb_xf86dri_query_version. */
+#define XCB_XF86DRI_QUERY_VERSION 0
+
+/**
+ * @brief xcb_xf86dri_query_version_request_t
+ **/
+typedef struct xcb_xf86dri_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_xf86dri_query_version_request_t;
+
+/**
+ * @brief xcb_xf86dri_query_version_reply_t
+ **/
+typedef struct xcb_xf86dri_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t dri_major_version;
+    uint16_t dri_minor_version;
+    uint32_t dri_minor_patch;
+} xcb_xf86dri_query_version_reply_t;
+
+/**
+ * @brief xcb_xf86dri_query_direct_rendering_capable_cookie_t
+ **/
+typedef struct xcb_xf86dri_query_direct_rendering_capable_cookie_t {
+    unsigned int sequence;
+} xcb_xf86dri_query_direct_rendering_capable_cookie_t;
+
+/** Opcode for xcb_xf86dri_query_direct_rendering_capable. */
+#define XCB_XF86DRI_QUERY_DIRECT_RENDERING_CAPABLE 1
+
+/**
+ * @brief xcb_xf86dri_query_direct_rendering_capable_request_t
+ **/
+typedef struct xcb_xf86dri_query_direct_rendering_capable_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t screen;
+} xcb_xf86dri_query_direct_rendering_capable_request_t;
+
+/**
+ * @brief xcb_xf86dri_query_direct_rendering_capable_reply_t
+ **/
+typedef struct xcb_xf86dri_query_direct_rendering_capable_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  is_capable;
+} xcb_xf86dri_query_direct_rendering_capable_reply_t;
+
+/**
+ * @brief xcb_xf86dri_open_connection_cookie_t
+ **/
+typedef struct xcb_xf86dri_open_connection_cookie_t {
+    unsigned int sequence;
+} xcb_xf86dri_open_connection_cookie_t;
+
+/** Opcode for xcb_xf86dri_open_connection. */
+#define XCB_XF86DRI_OPEN_CONNECTION 2
+
+/**
+ * @brief xcb_xf86dri_open_connection_request_t
+ **/
+typedef struct xcb_xf86dri_open_connection_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t screen;
+} xcb_xf86dri_open_connection_request_t;
+
+/**
+ * @brief xcb_xf86dri_open_connection_reply_t
+ **/
+typedef struct xcb_xf86dri_open_connection_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t sarea_handle_low;
+    uint32_t sarea_handle_high;
+    uint32_t bus_id_len;
+    uint8_t  pad1[12];
+} xcb_xf86dri_open_connection_reply_t;
+
+/** Opcode for xcb_xf86dri_close_connection. */
+#define XCB_XF86DRI_CLOSE_CONNECTION 3
+
+/**
+ * @brief xcb_xf86dri_close_connection_request_t
+ **/
+typedef struct xcb_xf86dri_close_connection_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t screen;
+} xcb_xf86dri_close_connection_request_t;
+
+/**
+ * @brief xcb_xf86dri_get_client_driver_name_cookie_t
+ **/
+typedef struct xcb_xf86dri_get_client_driver_name_cookie_t {
+    unsigned int sequence;
+} xcb_xf86dri_get_client_driver_name_cookie_t;
+
+/** Opcode for xcb_xf86dri_get_client_driver_name. */
+#define XCB_XF86DRI_GET_CLIENT_DRIVER_NAME 4
+
+/**
+ * @brief xcb_xf86dri_get_client_driver_name_request_t
+ **/
+typedef struct xcb_xf86dri_get_client_driver_name_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t screen;
+} xcb_xf86dri_get_client_driver_name_request_t;
+
+/**
+ * @brief xcb_xf86dri_get_client_driver_name_reply_t
+ **/
+typedef struct xcb_xf86dri_get_client_driver_name_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t client_driver_major_version;
+    uint32_t client_driver_minor_version;
+    uint32_t client_driver_patch_version;
+    uint32_t client_driver_name_len;
+    uint8_t  pad1[8];
+} xcb_xf86dri_get_client_driver_name_reply_t;
+
+/**
+ * @brief xcb_xf86dri_create_context_cookie_t
+ **/
+typedef struct xcb_xf86dri_create_context_cookie_t {
+    unsigned int sequence;
+} xcb_xf86dri_create_context_cookie_t;
+
+/** Opcode for xcb_xf86dri_create_context. */
+#define XCB_XF86DRI_CREATE_CONTEXT 5
+
+/**
+ * @brief xcb_xf86dri_create_context_request_t
+ **/
+typedef struct xcb_xf86dri_create_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t screen;
+    uint32_t visual;
+    uint32_t context;
+} xcb_xf86dri_create_context_request_t;
+
+/**
+ * @brief xcb_xf86dri_create_context_reply_t
+ **/
+typedef struct xcb_xf86dri_create_context_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t hw_context;
+} xcb_xf86dri_create_context_reply_t;
+
+/** Opcode for xcb_xf86dri_destroy_context. */
+#define XCB_XF86DRI_DESTROY_CONTEXT 6
+
+/**
+ * @brief xcb_xf86dri_destroy_context_request_t
+ **/
+typedef struct xcb_xf86dri_destroy_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t screen;
+    uint32_t context;
+} xcb_xf86dri_destroy_context_request_t;
+
+/**
+ * @brief xcb_xf86dri_create_drawable_cookie_t
+ **/
+typedef struct xcb_xf86dri_create_drawable_cookie_t {
+    unsigned int sequence;
+} xcb_xf86dri_create_drawable_cookie_t;
+
+/** Opcode for xcb_xf86dri_create_drawable. */
+#define XCB_XF86DRI_CREATE_DRAWABLE 7
+
+/**
+ * @brief xcb_xf86dri_create_drawable_request_t
+ **/
+typedef struct xcb_xf86dri_create_drawable_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t screen;
+    uint32_t drawable;
+} xcb_xf86dri_create_drawable_request_t;
+
+/**
+ * @brief xcb_xf86dri_create_drawable_reply_t
+ **/
+typedef struct xcb_xf86dri_create_drawable_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t hw_drawable_handle;
+} xcb_xf86dri_create_drawable_reply_t;
+
+/** Opcode for xcb_xf86dri_destroy_drawable. */
+#define XCB_XF86DRI_DESTROY_DRAWABLE 8
+
+/**
+ * @brief xcb_xf86dri_destroy_drawable_request_t
+ **/
+typedef struct xcb_xf86dri_destroy_drawable_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t screen;
+    uint32_t drawable;
+} xcb_xf86dri_destroy_drawable_request_t;
+
+/**
+ * @brief xcb_xf86dri_get_drawable_info_cookie_t
+ **/
+typedef struct xcb_xf86dri_get_drawable_info_cookie_t {
+    unsigned int sequence;
+} xcb_xf86dri_get_drawable_info_cookie_t;
+
+/** Opcode for xcb_xf86dri_get_drawable_info. */
+#define XCB_XF86DRI_GET_DRAWABLE_INFO 9
+
+/**
+ * @brief xcb_xf86dri_get_drawable_info_request_t
+ **/
+typedef struct xcb_xf86dri_get_drawable_info_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t screen;
+    uint32_t drawable;
+} xcb_xf86dri_get_drawable_info_request_t;
+
+/**
+ * @brief xcb_xf86dri_get_drawable_info_reply_t
+ **/
+typedef struct xcb_xf86dri_get_drawable_info_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t drawable_table_index;
+    uint32_t drawable_table_stamp;
+    int16_t  drawable_origin_X;
+    int16_t  drawable_origin_Y;
+    int16_t  drawable_size_W;
+    int16_t  drawable_size_H;
+    uint32_t num_clip_rects;
+    int16_t  back_x;
+    int16_t  back_y;
+    uint32_t num_back_clip_rects;
+} xcb_xf86dri_get_drawable_info_reply_t;
+
+/**
+ * @brief xcb_xf86dri_get_device_info_cookie_t
+ **/
+typedef struct xcb_xf86dri_get_device_info_cookie_t {
+    unsigned int sequence;
+} xcb_xf86dri_get_device_info_cookie_t;
+
+/** Opcode for xcb_xf86dri_get_device_info. */
+#define XCB_XF86DRI_GET_DEVICE_INFO 10
+
+/**
+ * @brief xcb_xf86dri_get_device_info_request_t
+ **/
+typedef struct xcb_xf86dri_get_device_info_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t screen;
+} xcb_xf86dri_get_device_info_request_t;
+
+/**
+ * @brief xcb_xf86dri_get_device_info_reply_t
+ **/
+typedef struct xcb_xf86dri_get_device_info_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t framebuffer_handle_low;
+    uint32_t framebuffer_handle_high;
+    uint32_t framebuffer_origin_offset;
+    uint32_t framebuffer_size;
+    uint32_t framebuffer_stride;
+    uint32_t device_private_size;
+} xcb_xf86dri_get_device_info_reply_t;
+
+/**
+ * @brief xcb_xf86dri_auth_connection_cookie_t
+ **/
+typedef struct xcb_xf86dri_auth_connection_cookie_t {
+    unsigned int sequence;
+} xcb_xf86dri_auth_connection_cookie_t;
+
+/** Opcode for xcb_xf86dri_auth_connection. */
+#define XCB_XF86DRI_AUTH_CONNECTION 11
+
+/**
+ * @brief xcb_xf86dri_auth_connection_request_t
+ **/
+typedef struct xcb_xf86dri_auth_connection_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t screen;
+    uint32_t magic;
+} xcb_xf86dri_auth_connection_request_t;
+
+/**
+ * @brief xcb_xf86dri_auth_connection_reply_t
+ **/
+typedef struct xcb_xf86dri_auth_connection_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t authenticated;
+} xcb_xf86dri_auth_connection_reply_t;
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xf86dri_drm_clip_rect_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xf86dri_drm_clip_rect_t)
+ */
+void
+xcb_xf86dri_drm_clip_rect_next (xcb_xf86dri_drm_clip_rect_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xf86dri_drm_clip_rect_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xf86dri_drm_clip_rect_end (xcb_xf86dri_drm_clip_rect_iterator_t i);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xf86dri_query_version_cookie_t
+xcb_xf86dri_query_version (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xf86dri_query_version_cookie_t
+xcb_xf86dri_query_version_unchecked (xcb_connection_t *c);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xf86dri_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xf86dri_query_version_reply_t *
+xcb_xf86dri_query_version_reply (xcb_connection_t                    *c,
+                                 xcb_xf86dri_query_version_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xf86dri_query_direct_rendering_capable_cookie_t
+xcb_xf86dri_query_direct_rendering_capable (xcb_connection_t *c,
+                                            uint32_t          screen);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xf86dri_query_direct_rendering_capable_cookie_t
+xcb_xf86dri_query_direct_rendering_capable_unchecked (xcb_connection_t *c,
+                                                      uint32_t          screen);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xf86dri_query_direct_rendering_capable_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xf86dri_query_direct_rendering_capable_reply_t *
+xcb_xf86dri_query_direct_rendering_capable_reply (xcb_connection_t                                     *c,
+                                                  xcb_xf86dri_query_direct_rendering_capable_cookie_t   cookie  /**< */,
+                                                  xcb_generic_error_t                                 **e);
+
+int
+xcb_xf86dri_open_connection_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xf86dri_open_connection_cookie_t
+xcb_xf86dri_open_connection (xcb_connection_t *c,
+                             uint32_t          screen);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xf86dri_open_connection_cookie_t
+xcb_xf86dri_open_connection_unchecked (xcb_connection_t *c,
+                                       uint32_t          screen);
+
+char *
+xcb_xf86dri_open_connection_bus_id (const xcb_xf86dri_open_connection_reply_t *R);
+
+int
+xcb_xf86dri_open_connection_bus_id_length (const xcb_xf86dri_open_connection_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_xf86dri_open_connection_bus_id_end (const xcb_xf86dri_open_connection_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xf86dri_open_connection_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xf86dri_open_connection_reply_t *
+xcb_xf86dri_open_connection_reply (xcb_connection_t                      *c,
+                                   xcb_xf86dri_open_connection_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xf86dri_close_connection_checked (xcb_connection_t *c,
+                                      uint32_t          screen);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xf86dri_close_connection (xcb_connection_t *c,
+                              uint32_t          screen);
+
+int
+xcb_xf86dri_get_client_driver_name_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xf86dri_get_client_driver_name_cookie_t
+xcb_xf86dri_get_client_driver_name (xcb_connection_t *c,
+                                    uint32_t          screen);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xf86dri_get_client_driver_name_cookie_t
+xcb_xf86dri_get_client_driver_name_unchecked (xcb_connection_t *c,
+                                              uint32_t          screen);
+
+char *
+xcb_xf86dri_get_client_driver_name_client_driver_name (const xcb_xf86dri_get_client_driver_name_reply_t *R);
+
+int
+xcb_xf86dri_get_client_driver_name_client_driver_name_length (const xcb_xf86dri_get_client_driver_name_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_xf86dri_get_client_driver_name_client_driver_name_end (const xcb_xf86dri_get_client_driver_name_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xf86dri_get_client_driver_name_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xf86dri_get_client_driver_name_reply_t *
+xcb_xf86dri_get_client_driver_name_reply (xcb_connection_t                             *c,
+                                          xcb_xf86dri_get_client_driver_name_cookie_t   cookie  /**< */,
+                                          xcb_generic_error_t                         **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xf86dri_create_context_cookie_t
+xcb_xf86dri_create_context (xcb_connection_t *c,
+                            uint32_t          screen,
+                            uint32_t          visual,
+                            uint32_t          context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xf86dri_create_context_cookie_t
+xcb_xf86dri_create_context_unchecked (xcb_connection_t *c,
+                                      uint32_t          screen,
+                                      uint32_t          visual,
+                                      uint32_t          context);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xf86dri_create_context_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xf86dri_create_context_reply_t *
+xcb_xf86dri_create_context_reply (xcb_connection_t                     *c,
+                                  xcb_xf86dri_create_context_cookie_t   cookie  /**< */,
+                                  xcb_generic_error_t                 **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xf86dri_destroy_context_checked (xcb_connection_t *c,
+                                     uint32_t          screen,
+                                     uint32_t          context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xf86dri_destroy_context (xcb_connection_t *c,
+                             uint32_t          screen,
+                             uint32_t          context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xf86dri_create_drawable_cookie_t
+xcb_xf86dri_create_drawable (xcb_connection_t *c,
+                             uint32_t          screen,
+                             uint32_t          drawable);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xf86dri_create_drawable_cookie_t
+xcb_xf86dri_create_drawable_unchecked (xcb_connection_t *c,
+                                       uint32_t          screen,
+                                       uint32_t          drawable);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xf86dri_create_drawable_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xf86dri_create_drawable_reply_t *
+xcb_xf86dri_create_drawable_reply (xcb_connection_t                      *c,
+                                   xcb_xf86dri_create_drawable_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xf86dri_destroy_drawable_checked (xcb_connection_t *c,
+                                      uint32_t          screen,
+                                      uint32_t          drawable);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xf86dri_destroy_drawable (xcb_connection_t *c,
+                              uint32_t          screen,
+                              uint32_t          drawable);
+
+int
+xcb_xf86dri_get_drawable_info_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xf86dri_get_drawable_info_cookie_t
+xcb_xf86dri_get_drawable_info (xcb_connection_t *c,
+                               uint32_t          screen,
+                               uint32_t          drawable);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xf86dri_get_drawable_info_cookie_t
+xcb_xf86dri_get_drawable_info_unchecked (xcb_connection_t *c,
+                                         uint32_t          screen,
+                                         uint32_t          drawable);
+
+xcb_xf86dri_drm_clip_rect_t *
+xcb_xf86dri_get_drawable_info_clip_rects (const xcb_xf86dri_get_drawable_info_reply_t *R);
+
+int
+xcb_xf86dri_get_drawable_info_clip_rects_length (const xcb_xf86dri_get_drawable_info_reply_t *R);
+
+xcb_xf86dri_drm_clip_rect_iterator_t
+xcb_xf86dri_get_drawable_info_clip_rects_iterator (const xcb_xf86dri_get_drawable_info_reply_t *R);
+
+xcb_xf86dri_drm_clip_rect_t *
+xcb_xf86dri_get_drawable_info_back_clip_rects (const xcb_xf86dri_get_drawable_info_reply_t *R);
+
+int
+xcb_xf86dri_get_drawable_info_back_clip_rects_length (const xcb_xf86dri_get_drawable_info_reply_t *R);
+
+xcb_xf86dri_drm_clip_rect_iterator_t
+xcb_xf86dri_get_drawable_info_back_clip_rects_iterator (const xcb_xf86dri_get_drawable_info_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xf86dri_get_drawable_info_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xf86dri_get_drawable_info_reply_t *
+xcb_xf86dri_get_drawable_info_reply (xcb_connection_t                        *c,
+                                     xcb_xf86dri_get_drawable_info_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e);
+
+int
+xcb_xf86dri_get_device_info_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xf86dri_get_device_info_cookie_t
+xcb_xf86dri_get_device_info (xcb_connection_t *c,
+                             uint32_t          screen);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xf86dri_get_device_info_cookie_t
+xcb_xf86dri_get_device_info_unchecked (xcb_connection_t *c,
+                                       uint32_t          screen);
+
+uint32_t *
+xcb_xf86dri_get_device_info_device_private (const xcb_xf86dri_get_device_info_reply_t *R);
+
+int
+xcb_xf86dri_get_device_info_device_private_length (const xcb_xf86dri_get_device_info_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_xf86dri_get_device_info_device_private_end (const xcb_xf86dri_get_device_info_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xf86dri_get_device_info_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xf86dri_get_device_info_reply_t *
+xcb_xf86dri_get_device_info_reply (xcb_connection_t                      *c,
+                                   xcb_xf86dri_get_device_info_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xf86dri_auth_connection_cookie_t
+xcb_xf86dri_auth_connection (xcb_connection_t *c,
+                             uint32_t          screen,
+                             uint32_t          magic);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xf86dri_auth_connection_cookie_t
+xcb_xf86dri_auth_connection_unchecked (xcb_connection_t *c,
+                                       uint32_t          screen,
+                                       uint32_t          magic);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xf86dri_auth_connection_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xf86dri_auth_connection_reply_t *
+xcb_xf86dri_auth_connection_reply (xcb_connection_t                      *c,
+                                   xcb_xf86dri_auth_connection_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/xfixes.h b/depends/libxcb/include/xcb/xfixes.h
new file mode 100644
index 0000000..cf95f63
--- /dev/null
+++ b/depends/libxcb/include/xcb/xfixes.h
@@ -0,0 +1,2128 @@
+/*
+ * This file generated automatically from xfixes.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_XFixes_API XCB XFixes API
+ * @brief XFixes XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __XFIXES_H
+#define __XFIXES_H
+
+#include "xcb.h"
+#include "xproto.h"
+#include "render.h"
+#include "shape.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_XFIXES_MAJOR_VERSION 6
+#define XCB_XFIXES_MINOR_VERSION 0
+
+extern xcb_extension_t xcb_xfixes_id;
+
+/**
+ * @brief xcb_xfixes_query_version_cookie_t
+ **/
+typedef struct xcb_xfixes_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_xfixes_query_version_cookie_t;
+
+/** Opcode for xcb_xfixes_query_version. */
+#define XCB_XFIXES_QUERY_VERSION 0
+
+/**
+ * @brief xcb_xfixes_query_version_request_t
+ **/
+typedef struct xcb_xfixes_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t client_major_version;
+    uint32_t client_minor_version;
+} xcb_xfixes_query_version_request_t;
+
+/**
+ * @brief xcb_xfixes_query_version_reply_t
+ **/
+typedef struct xcb_xfixes_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t major_version;
+    uint32_t minor_version;
+    uint8_t  pad1[16];
+} xcb_xfixes_query_version_reply_t;
+
+typedef enum xcb_xfixes_save_set_mode_t {
+    XCB_XFIXES_SAVE_SET_MODE_INSERT = 0,
+    XCB_XFIXES_SAVE_SET_MODE_DELETE = 1
+} xcb_xfixes_save_set_mode_t;
+
+typedef enum xcb_xfixes_save_set_target_t {
+    XCB_XFIXES_SAVE_SET_TARGET_NEAREST = 0,
+    XCB_XFIXES_SAVE_SET_TARGET_ROOT = 1
+} xcb_xfixes_save_set_target_t;
+
+typedef enum xcb_xfixes_save_set_mapping_t {
+    XCB_XFIXES_SAVE_SET_MAPPING_MAP = 0,
+    XCB_XFIXES_SAVE_SET_MAPPING_UNMAP = 1
+} xcb_xfixes_save_set_mapping_t;
+
+/** Opcode for xcb_xfixes_change_save_set. */
+#define XCB_XFIXES_CHANGE_SAVE_SET 1
+
+/**
+ * @brief xcb_xfixes_change_save_set_request_t
+ **/
+typedef struct xcb_xfixes_change_save_set_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    uint8_t      mode;
+    uint8_t      target;
+    uint8_t      map;
+    uint8_t      pad0;
+    xcb_window_t window;
+} xcb_xfixes_change_save_set_request_t;
+
+typedef enum xcb_xfixes_selection_event_t {
+    XCB_XFIXES_SELECTION_EVENT_SET_SELECTION_OWNER = 0,
+    XCB_XFIXES_SELECTION_EVENT_SELECTION_WINDOW_DESTROY = 1,
+    XCB_XFIXES_SELECTION_EVENT_SELECTION_CLIENT_CLOSE = 2
+} xcb_xfixes_selection_event_t;
+
+typedef enum xcb_xfixes_selection_event_mask_t {
+    XCB_XFIXES_SELECTION_EVENT_MASK_SET_SELECTION_OWNER = 1,
+    XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_WINDOW_DESTROY = 2,
+    XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_CLIENT_CLOSE = 4
+} xcb_xfixes_selection_event_mask_t;
+
+/** Opcode for xcb_xfixes_selection_notify. */
+#define XCB_XFIXES_SELECTION_NOTIFY 0
+
+/**
+ * @brief xcb_xfixes_selection_notify_event_t
+ **/
+typedef struct xcb_xfixes_selection_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         subtype;
+    uint16_t        sequence;
+    xcb_window_t    window;
+    xcb_window_t    owner;
+    xcb_atom_t      selection;
+    xcb_timestamp_t timestamp;
+    xcb_timestamp_t selection_timestamp;
+    uint8_t         pad0[8];
+} xcb_xfixes_selection_notify_event_t;
+
+/** Opcode for xcb_xfixes_select_selection_input. */
+#define XCB_XFIXES_SELECT_SELECTION_INPUT 2
+
+/**
+ * @brief xcb_xfixes_select_selection_input_request_t
+ **/
+typedef struct xcb_xfixes_select_selection_input_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    xcb_atom_t   selection;
+    uint32_t     event_mask;
+} xcb_xfixes_select_selection_input_request_t;
+
+typedef enum xcb_xfixes_cursor_notify_t {
+    XCB_XFIXES_CURSOR_NOTIFY_DISPLAY_CURSOR = 0
+} xcb_xfixes_cursor_notify_t;
+
+typedef enum xcb_xfixes_cursor_notify_mask_t {
+    XCB_XFIXES_CURSOR_NOTIFY_MASK_DISPLAY_CURSOR = 1
+} xcb_xfixes_cursor_notify_mask_t;
+
+/** Opcode for xcb_xfixes_cursor_notify. */
+#define XCB_XFIXES_CURSOR_NOTIFY 1
+
+/**
+ * @brief xcb_xfixes_cursor_notify_event_t
+ **/
+typedef struct xcb_xfixes_cursor_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         subtype;
+    uint16_t        sequence;
+    xcb_window_t    window;
+    uint32_t        cursor_serial;
+    xcb_timestamp_t timestamp;
+    xcb_atom_t      name;
+    uint8_t         pad0[12];
+} xcb_xfixes_cursor_notify_event_t;
+
+/** Opcode for xcb_xfixes_select_cursor_input. */
+#define XCB_XFIXES_SELECT_CURSOR_INPUT 3
+
+/**
+ * @brief xcb_xfixes_select_cursor_input_request_t
+ **/
+typedef struct xcb_xfixes_select_cursor_input_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    uint32_t     event_mask;
+} xcb_xfixes_select_cursor_input_request_t;
+
+/**
+ * @brief xcb_xfixes_get_cursor_image_cookie_t
+ **/
+typedef struct xcb_xfixes_get_cursor_image_cookie_t {
+    unsigned int sequence;
+} xcb_xfixes_get_cursor_image_cookie_t;
+
+/** Opcode for xcb_xfixes_get_cursor_image. */
+#define XCB_XFIXES_GET_CURSOR_IMAGE 4
+
+/**
+ * @brief xcb_xfixes_get_cursor_image_request_t
+ **/
+typedef struct xcb_xfixes_get_cursor_image_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_xfixes_get_cursor_image_request_t;
+
+/**
+ * @brief xcb_xfixes_get_cursor_image_reply_t
+ **/
+typedef struct xcb_xfixes_get_cursor_image_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    int16_t  x;
+    int16_t  y;
+    uint16_t width;
+    uint16_t height;
+    uint16_t xhot;
+    uint16_t yhot;
+    uint32_t cursor_serial;
+    uint8_t  pad1[8];
+} xcb_xfixes_get_cursor_image_reply_t;
+
+typedef uint32_t xcb_xfixes_region_t;
+
+/**
+ * @brief xcb_xfixes_region_iterator_t
+ **/
+typedef struct xcb_xfixes_region_iterator_t {
+    xcb_xfixes_region_t *data;
+    int                  rem;
+    int                  index;
+} xcb_xfixes_region_iterator_t;
+
+/** Opcode for xcb_xfixes_bad_region. */
+#define XCB_XFIXES_BAD_REGION 0
+
+/**
+ * @brief xcb_xfixes_bad_region_error_t
+ **/
+typedef struct xcb_xfixes_bad_region_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_xfixes_bad_region_error_t;
+
+typedef enum xcb_xfixes_region_enum_t {
+    XCB_XFIXES_REGION_NONE = 0
+} xcb_xfixes_region_enum_t;
+
+/** Opcode for xcb_xfixes_create_region. */
+#define XCB_XFIXES_CREATE_REGION 5
+
+/**
+ * @brief xcb_xfixes_create_region_request_t
+ **/
+typedef struct xcb_xfixes_create_region_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_xfixes_region_t region;
+} xcb_xfixes_create_region_request_t;
+
+/** Opcode for xcb_xfixes_create_region_from_bitmap. */
+#define XCB_XFIXES_CREATE_REGION_FROM_BITMAP 6
+
+/**
+ * @brief xcb_xfixes_create_region_from_bitmap_request_t
+ **/
+typedef struct xcb_xfixes_create_region_from_bitmap_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_xfixes_region_t region;
+    xcb_pixmap_t        bitmap;
+} xcb_xfixes_create_region_from_bitmap_request_t;
+
+/** Opcode for xcb_xfixes_create_region_from_window. */
+#define XCB_XFIXES_CREATE_REGION_FROM_WINDOW 7
+
+/**
+ * @brief xcb_xfixes_create_region_from_window_request_t
+ **/
+typedef struct xcb_xfixes_create_region_from_window_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_xfixes_region_t region;
+    xcb_window_t        window;
+    xcb_shape_kind_t    kind;
+    uint8_t             pad0[3];
+} xcb_xfixes_create_region_from_window_request_t;
+
+/** Opcode for xcb_xfixes_create_region_from_gc. */
+#define XCB_XFIXES_CREATE_REGION_FROM_GC 8
+
+/**
+ * @brief xcb_xfixes_create_region_from_gc_request_t
+ **/
+typedef struct xcb_xfixes_create_region_from_gc_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_xfixes_region_t region;
+    xcb_gcontext_t      gc;
+} xcb_xfixes_create_region_from_gc_request_t;
+
+/** Opcode for xcb_xfixes_create_region_from_picture. */
+#define XCB_XFIXES_CREATE_REGION_FROM_PICTURE 9
+
+/**
+ * @brief xcb_xfixes_create_region_from_picture_request_t
+ **/
+typedef struct xcb_xfixes_create_region_from_picture_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_xfixes_region_t  region;
+    xcb_render_picture_t picture;
+} xcb_xfixes_create_region_from_picture_request_t;
+
+/** Opcode for xcb_xfixes_destroy_region. */
+#define XCB_XFIXES_DESTROY_REGION 10
+
+/**
+ * @brief xcb_xfixes_destroy_region_request_t
+ **/
+typedef struct xcb_xfixes_destroy_region_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_xfixes_region_t region;
+} xcb_xfixes_destroy_region_request_t;
+
+/** Opcode for xcb_xfixes_set_region. */
+#define XCB_XFIXES_SET_REGION 11
+
+/**
+ * @brief xcb_xfixes_set_region_request_t
+ **/
+typedef struct xcb_xfixes_set_region_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_xfixes_region_t region;
+} xcb_xfixes_set_region_request_t;
+
+/** Opcode for xcb_xfixes_copy_region. */
+#define XCB_XFIXES_COPY_REGION 12
+
+/**
+ * @brief xcb_xfixes_copy_region_request_t
+ **/
+typedef struct xcb_xfixes_copy_region_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_xfixes_region_t source;
+    xcb_xfixes_region_t destination;
+} xcb_xfixes_copy_region_request_t;
+
+/** Opcode for xcb_xfixes_union_region. */
+#define XCB_XFIXES_UNION_REGION 13
+
+/**
+ * @brief xcb_xfixes_union_region_request_t
+ **/
+typedef struct xcb_xfixes_union_region_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_xfixes_region_t source1;
+    xcb_xfixes_region_t source2;
+    xcb_xfixes_region_t destination;
+} xcb_xfixes_union_region_request_t;
+
+/** Opcode for xcb_xfixes_intersect_region. */
+#define XCB_XFIXES_INTERSECT_REGION 14
+
+/**
+ * @brief xcb_xfixes_intersect_region_request_t
+ **/
+typedef struct xcb_xfixes_intersect_region_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_xfixes_region_t source1;
+    xcb_xfixes_region_t source2;
+    xcb_xfixes_region_t destination;
+} xcb_xfixes_intersect_region_request_t;
+
+/** Opcode for xcb_xfixes_subtract_region. */
+#define XCB_XFIXES_SUBTRACT_REGION 15
+
+/**
+ * @brief xcb_xfixes_subtract_region_request_t
+ **/
+typedef struct xcb_xfixes_subtract_region_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_xfixes_region_t source1;
+    xcb_xfixes_region_t source2;
+    xcb_xfixes_region_t destination;
+} xcb_xfixes_subtract_region_request_t;
+
+/** Opcode for xcb_xfixes_invert_region. */
+#define XCB_XFIXES_INVERT_REGION 16
+
+/**
+ * @brief xcb_xfixes_invert_region_request_t
+ **/
+typedef struct xcb_xfixes_invert_region_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_xfixes_region_t source;
+    xcb_rectangle_t     bounds;
+    xcb_xfixes_region_t destination;
+} xcb_xfixes_invert_region_request_t;
+
+/** Opcode for xcb_xfixes_translate_region. */
+#define XCB_XFIXES_TRANSLATE_REGION 17
+
+/**
+ * @brief xcb_xfixes_translate_region_request_t
+ **/
+typedef struct xcb_xfixes_translate_region_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_xfixes_region_t region;
+    int16_t             dx;
+    int16_t             dy;
+} xcb_xfixes_translate_region_request_t;
+
+/** Opcode for xcb_xfixes_region_extents. */
+#define XCB_XFIXES_REGION_EXTENTS 18
+
+/**
+ * @brief xcb_xfixes_region_extents_request_t
+ **/
+typedef struct xcb_xfixes_region_extents_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_xfixes_region_t source;
+    xcb_xfixes_region_t destination;
+} xcb_xfixes_region_extents_request_t;
+
+/**
+ * @brief xcb_xfixes_fetch_region_cookie_t
+ **/
+typedef struct xcb_xfixes_fetch_region_cookie_t {
+    unsigned int sequence;
+} xcb_xfixes_fetch_region_cookie_t;
+
+/** Opcode for xcb_xfixes_fetch_region. */
+#define XCB_XFIXES_FETCH_REGION 19
+
+/**
+ * @brief xcb_xfixes_fetch_region_request_t
+ **/
+typedef struct xcb_xfixes_fetch_region_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_xfixes_region_t region;
+} xcb_xfixes_fetch_region_request_t;
+
+/**
+ * @brief xcb_xfixes_fetch_region_reply_t
+ **/
+typedef struct xcb_xfixes_fetch_region_reply_t {
+    uint8_t         response_type;
+    uint8_t         pad0;
+    uint16_t        sequence;
+    uint32_t        length;
+    xcb_rectangle_t extents;
+    uint8_t         pad1[16];
+} xcb_xfixes_fetch_region_reply_t;
+
+/** Opcode for xcb_xfixes_set_gc_clip_region. */
+#define XCB_XFIXES_SET_GC_CLIP_REGION 20
+
+/**
+ * @brief xcb_xfixes_set_gc_clip_region_request_t
+ **/
+typedef struct xcb_xfixes_set_gc_clip_region_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_gcontext_t      gc;
+    xcb_xfixes_region_t region;
+    int16_t             x_origin;
+    int16_t             y_origin;
+} xcb_xfixes_set_gc_clip_region_request_t;
+
+/** Opcode for xcb_xfixes_set_window_shape_region. */
+#define XCB_XFIXES_SET_WINDOW_SHAPE_REGION 21
+
+/**
+ * @brief xcb_xfixes_set_window_shape_region_request_t
+ **/
+typedef struct xcb_xfixes_set_window_shape_region_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_window_t        dest;
+    xcb_shape_kind_t    dest_kind;
+    uint8_t             pad0[3];
+    int16_t             x_offset;
+    int16_t             y_offset;
+    xcb_xfixes_region_t region;
+} xcb_xfixes_set_window_shape_region_request_t;
+
+/** Opcode for xcb_xfixes_set_picture_clip_region. */
+#define XCB_XFIXES_SET_PICTURE_CLIP_REGION 22
+
+/**
+ * @brief xcb_xfixes_set_picture_clip_region_request_t
+ **/
+typedef struct xcb_xfixes_set_picture_clip_region_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_render_picture_t picture;
+    xcb_xfixes_region_t  region;
+    int16_t              x_origin;
+    int16_t              y_origin;
+} xcb_xfixes_set_picture_clip_region_request_t;
+
+/** Opcode for xcb_xfixes_set_cursor_name. */
+#define XCB_XFIXES_SET_CURSOR_NAME 23
+
+/**
+ * @brief xcb_xfixes_set_cursor_name_request_t
+ **/
+typedef struct xcb_xfixes_set_cursor_name_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_cursor_t cursor;
+    uint16_t     nbytes;
+    uint8_t      pad0[2];
+} xcb_xfixes_set_cursor_name_request_t;
+
+/**
+ * @brief xcb_xfixes_get_cursor_name_cookie_t
+ **/
+typedef struct xcb_xfixes_get_cursor_name_cookie_t {
+    unsigned int sequence;
+} xcb_xfixes_get_cursor_name_cookie_t;
+
+/** Opcode for xcb_xfixes_get_cursor_name. */
+#define XCB_XFIXES_GET_CURSOR_NAME 24
+
+/**
+ * @brief xcb_xfixes_get_cursor_name_request_t
+ **/
+typedef struct xcb_xfixes_get_cursor_name_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_cursor_t cursor;
+} xcb_xfixes_get_cursor_name_request_t;
+
+/**
+ * @brief xcb_xfixes_get_cursor_name_reply_t
+ **/
+typedef struct xcb_xfixes_get_cursor_name_reply_t {
+    uint8_t    response_type;
+    uint8_t    pad0;
+    uint16_t   sequence;
+    uint32_t   length;
+    xcb_atom_t atom;
+    uint16_t   nbytes;
+    uint8_t    pad1[18];
+} xcb_xfixes_get_cursor_name_reply_t;
+
+/**
+ * @brief xcb_xfixes_get_cursor_image_and_name_cookie_t
+ **/
+typedef struct xcb_xfixes_get_cursor_image_and_name_cookie_t {
+    unsigned int sequence;
+} xcb_xfixes_get_cursor_image_and_name_cookie_t;
+
+/** Opcode for xcb_xfixes_get_cursor_image_and_name. */
+#define XCB_XFIXES_GET_CURSOR_IMAGE_AND_NAME 25
+
+/**
+ * @brief xcb_xfixes_get_cursor_image_and_name_request_t
+ **/
+typedef struct xcb_xfixes_get_cursor_image_and_name_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_xfixes_get_cursor_image_and_name_request_t;
+
+/**
+ * @brief xcb_xfixes_get_cursor_image_and_name_reply_t
+ **/
+typedef struct xcb_xfixes_get_cursor_image_and_name_reply_t {
+    uint8_t    response_type;
+    uint8_t    pad0;
+    uint16_t   sequence;
+    uint32_t   length;
+    int16_t    x;
+    int16_t    y;
+    uint16_t   width;
+    uint16_t   height;
+    uint16_t   xhot;
+    uint16_t   yhot;
+    uint32_t   cursor_serial;
+    xcb_atom_t cursor_atom;
+    uint16_t   nbytes;
+    uint8_t    pad1[2];
+} xcb_xfixes_get_cursor_image_and_name_reply_t;
+
+/** Opcode for xcb_xfixes_change_cursor. */
+#define XCB_XFIXES_CHANGE_CURSOR 26
+
+/**
+ * @brief xcb_xfixes_change_cursor_request_t
+ **/
+typedef struct xcb_xfixes_change_cursor_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_cursor_t source;
+    xcb_cursor_t destination;
+} xcb_xfixes_change_cursor_request_t;
+
+/** Opcode for xcb_xfixes_change_cursor_by_name. */
+#define XCB_XFIXES_CHANGE_CURSOR_BY_NAME 27
+
+/**
+ * @brief xcb_xfixes_change_cursor_by_name_request_t
+ **/
+typedef struct xcb_xfixes_change_cursor_by_name_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_cursor_t src;
+    uint16_t     nbytes;
+    uint8_t      pad0[2];
+} xcb_xfixes_change_cursor_by_name_request_t;
+
+/** Opcode for xcb_xfixes_expand_region. */
+#define XCB_XFIXES_EXPAND_REGION 28
+
+/**
+ * @brief xcb_xfixes_expand_region_request_t
+ **/
+typedef struct xcb_xfixes_expand_region_request_t {
+    uint8_t             major_opcode;
+    uint8_t             minor_opcode;
+    uint16_t            length;
+    xcb_xfixes_region_t source;
+    xcb_xfixes_region_t destination;
+    uint16_t            left;
+    uint16_t            right;
+    uint16_t            top;
+    uint16_t            bottom;
+} xcb_xfixes_expand_region_request_t;
+
+/** Opcode for xcb_xfixes_hide_cursor. */
+#define XCB_XFIXES_HIDE_CURSOR 29
+
+/**
+ * @brief xcb_xfixes_hide_cursor_request_t
+ **/
+typedef struct xcb_xfixes_hide_cursor_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_xfixes_hide_cursor_request_t;
+
+/** Opcode for xcb_xfixes_show_cursor. */
+#define XCB_XFIXES_SHOW_CURSOR 30
+
+/**
+ * @brief xcb_xfixes_show_cursor_request_t
+ **/
+typedef struct xcb_xfixes_show_cursor_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_xfixes_show_cursor_request_t;
+
+typedef uint32_t xcb_xfixes_barrier_t;
+
+/**
+ * @brief xcb_xfixes_barrier_iterator_t
+ **/
+typedef struct xcb_xfixes_barrier_iterator_t {
+    xcb_xfixes_barrier_t *data;
+    int                   rem;
+    int                   index;
+} xcb_xfixes_barrier_iterator_t;
+
+typedef enum xcb_xfixes_barrier_directions_t {
+    XCB_XFIXES_BARRIER_DIRECTIONS_POSITIVE_X = 1,
+    XCB_XFIXES_BARRIER_DIRECTIONS_POSITIVE_Y = 2,
+    XCB_XFIXES_BARRIER_DIRECTIONS_NEGATIVE_X = 4,
+    XCB_XFIXES_BARRIER_DIRECTIONS_NEGATIVE_Y = 8
+} xcb_xfixes_barrier_directions_t;
+
+/** Opcode for xcb_xfixes_create_pointer_barrier. */
+#define XCB_XFIXES_CREATE_POINTER_BARRIER 31
+
+/**
+ * @brief xcb_xfixes_create_pointer_barrier_request_t
+ **/
+typedef struct xcb_xfixes_create_pointer_barrier_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_xfixes_barrier_t barrier;
+    xcb_window_t         window;
+    uint16_t             x1;
+    uint16_t             y1;
+    uint16_t             x2;
+    uint16_t             y2;
+    uint32_t             directions;
+    uint8_t              pad0[2];
+    uint16_t             num_devices;
+} xcb_xfixes_create_pointer_barrier_request_t;
+
+/** Opcode for xcb_xfixes_delete_pointer_barrier. */
+#define XCB_XFIXES_DELETE_POINTER_BARRIER 32
+
+/**
+ * @brief xcb_xfixes_delete_pointer_barrier_request_t
+ **/
+typedef struct xcb_xfixes_delete_pointer_barrier_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    xcb_xfixes_barrier_t barrier;
+} xcb_xfixes_delete_pointer_barrier_request_t;
+
+typedef enum xcb_xfixes_client_disconnect_flags_t {
+    XCB_XFIXES_CLIENT_DISCONNECT_FLAGS_DEFAULT = 0,
+    XCB_XFIXES_CLIENT_DISCONNECT_FLAGS_TERMINATE = 1
+} xcb_xfixes_client_disconnect_flags_t;
+
+/** Opcode for xcb_xfixes_set_client_disconnect_mode. */
+#define XCB_XFIXES_SET_CLIENT_DISCONNECT_MODE 33
+
+/**
+ * @brief xcb_xfixes_set_client_disconnect_mode_request_t
+ **/
+typedef struct xcb_xfixes_set_client_disconnect_mode_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t disconnect_mode;
+} xcb_xfixes_set_client_disconnect_mode_request_t;
+
+/**
+ * @brief xcb_xfixes_get_client_disconnect_mode_cookie_t
+ **/
+typedef struct xcb_xfixes_get_client_disconnect_mode_cookie_t {
+    unsigned int sequence;
+} xcb_xfixes_get_client_disconnect_mode_cookie_t;
+
+/** Opcode for xcb_xfixes_get_client_disconnect_mode. */
+#define XCB_XFIXES_GET_CLIENT_DISCONNECT_MODE 34
+
+/**
+ * @brief xcb_xfixes_get_client_disconnect_mode_request_t
+ **/
+typedef struct xcb_xfixes_get_client_disconnect_mode_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_xfixes_get_client_disconnect_mode_request_t;
+
+/**
+ * @brief xcb_xfixes_get_client_disconnect_mode_reply_t
+ **/
+typedef struct xcb_xfixes_get_client_disconnect_mode_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t disconnect_mode;
+    uint8_t  pad1[20];
+} xcb_xfixes_get_client_disconnect_mode_reply_t;
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xfixes_query_version_cookie_t
+xcb_xfixes_query_version (xcb_connection_t *c,
+                          uint32_t          client_major_version,
+                          uint32_t          client_minor_version);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xfixes_query_version_cookie_t
+xcb_xfixes_query_version_unchecked (xcb_connection_t *c,
+                                    uint32_t          client_major_version,
+                                    uint32_t          client_minor_version);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xfixes_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xfixes_query_version_reply_t *
+xcb_xfixes_query_version_reply (xcb_connection_t                   *c,
+                                xcb_xfixes_query_version_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_change_save_set_checked (xcb_connection_t *c,
+                                    uint8_t           mode,
+                                    uint8_t           target,
+                                    uint8_t           map,
+                                    xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_change_save_set (xcb_connection_t *c,
+                            uint8_t           mode,
+                            uint8_t           target,
+                            uint8_t           map,
+                            xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_select_selection_input_checked (xcb_connection_t *c,
+                                           xcb_window_t      window,
+                                           xcb_atom_t        selection,
+                                           uint32_t          event_mask);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_select_selection_input (xcb_connection_t *c,
+                                   xcb_window_t      window,
+                                   xcb_atom_t        selection,
+                                   uint32_t          event_mask);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_select_cursor_input_checked (xcb_connection_t *c,
+                                        xcb_window_t      window,
+                                        uint32_t          event_mask);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_select_cursor_input (xcb_connection_t *c,
+                                xcb_window_t      window,
+                                uint32_t          event_mask);
+
+int
+xcb_xfixes_get_cursor_image_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xfixes_get_cursor_image_cookie_t
+xcb_xfixes_get_cursor_image (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xfixes_get_cursor_image_cookie_t
+xcb_xfixes_get_cursor_image_unchecked (xcb_connection_t *c);
+
+uint32_t *
+xcb_xfixes_get_cursor_image_cursor_image (const xcb_xfixes_get_cursor_image_reply_t *R);
+
+int
+xcb_xfixes_get_cursor_image_cursor_image_length (const xcb_xfixes_get_cursor_image_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_xfixes_get_cursor_image_cursor_image_end (const xcb_xfixes_get_cursor_image_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xfixes_get_cursor_image_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xfixes_get_cursor_image_reply_t *
+xcb_xfixes_get_cursor_image_reply (xcb_connection_t                      *c,
+                                   xcb_xfixes_get_cursor_image_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xfixes_region_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xfixes_region_t)
+ */
+void
+xcb_xfixes_region_next (xcb_xfixes_region_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xfixes_region_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xfixes_region_end (xcb_xfixes_region_iterator_t i);
+
+int
+xcb_xfixes_create_region_sizeof (const void  *_buffer,
+                                 uint32_t     rectangles_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_create_region_checked (xcb_connection_t      *c,
+                                  xcb_xfixes_region_t    region,
+                                  uint32_t               rectangles_len,
+                                  const xcb_rectangle_t *rectangles);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_create_region (xcb_connection_t      *c,
+                          xcb_xfixes_region_t    region,
+                          uint32_t               rectangles_len,
+                          const xcb_rectangle_t *rectangles);
+
+xcb_rectangle_t *
+xcb_xfixes_create_region_rectangles (const xcb_xfixes_create_region_request_t *R);
+
+int
+xcb_xfixes_create_region_rectangles_length (const xcb_xfixes_create_region_request_t *R);
+
+xcb_rectangle_iterator_t
+xcb_xfixes_create_region_rectangles_iterator (const xcb_xfixes_create_region_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_create_region_from_bitmap_checked (xcb_connection_t    *c,
+                                              xcb_xfixes_region_t  region,
+                                              xcb_pixmap_t         bitmap);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_create_region_from_bitmap (xcb_connection_t    *c,
+                                      xcb_xfixes_region_t  region,
+                                      xcb_pixmap_t         bitmap);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_create_region_from_window_checked (xcb_connection_t    *c,
+                                              xcb_xfixes_region_t  region,
+                                              xcb_window_t         window,
+                                              xcb_shape_kind_t     kind);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_create_region_from_window (xcb_connection_t    *c,
+                                      xcb_xfixes_region_t  region,
+                                      xcb_window_t         window,
+                                      xcb_shape_kind_t     kind);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_create_region_from_gc_checked (xcb_connection_t    *c,
+                                          xcb_xfixes_region_t  region,
+                                          xcb_gcontext_t       gc);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_create_region_from_gc (xcb_connection_t    *c,
+                                  xcb_xfixes_region_t  region,
+                                  xcb_gcontext_t       gc);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_create_region_from_picture_checked (xcb_connection_t     *c,
+                                               xcb_xfixes_region_t   region,
+                                               xcb_render_picture_t  picture);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_create_region_from_picture (xcb_connection_t     *c,
+                                       xcb_xfixes_region_t   region,
+                                       xcb_render_picture_t  picture);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_destroy_region_checked (xcb_connection_t    *c,
+                                   xcb_xfixes_region_t  region);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_destroy_region (xcb_connection_t    *c,
+                           xcb_xfixes_region_t  region);
+
+int
+xcb_xfixes_set_region_sizeof (const void  *_buffer,
+                              uint32_t     rectangles_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_set_region_checked (xcb_connection_t      *c,
+                               xcb_xfixes_region_t    region,
+                               uint32_t               rectangles_len,
+                               const xcb_rectangle_t *rectangles);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_set_region (xcb_connection_t      *c,
+                       xcb_xfixes_region_t    region,
+                       uint32_t               rectangles_len,
+                       const xcb_rectangle_t *rectangles);
+
+xcb_rectangle_t *
+xcb_xfixes_set_region_rectangles (const xcb_xfixes_set_region_request_t *R);
+
+int
+xcb_xfixes_set_region_rectangles_length (const xcb_xfixes_set_region_request_t *R);
+
+xcb_rectangle_iterator_t
+xcb_xfixes_set_region_rectangles_iterator (const xcb_xfixes_set_region_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_copy_region_checked (xcb_connection_t    *c,
+                                xcb_xfixes_region_t  source,
+                                xcb_xfixes_region_t  destination);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_copy_region (xcb_connection_t    *c,
+                        xcb_xfixes_region_t  source,
+                        xcb_xfixes_region_t  destination);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_union_region_checked (xcb_connection_t    *c,
+                                 xcb_xfixes_region_t  source1,
+                                 xcb_xfixes_region_t  source2,
+                                 xcb_xfixes_region_t  destination);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_union_region (xcb_connection_t    *c,
+                         xcb_xfixes_region_t  source1,
+                         xcb_xfixes_region_t  source2,
+                         xcb_xfixes_region_t  destination);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_intersect_region_checked (xcb_connection_t    *c,
+                                     xcb_xfixes_region_t  source1,
+                                     xcb_xfixes_region_t  source2,
+                                     xcb_xfixes_region_t  destination);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_intersect_region (xcb_connection_t    *c,
+                             xcb_xfixes_region_t  source1,
+                             xcb_xfixes_region_t  source2,
+                             xcb_xfixes_region_t  destination);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_subtract_region_checked (xcb_connection_t    *c,
+                                    xcb_xfixes_region_t  source1,
+                                    xcb_xfixes_region_t  source2,
+                                    xcb_xfixes_region_t  destination);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_subtract_region (xcb_connection_t    *c,
+                            xcb_xfixes_region_t  source1,
+                            xcb_xfixes_region_t  source2,
+                            xcb_xfixes_region_t  destination);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_invert_region_checked (xcb_connection_t    *c,
+                                  xcb_xfixes_region_t  source,
+                                  xcb_rectangle_t      bounds,
+                                  xcb_xfixes_region_t  destination);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_invert_region (xcb_connection_t    *c,
+                          xcb_xfixes_region_t  source,
+                          xcb_rectangle_t      bounds,
+                          xcb_xfixes_region_t  destination);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_translate_region_checked (xcb_connection_t    *c,
+                                     xcb_xfixes_region_t  region,
+                                     int16_t              dx,
+                                     int16_t              dy);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_translate_region (xcb_connection_t    *c,
+                             xcb_xfixes_region_t  region,
+                             int16_t              dx,
+                             int16_t              dy);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_region_extents_checked (xcb_connection_t    *c,
+                                   xcb_xfixes_region_t  source,
+                                   xcb_xfixes_region_t  destination);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_region_extents (xcb_connection_t    *c,
+                           xcb_xfixes_region_t  source,
+                           xcb_xfixes_region_t  destination);
+
+int
+xcb_xfixes_fetch_region_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xfixes_fetch_region_cookie_t
+xcb_xfixes_fetch_region (xcb_connection_t    *c,
+                         xcb_xfixes_region_t  region);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xfixes_fetch_region_cookie_t
+xcb_xfixes_fetch_region_unchecked (xcb_connection_t    *c,
+                                   xcb_xfixes_region_t  region);
+
+xcb_rectangle_t *
+xcb_xfixes_fetch_region_rectangles (const xcb_xfixes_fetch_region_reply_t *R);
+
+int
+xcb_xfixes_fetch_region_rectangles_length (const xcb_xfixes_fetch_region_reply_t *R);
+
+xcb_rectangle_iterator_t
+xcb_xfixes_fetch_region_rectangles_iterator (const xcb_xfixes_fetch_region_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xfixes_fetch_region_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xfixes_fetch_region_reply_t *
+xcb_xfixes_fetch_region_reply (xcb_connection_t                  *c,
+                               xcb_xfixes_fetch_region_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_set_gc_clip_region_checked (xcb_connection_t    *c,
+                                       xcb_gcontext_t       gc,
+                                       xcb_xfixes_region_t  region,
+                                       int16_t              x_origin,
+                                       int16_t              y_origin);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_set_gc_clip_region (xcb_connection_t    *c,
+                               xcb_gcontext_t       gc,
+                               xcb_xfixes_region_t  region,
+                               int16_t              x_origin,
+                               int16_t              y_origin);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_set_window_shape_region_checked (xcb_connection_t    *c,
+                                            xcb_window_t         dest,
+                                            xcb_shape_kind_t     dest_kind,
+                                            int16_t              x_offset,
+                                            int16_t              y_offset,
+                                            xcb_xfixes_region_t  region);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_set_window_shape_region (xcb_connection_t    *c,
+                                    xcb_window_t         dest,
+                                    xcb_shape_kind_t     dest_kind,
+                                    int16_t              x_offset,
+                                    int16_t              y_offset,
+                                    xcb_xfixes_region_t  region);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_set_picture_clip_region_checked (xcb_connection_t     *c,
+                                            xcb_render_picture_t  picture,
+                                            xcb_xfixes_region_t   region,
+                                            int16_t               x_origin,
+                                            int16_t               y_origin);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_set_picture_clip_region (xcb_connection_t     *c,
+                                    xcb_render_picture_t  picture,
+                                    xcb_xfixes_region_t   region,
+                                    int16_t               x_origin,
+                                    int16_t               y_origin);
+
+int
+xcb_xfixes_set_cursor_name_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_set_cursor_name_checked (xcb_connection_t *c,
+                                    xcb_cursor_t      cursor,
+                                    uint16_t          nbytes,
+                                    const char       *name);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_set_cursor_name (xcb_connection_t *c,
+                            xcb_cursor_t      cursor,
+                            uint16_t          nbytes,
+                            const char       *name);
+
+char *
+xcb_xfixes_set_cursor_name_name (const xcb_xfixes_set_cursor_name_request_t *R);
+
+int
+xcb_xfixes_set_cursor_name_name_length (const xcb_xfixes_set_cursor_name_request_t *R);
+
+xcb_generic_iterator_t
+xcb_xfixes_set_cursor_name_name_end (const xcb_xfixes_set_cursor_name_request_t *R);
+
+int
+xcb_xfixes_get_cursor_name_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xfixes_get_cursor_name_cookie_t
+xcb_xfixes_get_cursor_name (xcb_connection_t *c,
+                            xcb_cursor_t      cursor);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xfixes_get_cursor_name_cookie_t
+xcb_xfixes_get_cursor_name_unchecked (xcb_connection_t *c,
+                                      xcb_cursor_t      cursor);
+
+char *
+xcb_xfixes_get_cursor_name_name (const xcb_xfixes_get_cursor_name_reply_t *R);
+
+int
+xcb_xfixes_get_cursor_name_name_length (const xcb_xfixes_get_cursor_name_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_xfixes_get_cursor_name_name_end (const xcb_xfixes_get_cursor_name_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xfixes_get_cursor_name_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xfixes_get_cursor_name_reply_t *
+xcb_xfixes_get_cursor_name_reply (xcb_connection_t                     *c,
+                                  xcb_xfixes_get_cursor_name_cookie_t   cookie  /**< */,
+                                  xcb_generic_error_t                 **e);
+
+int
+xcb_xfixes_get_cursor_image_and_name_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xfixes_get_cursor_image_and_name_cookie_t
+xcb_xfixes_get_cursor_image_and_name (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xfixes_get_cursor_image_and_name_cookie_t
+xcb_xfixes_get_cursor_image_and_name_unchecked (xcb_connection_t *c);
+
+uint32_t *
+xcb_xfixes_get_cursor_image_and_name_cursor_image (const xcb_xfixes_get_cursor_image_and_name_reply_t *R);
+
+int
+xcb_xfixes_get_cursor_image_and_name_cursor_image_length (const xcb_xfixes_get_cursor_image_and_name_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_xfixes_get_cursor_image_and_name_cursor_image_end (const xcb_xfixes_get_cursor_image_and_name_reply_t *R);
+
+char *
+xcb_xfixes_get_cursor_image_and_name_name (const xcb_xfixes_get_cursor_image_and_name_reply_t *R);
+
+int
+xcb_xfixes_get_cursor_image_and_name_name_length (const xcb_xfixes_get_cursor_image_and_name_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_xfixes_get_cursor_image_and_name_name_end (const xcb_xfixes_get_cursor_image_and_name_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xfixes_get_cursor_image_and_name_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xfixes_get_cursor_image_and_name_reply_t *
+xcb_xfixes_get_cursor_image_and_name_reply (xcb_connection_t                               *c,
+                                            xcb_xfixes_get_cursor_image_and_name_cookie_t   cookie  /**< */,
+                                            xcb_generic_error_t                           **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_change_cursor_checked (xcb_connection_t *c,
+                                  xcb_cursor_t      source,
+                                  xcb_cursor_t      destination);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_change_cursor (xcb_connection_t *c,
+                          xcb_cursor_t      source,
+                          xcb_cursor_t      destination);
+
+int
+xcb_xfixes_change_cursor_by_name_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_change_cursor_by_name_checked (xcb_connection_t *c,
+                                          xcb_cursor_t      src,
+                                          uint16_t          nbytes,
+                                          const char       *name);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_change_cursor_by_name (xcb_connection_t *c,
+                                  xcb_cursor_t      src,
+                                  uint16_t          nbytes,
+                                  const char       *name);
+
+char *
+xcb_xfixes_change_cursor_by_name_name (const xcb_xfixes_change_cursor_by_name_request_t *R);
+
+int
+xcb_xfixes_change_cursor_by_name_name_length (const xcb_xfixes_change_cursor_by_name_request_t *R);
+
+xcb_generic_iterator_t
+xcb_xfixes_change_cursor_by_name_name_end (const xcb_xfixes_change_cursor_by_name_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_expand_region_checked (xcb_connection_t    *c,
+                                  xcb_xfixes_region_t  source,
+                                  xcb_xfixes_region_t  destination,
+                                  uint16_t             left,
+                                  uint16_t             right,
+                                  uint16_t             top,
+                                  uint16_t             bottom);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_expand_region (xcb_connection_t    *c,
+                          xcb_xfixes_region_t  source,
+                          xcb_xfixes_region_t  destination,
+                          uint16_t             left,
+                          uint16_t             right,
+                          uint16_t             top,
+                          uint16_t             bottom);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_hide_cursor_checked (xcb_connection_t *c,
+                                xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_hide_cursor (xcb_connection_t *c,
+                        xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_show_cursor_checked (xcb_connection_t *c,
+                                xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_show_cursor (xcb_connection_t *c,
+                        xcb_window_t      window);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xfixes_barrier_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xfixes_barrier_t)
+ */
+void
+xcb_xfixes_barrier_next (xcb_xfixes_barrier_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xfixes_barrier_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xfixes_barrier_end (xcb_xfixes_barrier_iterator_t i);
+
+int
+xcb_xfixes_create_pointer_barrier_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_create_pointer_barrier_checked (xcb_connection_t     *c,
+                                           xcb_xfixes_barrier_t  barrier,
+                                           xcb_window_t          window,
+                                           uint16_t              x1,
+                                           uint16_t              y1,
+                                           uint16_t              x2,
+                                           uint16_t              y2,
+                                           uint32_t              directions,
+                                           uint16_t              num_devices,
+                                           const uint16_t       *devices);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_create_pointer_barrier (xcb_connection_t     *c,
+                                   xcb_xfixes_barrier_t  barrier,
+                                   xcb_window_t          window,
+                                   uint16_t              x1,
+                                   uint16_t              y1,
+                                   uint16_t              x2,
+                                   uint16_t              y2,
+                                   uint32_t              directions,
+                                   uint16_t              num_devices,
+                                   const uint16_t       *devices);
+
+uint16_t *
+xcb_xfixes_create_pointer_barrier_devices (const xcb_xfixes_create_pointer_barrier_request_t *R);
+
+int
+xcb_xfixes_create_pointer_barrier_devices_length (const xcb_xfixes_create_pointer_barrier_request_t *R);
+
+xcb_generic_iterator_t
+xcb_xfixes_create_pointer_barrier_devices_end (const xcb_xfixes_create_pointer_barrier_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_delete_pointer_barrier_checked (xcb_connection_t     *c,
+                                           xcb_xfixes_barrier_t  barrier);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_delete_pointer_barrier (xcb_connection_t     *c,
+                                   xcb_xfixes_barrier_t  barrier);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xfixes_set_client_disconnect_mode_checked (xcb_connection_t *c,
+                                               uint32_t          disconnect_mode);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xfixes_set_client_disconnect_mode (xcb_connection_t *c,
+                                       uint32_t          disconnect_mode);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xfixes_get_client_disconnect_mode_cookie_t
+xcb_xfixes_get_client_disconnect_mode (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xfixes_get_client_disconnect_mode_cookie_t
+xcb_xfixes_get_client_disconnect_mode_unchecked (xcb_connection_t *c);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xfixes_get_client_disconnect_mode_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xfixes_get_client_disconnect_mode_reply_t *
+xcb_xfixes_get_client_disconnect_mode_reply (xcb_connection_t                                *c,
+                                             xcb_xfixes_get_client_disconnect_mode_cookie_t   cookie  /**< */,
+                                             xcb_generic_error_t                            **e);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/xinerama.h b/depends/libxcb/include/xcb/xinerama.h
new file mode 100644
index 0000000..17a8212
--- /dev/null
+++ b/depends/libxcb/include/xcb/xinerama.h
@@ -0,0 +1,557 @@
+/*
+ * This file generated automatically from xinerama.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_Xinerama_API XCB Xinerama API
+ * @brief Xinerama XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __XINERAMA_H
+#define __XINERAMA_H
+
+#include "xcb.h"
+#include "xproto.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_XINERAMA_MAJOR_VERSION 1
+#define XCB_XINERAMA_MINOR_VERSION 1
+
+extern xcb_extension_t xcb_xinerama_id;
+
+/**
+ * @brief xcb_xinerama_screen_info_t
+ **/
+typedef struct xcb_xinerama_screen_info_t {
+    int16_t  x_org;
+    int16_t  y_org;
+    uint16_t width;
+    uint16_t height;
+} xcb_xinerama_screen_info_t;
+
+/**
+ * @brief xcb_xinerama_screen_info_iterator_t
+ **/
+typedef struct xcb_xinerama_screen_info_iterator_t {
+    xcb_xinerama_screen_info_t *data;
+    int                         rem;
+    int                         index;
+} xcb_xinerama_screen_info_iterator_t;
+
+/**
+ * @brief xcb_xinerama_query_version_cookie_t
+ **/
+typedef struct xcb_xinerama_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_xinerama_query_version_cookie_t;
+
+/** Opcode for xcb_xinerama_query_version. */
+#define XCB_XINERAMA_QUERY_VERSION 0
+
+/**
+ * @brief xcb_xinerama_query_version_request_t
+ **/
+typedef struct xcb_xinerama_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  major;
+    uint8_t  minor;
+} xcb_xinerama_query_version_request_t;
+
+/**
+ * @brief xcb_xinerama_query_version_reply_t
+ **/
+typedef struct xcb_xinerama_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t major;
+    uint16_t minor;
+} xcb_xinerama_query_version_reply_t;
+
+/**
+ * @brief xcb_xinerama_get_state_cookie_t
+ **/
+typedef struct xcb_xinerama_get_state_cookie_t {
+    unsigned int sequence;
+} xcb_xinerama_get_state_cookie_t;
+
+/** Opcode for xcb_xinerama_get_state. */
+#define XCB_XINERAMA_GET_STATE 1
+
+/**
+ * @brief xcb_xinerama_get_state_request_t
+ **/
+typedef struct xcb_xinerama_get_state_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_xinerama_get_state_request_t;
+
+/**
+ * @brief xcb_xinerama_get_state_reply_t
+ **/
+typedef struct xcb_xinerama_get_state_reply_t {
+    uint8_t      response_type;
+    uint8_t      state;
+    uint16_t     sequence;
+    uint32_t     length;
+    xcb_window_t window;
+} xcb_xinerama_get_state_reply_t;
+
+/**
+ * @brief xcb_xinerama_get_screen_count_cookie_t
+ **/
+typedef struct xcb_xinerama_get_screen_count_cookie_t {
+    unsigned int sequence;
+} xcb_xinerama_get_screen_count_cookie_t;
+
+/** Opcode for xcb_xinerama_get_screen_count. */
+#define XCB_XINERAMA_GET_SCREEN_COUNT 2
+
+/**
+ * @brief xcb_xinerama_get_screen_count_request_t
+ **/
+typedef struct xcb_xinerama_get_screen_count_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_xinerama_get_screen_count_request_t;
+
+/**
+ * @brief xcb_xinerama_get_screen_count_reply_t
+ **/
+typedef struct xcb_xinerama_get_screen_count_reply_t {
+    uint8_t      response_type;
+    uint8_t      screen_count;
+    uint16_t     sequence;
+    uint32_t     length;
+    xcb_window_t window;
+} xcb_xinerama_get_screen_count_reply_t;
+
+/**
+ * @brief xcb_xinerama_get_screen_size_cookie_t
+ **/
+typedef struct xcb_xinerama_get_screen_size_cookie_t {
+    unsigned int sequence;
+} xcb_xinerama_get_screen_size_cookie_t;
+
+/** Opcode for xcb_xinerama_get_screen_size. */
+#define XCB_XINERAMA_GET_SCREEN_SIZE 3
+
+/**
+ * @brief xcb_xinerama_get_screen_size_request_t
+ **/
+typedef struct xcb_xinerama_get_screen_size_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    uint32_t     screen;
+} xcb_xinerama_get_screen_size_request_t;
+
+/**
+ * @brief xcb_xinerama_get_screen_size_reply_t
+ **/
+typedef struct xcb_xinerama_get_screen_size_reply_t {
+    uint8_t      response_type;
+    uint8_t      pad0;
+    uint16_t     sequence;
+    uint32_t     length;
+    uint32_t     width;
+    uint32_t     height;
+    xcb_window_t window;
+    uint32_t     screen;
+} xcb_xinerama_get_screen_size_reply_t;
+
+/**
+ * @brief xcb_xinerama_is_active_cookie_t
+ **/
+typedef struct xcb_xinerama_is_active_cookie_t {
+    unsigned int sequence;
+} xcb_xinerama_is_active_cookie_t;
+
+/** Opcode for xcb_xinerama_is_active. */
+#define XCB_XINERAMA_IS_ACTIVE 4
+
+/**
+ * @brief xcb_xinerama_is_active_request_t
+ **/
+typedef struct xcb_xinerama_is_active_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_xinerama_is_active_request_t;
+
+/**
+ * @brief xcb_xinerama_is_active_reply_t
+ **/
+typedef struct xcb_xinerama_is_active_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t state;
+} xcb_xinerama_is_active_reply_t;
+
+/**
+ * @brief xcb_xinerama_query_screens_cookie_t
+ **/
+typedef struct xcb_xinerama_query_screens_cookie_t {
+    unsigned int sequence;
+} xcb_xinerama_query_screens_cookie_t;
+
+/** Opcode for xcb_xinerama_query_screens. */
+#define XCB_XINERAMA_QUERY_SCREENS 5
+
+/**
+ * @brief xcb_xinerama_query_screens_request_t
+ **/
+typedef struct xcb_xinerama_query_screens_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_xinerama_query_screens_request_t;
+
+/**
+ * @brief xcb_xinerama_query_screens_reply_t
+ **/
+typedef struct xcb_xinerama_query_screens_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t number;
+    uint8_t  pad1[20];
+} xcb_xinerama_query_screens_reply_t;
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xinerama_screen_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xinerama_screen_info_t)
+ */
+void
+xcb_xinerama_screen_info_next (xcb_xinerama_screen_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xinerama_screen_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xinerama_screen_info_end (xcb_xinerama_screen_info_iterator_t i);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xinerama_query_version_cookie_t
+xcb_xinerama_query_version (xcb_connection_t *c,
+                            uint8_t           major,
+                            uint8_t           minor);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xinerama_query_version_cookie_t
+xcb_xinerama_query_version_unchecked (xcb_connection_t *c,
+                                      uint8_t           major,
+                                      uint8_t           minor);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xinerama_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xinerama_query_version_reply_t *
+xcb_xinerama_query_version_reply (xcb_connection_t                     *c,
+                                  xcb_xinerama_query_version_cookie_t   cookie  /**< */,
+                                  xcb_generic_error_t                 **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xinerama_get_state_cookie_t
+xcb_xinerama_get_state (xcb_connection_t *c,
+                        xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xinerama_get_state_cookie_t
+xcb_xinerama_get_state_unchecked (xcb_connection_t *c,
+                                  xcb_window_t      window);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xinerama_get_state_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xinerama_get_state_reply_t *
+xcb_xinerama_get_state_reply (xcb_connection_t                 *c,
+                              xcb_xinerama_get_state_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xinerama_get_screen_count_cookie_t
+xcb_xinerama_get_screen_count (xcb_connection_t *c,
+                               xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xinerama_get_screen_count_cookie_t
+xcb_xinerama_get_screen_count_unchecked (xcb_connection_t *c,
+                                         xcb_window_t      window);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xinerama_get_screen_count_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xinerama_get_screen_count_reply_t *
+xcb_xinerama_get_screen_count_reply (xcb_connection_t                        *c,
+                                     xcb_xinerama_get_screen_count_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xinerama_get_screen_size_cookie_t
+xcb_xinerama_get_screen_size (xcb_connection_t *c,
+                              xcb_window_t      window,
+                              uint32_t          screen);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xinerama_get_screen_size_cookie_t
+xcb_xinerama_get_screen_size_unchecked (xcb_connection_t *c,
+                                        xcb_window_t      window,
+                                        uint32_t          screen);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xinerama_get_screen_size_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xinerama_get_screen_size_reply_t *
+xcb_xinerama_get_screen_size_reply (xcb_connection_t                       *c,
+                                    xcb_xinerama_get_screen_size_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xinerama_is_active_cookie_t
+xcb_xinerama_is_active (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xinerama_is_active_cookie_t
+xcb_xinerama_is_active_unchecked (xcb_connection_t *c);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xinerama_is_active_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xinerama_is_active_reply_t *
+xcb_xinerama_is_active_reply (xcb_connection_t                 *c,
+                              xcb_xinerama_is_active_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+int
+xcb_xinerama_query_screens_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xinerama_query_screens_cookie_t
+xcb_xinerama_query_screens (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xinerama_query_screens_cookie_t
+xcb_xinerama_query_screens_unchecked (xcb_connection_t *c);
+
+xcb_xinerama_screen_info_t *
+xcb_xinerama_query_screens_screen_info (const xcb_xinerama_query_screens_reply_t *R);
+
+int
+xcb_xinerama_query_screens_screen_info_length (const xcb_xinerama_query_screens_reply_t *R);
+
+xcb_xinerama_screen_info_iterator_t
+xcb_xinerama_query_screens_screen_info_iterator (const xcb_xinerama_query_screens_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xinerama_query_screens_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xinerama_query_screens_reply_t *
+xcb_xinerama_query_screens_reply (xcb_connection_t                     *c,
+                                  xcb_xinerama_query_screens_cookie_t   cookie  /**< */,
+                                  xcb_generic_error_t                 **e);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/xinput.h b/depends/libxcb/include/xcb/xinput.h
new file mode 100644
index 0000000..2e40be1
--- /dev/null
+++ b/depends/libxcb/include/xcb/xinput.h
@@ -0,0 +1,9732 @@
+/*
+ * This file generated automatically from xinput.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_Input_API XCB Input API
+ * @brief Input XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __XINPUT_H
+#define __XINPUT_H
+
+#include "xcb.h"
+#include "xfixes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_INPUT_MAJOR_VERSION 2
+#define XCB_INPUT_MINOR_VERSION 4
+
+extern xcb_extension_t xcb_input_id;
+
+typedef uint32_t xcb_input_event_class_t;
+
+/**
+ * @brief xcb_input_event_class_iterator_t
+ **/
+typedef struct xcb_input_event_class_iterator_t {
+    xcb_input_event_class_t *data;
+    int                      rem;
+    int                      index;
+} xcb_input_event_class_iterator_t;
+
+typedef uint8_t xcb_input_key_code_t;
+
+/**
+ * @brief xcb_input_key_code_iterator_t
+ **/
+typedef struct xcb_input_key_code_iterator_t {
+    xcb_input_key_code_t *data;
+    int                   rem;
+    int                   index;
+} xcb_input_key_code_iterator_t;
+
+typedef uint16_t xcb_input_device_id_t;
+
+/**
+ * @brief xcb_input_device_id_iterator_t
+ **/
+typedef struct xcb_input_device_id_iterator_t {
+    xcb_input_device_id_t *data;
+    int                    rem;
+    int                    index;
+} xcb_input_device_id_iterator_t;
+
+typedef int32_t xcb_input_fp1616_t;
+
+/**
+ * @brief xcb_input_fp1616_iterator_t
+ **/
+typedef struct xcb_input_fp1616_iterator_t {
+    xcb_input_fp1616_t *data;
+    int                 rem;
+    int                 index;
+} xcb_input_fp1616_iterator_t;
+
+/**
+ * @brief xcb_input_fp3232_t
+ **/
+typedef struct xcb_input_fp3232_t {
+    int32_t  integral;
+    uint32_t frac;
+} xcb_input_fp3232_t;
+
+/**
+ * @brief xcb_input_fp3232_iterator_t
+ **/
+typedef struct xcb_input_fp3232_iterator_t {
+    xcb_input_fp3232_t *data;
+    int                 rem;
+    int                 index;
+} xcb_input_fp3232_iterator_t;
+
+/**
+ * @brief xcb_input_get_extension_version_cookie_t
+ **/
+typedef struct xcb_input_get_extension_version_cookie_t {
+    unsigned int sequence;
+} xcb_input_get_extension_version_cookie_t;
+
+/** Opcode for xcb_input_get_extension_version. */
+#define XCB_INPUT_GET_EXTENSION_VERSION 1
+
+/**
+ * @brief xcb_input_get_extension_version_request_t
+ **/
+typedef struct xcb_input_get_extension_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint16_t name_len;
+    uint8_t  pad0[2];
+} xcb_input_get_extension_version_request_t;
+
+/**
+ * @brief xcb_input_get_extension_version_reply_t
+ **/
+typedef struct xcb_input_get_extension_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t server_major;
+    uint16_t server_minor;
+    uint8_t  present;
+    uint8_t  pad0[19];
+} xcb_input_get_extension_version_reply_t;
+
+typedef enum xcb_input_device_use_t {
+    XCB_INPUT_DEVICE_USE_IS_X_POINTER = 0,
+    XCB_INPUT_DEVICE_USE_IS_X_KEYBOARD = 1,
+    XCB_INPUT_DEVICE_USE_IS_X_EXTENSION_DEVICE = 2,
+    XCB_INPUT_DEVICE_USE_IS_X_EXTENSION_KEYBOARD = 3,
+    XCB_INPUT_DEVICE_USE_IS_X_EXTENSION_POINTER = 4
+} xcb_input_device_use_t;
+
+typedef enum xcb_input_input_class_t {
+    XCB_INPUT_INPUT_CLASS_KEY = 0,
+    XCB_INPUT_INPUT_CLASS_BUTTON = 1,
+    XCB_INPUT_INPUT_CLASS_VALUATOR = 2,
+    XCB_INPUT_INPUT_CLASS_FEEDBACK = 3,
+    XCB_INPUT_INPUT_CLASS_PROXIMITY = 4,
+    XCB_INPUT_INPUT_CLASS_FOCUS = 5,
+    XCB_INPUT_INPUT_CLASS_OTHER = 6
+} xcb_input_input_class_t;
+
+typedef enum xcb_input_valuator_mode_t {
+    XCB_INPUT_VALUATOR_MODE_RELATIVE = 0,
+    XCB_INPUT_VALUATOR_MODE_ABSOLUTE = 1
+} xcb_input_valuator_mode_t;
+
+/**
+ * @brief xcb_input_device_info_t
+ **/
+typedef struct xcb_input_device_info_t {
+    xcb_atom_t device_type;
+    uint8_t    device_id;
+    uint8_t    num_class_info;
+    uint8_t    device_use;
+    uint8_t    pad0;
+} xcb_input_device_info_t;
+
+/**
+ * @brief xcb_input_device_info_iterator_t
+ **/
+typedef struct xcb_input_device_info_iterator_t {
+    xcb_input_device_info_t *data;
+    int                      rem;
+    int                      index;
+} xcb_input_device_info_iterator_t;
+
+/**
+ * @brief xcb_input_key_info_t
+ **/
+typedef struct xcb_input_key_info_t {
+    uint8_t              class_id;
+    uint8_t              len;
+    xcb_input_key_code_t min_keycode;
+    xcb_input_key_code_t max_keycode;
+    uint16_t             num_keys;
+    uint8_t              pad0[2];
+} xcb_input_key_info_t;
+
+/**
+ * @brief xcb_input_key_info_iterator_t
+ **/
+typedef struct xcb_input_key_info_iterator_t {
+    xcb_input_key_info_t *data;
+    int                   rem;
+    int                   index;
+} xcb_input_key_info_iterator_t;
+
+/**
+ * @brief xcb_input_button_info_t
+ **/
+typedef struct xcb_input_button_info_t {
+    uint8_t  class_id;
+    uint8_t  len;
+    uint16_t num_buttons;
+} xcb_input_button_info_t;
+
+/**
+ * @brief xcb_input_button_info_iterator_t
+ **/
+typedef struct xcb_input_button_info_iterator_t {
+    xcb_input_button_info_t *data;
+    int                      rem;
+    int                      index;
+} xcb_input_button_info_iterator_t;
+
+/**
+ * @brief xcb_input_axis_info_t
+ **/
+typedef struct xcb_input_axis_info_t {
+    uint32_t resolution;
+    int32_t  minimum;
+    int32_t  maximum;
+} xcb_input_axis_info_t;
+
+/**
+ * @brief xcb_input_axis_info_iterator_t
+ **/
+typedef struct xcb_input_axis_info_iterator_t {
+    xcb_input_axis_info_t *data;
+    int                    rem;
+    int                    index;
+} xcb_input_axis_info_iterator_t;
+
+/**
+ * @brief xcb_input_valuator_info_t
+ **/
+typedef struct xcb_input_valuator_info_t {
+    uint8_t  class_id;
+    uint8_t  len;
+    uint8_t  axes_len;
+    uint8_t  mode;
+    uint32_t motion_size;
+} xcb_input_valuator_info_t;
+
+/**
+ * @brief xcb_input_valuator_info_iterator_t
+ **/
+typedef struct xcb_input_valuator_info_iterator_t {
+    xcb_input_valuator_info_t *data;
+    int                        rem;
+    int                        index;
+} xcb_input_valuator_info_iterator_t;
+
+/**
+ * @brief xcb_input_input_info_info_t
+ **/
+typedef struct xcb_input_input_info_info_t {
+    struct {
+        xcb_input_key_code_t   min_keycode;
+        xcb_input_key_code_t   max_keycode;
+        uint16_t               num_keys;
+        uint8_t                pad0[2];
+    } key;
+    struct {
+        uint16_t               num_buttons;
+    } button;
+    struct {
+        uint8_t                axes_len;
+        uint8_t                mode;
+        uint32_t               motion_size;
+        xcb_input_axis_info_t *axes;
+    } valuator;
+} xcb_input_input_info_info_t;
+
+/**
+ * @brief xcb_input_input_info_t
+ **/
+typedef struct xcb_input_input_info_t {
+    uint8_t class_id;
+    uint8_t len;
+} xcb_input_input_info_t;
+
+void *
+xcb_input_input_info_info (const xcb_input_input_info_t *R);
+
+/**
+ * @brief xcb_input_input_info_iterator_t
+ **/
+typedef struct xcb_input_input_info_iterator_t {
+    xcb_input_input_info_t *data;
+    int                     rem;
+    int                     index;
+} xcb_input_input_info_iterator_t;
+
+/**
+ * @brief xcb_input_device_name_t
+ **/
+typedef struct xcb_input_device_name_t {
+    uint8_t len;
+} xcb_input_device_name_t;
+
+/**
+ * @brief xcb_input_device_name_iterator_t
+ **/
+typedef struct xcb_input_device_name_iterator_t {
+    xcb_input_device_name_t *data;
+    int                      rem;
+    int                      index;
+} xcb_input_device_name_iterator_t;
+
+/**
+ * @brief xcb_input_list_input_devices_cookie_t
+ **/
+typedef struct xcb_input_list_input_devices_cookie_t {
+    unsigned int sequence;
+} xcb_input_list_input_devices_cookie_t;
+
+/** Opcode for xcb_input_list_input_devices. */
+#define XCB_INPUT_LIST_INPUT_DEVICES 2
+
+/**
+ * @brief xcb_input_list_input_devices_request_t
+ **/
+typedef struct xcb_input_list_input_devices_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_input_list_input_devices_request_t;
+
+/**
+ * @brief xcb_input_list_input_devices_reply_t
+ **/
+typedef struct xcb_input_list_input_devices_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  devices_len;
+    uint8_t  pad0[23];
+} xcb_input_list_input_devices_reply_t;
+
+typedef uint8_t xcb_input_event_type_base_t;
+
+/**
+ * @brief xcb_input_event_type_base_iterator_t
+ **/
+typedef struct xcb_input_event_type_base_iterator_t {
+    xcb_input_event_type_base_t *data;
+    int                          rem;
+    int                          index;
+} xcb_input_event_type_base_iterator_t;
+
+/**
+ * @brief xcb_input_input_class_info_t
+ **/
+typedef struct xcb_input_input_class_info_t {
+    uint8_t                     class_id;
+    xcb_input_event_type_base_t event_type_base;
+} xcb_input_input_class_info_t;
+
+/**
+ * @brief xcb_input_input_class_info_iterator_t
+ **/
+typedef struct xcb_input_input_class_info_iterator_t {
+    xcb_input_input_class_info_t *data;
+    int                           rem;
+    int                           index;
+} xcb_input_input_class_info_iterator_t;
+
+/**
+ * @brief xcb_input_open_device_cookie_t
+ **/
+typedef struct xcb_input_open_device_cookie_t {
+    unsigned int sequence;
+} xcb_input_open_device_cookie_t;
+
+/** Opcode for xcb_input_open_device. */
+#define XCB_INPUT_OPEN_DEVICE 3
+
+/**
+ * @brief xcb_input_open_device_request_t
+ **/
+typedef struct xcb_input_open_device_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  device_id;
+    uint8_t  pad0[3];
+} xcb_input_open_device_request_t;
+
+/**
+ * @brief xcb_input_open_device_reply_t
+ **/
+typedef struct xcb_input_open_device_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  num_classes;
+    uint8_t  pad0[23];
+} xcb_input_open_device_reply_t;
+
+/** Opcode for xcb_input_close_device. */
+#define XCB_INPUT_CLOSE_DEVICE 4
+
+/**
+ * @brief xcb_input_close_device_request_t
+ **/
+typedef struct xcb_input_close_device_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  device_id;
+    uint8_t  pad0[3];
+} xcb_input_close_device_request_t;
+
+/**
+ * @brief xcb_input_set_device_mode_cookie_t
+ **/
+typedef struct xcb_input_set_device_mode_cookie_t {
+    unsigned int sequence;
+} xcb_input_set_device_mode_cookie_t;
+
+/** Opcode for xcb_input_set_device_mode. */
+#define XCB_INPUT_SET_DEVICE_MODE 5
+
+/**
+ * @brief xcb_input_set_device_mode_request_t
+ **/
+typedef struct xcb_input_set_device_mode_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  device_id;
+    uint8_t  mode;
+    uint8_t  pad0[2];
+} xcb_input_set_device_mode_request_t;
+
+/**
+ * @brief xcb_input_set_device_mode_reply_t
+ **/
+typedef struct xcb_input_set_device_mode_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  status;
+    uint8_t  pad0[23];
+} xcb_input_set_device_mode_reply_t;
+
+/** Opcode for xcb_input_select_extension_event. */
+#define XCB_INPUT_SELECT_EXTENSION_EVENT 6
+
+/**
+ * @brief xcb_input_select_extension_event_request_t
+ **/
+typedef struct xcb_input_select_extension_event_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    uint16_t     num_classes;
+    uint8_t      pad0[2];
+} xcb_input_select_extension_event_request_t;
+
+/**
+ * @brief xcb_input_get_selected_extension_events_cookie_t
+ **/
+typedef struct xcb_input_get_selected_extension_events_cookie_t {
+    unsigned int sequence;
+} xcb_input_get_selected_extension_events_cookie_t;
+
+/** Opcode for xcb_input_get_selected_extension_events. */
+#define XCB_INPUT_GET_SELECTED_EXTENSION_EVENTS 7
+
+/**
+ * @brief xcb_input_get_selected_extension_events_request_t
+ **/
+typedef struct xcb_input_get_selected_extension_events_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_input_get_selected_extension_events_request_t;
+
+/**
+ * @brief xcb_input_get_selected_extension_events_reply_t
+ **/
+typedef struct xcb_input_get_selected_extension_events_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t num_this_classes;
+    uint16_t num_all_classes;
+    uint8_t  pad0[20];
+} xcb_input_get_selected_extension_events_reply_t;
+
+typedef enum xcb_input_propagate_mode_t {
+    XCB_INPUT_PROPAGATE_MODE_ADD_TO_LIST = 0,
+    XCB_INPUT_PROPAGATE_MODE_DELETE_FROM_LIST = 1
+} xcb_input_propagate_mode_t;
+
+/** Opcode for xcb_input_change_device_dont_propagate_list. */
+#define XCB_INPUT_CHANGE_DEVICE_DONT_PROPAGATE_LIST 8
+
+/**
+ * @brief xcb_input_change_device_dont_propagate_list_request_t
+ **/
+typedef struct xcb_input_change_device_dont_propagate_list_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    uint16_t     num_classes;
+    uint8_t      mode;
+    uint8_t      pad0;
+} xcb_input_change_device_dont_propagate_list_request_t;
+
+/**
+ * @brief xcb_input_get_device_dont_propagate_list_cookie_t
+ **/
+typedef struct xcb_input_get_device_dont_propagate_list_cookie_t {
+    unsigned int sequence;
+} xcb_input_get_device_dont_propagate_list_cookie_t;
+
+/** Opcode for xcb_input_get_device_dont_propagate_list. */
+#define XCB_INPUT_GET_DEVICE_DONT_PROPAGATE_LIST 9
+
+/**
+ * @brief xcb_input_get_device_dont_propagate_list_request_t
+ **/
+typedef struct xcb_input_get_device_dont_propagate_list_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_input_get_device_dont_propagate_list_request_t;
+
+/**
+ * @brief xcb_input_get_device_dont_propagate_list_reply_t
+ **/
+typedef struct xcb_input_get_device_dont_propagate_list_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t num_classes;
+    uint8_t  pad0[22];
+} xcb_input_get_device_dont_propagate_list_reply_t;
+
+/**
+ * @brief xcb_input_device_time_coord_t
+ **/
+typedef struct xcb_input_device_time_coord_t {
+    xcb_timestamp_t time;
+} xcb_input_device_time_coord_t;
+
+/**
+ * @brief xcb_input_device_time_coord_iterator_t
+ **/
+typedef struct xcb_input_device_time_coord_iterator_t {
+    xcb_input_device_time_coord_t *data;
+    int                            rem;
+    int                            index;
+    uint8_t                        num_axes; /**<  */
+} xcb_input_device_time_coord_iterator_t;
+
+/**
+ * @brief xcb_input_get_device_motion_events_cookie_t
+ **/
+typedef struct xcb_input_get_device_motion_events_cookie_t {
+    unsigned int sequence;
+} xcb_input_get_device_motion_events_cookie_t;
+
+/** Opcode for xcb_input_get_device_motion_events. */
+#define XCB_INPUT_GET_DEVICE_MOTION_EVENTS 10
+
+/**
+ * @brief xcb_input_get_device_motion_events_request_t
+ **/
+typedef struct xcb_input_get_device_motion_events_request_t {
+    uint8_t         major_opcode;
+    uint8_t         minor_opcode;
+    uint16_t        length;
+    xcb_timestamp_t start;
+    xcb_timestamp_t stop;
+    uint8_t         device_id;
+    uint8_t         pad0[3];
+} xcb_input_get_device_motion_events_request_t;
+
+/**
+ * @brief xcb_input_get_device_motion_events_reply_t
+ **/
+typedef struct xcb_input_get_device_motion_events_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t num_events;
+    uint8_t  num_axes;
+    uint8_t  device_mode;
+    uint8_t  pad0[18];
+} xcb_input_get_device_motion_events_reply_t;
+
+/**
+ * @brief xcb_input_change_keyboard_device_cookie_t
+ **/
+typedef struct xcb_input_change_keyboard_device_cookie_t {
+    unsigned int sequence;
+} xcb_input_change_keyboard_device_cookie_t;
+
+/** Opcode for xcb_input_change_keyboard_device. */
+#define XCB_INPUT_CHANGE_KEYBOARD_DEVICE 11
+
+/**
+ * @brief xcb_input_change_keyboard_device_request_t
+ **/
+typedef struct xcb_input_change_keyboard_device_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  device_id;
+    uint8_t  pad0[3];
+} xcb_input_change_keyboard_device_request_t;
+
+/**
+ * @brief xcb_input_change_keyboard_device_reply_t
+ **/
+typedef struct xcb_input_change_keyboard_device_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  status;
+    uint8_t  pad0[23];
+} xcb_input_change_keyboard_device_reply_t;
+
+/**
+ * @brief xcb_input_change_pointer_device_cookie_t
+ **/
+typedef struct xcb_input_change_pointer_device_cookie_t {
+    unsigned int sequence;
+} xcb_input_change_pointer_device_cookie_t;
+
+/** Opcode for xcb_input_change_pointer_device. */
+#define XCB_INPUT_CHANGE_POINTER_DEVICE 12
+
+/**
+ * @brief xcb_input_change_pointer_device_request_t
+ **/
+typedef struct xcb_input_change_pointer_device_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  x_axis;
+    uint8_t  y_axis;
+    uint8_t  device_id;
+    uint8_t  pad0;
+} xcb_input_change_pointer_device_request_t;
+
+/**
+ * @brief xcb_input_change_pointer_device_reply_t
+ **/
+typedef struct xcb_input_change_pointer_device_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  status;
+    uint8_t  pad0[23];
+} xcb_input_change_pointer_device_reply_t;
+
+/**
+ * @brief xcb_input_grab_device_cookie_t
+ **/
+typedef struct xcb_input_grab_device_cookie_t {
+    unsigned int sequence;
+} xcb_input_grab_device_cookie_t;
+
+/** Opcode for xcb_input_grab_device. */
+#define XCB_INPUT_GRAB_DEVICE 13
+
+/**
+ * @brief xcb_input_grab_device_request_t
+ **/
+typedef struct xcb_input_grab_device_request_t {
+    uint8_t         major_opcode;
+    uint8_t         minor_opcode;
+    uint16_t        length;
+    xcb_window_t    grab_window;
+    xcb_timestamp_t time;
+    uint16_t        num_classes;
+    uint8_t         this_device_mode;
+    uint8_t         other_device_mode;
+    uint8_t         owner_events;
+    uint8_t         device_id;
+    uint8_t         pad0[2];
+} xcb_input_grab_device_request_t;
+
+/**
+ * @brief xcb_input_grab_device_reply_t
+ **/
+typedef struct xcb_input_grab_device_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  status;
+    uint8_t  pad0[23];
+} xcb_input_grab_device_reply_t;
+
+/** Opcode for xcb_input_ungrab_device. */
+#define XCB_INPUT_UNGRAB_DEVICE 14
+
+/**
+ * @brief xcb_input_ungrab_device_request_t
+ **/
+typedef struct xcb_input_ungrab_device_request_t {
+    uint8_t         major_opcode;
+    uint8_t         minor_opcode;
+    uint16_t        length;
+    xcb_timestamp_t time;
+    uint8_t         device_id;
+    uint8_t         pad0[3];
+} xcb_input_ungrab_device_request_t;
+
+typedef enum xcb_input_modifier_device_t {
+    XCB_INPUT_MODIFIER_DEVICE_USE_X_KEYBOARD = 255
+} xcb_input_modifier_device_t;
+
+/** Opcode for xcb_input_grab_device_key. */
+#define XCB_INPUT_GRAB_DEVICE_KEY 15
+
+/**
+ * @brief xcb_input_grab_device_key_request_t
+ **/
+typedef struct xcb_input_grab_device_key_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t grab_window;
+    uint16_t     num_classes;
+    uint16_t     modifiers;
+    uint8_t      modifier_device;
+    uint8_t      grabbed_device;
+    uint8_t      key;
+    uint8_t      this_device_mode;
+    uint8_t      other_device_mode;
+    uint8_t      owner_events;
+    uint8_t      pad0[2];
+} xcb_input_grab_device_key_request_t;
+
+/** Opcode for xcb_input_ungrab_device_key. */
+#define XCB_INPUT_UNGRAB_DEVICE_KEY 16
+
+/**
+ * @brief xcb_input_ungrab_device_key_request_t
+ **/
+typedef struct xcb_input_ungrab_device_key_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t grabWindow;
+    uint16_t     modifiers;
+    uint8_t      modifier_device;
+    uint8_t      key;
+    uint8_t      grabbed_device;
+} xcb_input_ungrab_device_key_request_t;
+
+/** Opcode for xcb_input_grab_device_button. */
+#define XCB_INPUT_GRAB_DEVICE_BUTTON 17
+
+/**
+ * @brief xcb_input_grab_device_button_request_t
+ **/
+typedef struct xcb_input_grab_device_button_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t grab_window;
+    uint8_t      grabbed_device;
+    uint8_t      modifier_device;
+    uint16_t     num_classes;
+    uint16_t     modifiers;
+    uint8_t      this_device_mode;
+    uint8_t      other_device_mode;
+    uint8_t      button;
+    uint8_t      owner_events;
+    uint8_t      pad0[2];
+} xcb_input_grab_device_button_request_t;
+
+/** Opcode for xcb_input_ungrab_device_button. */
+#define XCB_INPUT_UNGRAB_DEVICE_BUTTON 18
+
+/**
+ * @brief xcb_input_ungrab_device_button_request_t
+ **/
+typedef struct xcb_input_ungrab_device_button_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t grab_window;
+    uint16_t     modifiers;
+    uint8_t      modifier_device;
+    uint8_t      button;
+    uint8_t      grabbed_device;
+    uint8_t      pad0[3];
+} xcb_input_ungrab_device_button_request_t;
+
+typedef enum xcb_input_device_input_mode_t {
+    XCB_INPUT_DEVICE_INPUT_MODE_ASYNC_THIS_DEVICE = 0,
+    XCB_INPUT_DEVICE_INPUT_MODE_SYNC_THIS_DEVICE = 1,
+    XCB_INPUT_DEVICE_INPUT_MODE_REPLAY_THIS_DEVICE = 2,
+    XCB_INPUT_DEVICE_INPUT_MODE_ASYNC_OTHER_DEVICES = 3,
+    XCB_INPUT_DEVICE_INPUT_MODE_ASYNC_ALL = 4,
+    XCB_INPUT_DEVICE_INPUT_MODE_SYNC_ALL = 5
+} xcb_input_device_input_mode_t;
+
+/** Opcode for xcb_input_allow_device_events. */
+#define XCB_INPUT_ALLOW_DEVICE_EVENTS 19
+
+/**
+ * @brief xcb_input_allow_device_events_request_t
+ **/
+typedef struct xcb_input_allow_device_events_request_t {
+    uint8_t         major_opcode;
+    uint8_t         minor_opcode;
+    uint16_t        length;
+    xcb_timestamp_t time;
+    uint8_t         mode;
+    uint8_t         device_id;
+    uint8_t         pad0[2];
+} xcb_input_allow_device_events_request_t;
+
+/**
+ * @brief xcb_input_get_device_focus_cookie_t
+ **/
+typedef struct xcb_input_get_device_focus_cookie_t {
+    unsigned int sequence;
+} xcb_input_get_device_focus_cookie_t;
+
+/** Opcode for xcb_input_get_device_focus. */
+#define XCB_INPUT_GET_DEVICE_FOCUS 20
+
+/**
+ * @brief xcb_input_get_device_focus_request_t
+ **/
+typedef struct xcb_input_get_device_focus_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  device_id;
+    uint8_t  pad0[3];
+} xcb_input_get_device_focus_request_t;
+
+/**
+ * @brief xcb_input_get_device_focus_reply_t
+ **/
+typedef struct xcb_input_get_device_focus_reply_t {
+    uint8_t         response_type;
+    uint8_t         xi_reply_type;
+    uint16_t        sequence;
+    uint32_t        length;
+    xcb_window_t    focus;
+    xcb_timestamp_t time;
+    uint8_t         revert_to;
+    uint8_t         pad0[15];
+} xcb_input_get_device_focus_reply_t;
+
+/** Opcode for xcb_input_set_device_focus. */
+#define XCB_INPUT_SET_DEVICE_FOCUS 21
+
+/**
+ * @brief xcb_input_set_device_focus_request_t
+ **/
+typedef struct xcb_input_set_device_focus_request_t {
+    uint8_t         major_opcode;
+    uint8_t         minor_opcode;
+    uint16_t        length;
+    xcb_window_t    focus;
+    xcb_timestamp_t time;
+    uint8_t         revert_to;
+    uint8_t         device_id;
+    uint8_t         pad0[2];
+} xcb_input_set_device_focus_request_t;
+
+typedef enum xcb_input_feedback_class_t {
+    XCB_INPUT_FEEDBACK_CLASS_KEYBOARD = 0,
+    XCB_INPUT_FEEDBACK_CLASS_POINTER = 1,
+    XCB_INPUT_FEEDBACK_CLASS_STRING = 2,
+    XCB_INPUT_FEEDBACK_CLASS_INTEGER = 3,
+    XCB_INPUT_FEEDBACK_CLASS_LED = 4,
+    XCB_INPUT_FEEDBACK_CLASS_BELL = 5
+} xcb_input_feedback_class_t;
+
+/**
+ * @brief xcb_input_kbd_feedback_state_t
+ **/
+typedef struct xcb_input_kbd_feedback_state_t {
+    uint8_t  class_id;
+    uint8_t  feedback_id;
+    uint16_t len;
+    uint16_t pitch;
+    uint16_t duration;
+    uint32_t led_mask;
+    uint32_t led_values;
+    uint8_t  global_auto_repeat;
+    uint8_t  click;
+    uint8_t  percent;
+    uint8_t  pad0;
+    uint8_t  auto_repeats[32];
+} xcb_input_kbd_feedback_state_t;
+
+/**
+ * @brief xcb_input_kbd_feedback_state_iterator_t
+ **/
+typedef struct xcb_input_kbd_feedback_state_iterator_t {
+    xcb_input_kbd_feedback_state_t *data;
+    int                             rem;
+    int                             index;
+} xcb_input_kbd_feedback_state_iterator_t;
+
+/**
+ * @brief xcb_input_ptr_feedback_state_t
+ **/
+typedef struct xcb_input_ptr_feedback_state_t {
+    uint8_t  class_id;
+    uint8_t  feedback_id;
+    uint16_t len;
+    uint8_t  pad0[2];
+    uint16_t accel_num;
+    uint16_t accel_denom;
+    uint16_t threshold;
+} xcb_input_ptr_feedback_state_t;
+
+/**
+ * @brief xcb_input_ptr_feedback_state_iterator_t
+ **/
+typedef struct xcb_input_ptr_feedback_state_iterator_t {
+    xcb_input_ptr_feedback_state_t *data;
+    int                             rem;
+    int                             index;
+} xcb_input_ptr_feedback_state_iterator_t;
+
+/**
+ * @brief xcb_input_integer_feedback_state_t
+ **/
+typedef struct xcb_input_integer_feedback_state_t {
+    uint8_t  class_id;
+    uint8_t  feedback_id;
+    uint16_t len;
+    uint32_t resolution;
+    int32_t  min_value;
+    int32_t  max_value;
+} xcb_input_integer_feedback_state_t;
+
+/**
+ * @brief xcb_input_integer_feedback_state_iterator_t
+ **/
+typedef struct xcb_input_integer_feedback_state_iterator_t {
+    xcb_input_integer_feedback_state_t *data;
+    int                                 rem;
+    int                                 index;
+} xcb_input_integer_feedback_state_iterator_t;
+
+/**
+ * @brief xcb_input_string_feedback_state_t
+ **/
+typedef struct xcb_input_string_feedback_state_t {
+    uint8_t  class_id;
+    uint8_t  feedback_id;
+    uint16_t len;
+    uint16_t max_symbols;
+    uint16_t num_keysyms;
+} xcb_input_string_feedback_state_t;
+
+/**
+ * @brief xcb_input_string_feedback_state_iterator_t
+ **/
+typedef struct xcb_input_string_feedback_state_iterator_t {
+    xcb_input_string_feedback_state_t *data;
+    int                                rem;
+    int                                index;
+} xcb_input_string_feedback_state_iterator_t;
+
+/**
+ * @brief xcb_input_bell_feedback_state_t
+ **/
+typedef struct xcb_input_bell_feedback_state_t {
+    uint8_t  class_id;
+    uint8_t  feedback_id;
+    uint16_t len;
+    uint8_t  percent;
+    uint8_t  pad0[3];
+    uint16_t pitch;
+    uint16_t duration;
+} xcb_input_bell_feedback_state_t;
+
+/**
+ * @brief xcb_input_bell_feedback_state_iterator_t
+ **/
+typedef struct xcb_input_bell_feedback_state_iterator_t {
+    xcb_input_bell_feedback_state_t *data;
+    int                              rem;
+    int                              index;
+} xcb_input_bell_feedback_state_iterator_t;
+
+/**
+ * @brief xcb_input_led_feedback_state_t
+ **/
+typedef struct xcb_input_led_feedback_state_t {
+    uint8_t  class_id;
+    uint8_t  feedback_id;
+    uint16_t len;
+    uint32_t led_mask;
+    uint32_t led_values;
+} xcb_input_led_feedback_state_t;
+
+/**
+ * @brief xcb_input_led_feedback_state_iterator_t
+ **/
+typedef struct xcb_input_led_feedback_state_iterator_t {
+    xcb_input_led_feedback_state_t *data;
+    int                             rem;
+    int                             index;
+} xcb_input_led_feedback_state_iterator_t;
+
+/**
+ * @brief xcb_input_feedback_state_data_t
+ **/
+typedef struct xcb_input_feedback_state_data_t {
+    struct {
+        uint16_t      pitch;
+        uint16_t      duration;
+        uint32_t      led_mask;
+        uint32_t      led_values;
+        uint8_t       global_auto_repeat;
+        uint8_t       click;
+        uint8_t       percent;
+        uint8_t       pad0;
+        uint8_t       auto_repeats[32];
+    } keyboard;
+    struct {
+        uint8_t       pad1[2];
+        uint16_t      accel_num;
+        uint16_t      accel_denom;
+        uint16_t      threshold;
+    } pointer;
+    struct {
+        uint16_t      max_symbols;
+        uint16_t      num_keysyms;
+        xcb_keysym_t *keysyms;
+    } string;
+    struct {
+        uint32_t      resolution;
+        int32_t       min_value;
+        int32_t       max_value;
+    } integer;
+    struct {
+        uint32_t      led_mask;
+        uint32_t      led_values;
+    } led;
+    struct {
+        uint8_t       percent;
+        uint8_t       pad2[3];
+        uint16_t      pitch;
+        uint16_t      duration;
+    } bell;
+} xcb_input_feedback_state_data_t;
+
+/**
+ * @brief xcb_input_feedback_state_t
+ **/
+typedef struct xcb_input_feedback_state_t {
+    uint8_t  class_id;
+    uint8_t  feedback_id;
+    uint16_t len;
+} xcb_input_feedback_state_t;
+
+void *
+xcb_input_feedback_state_data (const xcb_input_feedback_state_t *R);
+
+/**
+ * @brief xcb_input_feedback_state_iterator_t
+ **/
+typedef struct xcb_input_feedback_state_iterator_t {
+    xcb_input_feedback_state_t *data;
+    int                         rem;
+    int                         index;
+} xcb_input_feedback_state_iterator_t;
+
+/**
+ * @brief xcb_input_get_feedback_control_cookie_t
+ **/
+typedef struct xcb_input_get_feedback_control_cookie_t {
+    unsigned int sequence;
+} xcb_input_get_feedback_control_cookie_t;
+
+/** Opcode for xcb_input_get_feedback_control. */
+#define XCB_INPUT_GET_FEEDBACK_CONTROL 22
+
+/**
+ * @brief xcb_input_get_feedback_control_request_t
+ **/
+typedef struct xcb_input_get_feedback_control_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  device_id;
+    uint8_t  pad0[3];
+} xcb_input_get_feedback_control_request_t;
+
+/**
+ * @brief xcb_input_get_feedback_control_reply_t
+ **/
+typedef struct xcb_input_get_feedback_control_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t num_feedbacks;
+    uint8_t  pad0[22];
+} xcb_input_get_feedback_control_reply_t;
+
+/**
+ * @brief xcb_input_kbd_feedback_ctl_t
+ **/
+typedef struct xcb_input_kbd_feedback_ctl_t {
+    uint8_t              class_id;
+    uint8_t              feedback_id;
+    uint16_t             len;
+    xcb_input_key_code_t key;
+    uint8_t              auto_repeat_mode;
+    int8_t               key_click_percent;
+    int8_t               bell_percent;
+    int16_t              bell_pitch;
+    int16_t              bell_duration;
+    uint32_t             led_mask;
+    uint32_t             led_values;
+} xcb_input_kbd_feedback_ctl_t;
+
+/**
+ * @brief xcb_input_kbd_feedback_ctl_iterator_t
+ **/
+typedef struct xcb_input_kbd_feedback_ctl_iterator_t {
+    xcb_input_kbd_feedback_ctl_t *data;
+    int                           rem;
+    int                           index;
+} xcb_input_kbd_feedback_ctl_iterator_t;
+
+/**
+ * @brief xcb_input_ptr_feedback_ctl_t
+ **/
+typedef struct xcb_input_ptr_feedback_ctl_t {
+    uint8_t  class_id;
+    uint8_t  feedback_id;
+    uint16_t len;
+    uint8_t  pad0[2];
+    int16_t  num;
+    int16_t  denom;
+    int16_t  threshold;
+} xcb_input_ptr_feedback_ctl_t;
+
+/**
+ * @brief xcb_input_ptr_feedback_ctl_iterator_t
+ **/
+typedef struct xcb_input_ptr_feedback_ctl_iterator_t {
+    xcb_input_ptr_feedback_ctl_t *data;
+    int                           rem;
+    int                           index;
+} xcb_input_ptr_feedback_ctl_iterator_t;
+
+/**
+ * @brief xcb_input_integer_feedback_ctl_t
+ **/
+typedef struct xcb_input_integer_feedback_ctl_t {
+    uint8_t  class_id;
+    uint8_t  feedback_id;
+    uint16_t len;
+    int32_t  int_to_display;
+} xcb_input_integer_feedback_ctl_t;
+
+/**
+ * @brief xcb_input_integer_feedback_ctl_iterator_t
+ **/
+typedef struct xcb_input_integer_feedback_ctl_iterator_t {
+    xcb_input_integer_feedback_ctl_t *data;
+    int                               rem;
+    int                               index;
+} xcb_input_integer_feedback_ctl_iterator_t;
+
+/**
+ * @brief xcb_input_string_feedback_ctl_t
+ **/
+typedef struct xcb_input_string_feedback_ctl_t {
+    uint8_t  class_id;
+    uint8_t  feedback_id;
+    uint16_t len;
+    uint8_t  pad0[2];
+    uint16_t num_keysyms;
+} xcb_input_string_feedback_ctl_t;
+
+/**
+ * @brief xcb_input_string_feedback_ctl_iterator_t
+ **/
+typedef struct xcb_input_string_feedback_ctl_iterator_t {
+    xcb_input_string_feedback_ctl_t *data;
+    int                              rem;
+    int                              index;
+} xcb_input_string_feedback_ctl_iterator_t;
+
+/**
+ * @brief xcb_input_bell_feedback_ctl_t
+ **/
+typedef struct xcb_input_bell_feedback_ctl_t {
+    uint8_t  class_id;
+    uint8_t  feedback_id;
+    uint16_t len;
+    int8_t   percent;
+    uint8_t  pad0[3];
+    int16_t  pitch;
+    int16_t  duration;
+} xcb_input_bell_feedback_ctl_t;
+
+/**
+ * @brief xcb_input_bell_feedback_ctl_iterator_t
+ **/
+typedef struct xcb_input_bell_feedback_ctl_iterator_t {
+    xcb_input_bell_feedback_ctl_t *data;
+    int                            rem;
+    int                            index;
+} xcb_input_bell_feedback_ctl_iterator_t;
+
+/**
+ * @brief xcb_input_led_feedback_ctl_t
+ **/
+typedef struct xcb_input_led_feedback_ctl_t {
+    uint8_t  class_id;
+    uint8_t  feedback_id;
+    uint16_t len;
+    uint32_t led_mask;
+    uint32_t led_values;
+} xcb_input_led_feedback_ctl_t;
+
+/**
+ * @brief xcb_input_led_feedback_ctl_iterator_t
+ **/
+typedef struct xcb_input_led_feedback_ctl_iterator_t {
+    xcb_input_led_feedback_ctl_t *data;
+    int                           rem;
+    int                           index;
+} xcb_input_led_feedback_ctl_iterator_t;
+
+/**
+ * @brief xcb_input_feedback_ctl_data_t
+ **/
+typedef struct xcb_input_feedback_ctl_data_t {
+    struct {
+        xcb_input_key_code_t key;
+        uint8_t              auto_repeat_mode;
+        int8_t               key_click_percent;
+        int8_t               bell_percent;
+        int16_t              bell_pitch;
+        int16_t              bell_duration;
+        uint32_t             led_mask;
+        uint32_t             led_values;
+    } keyboard;
+    struct {
+        uint8_t              pad0[2];
+        int16_t              num;
+        int16_t              denom;
+        int16_t              threshold;
+    } pointer;
+    struct {
+        uint8_t              pad1[2];
+        uint16_t             num_keysyms;
+        xcb_keysym_t        *keysyms;
+    } string;
+    struct {
+        int32_t              int_to_display;
+    } integer;
+    struct {
+        uint32_t             led_mask;
+        uint32_t             led_values;
+    } led;
+    struct {
+        int8_t               percent;
+        uint8_t              pad2[3];
+        int16_t              pitch;
+        int16_t              duration;
+    } bell;
+} xcb_input_feedback_ctl_data_t;
+
+/**
+ * @brief xcb_input_feedback_ctl_t
+ **/
+typedef struct xcb_input_feedback_ctl_t {
+    uint8_t  class_id;
+    uint8_t  feedback_id;
+    uint16_t len;
+} xcb_input_feedback_ctl_t;
+
+void *
+xcb_input_feedback_ctl_data (const xcb_input_feedback_ctl_t *R);
+
+/**
+ * @brief xcb_input_feedback_ctl_iterator_t
+ **/
+typedef struct xcb_input_feedback_ctl_iterator_t {
+    xcb_input_feedback_ctl_t *data;
+    int                       rem;
+    int                       index;
+} xcb_input_feedback_ctl_iterator_t;
+
+typedef enum xcb_input_change_feedback_control_mask_t {
+    XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_KEY_CLICK_PERCENT = 1,
+    XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_PERCENT = 2,
+    XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_PITCH = 4,
+    XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_DURATION = 8,
+    XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_LED = 16,
+    XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_LED_MODE = 32,
+    XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_KEY = 64,
+    XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_AUTO_REPEAT_MODE = 128,
+    XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_STRING = 1,
+    XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_INTEGER = 1,
+    XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_ACCEL_NUM = 1,
+    XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_ACCEL_DENOM = 2,
+    XCB_INPUT_CHANGE_FEEDBACK_CONTROL_MASK_THRESHOLD = 4
+} xcb_input_change_feedback_control_mask_t;
+
+/** Opcode for xcb_input_change_feedback_control. */
+#define XCB_INPUT_CHANGE_FEEDBACK_CONTROL 23
+
+/**
+ * @brief xcb_input_change_feedback_control_request_t
+ **/
+typedef struct xcb_input_change_feedback_control_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t mask;
+    uint8_t  device_id;
+    uint8_t  feedback_id;
+    uint8_t  pad0[2];
+} xcb_input_change_feedback_control_request_t;
+
+/**
+ * @brief xcb_input_get_device_key_mapping_cookie_t
+ **/
+typedef struct xcb_input_get_device_key_mapping_cookie_t {
+    unsigned int sequence;
+} xcb_input_get_device_key_mapping_cookie_t;
+
+/** Opcode for xcb_input_get_device_key_mapping. */
+#define XCB_INPUT_GET_DEVICE_KEY_MAPPING 24
+
+/**
+ * @brief xcb_input_get_device_key_mapping_request_t
+ **/
+typedef struct xcb_input_get_device_key_mapping_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    uint8_t              device_id;
+    xcb_input_key_code_t first_keycode;
+    uint8_t              count;
+    uint8_t              pad0;
+} xcb_input_get_device_key_mapping_request_t;
+
+/**
+ * @brief xcb_input_get_device_key_mapping_reply_t
+ **/
+typedef struct xcb_input_get_device_key_mapping_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  keysyms_per_keycode;
+    uint8_t  pad0[23];
+} xcb_input_get_device_key_mapping_reply_t;
+
+/** Opcode for xcb_input_change_device_key_mapping. */
+#define XCB_INPUT_CHANGE_DEVICE_KEY_MAPPING 25
+
+/**
+ * @brief xcb_input_change_device_key_mapping_request_t
+ **/
+typedef struct xcb_input_change_device_key_mapping_request_t {
+    uint8_t              major_opcode;
+    uint8_t              minor_opcode;
+    uint16_t             length;
+    uint8_t              device_id;
+    xcb_input_key_code_t first_keycode;
+    uint8_t              keysyms_per_keycode;
+    uint8_t              keycode_count;
+} xcb_input_change_device_key_mapping_request_t;
+
+/**
+ * @brief xcb_input_get_device_modifier_mapping_cookie_t
+ **/
+typedef struct xcb_input_get_device_modifier_mapping_cookie_t {
+    unsigned int sequence;
+} xcb_input_get_device_modifier_mapping_cookie_t;
+
+/** Opcode for xcb_input_get_device_modifier_mapping. */
+#define XCB_INPUT_GET_DEVICE_MODIFIER_MAPPING 26
+
+/**
+ * @brief xcb_input_get_device_modifier_mapping_request_t
+ **/
+typedef struct xcb_input_get_device_modifier_mapping_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  device_id;
+    uint8_t  pad0[3];
+} xcb_input_get_device_modifier_mapping_request_t;
+
+/**
+ * @brief xcb_input_get_device_modifier_mapping_reply_t
+ **/
+typedef struct xcb_input_get_device_modifier_mapping_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  keycodes_per_modifier;
+    uint8_t  pad0[23];
+} xcb_input_get_device_modifier_mapping_reply_t;
+
+/**
+ * @brief xcb_input_set_device_modifier_mapping_cookie_t
+ **/
+typedef struct xcb_input_set_device_modifier_mapping_cookie_t {
+    unsigned int sequence;
+} xcb_input_set_device_modifier_mapping_cookie_t;
+
+/** Opcode for xcb_input_set_device_modifier_mapping. */
+#define XCB_INPUT_SET_DEVICE_MODIFIER_MAPPING 27
+
+/**
+ * @brief xcb_input_set_device_modifier_mapping_request_t
+ **/
+typedef struct xcb_input_set_device_modifier_mapping_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  device_id;
+    uint8_t  keycodes_per_modifier;
+    uint8_t  pad0[2];
+} xcb_input_set_device_modifier_mapping_request_t;
+
+/**
+ * @brief xcb_input_set_device_modifier_mapping_reply_t
+ **/
+typedef struct xcb_input_set_device_modifier_mapping_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  status;
+    uint8_t  pad0[23];
+} xcb_input_set_device_modifier_mapping_reply_t;
+
+/**
+ * @brief xcb_input_get_device_button_mapping_cookie_t
+ **/
+typedef struct xcb_input_get_device_button_mapping_cookie_t {
+    unsigned int sequence;
+} xcb_input_get_device_button_mapping_cookie_t;
+
+/** Opcode for xcb_input_get_device_button_mapping. */
+#define XCB_INPUT_GET_DEVICE_BUTTON_MAPPING 28
+
+/**
+ * @brief xcb_input_get_device_button_mapping_request_t
+ **/
+typedef struct xcb_input_get_device_button_mapping_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  device_id;
+    uint8_t  pad0[3];
+} xcb_input_get_device_button_mapping_request_t;
+
+/**
+ * @brief xcb_input_get_device_button_mapping_reply_t
+ **/
+typedef struct xcb_input_get_device_button_mapping_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  map_size;
+    uint8_t  pad0[23];
+} xcb_input_get_device_button_mapping_reply_t;
+
+/**
+ * @brief xcb_input_set_device_button_mapping_cookie_t
+ **/
+typedef struct xcb_input_set_device_button_mapping_cookie_t {
+    unsigned int sequence;
+} xcb_input_set_device_button_mapping_cookie_t;
+
+/** Opcode for xcb_input_set_device_button_mapping. */
+#define XCB_INPUT_SET_DEVICE_BUTTON_MAPPING 29
+
+/**
+ * @brief xcb_input_set_device_button_mapping_request_t
+ **/
+typedef struct xcb_input_set_device_button_mapping_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  device_id;
+    uint8_t  map_size;
+    uint8_t  pad0[2];
+} xcb_input_set_device_button_mapping_request_t;
+
+/**
+ * @brief xcb_input_set_device_button_mapping_reply_t
+ **/
+typedef struct xcb_input_set_device_button_mapping_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  status;
+    uint8_t  pad0[23];
+} xcb_input_set_device_button_mapping_reply_t;
+
+/**
+ * @brief xcb_input_key_state_t
+ **/
+typedef struct xcb_input_key_state_t {
+    uint8_t class_id;
+    uint8_t len;
+    uint8_t num_keys;
+    uint8_t pad0;
+    uint8_t keys[32];
+} xcb_input_key_state_t;
+
+/**
+ * @brief xcb_input_key_state_iterator_t
+ **/
+typedef struct xcb_input_key_state_iterator_t {
+    xcb_input_key_state_t *data;
+    int                    rem;
+    int                    index;
+} xcb_input_key_state_iterator_t;
+
+/**
+ * @brief xcb_input_button_state_t
+ **/
+typedef struct xcb_input_button_state_t {
+    uint8_t class_id;
+    uint8_t len;
+    uint8_t num_buttons;
+    uint8_t pad0;
+    uint8_t buttons[32];
+} xcb_input_button_state_t;
+
+/**
+ * @brief xcb_input_button_state_iterator_t
+ **/
+typedef struct xcb_input_button_state_iterator_t {
+    xcb_input_button_state_t *data;
+    int                       rem;
+    int                       index;
+} xcb_input_button_state_iterator_t;
+
+typedef enum xcb_input_valuator_state_mode_mask_t {
+    XCB_INPUT_VALUATOR_STATE_MODE_MASK_DEVICE_MODE_ABSOLUTE = 1,
+    XCB_INPUT_VALUATOR_STATE_MODE_MASK_OUT_OF_PROXIMITY = 2
+} xcb_input_valuator_state_mode_mask_t;
+
+/**
+ * @brief xcb_input_valuator_state_t
+ **/
+typedef struct xcb_input_valuator_state_t {
+    uint8_t class_id;
+    uint8_t len;
+    uint8_t num_valuators;
+    uint8_t mode;
+} xcb_input_valuator_state_t;
+
+/**
+ * @brief xcb_input_valuator_state_iterator_t
+ **/
+typedef struct xcb_input_valuator_state_iterator_t {
+    xcb_input_valuator_state_t *data;
+    int                         rem;
+    int                         index;
+} xcb_input_valuator_state_iterator_t;
+
+/**
+ * @brief xcb_input_input_state_data_t
+ **/
+typedef struct xcb_input_input_state_data_t {
+    struct {
+        uint8_t  num_keys;
+        uint8_t  pad0;
+        uint8_t  keys[32];
+    } key;
+    struct {
+        uint8_t  num_buttons;
+        uint8_t  pad1;
+        uint8_t  buttons[32];
+    } button;
+    struct {
+        uint8_t  num_valuators;
+        uint8_t  mode;
+        int32_t *valuators;
+    } valuator;
+} xcb_input_input_state_data_t;
+
+/**
+ * @brief xcb_input_input_state_t
+ **/
+typedef struct xcb_input_input_state_t {
+    uint8_t class_id;
+    uint8_t len;
+} xcb_input_input_state_t;
+
+void *
+xcb_input_input_state_data (const xcb_input_input_state_t *R);
+
+/**
+ * @brief xcb_input_input_state_iterator_t
+ **/
+typedef struct xcb_input_input_state_iterator_t {
+    xcb_input_input_state_t *data;
+    int                      rem;
+    int                      index;
+} xcb_input_input_state_iterator_t;
+
+/**
+ * @brief xcb_input_query_device_state_cookie_t
+ **/
+typedef struct xcb_input_query_device_state_cookie_t {
+    unsigned int sequence;
+} xcb_input_query_device_state_cookie_t;
+
+/** Opcode for xcb_input_query_device_state. */
+#define XCB_INPUT_QUERY_DEVICE_STATE 30
+
+/**
+ * @brief xcb_input_query_device_state_request_t
+ **/
+typedef struct xcb_input_query_device_state_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  device_id;
+    uint8_t  pad0[3];
+} xcb_input_query_device_state_request_t;
+
+/**
+ * @brief xcb_input_query_device_state_reply_t
+ **/
+typedef struct xcb_input_query_device_state_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  num_classes;
+    uint8_t  pad0[23];
+} xcb_input_query_device_state_reply_t;
+
+/** Opcode for xcb_input_device_bell. */
+#define XCB_INPUT_DEVICE_BELL 32
+
+/**
+ * @brief xcb_input_device_bell_request_t
+ **/
+typedef struct xcb_input_device_bell_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  device_id;
+    uint8_t  feedback_id;
+    uint8_t  feedback_class;
+    int8_t   percent;
+} xcb_input_device_bell_request_t;
+
+/**
+ * @brief xcb_input_set_device_valuators_cookie_t
+ **/
+typedef struct xcb_input_set_device_valuators_cookie_t {
+    unsigned int sequence;
+} xcb_input_set_device_valuators_cookie_t;
+
+/** Opcode for xcb_input_set_device_valuators. */
+#define XCB_INPUT_SET_DEVICE_VALUATORS 33
+
+/**
+ * @brief xcb_input_set_device_valuators_request_t
+ **/
+typedef struct xcb_input_set_device_valuators_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  device_id;
+    uint8_t  first_valuator;
+    uint8_t  num_valuators;
+    uint8_t  pad0;
+} xcb_input_set_device_valuators_request_t;
+
+/**
+ * @brief xcb_input_set_device_valuators_reply_t
+ **/
+typedef struct xcb_input_set_device_valuators_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  status;
+    uint8_t  pad0[23];
+} xcb_input_set_device_valuators_reply_t;
+
+typedef enum xcb_input_device_control_t {
+    XCB_INPUT_DEVICE_CONTROL_RESOLUTION = 1,
+    XCB_INPUT_DEVICE_CONTROL_ABS_CALIB = 2,
+    XCB_INPUT_DEVICE_CONTROL_CORE = 3,
+    XCB_INPUT_DEVICE_CONTROL_ENABLE = 4,
+    XCB_INPUT_DEVICE_CONTROL_ABS_AREA = 5
+} xcb_input_device_control_t;
+
+/**
+ * @brief xcb_input_device_resolution_state_t
+ **/
+typedef struct xcb_input_device_resolution_state_t {
+    uint16_t control_id;
+    uint16_t len;
+    uint32_t num_valuators;
+} xcb_input_device_resolution_state_t;
+
+/**
+ * @brief xcb_input_device_resolution_state_iterator_t
+ **/
+typedef struct xcb_input_device_resolution_state_iterator_t {
+    xcb_input_device_resolution_state_t *data;
+    int                                  rem;
+    int                                  index;
+} xcb_input_device_resolution_state_iterator_t;
+
+/**
+ * @brief xcb_input_device_abs_calib_state_t
+ **/
+typedef struct xcb_input_device_abs_calib_state_t {
+    uint16_t control_id;
+    uint16_t len;
+    int32_t  min_x;
+    int32_t  max_x;
+    int32_t  min_y;
+    int32_t  max_y;
+    uint32_t flip_x;
+    uint32_t flip_y;
+    uint32_t rotation;
+    uint32_t button_threshold;
+} xcb_input_device_abs_calib_state_t;
+
+/**
+ * @brief xcb_input_device_abs_calib_state_iterator_t
+ **/
+typedef struct xcb_input_device_abs_calib_state_iterator_t {
+    xcb_input_device_abs_calib_state_t *data;
+    int                                 rem;
+    int                                 index;
+} xcb_input_device_abs_calib_state_iterator_t;
+
+/**
+ * @brief xcb_input_device_abs_area_state_t
+ **/
+typedef struct xcb_input_device_abs_area_state_t {
+    uint16_t control_id;
+    uint16_t len;
+    uint32_t offset_x;
+    uint32_t offset_y;
+    uint32_t width;
+    uint32_t height;
+    uint32_t screen;
+    uint32_t following;
+} xcb_input_device_abs_area_state_t;
+
+/**
+ * @brief xcb_input_device_abs_area_state_iterator_t
+ **/
+typedef struct xcb_input_device_abs_area_state_iterator_t {
+    xcb_input_device_abs_area_state_t *data;
+    int                                rem;
+    int                                index;
+} xcb_input_device_abs_area_state_iterator_t;
+
+/**
+ * @brief xcb_input_device_core_state_t
+ **/
+typedef struct xcb_input_device_core_state_t {
+    uint16_t control_id;
+    uint16_t len;
+    uint8_t  status;
+    uint8_t  iscore;
+    uint8_t  pad0[2];
+} xcb_input_device_core_state_t;
+
+/**
+ * @brief xcb_input_device_core_state_iterator_t
+ **/
+typedef struct xcb_input_device_core_state_iterator_t {
+    xcb_input_device_core_state_t *data;
+    int                            rem;
+    int                            index;
+} xcb_input_device_core_state_iterator_t;
+
+/**
+ * @brief xcb_input_device_enable_state_t
+ **/
+typedef struct xcb_input_device_enable_state_t {
+    uint16_t control_id;
+    uint16_t len;
+    uint8_t  enable;
+    uint8_t  pad0[3];
+} xcb_input_device_enable_state_t;
+
+/**
+ * @brief xcb_input_device_enable_state_iterator_t
+ **/
+typedef struct xcb_input_device_enable_state_iterator_t {
+    xcb_input_device_enable_state_t *data;
+    int                              rem;
+    int                              index;
+} xcb_input_device_enable_state_iterator_t;
+
+/**
+ * @brief xcb_input_device_state_data_t
+ **/
+typedef struct xcb_input_device_state_data_t {
+    struct {
+        uint32_t  num_valuators;
+        uint32_t *resolution_values;
+        uint32_t *resolution_min;
+        uint32_t *resolution_max;
+    } resolution;
+    struct {
+        int32_t   min_x;
+        int32_t   max_x;
+        int32_t   min_y;
+        int32_t   max_y;
+        uint32_t  flip_x;
+        uint32_t  flip_y;
+        uint32_t  rotation;
+        uint32_t  button_threshold;
+    } abs_calib;
+    struct {
+        uint8_t   status;
+        uint8_t   iscore;
+        uint8_t   pad0[2];
+    } core;
+    struct {
+        uint8_t   enable;
+        uint8_t   pad1[3];
+    } enable;
+    struct {
+        uint32_t  offset_x;
+        uint32_t  offset_y;
+        uint32_t  width;
+        uint32_t  height;
+        uint32_t  screen;
+        uint32_t  following;
+    } abs_area;
+} xcb_input_device_state_data_t;
+
+/**
+ * @brief xcb_input_device_state_t
+ **/
+typedef struct xcb_input_device_state_t {
+    uint16_t control_id;
+    uint16_t len;
+} xcb_input_device_state_t;
+
+void *
+xcb_input_device_state_data (const xcb_input_device_state_t *R);
+
+/**
+ * @brief xcb_input_device_state_iterator_t
+ **/
+typedef struct xcb_input_device_state_iterator_t {
+    xcb_input_device_state_t *data;
+    int                       rem;
+    int                       index;
+} xcb_input_device_state_iterator_t;
+
+/**
+ * @brief xcb_input_get_device_control_cookie_t
+ **/
+typedef struct xcb_input_get_device_control_cookie_t {
+    unsigned int sequence;
+} xcb_input_get_device_control_cookie_t;
+
+/** Opcode for xcb_input_get_device_control. */
+#define XCB_INPUT_GET_DEVICE_CONTROL 34
+
+/**
+ * @brief xcb_input_get_device_control_request_t
+ **/
+typedef struct xcb_input_get_device_control_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint16_t control_id;
+    uint8_t  device_id;
+    uint8_t  pad0;
+} xcb_input_get_device_control_request_t;
+
+/**
+ * @brief xcb_input_get_device_control_reply_t
+ **/
+typedef struct xcb_input_get_device_control_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  status;
+    uint8_t  pad0[23];
+} xcb_input_get_device_control_reply_t;
+
+/**
+ * @brief xcb_input_device_resolution_ctl_t
+ **/
+typedef struct xcb_input_device_resolution_ctl_t {
+    uint16_t control_id;
+    uint16_t len;
+    uint8_t  first_valuator;
+    uint8_t  num_valuators;
+    uint8_t  pad0[2];
+} xcb_input_device_resolution_ctl_t;
+
+/**
+ * @brief xcb_input_device_resolution_ctl_iterator_t
+ **/
+typedef struct xcb_input_device_resolution_ctl_iterator_t {
+    xcb_input_device_resolution_ctl_t *data;
+    int                                rem;
+    int                                index;
+} xcb_input_device_resolution_ctl_iterator_t;
+
+/**
+ * @brief xcb_input_device_abs_calib_ctl_t
+ **/
+typedef struct xcb_input_device_abs_calib_ctl_t {
+    uint16_t control_id;
+    uint16_t len;
+    int32_t  min_x;
+    int32_t  max_x;
+    int32_t  min_y;
+    int32_t  max_y;
+    uint32_t flip_x;
+    uint32_t flip_y;
+    uint32_t rotation;
+    uint32_t button_threshold;
+} xcb_input_device_abs_calib_ctl_t;
+
+/**
+ * @brief xcb_input_device_abs_calib_ctl_iterator_t
+ **/
+typedef struct xcb_input_device_abs_calib_ctl_iterator_t {
+    xcb_input_device_abs_calib_ctl_t *data;
+    int                               rem;
+    int                               index;
+} xcb_input_device_abs_calib_ctl_iterator_t;
+
+/**
+ * @brief xcb_input_device_abs_area_ctrl_t
+ **/
+typedef struct xcb_input_device_abs_area_ctrl_t {
+    uint16_t control_id;
+    uint16_t len;
+    uint32_t offset_x;
+    uint32_t offset_y;
+    int32_t  width;
+    int32_t  height;
+    int32_t  screen;
+    uint32_t following;
+} xcb_input_device_abs_area_ctrl_t;
+
+/**
+ * @brief xcb_input_device_abs_area_ctrl_iterator_t
+ **/
+typedef struct xcb_input_device_abs_area_ctrl_iterator_t {
+    xcb_input_device_abs_area_ctrl_t *data;
+    int                               rem;
+    int                               index;
+} xcb_input_device_abs_area_ctrl_iterator_t;
+
+/**
+ * @brief xcb_input_device_core_ctrl_t
+ **/
+typedef struct xcb_input_device_core_ctrl_t {
+    uint16_t control_id;
+    uint16_t len;
+    uint8_t  status;
+    uint8_t  pad0[3];
+} xcb_input_device_core_ctrl_t;
+
+/**
+ * @brief xcb_input_device_core_ctrl_iterator_t
+ **/
+typedef struct xcb_input_device_core_ctrl_iterator_t {
+    xcb_input_device_core_ctrl_t *data;
+    int                           rem;
+    int                           index;
+} xcb_input_device_core_ctrl_iterator_t;
+
+/**
+ * @brief xcb_input_device_enable_ctrl_t
+ **/
+typedef struct xcb_input_device_enable_ctrl_t {
+    uint16_t control_id;
+    uint16_t len;
+    uint8_t  enable;
+    uint8_t  pad0[3];
+} xcb_input_device_enable_ctrl_t;
+
+/**
+ * @brief xcb_input_device_enable_ctrl_iterator_t
+ **/
+typedef struct xcb_input_device_enable_ctrl_iterator_t {
+    xcb_input_device_enable_ctrl_t *data;
+    int                             rem;
+    int                             index;
+} xcb_input_device_enable_ctrl_iterator_t;
+
+/**
+ * @brief xcb_input_device_ctl_data_t
+ **/
+typedef struct xcb_input_device_ctl_data_t {
+    struct {
+        uint8_t   first_valuator;
+        uint8_t   num_valuators;
+        uint8_t   pad0[2];
+        uint32_t *resolution_values;
+    } resolution;
+    struct {
+        int32_t   min_x;
+        int32_t   max_x;
+        int32_t   min_y;
+        int32_t   max_y;
+        uint32_t  flip_x;
+        uint32_t  flip_y;
+        uint32_t  rotation;
+        uint32_t  button_threshold;
+    } abs_calib;
+    struct {
+        uint8_t   status;
+        uint8_t   pad1[3];
+    } core;
+    struct {
+        uint8_t   enable;
+        uint8_t   pad2[3];
+    } enable;
+    struct {
+        uint32_t  offset_x;
+        uint32_t  offset_y;
+        int32_t   width;
+        int32_t   height;
+        int32_t   screen;
+        uint32_t  following;
+    } abs_area;
+} xcb_input_device_ctl_data_t;
+
+/**
+ * @brief xcb_input_device_ctl_t
+ **/
+typedef struct xcb_input_device_ctl_t {
+    uint16_t control_id;
+    uint16_t len;
+} xcb_input_device_ctl_t;
+
+void *
+xcb_input_device_ctl_data (const xcb_input_device_ctl_t *R);
+
+/**
+ * @brief xcb_input_device_ctl_iterator_t
+ **/
+typedef struct xcb_input_device_ctl_iterator_t {
+    xcb_input_device_ctl_t *data;
+    int                     rem;
+    int                     index;
+} xcb_input_device_ctl_iterator_t;
+
+/**
+ * @brief xcb_input_change_device_control_cookie_t
+ **/
+typedef struct xcb_input_change_device_control_cookie_t {
+    unsigned int sequence;
+} xcb_input_change_device_control_cookie_t;
+
+/** Opcode for xcb_input_change_device_control. */
+#define XCB_INPUT_CHANGE_DEVICE_CONTROL 35
+
+/**
+ * @brief xcb_input_change_device_control_request_t
+ **/
+typedef struct xcb_input_change_device_control_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint16_t control_id;
+    uint8_t  device_id;
+    uint8_t  pad0;
+} xcb_input_change_device_control_request_t;
+
+/**
+ * @brief xcb_input_change_device_control_reply_t
+ **/
+typedef struct xcb_input_change_device_control_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  status;
+    uint8_t  pad0[23];
+} xcb_input_change_device_control_reply_t;
+
+/**
+ * @brief xcb_input_list_device_properties_cookie_t
+ **/
+typedef struct xcb_input_list_device_properties_cookie_t {
+    unsigned int sequence;
+} xcb_input_list_device_properties_cookie_t;
+
+/** Opcode for xcb_input_list_device_properties. */
+#define XCB_INPUT_LIST_DEVICE_PROPERTIES 36
+
+/**
+ * @brief xcb_input_list_device_properties_request_t
+ **/
+typedef struct xcb_input_list_device_properties_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  device_id;
+    uint8_t  pad0[3];
+} xcb_input_list_device_properties_request_t;
+
+/**
+ * @brief xcb_input_list_device_properties_reply_t
+ **/
+typedef struct xcb_input_list_device_properties_reply_t {
+    uint8_t  response_type;
+    uint8_t  xi_reply_type;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t num_atoms;
+    uint8_t  pad0[22];
+} xcb_input_list_device_properties_reply_t;
+
+typedef enum xcb_input_property_format_t {
+    XCB_INPUT_PROPERTY_FORMAT_8_BITS = 8,
+    XCB_INPUT_PROPERTY_FORMAT_16_BITS = 16,
+    XCB_INPUT_PROPERTY_FORMAT_32_BITS = 32
+} xcb_input_property_format_t;
+
+/**
+ * @brief xcb_input_change_device_property_items_t
+ **/
+typedef struct xcb_input_change_device_property_items_t {
+    uint8_t  *data8;
+    uint16_t *data16;
+    uint32_t *data32;
+} xcb_input_change_device_property_items_t;
+
+/** Opcode for xcb_input_change_device_property. */
+#define XCB_INPUT_CHANGE_DEVICE_PROPERTY 37
+
+/**
+ * @brief xcb_input_change_device_property_request_t
+ **/
+typedef struct xcb_input_change_device_property_request_t {
+    uint8_t    major_opcode;
+    uint8_t    minor_opcode;
+    uint16_t   length;
+    xcb_atom_t property;
+    xcb_atom_t type;
+    uint8_t    device_id;
+    uint8_t    format;
+    uint8_t    mode;
+    uint8_t    pad0;
+    uint32_t   num_items;
+} xcb_input_change_device_property_request_t;
+
+/** Opcode for xcb_input_delete_device_property. */
+#define XCB_INPUT_DELETE_DEVICE_PROPERTY 38
+
+/**
+ * @brief xcb_input_delete_device_property_request_t
+ **/
+typedef struct xcb_input_delete_device_property_request_t {
+    uint8_t    major_opcode;
+    uint8_t    minor_opcode;
+    uint16_t   length;
+    xcb_atom_t property;
+    uint8_t    device_id;
+    uint8_t    pad0[3];
+} xcb_input_delete_device_property_request_t;
+
+/**
+ * @brief xcb_input_get_device_property_cookie_t
+ **/
+typedef struct xcb_input_get_device_property_cookie_t {
+    unsigned int sequence;
+} xcb_input_get_device_property_cookie_t;
+
+/** Opcode for xcb_input_get_device_property. */
+#define XCB_INPUT_GET_DEVICE_PROPERTY 39
+
+/**
+ * @brief xcb_input_get_device_property_request_t
+ **/
+typedef struct xcb_input_get_device_property_request_t {
+    uint8_t    major_opcode;
+    uint8_t    minor_opcode;
+    uint16_t   length;
+    xcb_atom_t property;
+    xcb_atom_t type;
+    uint32_t   offset;
+    uint32_t   len;
+    uint8_t    device_id;
+    uint8_t    _delete;
+    uint8_t    pad0[2];
+} xcb_input_get_device_property_request_t;
+
+/**
+ * @brief xcb_input_get_device_property_items_t
+ **/
+typedef struct xcb_input_get_device_property_items_t {
+    uint8_t  *data8;
+    uint16_t *data16;
+    uint32_t *data32;
+} xcb_input_get_device_property_items_t;
+
+/**
+ * @brief xcb_input_get_device_property_reply_t
+ **/
+typedef struct xcb_input_get_device_property_reply_t {
+    uint8_t    response_type;
+    uint8_t    xi_reply_type;
+    uint16_t   sequence;
+    uint32_t   length;
+    xcb_atom_t type;
+    uint32_t   bytes_after;
+    uint32_t   num_items;
+    uint8_t    format;
+    uint8_t    device_id;
+    uint8_t    pad0[10];
+} xcb_input_get_device_property_reply_t;
+
+typedef enum xcb_input_device_t {
+    XCB_INPUT_DEVICE_ALL = 0,
+    XCB_INPUT_DEVICE_ALL_MASTER = 1
+} xcb_input_device_t;
+
+/**
+ * @brief xcb_input_group_info_t
+ **/
+typedef struct xcb_input_group_info_t {
+    uint8_t base;
+    uint8_t latched;
+    uint8_t locked;
+    uint8_t effective;
+} xcb_input_group_info_t;
+
+/**
+ * @brief xcb_input_group_info_iterator_t
+ **/
+typedef struct xcb_input_group_info_iterator_t {
+    xcb_input_group_info_t *data;
+    int                     rem;
+    int                     index;
+} xcb_input_group_info_iterator_t;
+
+/**
+ * @brief xcb_input_modifier_info_t
+ **/
+typedef struct xcb_input_modifier_info_t {
+    uint32_t base;
+    uint32_t latched;
+    uint32_t locked;
+    uint32_t effective;
+} xcb_input_modifier_info_t;
+
+/**
+ * @brief xcb_input_modifier_info_iterator_t
+ **/
+typedef struct xcb_input_modifier_info_iterator_t {
+    xcb_input_modifier_info_t *data;
+    int                        rem;
+    int                        index;
+} xcb_input_modifier_info_iterator_t;
+
+/**
+ * @brief xcb_input_xi_query_pointer_cookie_t
+ **/
+typedef struct xcb_input_xi_query_pointer_cookie_t {
+    unsigned int sequence;
+} xcb_input_xi_query_pointer_cookie_t;
+
+/** Opcode for xcb_input_xi_query_pointer. */
+#define XCB_INPUT_XI_QUERY_POINTER 40
+
+/**
+ * @brief xcb_input_xi_query_pointer_request_t
+ **/
+typedef struct xcb_input_xi_query_pointer_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_window_t          window;
+    xcb_input_device_id_t deviceid;
+    uint8_t               pad0[2];
+} xcb_input_xi_query_pointer_request_t;
+
+/**
+ * @brief xcb_input_xi_query_pointer_reply_t
+ **/
+typedef struct xcb_input_xi_query_pointer_reply_t {
+    uint8_t                   response_type;
+    uint8_t                   pad0;
+    uint16_t                  sequence;
+    uint32_t                  length;
+    xcb_window_t              root;
+    xcb_window_t              child;
+    xcb_input_fp1616_t        root_x;
+    xcb_input_fp1616_t        root_y;
+    xcb_input_fp1616_t        win_x;
+    xcb_input_fp1616_t        win_y;
+    uint8_t                   same_screen;
+    uint8_t                   pad1;
+    uint16_t                  buttons_len;
+    xcb_input_modifier_info_t mods;
+    xcb_input_group_info_t    group;
+} xcb_input_xi_query_pointer_reply_t;
+
+/** Opcode for xcb_input_xi_warp_pointer. */
+#define XCB_INPUT_XI_WARP_POINTER 41
+
+/**
+ * @brief xcb_input_xi_warp_pointer_request_t
+ **/
+typedef struct xcb_input_xi_warp_pointer_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_window_t          src_win;
+    xcb_window_t          dst_win;
+    xcb_input_fp1616_t    src_x;
+    xcb_input_fp1616_t    src_y;
+    uint16_t              src_width;
+    uint16_t              src_height;
+    xcb_input_fp1616_t    dst_x;
+    xcb_input_fp1616_t    dst_y;
+    xcb_input_device_id_t deviceid;
+    uint8_t               pad0[2];
+} xcb_input_xi_warp_pointer_request_t;
+
+/** Opcode for xcb_input_xi_change_cursor. */
+#define XCB_INPUT_XI_CHANGE_CURSOR 42
+
+/**
+ * @brief xcb_input_xi_change_cursor_request_t
+ **/
+typedef struct xcb_input_xi_change_cursor_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_window_t          window;
+    xcb_cursor_t          cursor;
+    xcb_input_device_id_t deviceid;
+    uint8_t               pad0[2];
+} xcb_input_xi_change_cursor_request_t;
+
+typedef enum xcb_input_hierarchy_change_type_t {
+    XCB_INPUT_HIERARCHY_CHANGE_TYPE_ADD_MASTER = 1,
+    XCB_INPUT_HIERARCHY_CHANGE_TYPE_REMOVE_MASTER = 2,
+    XCB_INPUT_HIERARCHY_CHANGE_TYPE_ATTACH_SLAVE = 3,
+    XCB_INPUT_HIERARCHY_CHANGE_TYPE_DETACH_SLAVE = 4
+} xcb_input_hierarchy_change_type_t;
+
+typedef enum xcb_input_change_mode_t {
+    XCB_INPUT_CHANGE_MODE_ATTACH = 1,
+    XCB_INPUT_CHANGE_MODE_FLOAT = 2
+} xcb_input_change_mode_t;
+
+/**
+ * @brief xcb_input_add_master_t
+ **/
+typedef struct xcb_input_add_master_t {
+    uint16_t type;
+    uint16_t len;
+    uint16_t name_len;
+    uint8_t  send_core;
+    uint8_t  enable;
+} xcb_input_add_master_t;
+
+/**
+ * @brief xcb_input_add_master_iterator_t
+ **/
+typedef struct xcb_input_add_master_iterator_t {
+    xcb_input_add_master_t *data;
+    int                     rem;
+    int                     index;
+} xcb_input_add_master_iterator_t;
+
+/**
+ * @brief xcb_input_remove_master_t
+ **/
+typedef struct xcb_input_remove_master_t {
+    uint16_t              type;
+    uint16_t              len;
+    xcb_input_device_id_t deviceid;
+    uint8_t               return_mode;
+    uint8_t               pad0;
+    xcb_input_device_id_t return_pointer;
+    xcb_input_device_id_t return_keyboard;
+} xcb_input_remove_master_t;
+
+/**
+ * @brief xcb_input_remove_master_iterator_t
+ **/
+typedef struct xcb_input_remove_master_iterator_t {
+    xcb_input_remove_master_t *data;
+    int                        rem;
+    int                        index;
+} xcb_input_remove_master_iterator_t;
+
+/**
+ * @brief xcb_input_attach_slave_t
+ **/
+typedef struct xcb_input_attach_slave_t {
+    uint16_t              type;
+    uint16_t              len;
+    xcb_input_device_id_t deviceid;
+    xcb_input_device_id_t master;
+} xcb_input_attach_slave_t;
+
+/**
+ * @brief xcb_input_attach_slave_iterator_t
+ **/
+typedef struct xcb_input_attach_slave_iterator_t {
+    xcb_input_attach_slave_t *data;
+    int                       rem;
+    int                       index;
+} xcb_input_attach_slave_iterator_t;
+
+/**
+ * @brief xcb_input_detach_slave_t
+ **/
+typedef struct xcb_input_detach_slave_t {
+    uint16_t              type;
+    uint16_t              len;
+    xcb_input_device_id_t deviceid;
+    uint8_t               pad0[2];
+} xcb_input_detach_slave_t;
+
+/**
+ * @brief xcb_input_detach_slave_iterator_t
+ **/
+typedef struct xcb_input_detach_slave_iterator_t {
+    xcb_input_detach_slave_t *data;
+    int                       rem;
+    int                       index;
+} xcb_input_detach_slave_iterator_t;
+
+/**
+ * @brief xcb_input_hierarchy_change_data_t
+ **/
+typedef struct xcb_input_hierarchy_change_data_t {
+    struct {
+        uint16_t              name_len;
+        uint8_t               send_core;
+        uint8_t               enable;
+        char                 *name;
+    } add_master;
+    struct {
+        xcb_input_device_id_t deviceid;
+        uint8_t               return_mode;
+        uint8_t               pad1;
+        xcb_input_device_id_t return_pointer;
+        xcb_input_device_id_t return_keyboard;
+    } remove_master;
+    struct {
+        xcb_input_device_id_t deviceid;
+        xcb_input_device_id_t master;
+    } attach_slave;
+    struct {
+        xcb_input_device_id_t deviceid;
+        uint8_t               pad2[2];
+    } detach_slave;
+} xcb_input_hierarchy_change_data_t;
+
+/**
+ * @brief xcb_input_hierarchy_change_t
+ **/
+typedef struct xcb_input_hierarchy_change_t {
+    uint16_t type;
+    uint16_t len;
+} xcb_input_hierarchy_change_t;
+
+void *
+xcb_input_hierarchy_change_data (const xcb_input_hierarchy_change_t *R);
+
+/**
+ * @brief xcb_input_hierarchy_change_iterator_t
+ **/
+typedef struct xcb_input_hierarchy_change_iterator_t {
+    xcb_input_hierarchy_change_t *data;
+    int                           rem;
+    int                           index;
+} xcb_input_hierarchy_change_iterator_t;
+
+/** Opcode for xcb_input_xi_change_hierarchy. */
+#define XCB_INPUT_XI_CHANGE_HIERARCHY 43
+
+/**
+ * @brief xcb_input_xi_change_hierarchy_request_t
+ **/
+typedef struct xcb_input_xi_change_hierarchy_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  num_changes;
+    uint8_t  pad0[3];
+} xcb_input_xi_change_hierarchy_request_t;
+
+/** Opcode for xcb_input_xi_set_client_pointer. */
+#define XCB_INPUT_XI_SET_CLIENT_POINTER 44
+
+/**
+ * @brief xcb_input_xi_set_client_pointer_request_t
+ **/
+typedef struct xcb_input_xi_set_client_pointer_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_window_t          window;
+    xcb_input_device_id_t deviceid;
+    uint8_t               pad0[2];
+} xcb_input_xi_set_client_pointer_request_t;
+
+/**
+ * @brief xcb_input_xi_get_client_pointer_cookie_t
+ **/
+typedef struct xcb_input_xi_get_client_pointer_cookie_t {
+    unsigned int sequence;
+} xcb_input_xi_get_client_pointer_cookie_t;
+
+/** Opcode for xcb_input_xi_get_client_pointer. */
+#define XCB_INPUT_XI_GET_CLIENT_POINTER 45
+
+/**
+ * @brief xcb_input_xi_get_client_pointer_request_t
+ **/
+typedef struct xcb_input_xi_get_client_pointer_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_input_xi_get_client_pointer_request_t;
+
+/**
+ * @brief xcb_input_xi_get_client_pointer_reply_t
+ **/
+typedef struct xcb_input_xi_get_client_pointer_reply_t {
+    uint8_t               response_type;
+    uint8_t               pad0;
+    uint16_t              sequence;
+    uint32_t              length;
+    uint8_t               set;
+    uint8_t               pad1;
+    xcb_input_device_id_t deviceid;
+    uint8_t               pad2[20];
+} xcb_input_xi_get_client_pointer_reply_t;
+
+typedef enum xcb_input_xi_event_mask_t {
+    XCB_INPUT_XI_EVENT_MASK_DEVICE_CHANGED = 2,
+    XCB_INPUT_XI_EVENT_MASK_KEY_PRESS = 4,
+    XCB_INPUT_XI_EVENT_MASK_KEY_RELEASE = 8,
+    XCB_INPUT_XI_EVENT_MASK_BUTTON_PRESS = 16,
+    XCB_INPUT_XI_EVENT_MASK_BUTTON_RELEASE = 32,
+    XCB_INPUT_XI_EVENT_MASK_MOTION = 64,
+    XCB_INPUT_XI_EVENT_MASK_ENTER = 128,
+    XCB_INPUT_XI_EVENT_MASK_LEAVE = 256,
+    XCB_INPUT_XI_EVENT_MASK_FOCUS_IN = 512,
+    XCB_INPUT_XI_EVENT_MASK_FOCUS_OUT = 1024,
+    XCB_INPUT_XI_EVENT_MASK_HIERARCHY = 2048,
+    XCB_INPUT_XI_EVENT_MASK_PROPERTY = 4096,
+    XCB_INPUT_XI_EVENT_MASK_RAW_KEY_PRESS = 8192,
+    XCB_INPUT_XI_EVENT_MASK_RAW_KEY_RELEASE = 16384,
+    XCB_INPUT_XI_EVENT_MASK_RAW_BUTTON_PRESS = 32768,
+    XCB_INPUT_XI_EVENT_MASK_RAW_BUTTON_RELEASE = 65536,
+    XCB_INPUT_XI_EVENT_MASK_RAW_MOTION = 131072,
+    XCB_INPUT_XI_EVENT_MASK_TOUCH_BEGIN = 262144,
+    XCB_INPUT_XI_EVENT_MASK_TOUCH_UPDATE = 524288,
+    XCB_INPUT_XI_EVENT_MASK_TOUCH_END = 1048576,
+    XCB_INPUT_XI_EVENT_MASK_TOUCH_OWNERSHIP = 2097152,
+    XCB_INPUT_XI_EVENT_MASK_RAW_TOUCH_BEGIN = 4194304,
+    XCB_INPUT_XI_EVENT_MASK_RAW_TOUCH_UPDATE = 8388608,
+    XCB_INPUT_XI_EVENT_MASK_RAW_TOUCH_END = 16777216,
+    XCB_INPUT_XI_EVENT_MASK_BARRIER_HIT = 33554432,
+    XCB_INPUT_XI_EVENT_MASK_BARRIER_LEAVE = 67108864
+} xcb_input_xi_event_mask_t;
+
+/**
+ * @brief xcb_input_event_mask_t
+ **/
+typedef struct xcb_input_event_mask_t {
+    xcb_input_device_id_t deviceid;
+    uint16_t              mask_len;
+} xcb_input_event_mask_t;
+
+/**
+ * @brief xcb_input_event_mask_iterator_t
+ **/
+typedef struct xcb_input_event_mask_iterator_t {
+    xcb_input_event_mask_t *data;
+    int                     rem;
+    int                     index;
+} xcb_input_event_mask_iterator_t;
+
+/** Opcode for xcb_input_xi_select_events. */
+#define XCB_INPUT_XI_SELECT_EVENTS 46
+
+/**
+ * @brief xcb_input_xi_select_events_request_t
+ **/
+typedef struct xcb_input_xi_select_events_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    uint16_t     num_mask;
+    uint8_t      pad0[2];
+} xcb_input_xi_select_events_request_t;
+
+/**
+ * @brief xcb_input_xi_query_version_cookie_t
+ **/
+typedef struct xcb_input_xi_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_input_xi_query_version_cookie_t;
+
+/** Opcode for xcb_input_xi_query_version. */
+#define XCB_INPUT_XI_QUERY_VERSION 47
+
+/**
+ * @brief xcb_input_xi_query_version_request_t
+ **/
+typedef struct xcb_input_xi_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint16_t major_version;
+    uint16_t minor_version;
+} xcb_input_xi_query_version_request_t;
+
+/**
+ * @brief xcb_input_xi_query_version_reply_t
+ **/
+typedef struct xcb_input_xi_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t major_version;
+    uint16_t minor_version;
+    uint8_t  pad1[20];
+} xcb_input_xi_query_version_reply_t;
+
+typedef enum xcb_input_device_class_type_t {
+    XCB_INPUT_DEVICE_CLASS_TYPE_KEY = 0,
+    XCB_INPUT_DEVICE_CLASS_TYPE_BUTTON = 1,
+    XCB_INPUT_DEVICE_CLASS_TYPE_VALUATOR = 2,
+    XCB_INPUT_DEVICE_CLASS_TYPE_SCROLL = 3,
+    XCB_INPUT_DEVICE_CLASS_TYPE_TOUCH = 8,
+    XCB_INPUT_DEVICE_CLASS_TYPE_GESTURE = 9
+} xcb_input_device_class_type_t;
+
+typedef enum xcb_input_device_type_t {
+    XCB_INPUT_DEVICE_TYPE_MASTER_POINTER = 1,
+    XCB_INPUT_DEVICE_TYPE_MASTER_KEYBOARD = 2,
+    XCB_INPUT_DEVICE_TYPE_SLAVE_POINTER = 3,
+    XCB_INPUT_DEVICE_TYPE_SLAVE_KEYBOARD = 4,
+    XCB_INPUT_DEVICE_TYPE_FLOATING_SLAVE = 5
+} xcb_input_device_type_t;
+
+typedef enum xcb_input_scroll_flags_t {
+    XCB_INPUT_SCROLL_FLAGS_NO_EMULATION = 1,
+    XCB_INPUT_SCROLL_FLAGS_PREFERRED = 2
+} xcb_input_scroll_flags_t;
+
+typedef enum xcb_input_scroll_type_t {
+    XCB_INPUT_SCROLL_TYPE_VERTICAL = 1,
+    XCB_INPUT_SCROLL_TYPE_HORIZONTAL = 2
+} xcb_input_scroll_type_t;
+
+typedef enum xcb_input_touch_mode_t {
+    XCB_INPUT_TOUCH_MODE_DIRECT = 1,
+    XCB_INPUT_TOUCH_MODE_DEPENDENT = 2
+} xcb_input_touch_mode_t;
+
+/**
+ * @brief xcb_input_button_class_t
+ **/
+typedef struct xcb_input_button_class_t {
+    uint16_t              type;
+    uint16_t              len;
+    xcb_input_device_id_t sourceid;
+    uint16_t              num_buttons;
+} xcb_input_button_class_t;
+
+/**
+ * @brief xcb_input_button_class_iterator_t
+ **/
+typedef struct xcb_input_button_class_iterator_t {
+    xcb_input_button_class_t *data;
+    int                       rem;
+    int                       index;
+} xcb_input_button_class_iterator_t;
+
+/**
+ * @brief xcb_input_key_class_t
+ **/
+typedef struct xcb_input_key_class_t {
+    uint16_t              type;
+    uint16_t              len;
+    xcb_input_device_id_t sourceid;
+    uint16_t              num_keys;
+} xcb_input_key_class_t;
+
+/**
+ * @brief xcb_input_key_class_iterator_t
+ **/
+typedef struct xcb_input_key_class_iterator_t {
+    xcb_input_key_class_t *data;
+    int                    rem;
+    int                    index;
+} xcb_input_key_class_iterator_t;
+
+/**
+ * @brief xcb_input_scroll_class_t
+ **/
+typedef struct xcb_input_scroll_class_t {
+    uint16_t              type;
+    uint16_t              len;
+    xcb_input_device_id_t sourceid;
+    uint16_t              number;
+    uint16_t              scroll_type;
+    uint8_t               pad0[2];
+    uint32_t              flags;
+    xcb_input_fp3232_t    increment;
+} xcb_input_scroll_class_t;
+
+/**
+ * @brief xcb_input_scroll_class_iterator_t
+ **/
+typedef struct xcb_input_scroll_class_iterator_t {
+    xcb_input_scroll_class_t *data;
+    int                       rem;
+    int                       index;
+} xcb_input_scroll_class_iterator_t;
+
+/**
+ * @brief xcb_input_touch_class_t
+ **/
+typedef struct xcb_input_touch_class_t {
+    uint16_t              type;
+    uint16_t              len;
+    xcb_input_device_id_t sourceid;
+    uint8_t               mode;
+    uint8_t               num_touches;
+} xcb_input_touch_class_t;
+
+/**
+ * @brief xcb_input_touch_class_iterator_t
+ **/
+typedef struct xcb_input_touch_class_iterator_t {
+    xcb_input_touch_class_t *data;
+    int                      rem;
+    int                      index;
+} xcb_input_touch_class_iterator_t;
+
+/**
+ * @brief xcb_input_gesture_class_t
+ **/
+typedef struct xcb_input_gesture_class_t {
+    uint16_t              type;
+    uint16_t              len;
+    xcb_input_device_id_t sourceid;
+    uint8_t               num_touches;
+    uint8_t               pad0;
+} xcb_input_gesture_class_t;
+
+/**
+ * @brief xcb_input_gesture_class_iterator_t
+ **/
+typedef struct xcb_input_gesture_class_iterator_t {
+    xcb_input_gesture_class_t *data;
+    int                        rem;
+    int                        index;
+} xcb_input_gesture_class_iterator_t;
+
+/**
+ * @brief xcb_input_valuator_class_t
+ **/
+typedef struct xcb_input_valuator_class_t {
+    uint16_t              type;
+    uint16_t              len;
+    xcb_input_device_id_t sourceid;
+    uint16_t              number;
+    xcb_atom_t            label;
+    xcb_input_fp3232_t    min;
+    xcb_input_fp3232_t    max;
+    xcb_input_fp3232_t    value;
+    uint32_t              resolution;
+    uint8_t               mode;
+    uint8_t               pad0[3];
+} xcb_input_valuator_class_t;
+
+/**
+ * @brief xcb_input_valuator_class_iterator_t
+ **/
+typedef struct xcb_input_valuator_class_iterator_t {
+    xcb_input_valuator_class_t *data;
+    int                         rem;
+    int                         index;
+} xcb_input_valuator_class_iterator_t;
+
+/**
+ * @brief xcb_input_device_class_data_t
+ **/
+typedef struct xcb_input_device_class_data_t {
+    struct {
+        uint16_t           num_keys;
+        uint32_t          *keys;
+    } key;
+    struct {
+        uint16_t           num_buttons;
+        uint32_t          *state;
+        xcb_atom_t        *labels;
+    } button;
+    struct {
+        uint16_t           number;
+        xcb_atom_t         label;
+        xcb_input_fp3232_t min;
+        xcb_input_fp3232_t max;
+        xcb_input_fp3232_t value;
+        uint32_t           resolution;
+        uint8_t            mode;
+        uint8_t            pad0[3];
+    } valuator;
+    struct {
+        uint16_t           number;
+        uint16_t           scroll_type;
+        uint8_t            pad1[2];
+        uint32_t           flags;
+        xcb_input_fp3232_t increment;
+    } scroll;
+    struct {
+        uint8_t            mode;
+        uint8_t            num_touches;
+    } touch;
+    struct {
+        uint8_t            num_touches;
+        uint8_t            pad2;
+    } gesture;
+} xcb_input_device_class_data_t;
+
+/**
+ * @brief xcb_input_device_class_t
+ **/
+typedef struct xcb_input_device_class_t {
+    uint16_t              type;
+    uint16_t              len;
+    xcb_input_device_id_t sourceid;
+} xcb_input_device_class_t;
+
+void *
+xcb_input_device_class_data (const xcb_input_device_class_t *R);
+
+/**
+ * @brief xcb_input_device_class_iterator_t
+ **/
+typedef struct xcb_input_device_class_iterator_t {
+    xcb_input_device_class_t *data;
+    int                       rem;
+    int                       index;
+} xcb_input_device_class_iterator_t;
+
+/**
+ * @brief xcb_input_xi_device_info_t
+ **/
+typedef struct xcb_input_xi_device_info_t {
+    xcb_input_device_id_t deviceid;
+    uint16_t              type;
+    xcb_input_device_id_t attachment;
+    uint16_t              num_classes;
+    uint16_t              name_len;
+    uint8_t               enabled;
+    uint8_t               pad0;
+} xcb_input_xi_device_info_t;
+
+/**
+ * @brief xcb_input_xi_device_info_iterator_t
+ **/
+typedef struct xcb_input_xi_device_info_iterator_t {
+    xcb_input_xi_device_info_t *data;
+    int                         rem;
+    int                         index;
+} xcb_input_xi_device_info_iterator_t;
+
+/**
+ * @brief xcb_input_xi_query_device_cookie_t
+ **/
+typedef struct xcb_input_xi_query_device_cookie_t {
+    unsigned int sequence;
+} xcb_input_xi_query_device_cookie_t;
+
+/** Opcode for xcb_input_xi_query_device. */
+#define XCB_INPUT_XI_QUERY_DEVICE 48
+
+/**
+ * @brief xcb_input_xi_query_device_request_t
+ **/
+typedef struct xcb_input_xi_query_device_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_input_device_id_t deviceid;
+    uint8_t               pad0[2];
+} xcb_input_xi_query_device_request_t;
+
+/**
+ * @brief xcb_input_xi_query_device_reply_t
+ **/
+typedef struct xcb_input_xi_query_device_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t num_infos;
+    uint8_t  pad1[22];
+} xcb_input_xi_query_device_reply_t;
+
+/** Opcode for xcb_input_xi_set_focus. */
+#define XCB_INPUT_XI_SET_FOCUS 49
+
+/**
+ * @brief xcb_input_xi_set_focus_request_t
+ **/
+typedef struct xcb_input_xi_set_focus_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_window_t          window;
+    xcb_timestamp_t       time;
+    xcb_input_device_id_t deviceid;
+    uint8_t               pad0[2];
+} xcb_input_xi_set_focus_request_t;
+
+/**
+ * @brief xcb_input_xi_get_focus_cookie_t
+ **/
+typedef struct xcb_input_xi_get_focus_cookie_t {
+    unsigned int sequence;
+} xcb_input_xi_get_focus_cookie_t;
+
+/** Opcode for xcb_input_xi_get_focus. */
+#define XCB_INPUT_XI_GET_FOCUS 50
+
+/**
+ * @brief xcb_input_xi_get_focus_request_t
+ **/
+typedef struct xcb_input_xi_get_focus_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_input_device_id_t deviceid;
+    uint8_t               pad0[2];
+} xcb_input_xi_get_focus_request_t;
+
+/**
+ * @brief xcb_input_xi_get_focus_reply_t
+ **/
+typedef struct xcb_input_xi_get_focus_reply_t {
+    uint8_t      response_type;
+    uint8_t      pad0;
+    uint16_t     sequence;
+    uint32_t     length;
+    xcb_window_t focus;
+    uint8_t      pad1[20];
+} xcb_input_xi_get_focus_reply_t;
+
+typedef enum xcb_input_grab_owner_t {
+    XCB_INPUT_GRAB_OWNER_NO_OWNER = 0,
+    XCB_INPUT_GRAB_OWNER_OWNER = 1
+} xcb_input_grab_owner_t;
+
+/**
+ * @brief xcb_input_xi_grab_device_cookie_t
+ **/
+typedef struct xcb_input_xi_grab_device_cookie_t {
+    unsigned int sequence;
+} xcb_input_xi_grab_device_cookie_t;
+
+/** Opcode for xcb_input_xi_grab_device. */
+#define XCB_INPUT_XI_GRAB_DEVICE 51
+
+/**
+ * @brief xcb_input_xi_grab_device_request_t
+ **/
+typedef struct xcb_input_xi_grab_device_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_window_t          window;
+    xcb_timestamp_t       time;
+    xcb_cursor_t          cursor;
+    xcb_input_device_id_t deviceid;
+    uint8_t               mode;
+    uint8_t               paired_device_mode;
+    uint8_t               owner_events;
+    uint8_t               pad0;
+    uint16_t              mask_len;
+} xcb_input_xi_grab_device_request_t;
+
+/**
+ * @brief xcb_input_xi_grab_device_reply_t
+ **/
+typedef struct xcb_input_xi_grab_device_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  status;
+    uint8_t  pad1[23];
+} xcb_input_xi_grab_device_reply_t;
+
+/** Opcode for xcb_input_xi_ungrab_device. */
+#define XCB_INPUT_XI_UNGRAB_DEVICE 52
+
+/**
+ * @brief xcb_input_xi_ungrab_device_request_t
+ **/
+typedef struct xcb_input_xi_ungrab_device_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_timestamp_t       time;
+    xcb_input_device_id_t deviceid;
+    uint8_t               pad0[2];
+} xcb_input_xi_ungrab_device_request_t;
+
+typedef enum xcb_input_event_mode_t {
+    XCB_INPUT_EVENT_MODE_ASYNC_DEVICE = 0,
+    XCB_INPUT_EVENT_MODE_SYNC_DEVICE = 1,
+    XCB_INPUT_EVENT_MODE_REPLAY_DEVICE = 2,
+    XCB_INPUT_EVENT_MODE_ASYNC_PAIRED_DEVICE = 3,
+    XCB_INPUT_EVENT_MODE_ASYNC_PAIR = 4,
+    XCB_INPUT_EVENT_MODE_SYNC_PAIR = 5,
+    XCB_INPUT_EVENT_MODE_ACCEPT_TOUCH = 6,
+    XCB_INPUT_EVENT_MODE_REJECT_TOUCH = 7
+} xcb_input_event_mode_t;
+
+/** Opcode for xcb_input_xi_allow_events. */
+#define XCB_INPUT_XI_ALLOW_EVENTS 53
+
+/**
+ * @brief xcb_input_xi_allow_events_request_t
+ **/
+typedef struct xcb_input_xi_allow_events_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_timestamp_t       time;
+    xcb_input_device_id_t deviceid;
+    uint8_t               event_mode;
+    uint8_t               pad0;
+    uint32_t              touchid;
+    xcb_window_t          grab_window;
+} xcb_input_xi_allow_events_request_t;
+
+typedef enum xcb_input_grab_mode_22_t {
+    XCB_INPUT_GRAB_MODE_22_SYNC = 0,
+    XCB_INPUT_GRAB_MODE_22_ASYNC = 1,
+    XCB_INPUT_GRAB_MODE_22_TOUCH = 2
+} xcb_input_grab_mode_22_t;
+
+typedef enum xcb_input_grab_type_t {
+    XCB_INPUT_GRAB_TYPE_BUTTON = 0,
+    XCB_INPUT_GRAB_TYPE_KEYCODE = 1,
+    XCB_INPUT_GRAB_TYPE_ENTER = 2,
+    XCB_INPUT_GRAB_TYPE_FOCUS_IN = 3,
+    XCB_INPUT_GRAB_TYPE_TOUCH_BEGIN = 4,
+    XCB_INPUT_GRAB_TYPE_GESTURE_PINCH_BEGIN = 5,
+    XCB_INPUT_GRAB_TYPE_GESTURE_SWIPE_BEGIN = 6
+} xcb_input_grab_type_t;
+
+typedef enum xcb_input_modifier_mask_t {
+    XCB_INPUT_MODIFIER_MASK_ANY = 2147483648
+} xcb_input_modifier_mask_t;
+
+/**
+ * @brief xcb_input_grab_modifier_info_t
+ **/
+typedef struct xcb_input_grab_modifier_info_t {
+    uint32_t modifiers;
+    uint8_t  status;
+    uint8_t  pad0[3];
+} xcb_input_grab_modifier_info_t;
+
+/**
+ * @brief xcb_input_grab_modifier_info_iterator_t
+ **/
+typedef struct xcb_input_grab_modifier_info_iterator_t {
+    xcb_input_grab_modifier_info_t *data;
+    int                             rem;
+    int                             index;
+} xcb_input_grab_modifier_info_iterator_t;
+
+/**
+ * @brief xcb_input_xi_passive_grab_device_cookie_t
+ **/
+typedef struct xcb_input_xi_passive_grab_device_cookie_t {
+    unsigned int sequence;
+} xcb_input_xi_passive_grab_device_cookie_t;
+
+/** Opcode for xcb_input_xi_passive_grab_device. */
+#define XCB_INPUT_XI_PASSIVE_GRAB_DEVICE 54
+
+/**
+ * @brief xcb_input_xi_passive_grab_device_request_t
+ **/
+typedef struct xcb_input_xi_passive_grab_device_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_timestamp_t       time;
+    xcb_window_t          grab_window;
+    xcb_cursor_t          cursor;
+    uint32_t              detail;
+    xcb_input_device_id_t deviceid;
+    uint16_t              num_modifiers;
+    uint16_t              mask_len;
+    uint8_t               grab_type;
+    uint8_t               grab_mode;
+    uint8_t               paired_device_mode;
+    uint8_t               owner_events;
+    uint8_t               pad0[2];
+} xcb_input_xi_passive_grab_device_request_t;
+
+/**
+ * @brief xcb_input_xi_passive_grab_device_reply_t
+ **/
+typedef struct xcb_input_xi_passive_grab_device_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t num_modifiers;
+    uint8_t  pad1[22];
+} xcb_input_xi_passive_grab_device_reply_t;
+
+/** Opcode for xcb_input_xi_passive_ungrab_device. */
+#define XCB_INPUT_XI_PASSIVE_UNGRAB_DEVICE 55
+
+/**
+ * @brief xcb_input_xi_passive_ungrab_device_request_t
+ **/
+typedef struct xcb_input_xi_passive_ungrab_device_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_window_t          grab_window;
+    uint32_t              detail;
+    xcb_input_device_id_t deviceid;
+    uint16_t              num_modifiers;
+    uint8_t               grab_type;
+    uint8_t               pad0[3];
+} xcb_input_xi_passive_ungrab_device_request_t;
+
+/**
+ * @brief xcb_input_xi_list_properties_cookie_t
+ **/
+typedef struct xcb_input_xi_list_properties_cookie_t {
+    unsigned int sequence;
+} xcb_input_xi_list_properties_cookie_t;
+
+/** Opcode for xcb_input_xi_list_properties. */
+#define XCB_INPUT_XI_LIST_PROPERTIES 56
+
+/**
+ * @brief xcb_input_xi_list_properties_request_t
+ **/
+typedef struct xcb_input_xi_list_properties_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_input_device_id_t deviceid;
+    uint8_t               pad0[2];
+} xcb_input_xi_list_properties_request_t;
+
+/**
+ * @brief xcb_input_xi_list_properties_reply_t
+ **/
+typedef struct xcb_input_xi_list_properties_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t num_properties;
+    uint8_t  pad1[22];
+} xcb_input_xi_list_properties_reply_t;
+
+/**
+ * @brief xcb_input_xi_change_property_items_t
+ **/
+typedef struct xcb_input_xi_change_property_items_t {
+    uint8_t  *data8;
+    uint16_t *data16;
+    uint32_t *data32;
+} xcb_input_xi_change_property_items_t;
+
+/** Opcode for xcb_input_xi_change_property. */
+#define XCB_INPUT_XI_CHANGE_PROPERTY 57
+
+/**
+ * @brief xcb_input_xi_change_property_request_t
+ **/
+typedef struct xcb_input_xi_change_property_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_input_device_id_t deviceid;
+    uint8_t               mode;
+    uint8_t               format;
+    xcb_atom_t            property;
+    xcb_atom_t            type;
+    uint32_t              num_items;
+} xcb_input_xi_change_property_request_t;
+
+/** Opcode for xcb_input_xi_delete_property. */
+#define XCB_INPUT_XI_DELETE_PROPERTY 58
+
+/**
+ * @brief xcb_input_xi_delete_property_request_t
+ **/
+typedef struct xcb_input_xi_delete_property_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_input_device_id_t deviceid;
+    uint8_t               pad0[2];
+    xcb_atom_t            property;
+} xcb_input_xi_delete_property_request_t;
+
+/**
+ * @brief xcb_input_xi_get_property_cookie_t
+ **/
+typedef struct xcb_input_xi_get_property_cookie_t {
+    unsigned int sequence;
+} xcb_input_xi_get_property_cookie_t;
+
+/** Opcode for xcb_input_xi_get_property. */
+#define XCB_INPUT_XI_GET_PROPERTY 59
+
+/**
+ * @brief xcb_input_xi_get_property_request_t
+ **/
+typedef struct xcb_input_xi_get_property_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_input_device_id_t deviceid;
+    uint8_t               _delete;
+    uint8_t               pad0;
+    xcb_atom_t            property;
+    xcb_atom_t            type;
+    uint32_t              offset;
+    uint32_t              len;
+} xcb_input_xi_get_property_request_t;
+
+/**
+ * @brief xcb_input_xi_get_property_items_t
+ **/
+typedef struct xcb_input_xi_get_property_items_t {
+    uint8_t  *data8;
+    uint16_t *data16;
+    uint32_t *data32;
+} xcb_input_xi_get_property_items_t;
+
+/**
+ * @brief xcb_input_xi_get_property_reply_t
+ **/
+typedef struct xcb_input_xi_get_property_reply_t {
+    uint8_t    response_type;
+    uint8_t    pad0;
+    uint16_t   sequence;
+    uint32_t   length;
+    xcb_atom_t type;
+    uint32_t   bytes_after;
+    uint32_t   num_items;
+    uint8_t    format;
+    uint8_t    pad1[11];
+} xcb_input_xi_get_property_reply_t;
+
+/**
+ * @brief xcb_input_xi_get_selected_events_cookie_t
+ **/
+typedef struct xcb_input_xi_get_selected_events_cookie_t {
+    unsigned int sequence;
+} xcb_input_xi_get_selected_events_cookie_t;
+
+/** Opcode for xcb_input_xi_get_selected_events. */
+#define XCB_INPUT_XI_GET_SELECTED_EVENTS 60
+
+/**
+ * @brief xcb_input_xi_get_selected_events_request_t
+ **/
+typedef struct xcb_input_xi_get_selected_events_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_input_xi_get_selected_events_request_t;
+
+/**
+ * @brief xcb_input_xi_get_selected_events_reply_t
+ **/
+typedef struct xcb_input_xi_get_selected_events_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t num_masks;
+    uint8_t  pad1[22];
+} xcb_input_xi_get_selected_events_reply_t;
+
+/**
+ * @brief xcb_input_barrier_release_pointer_info_t
+ **/
+typedef struct xcb_input_barrier_release_pointer_info_t {
+    xcb_input_device_id_t deviceid;
+    uint8_t               pad0[2];
+    xcb_xfixes_barrier_t  barrier;
+    uint32_t              eventid;
+} xcb_input_barrier_release_pointer_info_t;
+
+/**
+ * @brief xcb_input_barrier_release_pointer_info_iterator_t
+ **/
+typedef struct xcb_input_barrier_release_pointer_info_iterator_t {
+    xcb_input_barrier_release_pointer_info_t *data;
+    int                                       rem;
+    int                                       index;
+} xcb_input_barrier_release_pointer_info_iterator_t;
+
+/** Opcode for xcb_input_xi_barrier_release_pointer. */
+#define XCB_INPUT_XI_BARRIER_RELEASE_POINTER 61
+
+/**
+ * @brief xcb_input_xi_barrier_release_pointer_request_t
+ **/
+typedef struct xcb_input_xi_barrier_release_pointer_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t num_barriers;
+} xcb_input_xi_barrier_release_pointer_request_t;
+
+/** Opcode for xcb_input_device_valuator. */
+#define XCB_INPUT_DEVICE_VALUATOR 0
+
+/**
+ * @brief xcb_input_device_valuator_event_t
+ **/
+typedef struct xcb_input_device_valuator_event_t {
+    uint8_t  response_type;
+    uint8_t  device_id;
+    uint16_t sequence;
+    uint16_t device_state;
+    uint8_t  num_valuators;
+    uint8_t  first_valuator;
+    int32_t  valuators[6];
+} xcb_input_device_valuator_event_t;
+
+typedef enum xcb_input_more_events_mask_t {
+    XCB_INPUT_MORE_EVENTS_MASK_MORE_EVENTS = 128
+} xcb_input_more_events_mask_t;
+
+/** Opcode for xcb_input_device_key_press. */
+#define XCB_INPUT_DEVICE_KEY_PRESS 1
+
+/**
+ * @brief xcb_input_device_key_press_event_t
+ **/
+typedef struct xcb_input_device_key_press_event_t {
+    uint8_t         response_type;
+    uint8_t         detail;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    xcb_window_t    root;
+    xcb_window_t    event;
+    xcb_window_t    child;
+    int16_t         root_x;
+    int16_t         root_y;
+    int16_t         event_x;
+    int16_t         event_y;
+    uint16_t        state;
+    uint8_t         same_screen;
+    uint8_t         device_id;
+} xcb_input_device_key_press_event_t;
+
+/** Opcode for xcb_input_device_key_release. */
+#define XCB_INPUT_DEVICE_KEY_RELEASE 2
+
+typedef xcb_input_device_key_press_event_t xcb_input_device_key_release_event_t;
+
+/** Opcode for xcb_input_device_button_press. */
+#define XCB_INPUT_DEVICE_BUTTON_PRESS 3
+
+typedef xcb_input_device_key_press_event_t xcb_input_device_button_press_event_t;
+
+/** Opcode for xcb_input_device_button_release. */
+#define XCB_INPUT_DEVICE_BUTTON_RELEASE 4
+
+typedef xcb_input_device_key_press_event_t xcb_input_device_button_release_event_t;
+
+/** Opcode for xcb_input_device_motion_notify. */
+#define XCB_INPUT_DEVICE_MOTION_NOTIFY 5
+
+typedef xcb_input_device_key_press_event_t xcb_input_device_motion_notify_event_t;
+
+/** Opcode for xcb_input_device_focus_in. */
+#define XCB_INPUT_DEVICE_FOCUS_IN 6
+
+/**
+ * @brief xcb_input_device_focus_in_event_t
+ **/
+typedef struct xcb_input_device_focus_in_event_t {
+    uint8_t         response_type;
+    uint8_t         detail;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    xcb_window_t    window;
+    uint8_t         mode;
+    uint8_t         device_id;
+    uint8_t         pad0[18];
+} xcb_input_device_focus_in_event_t;
+
+/** Opcode for xcb_input_device_focus_out. */
+#define XCB_INPUT_DEVICE_FOCUS_OUT 7
+
+typedef xcb_input_device_focus_in_event_t xcb_input_device_focus_out_event_t;
+
+/** Opcode for xcb_input_proximity_in. */
+#define XCB_INPUT_PROXIMITY_IN 8
+
+typedef xcb_input_device_key_press_event_t xcb_input_proximity_in_event_t;
+
+/** Opcode for xcb_input_proximity_out. */
+#define XCB_INPUT_PROXIMITY_OUT 9
+
+typedef xcb_input_device_key_press_event_t xcb_input_proximity_out_event_t;
+
+typedef enum xcb_input_classes_reported_mask_t {
+    XCB_INPUT_CLASSES_REPORTED_MASK_OUT_OF_PROXIMITY = 128,
+    XCB_INPUT_CLASSES_REPORTED_MASK_DEVICE_MODE_ABSOLUTE = 64,
+    XCB_INPUT_CLASSES_REPORTED_MASK_REPORTING_VALUATORS = 4,
+    XCB_INPUT_CLASSES_REPORTED_MASK_REPORTING_BUTTONS = 2,
+    XCB_INPUT_CLASSES_REPORTED_MASK_REPORTING_KEYS = 1
+} xcb_input_classes_reported_mask_t;
+
+/** Opcode for xcb_input_device_state_notify. */
+#define XCB_INPUT_DEVICE_STATE_NOTIFY 10
+
+/**
+ * @brief xcb_input_device_state_notify_event_t
+ **/
+typedef struct xcb_input_device_state_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         device_id;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    uint8_t         num_keys;
+    uint8_t         num_buttons;
+    uint8_t         num_valuators;
+    uint8_t         classes_reported;
+    uint8_t         buttons[4];
+    uint8_t         keys[4];
+    uint32_t        valuators[3];
+} xcb_input_device_state_notify_event_t;
+
+/** Opcode for xcb_input_device_mapping_notify. */
+#define XCB_INPUT_DEVICE_MAPPING_NOTIFY 11
+
+/**
+ * @brief xcb_input_device_mapping_notify_event_t
+ **/
+typedef struct xcb_input_device_mapping_notify_event_t {
+    uint8_t              response_type;
+    uint8_t              device_id;
+    uint16_t             sequence;
+    uint8_t              request;
+    xcb_input_key_code_t first_keycode;
+    uint8_t              count;
+    uint8_t              pad0;
+    xcb_timestamp_t      time;
+    uint8_t              pad1[20];
+} xcb_input_device_mapping_notify_event_t;
+
+typedef enum xcb_input_change_device_t {
+    XCB_INPUT_CHANGE_DEVICE_NEW_POINTER = 0,
+    XCB_INPUT_CHANGE_DEVICE_NEW_KEYBOARD = 1
+} xcb_input_change_device_t;
+
+/** Opcode for xcb_input_change_device_notify. */
+#define XCB_INPUT_CHANGE_DEVICE_NOTIFY 12
+
+/**
+ * @brief xcb_input_change_device_notify_event_t
+ **/
+typedef struct xcb_input_change_device_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         device_id;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    uint8_t         request;
+    uint8_t         pad0[23];
+} xcb_input_change_device_notify_event_t;
+
+/** Opcode for xcb_input_device_key_state_notify. */
+#define XCB_INPUT_DEVICE_KEY_STATE_NOTIFY 13
+
+/**
+ * @brief xcb_input_device_key_state_notify_event_t
+ **/
+typedef struct xcb_input_device_key_state_notify_event_t {
+    uint8_t  response_type;
+    uint8_t  device_id;
+    uint16_t sequence;
+    uint8_t  keys[28];
+} xcb_input_device_key_state_notify_event_t;
+
+/** Opcode for xcb_input_device_button_state_notify. */
+#define XCB_INPUT_DEVICE_BUTTON_STATE_NOTIFY 14
+
+/**
+ * @brief xcb_input_device_button_state_notify_event_t
+ **/
+typedef struct xcb_input_device_button_state_notify_event_t {
+    uint8_t  response_type;
+    uint8_t  device_id;
+    uint16_t sequence;
+    uint8_t  buttons[28];
+} xcb_input_device_button_state_notify_event_t;
+
+typedef enum xcb_input_device_change_t {
+    XCB_INPUT_DEVICE_CHANGE_ADDED = 0,
+    XCB_INPUT_DEVICE_CHANGE_REMOVED = 1,
+    XCB_INPUT_DEVICE_CHANGE_ENABLED = 2,
+    XCB_INPUT_DEVICE_CHANGE_DISABLED = 3,
+    XCB_INPUT_DEVICE_CHANGE_UNRECOVERABLE = 4,
+    XCB_INPUT_DEVICE_CHANGE_CONTROL_CHANGED = 5
+} xcb_input_device_change_t;
+
+/** Opcode for xcb_input_device_presence_notify. */
+#define XCB_INPUT_DEVICE_PRESENCE_NOTIFY 15
+
+/**
+ * @brief xcb_input_device_presence_notify_event_t
+ **/
+typedef struct xcb_input_device_presence_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         pad0;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    uint8_t         devchange;
+    uint8_t         device_id;
+    uint16_t        control;
+    uint8_t         pad1[20];
+} xcb_input_device_presence_notify_event_t;
+
+/** Opcode for xcb_input_device_property_notify. */
+#define XCB_INPUT_DEVICE_PROPERTY_NOTIFY 16
+
+/**
+ * @brief xcb_input_device_property_notify_event_t
+ **/
+typedef struct xcb_input_device_property_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         state;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    xcb_atom_t      property;
+    uint8_t         pad0[19];
+    uint8_t         device_id;
+} xcb_input_device_property_notify_event_t;
+
+typedef enum xcb_input_change_reason_t {
+    XCB_INPUT_CHANGE_REASON_SLAVE_SWITCH = 1,
+    XCB_INPUT_CHANGE_REASON_DEVICE_CHANGE = 2
+} xcb_input_change_reason_t;
+
+/** Opcode for xcb_input_device_changed. */
+#define XCB_INPUT_DEVICE_CHANGED 1
+
+/**
+ * @brief xcb_input_device_changed_event_t
+ **/
+typedef struct xcb_input_device_changed_event_t {
+    uint8_t               response_type;
+    uint8_t               extension;
+    uint16_t              sequence;
+    uint32_t              length;
+    uint16_t              event_type;
+    xcb_input_device_id_t deviceid;
+    xcb_timestamp_t       time;
+    uint16_t              num_classes;
+    xcb_input_device_id_t sourceid;
+    uint8_t               reason;
+    uint8_t               pad0[11];
+    uint32_t              full_sequence;
+} xcb_input_device_changed_event_t;
+
+typedef enum xcb_input_key_event_flags_t {
+    XCB_INPUT_KEY_EVENT_FLAGS_KEY_REPEAT = 65536
+} xcb_input_key_event_flags_t;
+
+/** Opcode for xcb_input_key_press. */
+#define XCB_INPUT_KEY_PRESS 2
+
+/**
+ * @brief xcb_input_key_press_event_t
+ **/
+typedef struct xcb_input_key_press_event_t {
+    uint8_t                   response_type;
+    uint8_t                   extension;
+    uint16_t                  sequence;
+    uint32_t                  length;
+    uint16_t                  event_type;
+    xcb_input_device_id_t     deviceid;
+    xcb_timestamp_t           time;
+    uint32_t                  detail;
+    xcb_window_t              root;
+    xcb_window_t              event;
+    xcb_window_t              child;
+    uint32_t                  full_sequence;
+    xcb_input_fp1616_t        root_x;
+    xcb_input_fp1616_t        root_y;
+    xcb_input_fp1616_t        event_x;
+    xcb_input_fp1616_t        event_y;
+    uint16_t                  buttons_len;
+    uint16_t                  valuators_len;
+    xcb_input_device_id_t     sourceid;
+    uint8_t                   pad0[2];
+    uint32_t                  flags;
+    xcb_input_modifier_info_t mods;
+    xcb_input_group_info_t    group;
+} xcb_input_key_press_event_t;
+
+/** Opcode for xcb_input_key_release. */
+#define XCB_INPUT_KEY_RELEASE 3
+
+typedef xcb_input_key_press_event_t xcb_input_key_release_event_t;
+
+typedef enum xcb_input_pointer_event_flags_t {
+    XCB_INPUT_POINTER_EVENT_FLAGS_POINTER_EMULATED = 65536
+} xcb_input_pointer_event_flags_t;
+
+/** Opcode for xcb_input_button_press. */
+#define XCB_INPUT_BUTTON_PRESS 4
+
+/**
+ * @brief xcb_input_button_press_event_t
+ **/
+typedef struct xcb_input_button_press_event_t {
+    uint8_t                   response_type;
+    uint8_t                   extension;
+    uint16_t                  sequence;
+    uint32_t                  length;
+    uint16_t                  event_type;
+    xcb_input_device_id_t     deviceid;
+    xcb_timestamp_t           time;
+    uint32_t                  detail;
+    xcb_window_t              root;
+    xcb_window_t              event;
+    xcb_window_t              child;
+    uint32_t                  full_sequence;
+    xcb_input_fp1616_t        root_x;
+    xcb_input_fp1616_t        root_y;
+    xcb_input_fp1616_t        event_x;
+    xcb_input_fp1616_t        event_y;
+    uint16_t                  buttons_len;
+    uint16_t                  valuators_len;
+    xcb_input_device_id_t     sourceid;
+    uint8_t                   pad0[2];
+    uint32_t                  flags;
+    xcb_input_modifier_info_t mods;
+    xcb_input_group_info_t    group;
+} xcb_input_button_press_event_t;
+
+/** Opcode for xcb_input_button_release. */
+#define XCB_INPUT_BUTTON_RELEASE 5
+
+typedef xcb_input_button_press_event_t xcb_input_button_release_event_t;
+
+/** Opcode for xcb_input_motion. */
+#define XCB_INPUT_MOTION 6
+
+typedef xcb_input_button_press_event_t xcb_input_motion_event_t;
+
+typedef enum xcb_input_notify_mode_t {
+    XCB_INPUT_NOTIFY_MODE_NORMAL = 0,
+    XCB_INPUT_NOTIFY_MODE_GRAB = 1,
+    XCB_INPUT_NOTIFY_MODE_UNGRAB = 2,
+    XCB_INPUT_NOTIFY_MODE_WHILE_GRABBED = 3,
+    XCB_INPUT_NOTIFY_MODE_PASSIVE_GRAB = 4,
+    XCB_INPUT_NOTIFY_MODE_PASSIVE_UNGRAB = 5
+} xcb_input_notify_mode_t;
+
+typedef enum xcb_input_notify_detail_t {
+    XCB_INPUT_NOTIFY_DETAIL_ANCESTOR = 0,
+    XCB_INPUT_NOTIFY_DETAIL_VIRTUAL = 1,
+    XCB_INPUT_NOTIFY_DETAIL_INFERIOR = 2,
+    XCB_INPUT_NOTIFY_DETAIL_NONLINEAR = 3,
+    XCB_INPUT_NOTIFY_DETAIL_NONLINEAR_VIRTUAL = 4,
+    XCB_INPUT_NOTIFY_DETAIL_POINTER = 5,
+    XCB_INPUT_NOTIFY_DETAIL_POINTER_ROOT = 6,
+    XCB_INPUT_NOTIFY_DETAIL_NONE = 7
+} xcb_input_notify_detail_t;
+
+/** Opcode for xcb_input_enter. */
+#define XCB_INPUT_ENTER 7
+
+/**
+ * @brief xcb_input_enter_event_t
+ **/
+typedef struct xcb_input_enter_event_t {
+    uint8_t                   response_type;
+    uint8_t                   extension;
+    uint16_t                  sequence;
+    uint32_t                  length;
+    uint16_t                  event_type;
+    xcb_input_device_id_t     deviceid;
+    xcb_timestamp_t           time;
+    xcb_input_device_id_t     sourceid;
+    uint8_t                   mode;
+    uint8_t                   detail;
+    xcb_window_t              root;
+    xcb_window_t              event;
+    xcb_window_t              child;
+    uint32_t                  full_sequence;
+    xcb_input_fp1616_t        root_x;
+    xcb_input_fp1616_t        root_y;
+    xcb_input_fp1616_t        event_x;
+    xcb_input_fp1616_t        event_y;
+    uint8_t                   same_screen;
+    uint8_t                   focus;
+    uint16_t                  buttons_len;
+    xcb_input_modifier_info_t mods;
+    xcb_input_group_info_t    group;
+} xcb_input_enter_event_t;
+
+/** Opcode for xcb_input_leave. */
+#define XCB_INPUT_LEAVE 8
+
+typedef xcb_input_enter_event_t xcb_input_leave_event_t;
+
+/** Opcode for xcb_input_focus_in. */
+#define XCB_INPUT_FOCUS_IN 9
+
+typedef xcb_input_enter_event_t xcb_input_focus_in_event_t;
+
+/** Opcode for xcb_input_focus_out. */
+#define XCB_INPUT_FOCUS_OUT 10
+
+typedef xcb_input_enter_event_t xcb_input_focus_out_event_t;
+
+typedef enum xcb_input_hierarchy_mask_t {
+    XCB_INPUT_HIERARCHY_MASK_MASTER_ADDED = 1,
+    XCB_INPUT_HIERARCHY_MASK_MASTER_REMOVED = 2,
+    XCB_INPUT_HIERARCHY_MASK_SLAVE_ADDED = 4,
+    XCB_INPUT_HIERARCHY_MASK_SLAVE_REMOVED = 8,
+    XCB_INPUT_HIERARCHY_MASK_SLAVE_ATTACHED = 16,
+    XCB_INPUT_HIERARCHY_MASK_SLAVE_DETACHED = 32,
+    XCB_INPUT_HIERARCHY_MASK_DEVICE_ENABLED = 64,
+    XCB_INPUT_HIERARCHY_MASK_DEVICE_DISABLED = 128
+} xcb_input_hierarchy_mask_t;
+
+/**
+ * @brief xcb_input_hierarchy_info_t
+ **/
+typedef struct xcb_input_hierarchy_info_t {
+    xcb_input_device_id_t deviceid;
+    xcb_input_device_id_t attachment;
+    uint8_t               type;
+    uint8_t               enabled;
+    uint8_t               pad0[2];
+    uint32_t              flags;
+} xcb_input_hierarchy_info_t;
+
+/**
+ * @brief xcb_input_hierarchy_info_iterator_t
+ **/
+typedef struct xcb_input_hierarchy_info_iterator_t {
+    xcb_input_hierarchy_info_t *data;
+    int                         rem;
+    int                         index;
+} xcb_input_hierarchy_info_iterator_t;
+
+/** Opcode for xcb_input_hierarchy. */
+#define XCB_INPUT_HIERARCHY 11
+
+/**
+ * @brief xcb_input_hierarchy_event_t
+ **/
+typedef struct xcb_input_hierarchy_event_t {
+    uint8_t               response_type;
+    uint8_t               extension;
+    uint16_t              sequence;
+    uint32_t              length;
+    uint16_t              event_type;
+    xcb_input_device_id_t deviceid;
+    xcb_timestamp_t       time;
+    uint32_t              flags;
+    uint16_t              num_infos;
+    uint8_t               pad0[10];
+    uint32_t              full_sequence;
+} xcb_input_hierarchy_event_t;
+
+typedef enum xcb_input_property_flag_t {
+    XCB_INPUT_PROPERTY_FLAG_DELETED = 0,
+    XCB_INPUT_PROPERTY_FLAG_CREATED = 1,
+    XCB_INPUT_PROPERTY_FLAG_MODIFIED = 2
+} xcb_input_property_flag_t;
+
+/** Opcode for xcb_input_property. */
+#define XCB_INPUT_PROPERTY 12
+
+/**
+ * @brief xcb_input_property_event_t
+ **/
+typedef struct xcb_input_property_event_t {
+    uint8_t               response_type;
+    uint8_t               extension;
+    uint16_t              sequence;
+    uint32_t              length;
+    uint16_t              event_type;
+    xcb_input_device_id_t deviceid;
+    xcb_timestamp_t       time;
+    xcb_atom_t            property;
+    uint8_t               what;
+    uint8_t               pad0[11];
+    uint32_t              full_sequence;
+} xcb_input_property_event_t;
+
+/** Opcode for xcb_input_raw_key_press. */
+#define XCB_INPUT_RAW_KEY_PRESS 13
+
+/**
+ * @brief xcb_input_raw_key_press_event_t
+ **/
+typedef struct xcb_input_raw_key_press_event_t {
+    uint8_t               response_type;
+    uint8_t               extension;
+    uint16_t              sequence;
+    uint32_t              length;
+    uint16_t              event_type;
+    xcb_input_device_id_t deviceid;
+    xcb_timestamp_t       time;
+    uint32_t              detail;
+    xcb_input_device_id_t sourceid;
+    uint16_t              valuators_len;
+    uint32_t              flags;
+    uint8_t               pad0[4];
+    uint32_t              full_sequence;
+} xcb_input_raw_key_press_event_t;
+
+/** Opcode for xcb_input_raw_key_release. */
+#define XCB_INPUT_RAW_KEY_RELEASE 14
+
+typedef xcb_input_raw_key_press_event_t xcb_input_raw_key_release_event_t;
+
+/** Opcode for xcb_input_raw_button_press. */
+#define XCB_INPUT_RAW_BUTTON_PRESS 15
+
+/**
+ * @brief xcb_input_raw_button_press_event_t
+ **/
+typedef struct xcb_input_raw_button_press_event_t {
+    uint8_t               response_type;
+    uint8_t               extension;
+    uint16_t              sequence;
+    uint32_t              length;
+    uint16_t              event_type;
+    xcb_input_device_id_t deviceid;
+    xcb_timestamp_t       time;
+    uint32_t              detail;
+    xcb_input_device_id_t sourceid;
+    uint16_t              valuators_len;
+    uint32_t              flags;
+    uint8_t               pad0[4];
+    uint32_t              full_sequence;
+} xcb_input_raw_button_press_event_t;
+
+/** Opcode for xcb_input_raw_button_release. */
+#define XCB_INPUT_RAW_BUTTON_RELEASE 16
+
+typedef xcb_input_raw_button_press_event_t xcb_input_raw_button_release_event_t;
+
+/** Opcode for xcb_input_raw_motion. */
+#define XCB_INPUT_RAW_MOTION 17
+
+typedef xcb_input_raw_button_press_event_t xcb_input_raw_motion_event_t;
+
+typedef enum xcb_input_touch_event_flags_t {
+    XCB_INPUT_TOUCH_EVENT_FLAGS_TOUCH_PENDING_END = 65536,
+    XCB_INPUT_TOUCH_EVENT_FLAGS_TOUCH_EMULATING_POINTER = 131072
+} xcb_input_touch_event_flags_t;
+
+/** Opcode for xcb_input_touch_begin. */
+#define XCB_INPUT_TOUCH_BEGIN 18
+
+/**
+ * @brief xcb_input_touch_begin_event_t
+ **/
+typedef struct xcb_input_touch_begin_event_t {
+    uint8_t                   response_type;
+    uint8_t                   extension;
+    uint16_t                  sequence;
+    uint32_t                  length;
+    uint16_t                  event_type;
+    xcb_input_device_id_t     deviceid;
+    xcb_timestamp_t           time;
+    uint32_t                  detail;
+    xcb_window_t              root;
+    xcb_window_t              event;
+    xcb_window_t              child;
+    uint32_t                  full_sequence;
+    xcb_input_fp1616_t        root_x;
+    xcb_input_fp1616_t        root_y;
+    xcb_input_fp1616_t        event_x;
+    xcb_input_fp1616_t        event_y;
+    uint16_t                  buttons_len;
+    uint16_t                  valuators_len;
+    xcb_input_device_id_t     sourceid;
+    uint8_t                   pad0[2];
+    uint32_t                  flags;
+    xcb_input_modifier_info_t mods;
+    xcb_input_group_info_t    group;
+} xcb_input_touch_begin_event_t;
+
+/** Opcode for xcb_input_touch_update. */
+#define XCB_INPUT_TOUCH_UPDATE 19
+
+typedef xcb_input_touch_begin_event_t xcb_input_touch_update_event_t;
+
+/** Opcode for xcb_input_touch_end. */
+#define XCB_INPUT_TOUCH_END 20
+
+typedef xcb_input_touch_begin_event_t xcb_input_touch_end_event_t;
+
+typedef enum xcb_input_touch_ownership_flags_t {
+    XCB_INPUT_TOUCH_OWNERSHIP_FLAGS_NONE = 0
+} xcb_input_touch_ownership_flags_t;
+
+/** Opcode for xcb_input_touch_ownership. */
+#define XCB_INPUT_TOUCH_OWNERSHIP 21
+
+/**
+ * @brief xcb_input_touch_ownership_event_t
+ **/
+typedef struct xcb_input_touch_ownership_event_t {
+    uint8_t               response_type;
+    uint8_t               extension;
+    uint16_t              sequence;
+    uint32_t              length;
+    uint16_t              event_type;
+    xcb_input_device_id_t deviceid;
+    xcb_timestamp_t       time;
+    uint32_t              touchid;
+    xcb_window_t          root;
+    xcb_window_t          event;
+    xcb_window_t          child;
+    uint32_t              full_sequence;
+    xcb_input_device_id_t sourceid;
+    uint8_t               pad0[2];
+    uint32_t              flags;
+    uint8_t               pad1[8];
+} xcb_input_touch_ownership_event_t;
+
+/** Opcode for xcb_input_raw_touch_begin. */
+#define XCB_INPUT_RAW_TOUCH_BEGIN 22
+
+/**
+ * @brief xcb_input_raw_touch_begin_event_t
+ **/
+typedef struct xcb_input_raw_touch_begin_event_t {
+    uint8_t               response_type;
+    uint8_t               extension;
+    uint16_t              sequence;
+    uint32_t              length;
+    uint16_t              event_type;
+    xcb_input_device_id_t deviceid;
+    xcb_timestamp_t       time;
+    uint32_t              detail;
+    xcb_input_device_id_t sourceid;
+    uint16_t              valuators_len;
+    uint32_t              flags;
+    uint8_t               pad0[4];
+    uint32_t              full_sequence;
+} xcb_input_raw_touch_begin_event_t;
+
+/** Opcode for xcb_input_raw_touch_update. */
+#define XCB_INPUT_RAW_TOUCH_UPDATE 23
+
+typedef xcb_input_raw_touch_begin_event_t xcb_input_raw_touch_update_event_t;
+
+/** Opcode for xcb_input_raw_touch_end. */
+#define XCB_INPUT_RAW_TOUCH_END 24
+
+typedef xcb_input_raw_touch_begin_event_t xcb_input_raw_touch_end_event_t;
+
+typedef enum xcb_input_barrier_flags_t {
+    XCB_INPUT_BARRIER_FLAGS_POINTER_RELEASED = 1,
+    XCB_INPUT_BARRIER_FLAGS_DEVICE_IS_GRABBED = 2
+} xcb_input_barrier_flags_t;
+
+/** Opcode for xcb_input_barrier_hit. */
+#define XCB_INPUT_BARRIER_HIT 25
+
+/**
+ * @brief xcb_input_barrier_hit_event_t
+ **/
+typedef struct xcb_input_barrier_hit_event_t {
+    uint8_t               response_type;
+    uint8_t               extension;
+    uint16_t              sequence;
+    uint32_t              length;
+    uint16_t              event_type;
+    xcb_input_device_id_t deviceid;
+    xcb_timestamp_t       time;
+    uint32_t              eventid;
+    xcb_window_t          root;
+    xcb_window_t          event;
+    xcb_xfixes_barrier_t  barrier;
+    uint32_t              full_sequence;
+    uint32_t              dtime;
+    uint32_t              flags;
+    xcb_input_device_id_t sourceid;
+    uint8_t               pad0[2];
+    xcb_input_fp1616_t    root_x;
+    xcb_input_fp1616_t    root_y;
+    xcb_input_fp3232_t    dx;
+    xcb_input_fp3232_t    dy;
+} xcb_input_barrier_hit_event_t;
+
+/** Opcode for xcb_input_barrier_leave. */
+#define XCB_INPUT_BARRIER_LEAVE 26
+
+typedef xcb_input_barrier_hit_event_t xcb_input_barrier_leave_event_t;
+
+typedef enum xcb_input_gesture_pinch_event_flags_t {
+    XCB_INPUT_GESTURE_PINCH_EVENT_FLAGS_GESTURE_PINCH_CANCELLED = 1
+} xcb_input_gesture_pinch_event_flags_t;
+
+/** Opcode for xcb_input_gesture_pinch_begin. */
+#define XCB_INPUT_GESTURE_PINCH_BEGIN 27
+
+/**
+ * @brief xcb_input_gesture_pinch_begin_event_t
+ **/
+typedef struct xcb_input_gesture_pinch_begin_event_t {
+    uint8_t                   response_type;
+    uint8_t                   extension;
+    uint16_t                  sequence;
+    uint32_t                  length;
+    uint16_t                  event_type;
+    xcb_input_device_id_t     deviceid;
+    xcb_timestamp_t           time;
+    uint32_t                  detail;
+    xcb_window_t              root;
+    xcb_window_t              event;
+    xcb_window_t              child;
+    uint32_t                  full_sequence;
+    xcb_input_fp1616_t        root_x;
+    xcb_input_fp1616_t        root_y;
+    xcb_input_fp1616_t        event_x;
+    xcb_input_fp1616_t        event_y;
+    xcb_input_fp1616_t        delta_x;
+    xcb_input_fp1616_t        delta_y;
+    xcb_input_fp1616_t        delta_unaccel_x;
+    xcb_input_fp1616_t        delta_unaccel_y;
+    xcb_input_fp1616_t        scale;
+    xcb_input_fp1616_t        delta_angle;
+    xcb_input_device_id_t     sourceid;
+    uint8_t                   pad0[2];
+    xcb_input_modifier_info_t mods;
+    xcb_input_group_info_t    group;
+    uint32_t                  flags;
+} xcb_input_gesture_pinch_begin_event_t;
+
+/** Opcode for xcb_input_gesture_pinch_update. */
+#define XCB_INPUT_GESTURE_PINCH_UPDATE 28
+
+typedef xcb_input_gesture_pinch_begin_event_t xcb_input_gesture_pinch_update_event_t;
+
+/** Opcode for xcb_input_gesture_pinch_end. */
+#define XCB_INPUT_GESTURE_PINCH_END 29
+
+typedef xcb_input_gesture_pinch_begin_event_t xcb_input_gesture_pinch_end_event_t;
+
+typedef enum xcb_input_gesture_swipe_event_flags_t {
+    XCB_INPUT_GESTURE_SWIPE_EVENT_FLAGS_GESTURE_SWIPE_CANCELLED = 1
+} xcb_input_gesture_swipe_event_flags_t;
+
+/** Opcode for xcb_input_gesture_swipe_begin. */
+#define XCB_INPUT_GESTURE_SWIPE_BEGIN 30
+
+/**
+ * @brief xcb_input_gesture_swipe_begin_event_t
+ **/
+typedef struct xcb_input_gesture_swipe_begin_event_t {
+    uint8_t                   response_type;
+    uint8_t                   extension;
+    uint16_t                  sequence;
+    uint32_t                  length;
+    uint16_t                  event_type;
+    xcb_input_device_id_t     deviceid;
+    xcb_timestamp_t           time;
+    uint32_t                  detail;
+    xcb_window_t              root;
+    xcb_window_t              event;
+    xcb_window_t              child;
+    uint32_t                  full_sequence;
+    xcb_input_fp1616_t        root_x;
+    xcb_input_fp1616_t        root_y;
+    xcb_input_fp1616_t        event_x;
+    xcb_input_fp1616_t        event_y;
+    xcb_input_fp1616_t        delta_x;
+    xcb_input_fp1616_t        delta_y;
+    xcb_input_fp1616_t        delta_unaccel_x;
+    xcb_input_fp1616_t        delta_unaccel_y;
+    xcb_input_device_id_t     sourceid;
+    uint8_t                   pad0[2];
+    xcb_input_modifier_info_t mods;
+    xcb_input_group_info_t    group;
+    uint32_t                  flags;
+} xcb_input_gesture_swipe_begin_event_t;
+
+/** Opcode for xcb_input_gesture_swipe_update. */
+#define XCB_INPUT_GESTURE_SWIPE_UPDATE 31
+
+typedef xcb_input_gesture_swipe_begin_event_t xcb_input_gesture_swipe_update_event_t;
+
+/** Opcode for xcb_input_gesture_swipe_end. */
+#define XCB_INPUT_GESTURE_SWIPE_END 32
+
+typedef xcb_input_gesture_swipe_begin_event_t xcb_input_gesture_swipe_end_event_t;
+
+/**
+ * @brief xcb_input_event_for_send_t
+ **/
+typedef union xcb_input_event_for_send_t {
+    xcb_input_device_valuator_event_t            device_valuator;
+    xcb_input_device_key_press_event_t           device_key_press;
+    xcb_input_device_key_release_event_t         device_key_release;
+    xcb_input_device_button_press_event_t        device_button_press;
+    xcb_input_device_button_release_event_t      device_button_release;
+    xcb_input_device_motion_notify_event_t       device_motion_notify;
+    xcb_input_device_focus_in_event_t            device_focus_in;
+    xcb_input_device_focus_out_event_t           device_focus_out;
+    xcb_input_proximity_in_event_t               proximity_in;
+    xcb_input_proximity_out_event_t              proximity_out;
+    xcb_input_device_state_notify_event_t        device_state_notify;
+    xcb_input_device_mapping_notify_event_t      device_mapping_notify;
+    xcb_input_change_device_notify_event_t       change_device_notify;
+    xcb_input_device_key_state_notify_event_t    device_key_state_notify;
+    xcb_input_device_button_state_notify_event_t device_button_state_notify;
+    xcb_input_device_presence_notify_event_t     device_presence_notify;
+    xcb_raw_generic_event_t                      event_header;
+} xcb_input_event_for_send_t;
+
+/**
+ * @brief xcb_input_event_for_send_iterator_t
+ **/
+typedef struct xcb_input_event_for_send_iterator_t {
+    xcb_input_event_for_send_t *data;
+    int                         rem;
+    int                         index;
+} xcb_input_event_for_send_iterator_t;
+
+/** Opcode for xcb_input_send_extension_event. */
+#define XCB_INPUT_SEND_EXTENSION_EVENT 31
+
+/**
+ * @brief xcb_input_send_extension_event_request_t
+ **/
+typedef struct xcb_input_send_extension_event_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t destination;
+    uint8_t      device_id;
+    uint8_t      propagate;
+    uint16_t     num_classes;
+    uint8_t      num_events;
+    uint8_t      pad0[3];
+} xcb_input_send_extension_event_request_t;
+
+/** Opcode for xcb_input_device. */
+#define XCB_INPUT_DEVICE 0
+
+/**
+ * @brief xcb_input_device_error_t
+ **/
+typedef struct xcb_input_device_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_input_device_error_t;
+
+/** Opcode for xcb_input_event. */
+#define XCB_INPUT_EVENT 1
+
+/**
+ * @brief xcb_input_event_error_t
+ **/
+typedef struct xcb_input_event_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_input_event_error_t;
+
+/** Opcode for xcb_input_mode. */
+#define XCB_INPUT_MODE 2
+
+/**
+ * @brief xcb_input_mode_error_t
+ **/
+typedef struct xcb_input_mode_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_input_mode_error_t;
+
+/** Opcode for xcb_input_device_busy. */
+#define XCB_INPUT_DEVICE_BUSY 3
+
+/**
+ * @brief xcb_input_device_busy_error_t
+ **/
+typedef struct xcb_input_device_busy_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_input_device_busy_error_t;
+
+/** Opcode for xcb_input_class. */
+#define XCB_INPUT_CLASS 4
+
+/**
+ * @brief xcb_input_class_error_t
+ **/
+typedef struct xcb_input_class_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_input_class_error_t;
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_event_class_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_event_class_t)
+ */
+void
+xcb_input_event_class_next (xcb_input_event_class_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_event_class_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_event_class_end (xcb_input_event_class_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_key_code_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_key_code_t)
+ */
+void
+xcb_input_key_code_next (xcb_input_key_code_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_key_code_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_key_code_end (xcb_input_key_code_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_device_id_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_device_id_t)
+ */
+void
+xcb_input_device_id_next (xcb_input_device_id_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_device_id_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_device_id_end (xcb_input_device_id_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_fp1616_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_fp1616_t)
+ */
+void
+xcb_input_fp1616_next (xcb_input_fp1616_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_fp1616_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_fp1616_end (xcb_input_fp1616_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_fp3232_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_fp3232_t)
+ */
+void
+xcb_input_fp3232_next (xcb_input_fp3232_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_fp3232_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_fp3232_end (xcb_input_fp3232_iterator_t i);
+
+int
+xcb_input_get_extension_version_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_get_extension_version_cookie_t
+xcb_input_get_extension_version (xcb_connection_t *c,
+                                 uint16_t          name_len,
+                                 const char       *name);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_get_extension_version_cookie_t
+xcb_input_get_extension_version_unchecked (xcb_connection_t *c,
+                                           uint16_t          name_len,
+                                           const char       *name);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_get_extension_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_get_extension_version_reply_t *
+xcb_input_get_extension_version_reply (xcb_connection_t                          *c,
+                                       xcb_input_get_extension_version_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_device_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_device_info_t)
+ */
+void
+xcb_input_device_info_next (xcb_input_device_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_device_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_device_info_end (xcb_input_device_info_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_key_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_key_info_t)
+ */
+void
+xcb_input_key_info_next (xcb_input_key_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_key_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_key_info_end (xcb_input_key_info_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_button_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_button_info_t)
+ */
+void
+xcb_input_button_info_next (xcb_input_button_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_button_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_button_info_end (xcb_input_button_info_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_axis_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_axis_info_t)
+ */
+void
+xcb_input_axis_info_next (xcb_input_axis_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_axis_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_axis_info_end (xcb_input_axis_info_iterator_t i);
+
+int
+xcb_input_valuator_info_sizeof (const void  *_buffer);
+
+xcb_input_axis_info_t *
+xcb_input_valuator_info_axes (const xcb_input_valuator_info_t *R);
+
+int
+xcb_input_valuator_info_axes_length (const xcb_input_valuator_info_t *R);
+
+xcb_input_axis_info_iterator_t
+xcb_input_valuator_info_axes_iterator (const xcb_input_valuator_info_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_valuator_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_valuator_info_t)
+ */
+void
+xcb_input_valuator_info_next (xcb_input_valuator_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_valuator_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_valuator_info_end (xcb_input_valuator_info_iterator_t i);
+
+xcb_input_axis_info_t *
+xcb_input_input_info_info_valuator_axes (const xcb_input_input_info_info_t *S);
+
+int
+xcb_input_input_info_info_valuator_axes_length (const xcb_input_input_info_t *R,
+                                                const xcb_input_input_info_info_t *S);
+
+xcb_input_axis_info_iterator_t
+xcb_input_input_info_info_valuator_axes_iterator (const xcb_input_input_info_t *R,
+                                                  const xcb_input_input_info_info_t *S);
+
+int
+xcb_input_input_info_info_serialize (void                              **_buffer,
+                                     uint8_t                             class_id,
+                                     const xcb_input_input_info_info_t  *_aux);
+
+int
+xcb_input_input_info_info_unpack (const void                   *_buffer,
+                                  uint8_t                       class_id,
+                                  xcb_input_input_info_info_t  *_aux);
+
+int
+xcb_input_input_info_info_sizeof (const void  *_buffer,
+                                  uint8_t      class_id);
+
+int
+xcb_input_input_info_sizeof (const void  *_buffer);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_input_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_input_info_t)
+ */
+void
+xcb_input_input_info_next (xcb_input_input_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_input_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_input_info_end (xcb_input_input_info_iterator_t i);
+
+int
+xcb_input_device_name_sizeof (const void  *_buffer);
+
+char *
+xcb_input_device_name_string (const xcb_input_device_name_t *R);
+
+int
+xcb_input_device_name_string_length (const xcb_input_device_name_t *R);
+
+xcb_generic_iterator_t
+xcb_input_device_name_string_end (const xcb_input_device_name_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_device_name_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_device_name_t)
+ */
+void
+xcb_input_device_name_next (xcb_input_device_name_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_device_name_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_device_name_end (xcb_input_device_name_iterator_t i);
+
+int
+xcb_input_list_input_devices_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_list_input_devices_cookie_t
+xcb_input_list_input_devices (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_list_input_devices_cookie_t
+xcb_input_list_input_devices_unchecked (xcb_connection_t *c);
+
+xcb_input_device_info_t *
+xcb_input_list_input_devices_devices (const xcb_input_list_input_devices_reply_t *R);
+
+int
+xcb_input_list_input_devices_devices_length (const xcb_input_list_input_devices_reply_t *R);
+
+xcb_input_device_info_iterator_t
+xcb_input_list_input_devices_devices_iterator (const xcb_input_list_input_devices_reply_t *R);
+
+int
+xcb_input_list_input_devices_infos_length (const xcb_input_list_input_devices_reply_t *R);
+
+xcb_input_input_info_iterator_t
+xcb_input_list_input_devices_infos_iterator (const xcb_input_list_input_devices_reply_t *R);
+
+int
+xcb_input_list_input_devices_names_length (const xcb_input_list_input_devices_reply_t *R);
+
+xcb_str_iterator_t
+xcb_input_list_input_devices_names_iterator (const xcb_input_list_input_devices_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_list_input_devices_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_list_input_devices_reply_t *
+xcb_input_list_input_devices_reply (xcb_connection_t                       *c,
+                                    xcb_input_list_input_devices_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_event_type_base_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_event_type_base_t)
+ */
+void
+xcb_input_event_type_base_next (xcb_input_event_type_base_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_event_type_base_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_event_type_base_end (xcb_input_event_type_base_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_input_class_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_input_class_info_t)
+ */
+void
+xcb_input_input_class_info_next (xcb_input_input_class_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_input_class_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_input_class_info_end (xcb_input_input_class_info_iterator_t i);
+
+int
+xcb_input_open_device_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_open_device_cookie_t
+xcb_input_open_device (xcb_connection_t *c,
+                       uint8_t           device_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_open_device_cookie_t
+xcb_input_open_device_unchecked (xcb_connection_t *c,
+                                 uint8_t           device_id);
+
+xcb_input_input_class_info_t *
+xcb_input_open_device_class_info (const xcb_input_open_device_reply_t *R);
+
+int
+xcb_input_open_device_class_info_length (const xcb_input_open_device_reply_t *R);
+
+xcb_input_input_class_info_iterator_t
+xcb_input_open_device_class_info_iterator (const xcb_input_open_device_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_open_device_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_open_device_reply_t *
+xcb_input_open_device_reply (xcb_connection_t                *c,
+                             xcb_input_open_device_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_close_device_checked (xcb_connection_t *c,
+                                uint8_t           device_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_close_device (xcb_connection_t *c,
+                        uint8_t           device_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_set_device_mode_cookie_t
+xcb_input_set_device_mode (xcb_connection_t *c,
+                           uint8_t           device_id,
+                           uint8_t           mode);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_set_device_mode_cookie_t
+xcb_input_set_device_mode_unchecked (xcb_connection_t *c,
+                                     uint8_t           device_id,
+                                     uint8_t           mode);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_set_device_mode_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_set_device_mode_reply_t *
+xcb_input_set_device_mode_reply (xcb_connection_t                    *c,
+                                 xcb_input_set_device_mode_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e);
+
+int
+xcb_input_select_extension_event_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_select_extension_event_checked (xcb_connection_t              *c,
+                                          xcb_window_t                   window,
+                                          uint16_t                       num_classes,
+                                          const xcb_input_event_class_t *classes);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_select_extension_event (xcb_connection_t              *c,
+                                  xcb_window_t                   window,
+                                  uint16_t                       num_classes,
+                                  const xcb_input_event_class_t *classes);
+
+xcb_input_event_class_t *
+xcb_input_select_extension_event_classes (const xcb_input_select_extension_event_request_t *R);
+
+int
+xcb_input_select_extension_event_classes_length (const xcb_input_select_extension_event_request_t *R);
+
+xcb_generic_iterator_t
+xcb_input_select_extension_event_classes_end (const xcb_input_select_extension_event_request_t *R);
+
+int
+xcb_input_get_selected_extension_events_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_get_selected_extension_events_cookie_t
+xcb_input_get_selected_extension_events (xcb_connection_t *c,
+                                         xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_get_selected_extension_events_cookie_t
+xcb_input_get_selected_extension_events_unchecked (xcb_connection_t *c,
+                                                   xcb_window_t      window);
+
+xcb_input_event_class_t *
+xcb_input_get_selected_extension_events_this_classes (const xcb_input_get_selected_extension_events_reply_t *R);
+
+int
+xcb_input_get_selected_extension_events_this_classes_length (const xcb_input_get_selected_extension_events_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_input_get_selected_extension_events_this_classes_end (const xcb_input_get_selected_extension_events_reply_t *R);
+
+xcb_input_event_class_t *
+xcb_input_get_selected_extension_events_all_classes (const xcb_input_get_selected_extension_events_reply_t *R);
+
+int
+xcb_input_get_selected_extension_events_all_classes_length (const xcb_input_get_selected_extension_events_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_input_get_selected_extension_events_all_classes_end (const xcb_input_get_selected_extension_events_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_get_selected_extension_events_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_get_selected_extension_events_reply_t *
+xcb_input_get_selected_extension_events_reply (xcb_connection_t                                  *c,
+                                               xcb_input_get_selected_extension_events_cookie_t   cookie  /**< */,
+                                               xcb_generic_error_t                              **e);
+
+int
+xcb_input_change_device_dont_propagate_list_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_change_device_dont_propagate_list_checked (xcb_connection_t              *c,
+                                                     xcb_window_t                   window,
+                                                     uint16_t                       num_classes,
+                                                     uint8_t                        mode,
+                                                     const xcb_input_event_class_t *classes);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_change_device_dont_propagate_list (xcb_connection_t              *c,
+                                             xcb_window_t                   window,
+                                             uint16_t                       num_classes,
+                                             uint8_t                        mode,
+                                             const xcb_input_event_class_t *classes);
+
+xcb_input_event_class_t *
+xcb_input_change_device_dont_propagate_list_classes (const xcb_input_change_device_dont_propagate_list_request_t *R);
+
+int
+xcb_input_change_device_dont_propagate_list_classes_length (const xcb_input_change_device_dont_propagate_list_request_t *R);
+
+xcb_generic_iterator_t
+xcb_input_change_device_dont_propagate_list_classes_end (const xcb_input_change_device_dont_propagate_list_request_t *R);
+
+int
+xcb_input_get_device_dont_propagate_list_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_get_device_dont_propagate_list_cookie_t
+xcb_input_get_device_dont_propagate_list (xcb_connection_t *c,
+                                          xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_get_device_dont_propagate_list_cookie_t
+xcb_input_get_device_dont_propagate_list_unchecked (xcb_connection_t *c,
+                                                    xcb_window_t      window);
+
+xcb_input_event_class_t *
+xcb_input_get_device_dont_propagate_list_classes (const xcb_input_get_device_dont_propagate_list_reply_t *R);
+
+int
+xcb_input_get_device_dont_propagate_list_classes_length (const xcb_input_get_device_dont_propagate_list_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_input_get_device_dont_propagate_list_classes_end (const xcb_input_get_device_dont_propagate_list_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_get_device_dont_propagate_list_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_get_device_dont_propagate_list_reply_t *
+xcb_input_get_device_dont_propagate_list_reply (xcb_connection_t                                   *c,
+                                                xcb_input_get_device_dont_propagate_list_cookie_t   cookie  /**< */,
+                                                xcb_generic_error_t                               **e);
+
+int
+xcb_input_device_time_coord_sizeof (const void  *_buffer,
+                                    uint8_t      num_axes);
+
+int32_t *
+xcb_input_device_time_coord_axisvalues (const xcb_input_device_time_coord_t *R);
+
+int
+xcb_input_device_time_coord_axisvalues_length (const xcb_input_device_time_coord_t *R,
+                                               uint8_t num_axes);
+
+xcb_generic_iterator_t
+xcb_input_device_time_coord_axisvalues_end (const xcb_input_device_time_coord_t *R,
+                                            uint8_t num_axes);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_device_time_coord_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_device_time_coord_t)
+ */
+void
+xcb_input_device_time_coord_next (xcb_input_device_time_coord_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_device_time_coord_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_device_time_coord_end (xcb_input_device_time_coord_iterator_t i);
+
+int
+xcb_input_get_device_motion_events_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_get_device_motion_events_cookie_t
+xcb_input_get_device_motion_events (xcb_connection_t *c,
+                                    xcb_timestamp_t   start,
+                                    xcb_timestamp_t   stop,
+                                    uint8_t           device_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_get_device_motion_events_cookie_t
+xcb_input_get_device_motion_events_unchecked (xcb_connection_t *c,
+                                              xcb_timestamp_t   start,
+                                              xcb_timestamp_t   stop,
+                                              uint8_t           device_id);
+
+int
+xcb_input_get_device_motion_events_events_length (const xcb_input_get_device_motion_events_reply_t *R);
+
+xcb_input_device_time_coord_iterator_t
+xcb_input_get_device_motion_events_events_iterator (const xcb_input_get_device_motion_events_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_get_device_motion_events_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_get_device_motion_events_reply_t *
+xcb_input_get_device_motion_events_reply (xcb_connection_t                             *c,
+                                          xcb_input_get_device_motion_events_cookie_t   cookie  /**< */,
+                                          xcb_generic_error_t                         **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_change_keyboard_device_cookie_t
+xcb_input_change_keyboard_device (xcb_connection_t *c,
+                                  uint8_t           device_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_change_keyboard_device_cookie_t
+xcb_input_change_keyboard_device_unchecked (xcb_connection_t *c,
+                                            uint8_t           device_id);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_change_keyboard_device_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_change_keyboard_device_reply_t *
+xcb_input_change_keyboard_device_reply (xcb_connection_t                           *c,
+                                        xcb_input_change_keyboard_device_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_change_pointer_device_cookie_t
+xcb_input_change_pointer_device (xcb_connection_t *c,
+                                 uint8_t           x_axis,
+                                 uint8_t           y_axis,
+                                 uint8_t           device_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_change_pointer_device_cookie_t
+xcb_input_change_pointer_device_unchecked (xcb_connection_t *c,
+                                           uint8_t           x_axis,
+                                           uint8_t           y_axis,
+                                           uint8_t           device_id);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_change_pointer_device_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_change_pointer_device_reply_t *
+xcb_input_change_pointer_device_reply (xcb_connection_t                          *c,
+                                       xcb_input_change_pointer_device_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e);
+
+int
+xcb_input_grab_device_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_grab_device_cookie_t
+xcb_input_grab_device (xcb_connection_t              *c,
+                       xcb_window_t                   grab_window,
+                       xcb_timestamp_t                time,
+                       uint16_t                       num_classes,
+                       uint8_t                        this_device_mode,
+                       uint8_t                        other_device_mode,
+                       uint8_t                        owner_events,
+                       uint8_t                        device_id,
+                       const xcb_input_event_class_t *classes);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_grab_device_cookie_t
+xcb_input_grab_device_unchecked (xcb_connection_t              *c,
+                                 xcb_window_t                   grab_window,
+                                 xcb_timestamp_t                time,
+                                 uint16_t                       num_classes,
+                                 uint8_t                        this_device_mode,
+                                 uint8_t                        other_device_mode,
+                                 uint8_t                        owner_events,
+                                 uint8_t                        device_id,
+                                 const xcb_input_event_class_t *classes);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_grab_device_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_grab_device_reply_t *
+xcb_input_grab_device_reply (xcb_connection_t                *c,
+                             xcb_input_grab_device_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_ungrab_device_checked (xcb_connection_t *c,
+                                 xcb_timestamp_t   time,
+                                 uint8_t           device_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_ungrab_device (xcb_connection_t *c,
+                         xcb_timestamp_t   time,
+                         uint8_t           device_id);
+
+int
+xcb_input_grab_device_key_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_grab_device_key_checked (xcb_connection_t              *c,
+                                   xcb_window_t                   grab_window,
+                                   uint16_t                       num_classes,
+                                   uint16_t                       modifiers,
+                                   uint8_t                        modifier_device,
+                                   uint8_t                        grabbed_device,
+                                   uint8_t                        key,
+                                   uint8_t                        this_device_mode,
+                                   uint8_t                        other_device_mode,
+                                   uint8_t                        owner_events,
+                                   const xcb_input_event_class_t *classes);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_grab_device_key (xcb_connection_t              *c,
+                           xcb_window_t                   grab_window,
+                           uint16_t                       num_classes,
+                           uint16_t                       modifiers,
+                           uint8_t                        modifier_device,
+                           uint8_t                        grabbed_device,
+                           uint8_t                        key,
+                           uint8_t                        this_device_mode,
+                           uint8_t                        other_device_mode,
+                           uint8_t                        owner_events,
+                           const xcb_input_event_class_t *classes);
+
+xcb_input_event_class_t *
+xcb_input_grab_device_key_classes (const xcb_input_grab_device_key_request_t *R);
+
+int
+xcb_input_grab_device_key_classes_length (const xcb_input_grab_device_key_request_t *R);
+
+xcb_generic_iterator_t
+xcb_input_grab_device_key_classes_end (const xcb_input_grab_device_key_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_ungrab_device_key_checked (xcb_connection_t *c,
+                                     xcb_window_t      grabWindow,
+                                     uint16_t          modifiers,
+                                     uint8_t           modifier_device,
+                                     uint8_t           key,
+                                     uint8_t           grabbed_device);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_ungrab_device_key (xcb_connection_t *c,
+                             xcb_window_t      grabWindow,
+                             uint16_t          modifiers,
+                             uint8_t           modifier_device,
+                             uint8_t           key,
+                             uint8_t           grabbed_device);
+
+int
+xcb_input_grab_device_button_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_grab_device_button_checked (xcb_connection_t              *c,
+                                      xcb_window_t                   grab_window,
+                                      uint8_t                        grabbed_device,
+                                      uint8_t                        modifier_device,
+                                      uint16_t                       num_classes,
+                                      uint16_t                       modifiers,
+                                      uint8_t                        this_device_mode,
+                                      uint8_t                        other_device_mode,
+                                      uint8_t                        button,
+                                      uint8_t                        owner_events,
+                                      const xcb_input_event_class_t *classes);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_grab_device_button (xcb_connection_t              *c,
+                              xcb_window_t                   grab_window,
+                              uint8_t                        grabbed_device,
+                              uint8_t                        modifier_device,
+                              uint16_t                       num_classes,
+                              uint16_t                       modifiers,
+                              uint8_t                        this_device_mode,
+                              uint8_t                        other_device_mode,
+                              uint8_t                        button,
+                              uint8_t                        owner_events,
+                              const xcb_input_event_class_t *classes);
+
+xcb_input_event_class_t *
+xcb_input_grab_device_button_classes (const xcb_input_grab_device_button_request_t *R);
+
+int
+xcb_input_grab_device_button_classes_length (const xcb_input_grab_device_button_request_t *R);
+
+xcb_generic_iterator_t
+xcb_input_grab_device_button_classes_end (const xcb_input_grab_device_button_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_ungrab_device_button_checked (xcb_connection_t *c,
+                                        xcb_window_t      grab_window,
+                                        uint16_t          modifiers,
+                                        uint8_t           modifier_device,
+                                        uint8_t           button,
+                                        uint8_t           grabbed_device);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_ungrab_device_button (xcb_connection_t *c,
+                                xcb_window_t      grab_window,
+                                uint16_t          modifiers,
+                                uint8_t           modifier_device,
+                                uint8_t           button,
+                                uint8_t           grabbed_device);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_allow_device_events_checked (xcb_connection_t *c,
+                                       xcb_timestamp_t   time,
+                                       uint8_t           mode,
+                                       uint8_t           device_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_allow_device_events (xcb_connection_t *c,
+                               xcb_timestamp_t   time,
+                               uint8_t           mode,
+                               uint8_t           device_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_get_device_focus_cookie_t
+xcb_input_get_device_focus (xcb_connection_t *c,
+                            uint8_t           device_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_get_device_focus_cookie_t
+xcb_input_get_device_focus_unchecked (xcb_connection_t *c,
+                                      uint8_t           device_id);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_get_device_focus_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_get_device_focus_reply_t *
+xcb_input_get_device_focus_reply (xcb_connection_t                     *c,
+                                  xcb_input_get_device_focus_cookie_t   cookie  /**< */,
+                                  xcb_generic_error_t                 **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_set_device_focus_checked (xcb_connection_t *c,
+                                    xcb_window_t      focus,
+                                    xcb_timestamp_t   time,
+                                    uint8_t           revert_to,
+                                    uint8_t           device_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_set_device_focus (xcb_connection_t *c,
+                            xcb_window_t      focus,
+                            xcb_timestamp_t   time,
+                            uint8_t           revert_to,
+                            uint8_t           device_id);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_kbd_feedback_state_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_kbd_feedback_state_t)
+ */
+void
+xcb_input_kbd_feedback_state_next (xcb_input_kbd_feedback_state_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_kbd_feedback_state_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_kbd_feedback_state_end (xcb_input_kbd_feedback_state_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_ptr_feedback_state_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_ptr_feedback_state_t)
+ */
+void
+xcb_input_ptr_feedback_state_next (xcb_input_ptr_feedback_state_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_ptr_feedback_state_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_ptr_feedback_state_end (xcb_input_ptr_feedback_state_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_integer_feedback_state_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_integer_feedback_state_t)
+ */
+void
+xcb_input_integer_feedback_state_next (xcb_input_integer_feedback_state_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_integer_feedback_state_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_integer_feedback_state_end (xcb_input_integer_feedback_state_iterator_t i);
+
+int
+xcb_input_string_feedback_state_sizeof (const void  *_buffer);
+
+xcb_keysym_t *
+xcb_input_string_feedback_state_keysyms (const xcb_input_string_feedback_state_t *R);
+
+int
+xcb_input_string_feedback_state_keysyms_length (const xcb_input_string_feedback_state_t *R);
+
+xcb_generic_iterator_t
+xcb_input_string_feedback_state_keysyms_end (const xcb_input_string_feedback_state_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_string_feedback_state_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_string_feedback_state_t)
+ */
+void
+xcb_input_string_feedback_state_next (xcb_input_string_feedback_state_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_string_feedback_state_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_string_feedback_state_end (xcb_input_string_feedback_state_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_bell_feedback_state_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_bell_feedback_state_t)
+ */
+void
+xcb_input_bell_feedback_state_next (xcb_input_bell_feedback_state_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_bell_feedback_state_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_bell_feedback_state_end (xcb_input_bell_feedback_state_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_led_feedback_state_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_led_feedback_state_t)
+ */
+void
+xcb_input_led_feedback_state_next (xcb_input_led_feedback_state_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_led_feedback_state_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_led_feedback_state_end (xcb_input_led_feedback_state_iterator_t i);
+
+xcb_keysym_t *
+xcb_input_feedback_state_data_string_keysyms (const xcb_input_feedback_state_data_t *S);
+
+int
+xcb_input_feedback_state_data_string_keysyms_length (const xcb_input_feedback_state_t *R,
+                                                     const xcb_input_feedback_state_data_t *S);
+
+xcb_generic_iterator_t
+xcb_input_feedback_state_data_string_keysyms_end (const xcb_input_feedback_state_t *R,
+                                                  const xcb_input_feedback_state_data_t *S);
+
+int
+xcb_input_feedback_state_data_serialize (void                                  **_buffer,
+                                         uint8_t                                 class_id,
+                                         const xcb_input_feedback_state_data_t  *_aux);
+
+int
+xcb_input_feedback_state_data_unpack (const void                       *_buffer,
+                                      uint8_t                           class_id,
+                                      xcb_input_feedback_state_data_t  *_aux);
+
+int
+xcb_input_feedback_state_data_sizeof (const void  *_buffer,
+                                      uint8_t      class_id);
+
+int
+xcb_input_feedback_state_sizeof (const void  *_buffer);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_feedback_state_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_feedback_state_t)
+ */
+void
+xcb_input_feedback_state_next (xcb_input_feedback_state_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_feedback_state_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_feedback_state_end (xcb_input_feedback_state_iterator_t i);
+
+int
+xcb_input_get_feedback_control_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_get_feedback_control_cookie_t
+xcb_input_get_feedback_control (xcb_connection_t *c,
+                                uint8_t           device_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_get_feedback_control_cookie_t
+xcb_input_get_feedback_control_unchecked (xcb_connection_t *c,
+                                          uint8_t           device_id);
+
+int
+xcb_input_get_feedback_control_feedbacks_length (const xcb_input_get_feedback_control_reply_t *R);
+
+xcb_input_feedback_state_iterator_t
+xcb_input_get_feedback_control_feedbacks_iterator (const xcb_input_get_feedback_control_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_get_feedback_control_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_get_feedback_control_reply_t *
+xcb_input_get_feedback_control_reply (xcb_connection_t                         *c,
+                                      xcb_input_get_feedback_control_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_kbd_feedback_ctl_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_kbd_feedback_ctl_t)
+ */
+void
+xcb_input_kbd_feedback_ctl_next (xcb_input_kbd_feedback_ctl_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_kbd_feedback_ctl_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_kbd_feedback_ctl_end (xcb_input_kbd_feedback_ctl_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_ptr_feedback_ctl_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_ptr_feedback_ctl_t)
+ */
+void
+xcb_input_ptr_feedback_ctl_next (xcb_input_ptr_feedback_ctl_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_ptr_feedback_ctl_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_ptr_feedback_ctl_end (xcb_input_ptr_feedback_ctl_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_integer_feedback_ctl_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_integer_feedback_ctl_t)
+ */
+void
+xcb_input_integer_feedback_ctl_next (xcb_input_integer_feedback_ctl_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_integer_feedback_ctl_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_integer_feedback_ctl_end (xcb_input_integer_feedback_ctl_iterator_t i);
+
+int
+xcb_input_string_feedback_ctl_sizeof (const void  *_buffer);
+
+xcb_keysym_t *
+xcb_input_string_feedback_ctl_keysyms (const xcb_input_string_feedback_ctl_t *R);
+
+int
+xcb_input_string_feedback_ctl_keysyms_length (const xcb_input_string_feedback_ctl_t *R);
+
+xcb_generic_iterator_t
+xcb_input_string_feedback_ctl_keysyms_end (const xcb_input_string_feedback_ctl_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_string_feedback_ctl_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_string_feedback_ctl_t)
+ */
+void
+xcb_input_string_feedback_ctl_next (xcb_input_string_feedback_ctl_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_string_feedback_ctl_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_string_feedback_ctl_end (xcb_input_string_feedback_ctl_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_bell_feedback_ctl_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_bell_feedback_ctl_t)
+ */
+void
+xcb_input_bell_feedback_ctl_next (xcb_input_bell_feedback_ctl_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_bell_feedback_ctl_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_bell_feedback_ctl_end (xcb_input_bell_feedback_ctl_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_led_feedback_ctl_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_led_feedback_ctl_t)
+ */
+void
+xcb_input_led_feedback_ctl_next (xcb_input_led_feedback_ctl_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_led_feedback_ctl_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_led_feedback_ctl_end (xcb_input_led_feedback_ctl_iterator_t i);
+
+xcb_keysym_t *
+xcb_input_feedback_ctl_data_string_keysyms (const xcb_input_feedback_ctl_data_t *S);
+
+int
+xcb_input_feedback_ctl_data_string_keysyms_length (const xcb_input_feedback_ctl_t *R,
+                                                   const xcb_input_feedback_ctl_data_t *S);
+
+xcb_generic_iterator_t
+xcb_input_feedback_ctl_data_string_keysyms_end (const xcb_input_feedback_ctl_t *R,
+                                                const xcb_input_feedback_ctl_data_t *S);
+
+int
+xcb_input_feedback_ctl_data_serialize (void                                **_buffer,
+                                       uint8_t                               class_id,
+                                       const xcb_input_feedback_ctl_data_t  *_aux);
+
+int
+xcb_input_feedback_ctl_data_unpack (const void                     *_buffer,
+                                    uint8_t                         class_id,
+                                    xcb_input_feedback_ctl_data_t  *_aux);
+
+int
+xcb_input_feedback_ctl_data_sizeof (const void  *_buffer,
+                                    uint8_t      class_id);
+
+int
+xcb_input_feedback_ctl_sizeof (const void  *_buffer);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_feedback_ctl_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_feedback_ctl_t)
+ */
+void
+xcb_input_feedback_ctl_next (xcb_input_feedback_ctl_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_feedback_ctl_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_feedback_ctl_end (xcb_input_feedback_ctl_iterator_t i);
+
+int
+xcb_input_change_feedback_control_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_change_feedback_control_checked (xcb_connection_t         *c,
+                                           uint32_t                  mask,
+                                           uint8_t                   device_id,
+                                           uint8_t                   feedback_id,
+                                           xcb_input_feedback_ctl_t *feedback);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_change_feedback_control (xcb_connection_t         *c,
+                                   uint32_t                  mask,
+                                   uint8_t                   device_id,
+                                   uint8_t                   feedback_id,
+                                   xcb_input_feedback_ctl_t *feedback);
+
+xcb_input_feedback_ctl_t *
+xcb_input_change_feedback_control_feedback (const xcb_input_change_feedback_control_request_t *R);
+
+int
+xcb_input_get_device_key_mapping_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_get_device_key_mapping_cookie_t
+xcb_input_get_device_key_mapping (xcb_connection_t     *c,
+                                  uint8_t               device_id,
+                                  xcb_input_key_code_t  first_keycode,
+                                  uint8_t               count);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_get_device_key_mapping_cookie_t
+xcb_input_get_device_key_mapping_unchecked (xcb_connection_t     *c,
+                                            uint8_t               device_id,
+                                            xcb_input_key_code_t  first_keycode,
+                                            uint8_t               count);
+
+xcb_keysym_t *
+xcb_input_get_device_key_mapping_keysyms (const xcb_input_get_device_key_mapping_reply_t *R);
+
+int
+xcb_input_get_device_key_mapping_keysyms_length (const xcb_input_get_device_key_mapping_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_input_get_device_key_mapping_keysyms_end (const xcb_input_get_device_key_mapping_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_get_device_key_mapping_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_get_device_key_mapping_reply_t *
+xcb_input_get_device_key_mapping_reply (xcb_connection_t                           *c,
+                                        xcb_input_get_device_key_mapping_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e);
+
+int
+xcb_input_change_device_key_mapping_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_change_device_key_mapping_checked (xcb_connection_t     *c,
+                                             uint8_t               device_id,
+                                             xcb_input_key_code_t  first_keycode,
+                                             uint8_t               keysyms_per_keycode,
+                                             uint8_t               keycode_count,
+                                             const xcb_keysym_t   *keysyms);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_change_device_key_mapping (xcb_connection_t     *c,
+                                     uint8_t               device_id,
+                                     xcb_input_key_code_t  first_keycode,
+                                     uint8_t               keysyms_per_keycode,
+                                     uint8_t               keycode_count,
+                                     const xcb_keysym_t   *keysyms);
+
+xcb_keysym_t *
+xcb_input_change_device_key_mapping_keysyms (const xcb_input_change_device_key_mapping_request_t *R);
+
+int
+xcb_input_change_device_key_mapping_keysyms_length (const xcb_input_change_device_key_mapping_request_t *R);
+
+xcb_generic_iterator_t
+xcb_input_change_device_key_mapping_keysyms_end (const xcb_input_change_device_key_mapping_request_t *R);
+
+int
+xcb_input_get_device_modifier_mapping_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_get_device_modifier_mapping_cookie_t
+xcb_input_get_device_modifier_mapping (xcb_connection_t *c,
+                                       uint8_t           device_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_get_device_modifier_mapping_cookie_t
+xcb_input_get_device_modifier_mapping_unchecked (xcb_connection_t *c,
+                                                 uint8_t           device_id);
+
+uint8_t *
+xcb_input_get_device_modifier_mapping_keymaps (const xcb_input_get_device_modifier_mapping_reply_t *R);
+
+int
+xcb_input_get_device_modifier_mapping_keymaps_length (const xcb_input_get_device_modifier_mapping_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_input_get_device_modifier_mapping_keymaps_end (const xcb_input_get_device_modifier_mapping_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_get_device_modifier_mapping_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_get_device_modifier_mapping_reply_t *
+xcb_input_get_device_modifier_mapping_reply (xcb_connection_t                                *c,
+                                             xcb_input_get_device_modifier_mapping_cookie_t   cookie  /**< */,
+                                             xcb_generic_error_t                            **e);
+
+int
+xcb_input_set_device_modifier_mapping_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_set_device_modifier_mapping_cookie_t
+xcb_input_set_device_modifier_mapping (xcb_connection_t *c,
+                                       uint8_t           device_id,
+                                       uint8_t           keycodes_per_modifier,
+                                       const uint8_t    *keymaps);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_set_device_modifier_mapping_cookie_t
+xcb_input_set_device_modifier_mapping_unchecked (xcb_connection_t *c,
+                                                 uint8_t           device_id,
+                                                 uint8_t           keycodes_per_modifier,
+                                                 const uint8_t    *keymaps);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_set_device_modifier_mapping_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_set_device_modifier_mapping_reply_t *
+xcb_input_set_device_modifier_mapping_reply (xcb_connection_t                                *c,
+                                             xcb_input_set_device_modifier_mapping_cookie_t   cookie  /**< */,
+                                             xcb_generic_error_t                            **e);
+
+int
+xcb_input_get_device_button_mapping_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_get_device_button_mapping_cookie_t
+xcb_input_get_device_button_mapping (xcb_connection_t *c,
+                                     uint8_t           device_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_get_device_button_mapping_cookie_t
+xcb_input_get_device_button_mapping_unchecked (xcb_connection_t *c,
+                                               uint8_t           device_id);
+
+uint8_t *
+xcb_input_get_device_button_mapping_map (const xcb_input_get_device_button_mapping_reply_t *R);
+
+int
+xcb_input_get_device_button_mapping_map_length (const xcb_input_get_device_button_mapping_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_input_get_device_button_mapping_map_end (const xcb_input_get_device_button_mapping_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_get_device_button_mapping_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_get_device_button_mapping_reply_t *
+xcb_input_get_device_button_mapping_reply (xcb_connection_t                              *c,
+                                           xcb_input_get_device_button_mapping_cookie_t   cookie  /**< */,
+                                           xcb_generic_error_t                          **e);
+
+int
+xcb_input_set_device_button_mapping_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_set_device_button_mapping_cookie_t
+xcb_input_set_device_button_mapping (xcb_connection_t *c,
+                                     uint8_t           device_id,
+                                     uint8_t           map_size,
+                                     const uint8_t    *map);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_set_device_button_mapping_cookie_t
+xcb_input_set_device_button_mapping_unchecked (xcb_connection_t *c,
+                                               uint8_t           device_id,
+                                               uint8_t           map_size,
+                                               const uint8_t    *map);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_set_device_button_mapping_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_set_device_button_mapping_reply_t *
+xcb_input_set_device_button_mapping_reply (xcb_connection_t                              *c,
+                                           xcb_input_set_device_button_mapping_cookie_t   cookie  /**< */,
+                                           xcb_generic_error_t                          **e);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_key_state_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_key_state_t)
+ */
+void
+xcb_input_key_state_next (xcb_input_key_state_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_key_state_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_key_state_end (xcb_input_key_state_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_button_state_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_button_state_t)
+ */
+void
+xcb_input_button_state_next (xcb_input_button_state_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_button_state_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_button_state_end (xcb_input_button_state_iterator_t i);
+
+int
+xcb_input_valuator_state_sizeof (const void  *_buffer);
+
+int32_t *
+xcb_input_valuator_state_valuators (const xcb_input_valuator_state_t *R);
+
+int
+xcb_input_valuator_state_valuators_length (const xcb_input_valuator_state_t *R);
+
+xcb_generic_iterator_t
+xcb_input_valuator_state_valuators_end (const xcb_input_valuator_state_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_valuator_state_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_valuator_state_t)
+ */
+void
+xcb_input_valuator_state_next (xcb_input_valuator_state_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_valuator_state_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_valuator_state_end (xcb_input_valuator_state_iterator_t i);
+
+int32_t *
+xcb_input_input_state_data_valuator_valuators (const xcb_input_input_state_data_t *S);
+
+int
+xcb_input_input_state_data_valuator_valuators_length (const xcb_input_input_state_t *R,
+                                                      const xcb_input_input_state_data_t *S);
+
+xcb_generic_iterator_t
+xcb_input_input_state_data_valuator_valuators_end (const xcb_input_input_state_t *R,
+                                                   const xcb_input_input_state_data_t *S);
+
+int
+xcb_input_input_state_data_serialize (void                               **_buffer,
+                                      uint8_t                              class_id,
+                                      const xcb_input_input_state_data_t  *_aux);
+
+int
+xcb_input_input_state_data_unpack (const void                    *_buffer,
+                                   uint8_t                        class_id,
+                                   xcb_input_input_state_data_t  *_aux);
+
+int
+xcb_input_input_state_data_sizeof (const void  *_buffer,
+                                   uint8_t      class_id);
+
+int
+xcb_input_input_state_sizeof (const void  *_buffer);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_input_state_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_input_state_t)
+ */
+void
+xcb_input_input_state_next (xcb_input_input_state_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_input_state_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_input_state_end (xcb_input_input_state_iterator_t i);
+
+int
+xcb_input_query_device_state_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_query_device_state_cookie_t
+xcb_input_query_device_state (xcb_connection_t *c,
+                              uint8_t           device_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_query_device_state_cookie_t
+xcb_input_query_device_state_unchecked (xcb_connection_t *c,
+                                        uint8_t           device_id);
+
+int
+xcb_input_query_device_state_classes_length (const xcb_input_query_device_state_reply_t *R);
+
+xcb_input_input_state_iterator_t
+xcb_input_query_device_state_classes_iterator (const xcb_input_query_device_state_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_query_device_state_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_query_device_state_reply_t *
+xcb_input_query_device_state_reply (xcb_connection_t                       *c,
+                                    xcb_input_query_device_state_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_device_bell_checked (xcb_connection_t *c,
+                               uint8_t           device_id,
+                               uint8_t           feedback_id,
+                               uint8_t           feedback_class,
+                               int8_t            percent);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_device_bell (xcb_connection_t *c,
+                       uint8_t           device_id,
+                       uint8_t           feedback_id,
+                       uint8_t           feedback_class,
+                       int8_t            percent);
+
+int
+xcb_input_set_device_valuators_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_set_device_valuators_cookie_t
+xcb_input_set_device_valuators (xcb_connection_t *c,
+                                uint8_t           device_id,
+                                uint8_t           first_valuator,
+                                uint8_t           num_valuators,
+                                const int32_t    *valuators);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_set_device_valuators_cookie_t
+xcb_input_set_device_valuators_unchecked (xcb_connection_t *c,
+                                          uint8_t           device_id,
+                                          uint8_t           first_valuator,
+                                          uint8_t           num_valuators,
+                                          const int32_t    *valuators);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_set_device_valuators_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_set_device_valuators_reply_t *
+xcb_input_set_device_valuators_reply (xcb_connection_t                         *c,
+                                      xcb_input_set_device_valuators_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e);
+
+int
+xcb_input_device_resolution_state_sizeof (const void  *_buffer);
+
+uint32_t *
+xcb_input_device_resolution_state_resolution_values (const xcb_input_device_resolution_state_t *R);
+
+int
+xcb_input_device_resolution_state_resolution_values_length (const xcb_input_device_resolution_state_t *R);
+
+xcb_generic_iterator_t
+xcb_input_device_resolution_state_resolution_values_end (const xcb_input_device_resolution_state_t *R);
+
+uint32_t *
+xcb_input_device_resolution_state_resolution_min (const xcb_input_device_resolution_state_t *R);
+
+int
+xcb_input_device_resolution_state_resolution_min_length (const xcb_input_device_resolution_state_t *R);
+
+xcb_generic_iterator_t
+xcb_input_device_resolution_state_resolution_min_end (const xcb_input_device_resolution_state_t *R);
+
+uint32_t *
+xcb_input_device_resolution_state_resolution_max (const xcb_input_device_resolution_state_t *R);
+
+int
+xcb_input_device_resolution_state_resolution_max_length (const xcb_input_device_resolution_state_t *R);
+
+xcb_generic_iterator_t
+xcb_input_device_resolution_state_resolution_max_end (const xcb_input_device_resolution_state_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_device_resolution_state_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_device_resolution_state_t)
+ */
+void
+xcb_input_device_resolution_state_next (xcb_input_device_resolution_state_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_device_resolution_state_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_device_resolution_state_end (xcb_input_device_resolution_state_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_device_abs_calib_state_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_device_abs_calib_state_t)
+ */
+void
+xcb_input_device_abs_calib_state_next (xcb_input_device_abs_calib_state_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_device_abs_calib_state_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_device_abs_calib_state_end (xcb_input_device_abs_calib_state_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_device_abs_area_state_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_device_abs_area_state_t)
+ */
+void
+xcb_input_device_abs_area_state_next (xcb_input_device_abs_area_state_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_device_abs_area_state_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_device_abs_area_state_end (xcb_input_device_abs_area_state_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_device_core_state_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_device_core_state_t)
+ */
+void
+xcb_input_device_core_state_next (xcb_input_device_core_state_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_device_core_state_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_device_core_state_end (xcb_input_device_core_state_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_device_enable_state_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_device_enable_state_t)
+ */
+void
+xcb_input_device_enable_state_next (xcb_input_device_enable_state_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_device_enable_state_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_device_enable_state_end (xcb_input_device_enable_state_iterator_t i);
+
+uint32_t *
+xcb_input_device_state_data_resolution_resolution_values (const xcb_input_device_state_data_t *S);
+
+int
+xcb_input_device_state_data_resolution_resolution_values_length (const xcb_input_device_state_t *R,
+                                                                 const xcb_input_device_state_data_t *S);
+
+xcb_generic_iterator_t
+xcb_input_device_state_data_resolution_resolution_values_end (const xcb_input_device_state_t *R,
+                                                              const xcb_input_device_state_data_t *S);
+
+uint32_t *
+xcb_input_device_state_data_resolution_resolution_min (const xcb_input_device_state_data_t *S);
+
+int
+xcb_input_device_state_data_resolution_resolution_min_length (const xcb_input_device_state_t *R,
+                                                              const xcb_input_device_state_data_t *S);
+
+xcb_generic_iterator_t
+xcb_input_device_state_data_resolution_resolution_min_end (const xcb_input_device_state_t *R,
+                                                           const xcb_input_device_state_data_t *S);
+
+uint32_t *
+xcb_input_device_state_data_resolution_resolution_max (const xcb_input_device_state_data_t *S);
+
+int
+xcb_input_device_state_data_resolution_resolution_max_length (const xcb_input_device_state_t *R,
+                                                              const xcb_input_device_state_data_t *S);
+
+xcb_generic_iterator_t
+xcb_input_device_state_data_resolution_resolution_max_end (const xcb_input_device_state_t *R,
+                                                           const xcb_input_device_state_data_t *S);
+
+int
+xcb_input_device_state_data_serialize (void                                **_buffer,
+                                       uint16_t                              control_id,
+                                       const xcb_input_device_state_data_t  *_aux);
+
+int
+xcb_input_device_state_data_unpack (const void                     *_buffer,
+                                    uint16_t                        control_id,
+                                    xcb_input_device_state_data_t  *_aux);
+
+int
+xcb_input_device_state_data_sizeof (const void  *_buffer,
+                                    uint16_t     control_id);
+
+int
+xcb_input_device_state_sizeof (const void  *_buffer);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_device_state_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_device_state_t)
+ */
+void
+xcb_input_device_state_next (xcb_input_device_state_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_device_state_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_device_state_end (xcb_input_device_state_iterator_t i);
+
+int
+xcb_input_get_device_control_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_get_device_control_cookie_t
+xcb_input_get_device_control (xcb_connection_t *c,
+                              uint16_t          control_id,
+                              uint8_t           device_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_get_device_control_cookie_t
+xcb_input_get_device_control_unchecked (xcb_connection_t *c,
+                                        uint16_t          control_id,
+                                        uint8_t           device_id);
+
+xcb_input_device_state_t *
+xcb_input_get_device_control_control (const xcb_input_get_device_control_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_get_device_control_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_get_device_control_reply_t *
+xcb_input_get_device_control_reply (xcb_connection_t                       *c,
+                                    xcb_input_get_device_control_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e);
+
+int
+xcb_input_device_resolution_ctl_sizeof (const void  *_buffer);
+
+uint32_t *
+xcb_input_device_resolution_ctl_resolution_values (const xcb_input_device_resolution_ctl_t *R);
+
+int
+xcb_input_device_resolution_ctl_resolution_values_length (const xcb_input_device_resolution_ctl_t *R);
+
+xcb_generic_iterator_t
+xcb_input_device_resolution_ctl_resolution_values_end (const xcb_input_device_resolution_ctl_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_device_resolution_ctl_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_device_resolution_ctl_t)
+ */
+void
+xcb_input_device_resolution_ctl_next (xcb_input_device_resolution_ctl_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_device_resolution_ctl_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_device_resolution_ctl_end (xcb_input_device_resolution_ctl_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_device_abs_calib_ctl_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_device_abs_calib_ctl_t)
+ */
+void
+xcb_input_device_abs_calib_ctl_next (xcb_input_device_abs_calib_ctl_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_device_abs_calib_ctl_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_device_abs_calib_ctl_end (xcb_input_device_abs_calib_ctl_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_device_abs_area_ctrl_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_device_abs_area_ctrl_t)
+ */
+void
+xcb_input_device_abs_area_ctrl_next (xcb_input_device_abs_area_ctrl_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_device_abs_area_ctrl_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_device_abs_area_ctrl_end (xcb_input_device_abs_area_ctrl_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_device_core_ctrl_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_device_core_ctrl_t)
+ */
+void
+xcb_input_device_core_ctrl_next (xcb_input_device_core_ctrl_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_device_core_ctrl_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_device_core_ctrl_end (xcb_input_device_core_ctrl_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_device_enable_ctrl_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_device_enable_ctrl_t)
+ */
+void
+xcb_input_device_enable_ctrl_next (xcb_input_device_enable_ctrl_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_device_enable_ctrl_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_device_enable_ctrl_end (xcb_input_device_enable_ctrl_iterator_t i);
+
+uint32_t *
+xcb_input_device_ctl_data_resolution_resolution_values (const xcb_input_device_ctl_data_t *S);
+
+int
+xcb_input_device_ctl_data_resolution_resolution_values_length (const xcb_input_device_ctl_t *R,
+                                                               const xcb_input_device_ctl_data_t *S);
+
+xcb_generic_iterator_t
+xcb_input_device_ctl_data_resolution_resolution_values_end (const xcb_input_device_ctl_t *R,
+                                                            const xcb_input_device_ctl_data_t *S);
+
+int
+xcb_input_device_ctl_data_serialize (void                              **_buffer,
+                                     uint16_t                            control_id,
+                                     const xcb_input_device_ctl_data_t  *_aux);
+
+int
+xcb_input_device_ctl_data_unpack (const void                   *_buffer,
+                                  uint16_t                      control_id,
+                                  xcb_input_device_ctl_data_t  *_aux);
+
+int
+xcb_input_device_ctl_data_sizeof (const void  *_buffer,
+                                  uint16_t     control_id);
+
+int
+xcb_input_device_ctl_sizeof (const void  *_buffer);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_device_ctl_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_device_ctl_t)
+ */
+void
+xcb_input_device_ctl_next (xcb_input_device_ctl_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_device_ctl_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_device_ctl_end (xcb_input_device_ctl_iterator_t i);
+
+int
+xcb_input_change_device_control_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_change_device_control_cookie_t
+xcb_input_change_device_control (xcb_connection_t       *c,
+                                 uint16_t                control_id,
+                                 uint8_t                 device_id,
+                                 xcb_input_device_ctl_t *control);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_change_device_control_cookie_t
+xcb_input_change_device_control_unchecked (xcb_connection_t       *c,
+                                           uint16_t                control_id,
+                                           uint8_t                 device_id,
+                                           xcb_input_device_ctl_t *control);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_change_device_control_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_change_device_control_reply_t *
+xcb_input_change_device_control_reply (xcb_connection_t                          *c,
+                                       xcb_input_change_device_control_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e);
+
+int
+xcb_input_list_device_properties_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_list_device_properties_cookie_t
+xcb_input_list_device_properties (xcb_connection_t *c,
+                                  uint8_t           device_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_list_device_properties_cookie_t
+xcb_input_list_device_properties_unchecked (xcb_connection_t *c,
+                                            uint8_t           device_id);
+
+xcb_atom_t *
+xcb_input_list_device_properties_atoms (const xcb_input_list_device_properties_reply_t *R);
+
+int
+xcb_input_list_device_properties_atoms_length (const xcb_input_list_device_properties_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_input_list_device_properties_atoms_end (const xcb_input_list_device_properties_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_list_device_properties_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_list_device_properties_reply_t *
+xcb_input_list_device_properties_reply (xcb_connection_t                           *c,
+                                        xcb_input_list_device_properties_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e);
+
+uint8_t *
+xcb_input_change_device_property_items_data_8 (const xcb_input_change_device_property_items_t *S);
+
+int
+xcb_input_change_device_property_items_data_8_length (const xcb_input_change_device_property_request_t *R,
+                                                      const xcb_input_change_device_property_items_t *S);
+
+xcb_generic_iterator_t
+xcb_input_change_device_property_items_data_8_end (const xcb_input_change_device_property_request_t *R,
+                                                   const xcb_input_change_device_property_items_t *S);
+
+uint16_t *
+xcb_input_change_device_property_items_data_16 (const xcb_input_change_device_property_items_t *S);
+
+int
+xcb_input_change_device_property_items_data_16_length (const xcb_input_change_device_property_request_t *R,
+                                                       const xcb_input_change_device_property_items_t *S);
+
+xcb_generic_iterator_t
+xcb_input_change_device_property_items_data_16_end (const xcb_input_change_device_property_request_t *R,
+                                                    const xcb_input_change_device_property_items_t *S);
+
+uint32_t *
+xcb_input_change_device_property_items_data_32 (const xcb_input_change_device_property_items_t *S);
+
+int
+xcb_input_change_device_property_items_data_32_length (const xcb_input_change_device_property_request_t *R,
+                                                       const xcb_input_change_device_property_items_t *S);
+
+xcb_generic_iterator_t
+xcb_input_change_device_property_items_data_32_end (const xcb_input_change_device_property_request_t *R,
+                                                    const xcb_input_change_device_property_items_t *S);
+
+int
+xcb_input_change_device_property_items_serialize (void                                           **_buffer,
+                                                  uint32_t                                         num_items,
+                                                  uint8_t                                          format,
+                                                  const xcb_input_change_device_property_items_t  *_aux);
+
+int
+xcb_input_change_device_property_items_unpack (const void                                *_buffer,
+                                               uint32_t                                   num_items,
+                                               uint8_t                                    format,
+                                               xcb_input_change_device_property_items_t  *_aux);
+
+int
+xcb_input_change_device_property_items_sizeof (const void  *_buffer,
+                                               uint32_t     num_items,
+                                               uint8_t      format);
+
+int
+xcb_input_change_device_property_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_change_device_property_checked (xcb_connection_t *c,
+                                          xcb_atom_t        property,
+                                          xcb_atom_t        type,
+                                          uint8_t           device_id,
+                                          uint8_t           format,
+                                          uint8_t           mode,
+                                          uint32_t          num_items,
+                                          const void       *items);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_change_device_property (xcb_connection_t *c,
+                                  xcb_atom_t        property,
+                                  xcb_atom_t        type,
+                                  uint8_t           device_id,
+                                  uint8_t           format,
+                                  uint8_t           mode,
+                                  uint32_t          num_items,
+                                  const void       *items);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_change_device_property_aux_checked (xcb_connection_t                               *c,
+                                              xcb_atom_t                                      property,
+                                              xcb_atom_t                                      type,
+                                              uint8_t                                         device_id,
+                                              uint8_t                                         format,
+                                              uint8_t                                         mode,
+                                              uint32_t                                        num_items,
+                                              const xcb_input_change_device_property_items_t *items);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_change_device_property_aux (xcb_connection_t                               *c,
+                                      xcb_atom_t                                      property,
+                                      xcb_atom_t                                      type,
+                                      uint8_t                                         device_id,
+                                      uint8_t                                         format,
+                                      uint8_t                                         mode,
+                                      uint32_t                                        num_items,
+                                      const xcb_input_change_device_property_items_t *items);
+
+void *
+xcb_input_change_device_property_items (const xcb_input_change_device_property_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_delete_device_property_checked (xcb_connection_t *c,
+                                          xcb_atom_t        property,
+                                          uint8_t           device_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_delete_device_property (xcb_connection_t *c,
+                                  xcb_atom_t        property,
+                                  uint8_t           device_id);
+
+uint8_t *
+xcb_input_get_device_property_items_data_8 (const xcb_input_get_device_property_items_t *S);
+
+int
+xcb_input_get_device_property_items_data_8_length (const xcb_input_get_device_property_reply_t *R,
+                                                   const xcb_input_get_device_property_items_t *S);
+
+xcb_generic_iterator_t
+xcb_input_get_device_property_items_data_8_end (const xcb_input_get_device_property_reply_t *R,
+                                                const xcb_input_get_device_property_items_t *S);
+
+uint16_t *
+xcb_input_get_device_property_items_data_16 (const xcb_input_get_device_property_items_t *S);
+
+int
+xcb_input_get_device_property_items_data_16_length (const xcb_input_get_device_property_reply_t *R,
+                                                    const xcb_input_get_device_property_items_t *S);
+
+xcb_generic_iterator_t
+xcb_input_get_device_property_items_data_16_end (const xcb_input_get_device_property_reply_t *R,
+                                                 const xcb_input_get_device_property_items_t *S);
+
+uint32_t *
+xcb_input_get_device_property_items_data_32 (const xcb_input_get_device_property_items_t *S);
+
+int
+xcb_input_get_device_property_items_data_32_length (const xcb_input_get_device_property_reply_t *R,
+                                                    const xcb_input_get_device_property_items_t *S);
+
+xcb_generic_iterator_t
+xcb_input_get_device_property_items_data_32_end (const xcb_input_get_device_property_reply_t *R,
+                                                 const xcb_input_get_device_property_items_t *S);
+
+int
+xcb_input_get_device_property_items_serialize (void                                        **_buffer,
+                                               uint32_t                                      num_items,
+                                               uint8_t                                       format,
+                                               const xcb_input_get_device_property_items_t  *_aux);
+
+int
+xcb_input_get_device_property_items_unpack (const void                             *_buffer,
+                                            uint32_t                                num_items,
+                                            uint8_t                                 format,
+                                            xcb_input_get_device_property_items_t  *_aux);
+
+int
+xcb_input_get_device_property_items_sizeof (const void  *_buffer,
+                                            uint32_t     num_items,
+                                            uint8_t      format);
+
+int
+xcb_input_get_device_property_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_get_device_property_cookie_t
+xcb_input_get_device_property (xcb_connection_t *c,
+                               xcb_atom_t        property,
+                               xcb_atom_t        type,
+                               uint32_t          offset,
+                               uint32_t          len,
+                               uint8_t           device_id,
+                               uint8_t           _delete);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_get_device_property_cookie_t
+xcb_input_get_device_property_unchecked (xcb_connection_t *c,
+                                         xcb_atom_t        property,
+                                         xcb_atom_t        type,
+                                         uint32_t          offset,
+                                         uint32_t          len,
+                                         uint8_t           device_id,
+                                         uint8_t           _delete);
+
+void *
+xcb_input_get_device_property_items (const xcb_input_get_device_property_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_get_device_property_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_get_device_property_reply_t *
+xcb_input_get_device_property_reply (xcb_connection_t                        *c,
+                                     xcb_input_get_device_property_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_group_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_group_info_t)
+ */
+void
+xcb_input_group_info_next (xcb_input_group_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_group_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_group_info_end (xcb_input_group_info_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_modifier_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_modifier_info_t)
+ */
+void
+xcb_input_modifier_info_next (xcb_input_modifier_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_modifier_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_modifier_info_end (xcb_input_modifier_info_iterator_t i);
+
+int
+xcb_input_xi_query_pointer_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_xi_query_pointer_cookie_t
+xcb_input_xi_query_pointer (xcb_connection_t      *c,
+                            xcb_window_t           window,
+                            xcb_input_device_id_t  deviceid);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_xi_query_pointer_cookie_t
+xcb_input_xi_query_pointer_unchecked (xcb_connection_t      *c,
+                                      xcb_window_t           window,
+                                      xcb_input_device_id_t  deviceid);
+
+uint32_t *
+xcb_input_xi_query_pointer_buttons (const xcb_input_xi_query_pointer_reply_t *R);
+
+int
+xcb_input_xi_query_pointer_buttons_length (const xcb_input_xi_query_pointer_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_input_xi_query_pointer_buttons_end (const xcb_input_xi_query_pointer_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_xi_query_pointer_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_xi_query_pointer_reply_t *
+xcb_input_xi_query_pointer_reply (xcb_connection_t                     *c,
+                                  xcb_input_xi_query_pointer_cookie_t   cookie  /**< */,
+                                  xcb_generic_error_t                 **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_xi_warp_pointer_checked (xcb_connection_t      *c,
+                                   xcb_window_t           src_win,
+                                   xcb_window_t           dst_win,
+                                   xcb_input_fp1616_t     src_x,
+                                   xcb_input_fp1616_t     src_y,
+                                   uint16_t               src_width,
+                                   uint16_t               src_height,
+                                   xcb_input_fp1616_t     dst_x,
+                                   xcb_input_fp1616_t     dst_y,
+                                   xcb_input_device_id_t  deviceid);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_xi_warp_pointer (xcb_connection_t      *c,
+                           xcb_window_t           src_win,
+                           xcb_window_t           dst_win,
+                           xcb_input_fp1616_t     src_x,
+                           xcb_input_fp1616_t     src_y,
+                           uint16_t               src_width,
+                           uint16_t               src_height,
+                           xcb_input_fp1616_t     dst_x,
+                           xcb_input_fp1616_t     dst_y,
+                           xcb_input_device_id_t  deviceid);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_xi_change_cursor_checked (xcb_connection_t      *c,
+                                    xcb_window_t           window,
+                                    xcb_cursor_t           cursor,
+                                    xcb_input_device_id_t  deviceid);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_xi_change_cursor (xcb_connection_t      *c,
+                            xcb_window_t           window,
+                            xcb_cursor_t           cursor,
+                            xcb_input_device_id_t  deviceid);
+
+int
+xcb_input_add_master_sizeof (const void  *_buffer);
+
+char *
+xcb_input_add_master_name (const xcb_input_add_master_t *R);
+
+int
+xcb_input_add_master_name_length (const xcb_input_add_master_t *R);
+
+xcb_generic_iterator_t
+xcb_input_add_master_name_end (const xcb_input_add_master_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_add_master_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_add_master_t)
+ */
+void
+xcb_input_add_master_next (xcb_input_add_master_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_add_master_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_add_master_end (xcb_input_add_master_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_remove_master_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_remove_master_t)
+ */
+void
+xcb_input_remove_master_next (xcb_input_remove_master_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_remove_master_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_remove_master_end (xcb_input_remove_master_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_attach_slave_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_attach_slave_t)
+ */
+void
+xcb_input_attach_slave_next (xcb_input_attach_slave_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_attach_slave_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_attach_slave_end (xcb_input_attach_slave_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_detach_slave_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_detach_slave_t)
+ */
+void
+xcb_input_detach_slave_next (xcb_input_detach_slave_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_detach_slave_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_detach_slave_end (xcb_input_detach_slave_iterator_t i);
+
+char *
+xcb_input_hierarchy_change_data_add_master_name (const xcb_input_hierarchy_change_data_t *S);
+
+int
+xcb_input_hierarchy_change_data_add_master_name_length (const xcb_input_hierarchy_change_t *R,
+                                                        const xcb_input_hierarchy_change_data_t *S);
+
+xcb_generic_iterator_t
+xcb_input_hierarchy_change_data_add_master_name_end (const xcb_input_hierarchy_change_t *R,
+                                                     const xcb_input_hierarchy_change_data_t *S);
+
+int
+xcb_input_hierarchy_change_data_serialize (void                                    **_buffer,
+                                           uint16_t                                  type,
+                                           const xcb_input_hierarchy_change_data_t  *_aux);
+
+int
+xcb_input_hierarchy_change_data_unpack (const void                         *_buffer,
+                                        uint16_t                            type,
+                                        xcb_input_hierarchy_change_data_t  *_aux);
+
+int
+xcb_input_hierarchy_change_data_sizeof (const void  *_buffer,
+                                        uint16_t     type);
+
+int
+xcb_input_hierarchy_change_sizeof (const void  *_buffer);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_hierarchy_change_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_hierarchy_change_t)
+ */
+void
+xcb_input_hierarchy_change_next (xcb_input_hierarchy_change_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_hierarchy_change_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_hierarchy_change_end (xcb_input_hierarchy_change_iterator_t i);
+
+int
+xcb_input_xi_change_hierarchy_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_xi_change_hierarchy_checked (xcb_connection_t                   *c,
+                                       uint8_t                             num_changes,
+                                       const xcb_input_hierarchy_change_t *changes);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_xi_change_hierarchy (xcb_connection_t                   *c,
+                               uint8_t                             num_changes,
+                               const xcb_input_hierarchy_change_t *changes);
+
+int
+xcb_input_xi_change_hierarchy_changes_length (const xcb_input_xi_change_hierarchy_request_t *R);
+
+xcb_input_hierarchy_change_iterator_t
+xcb_input_xi_change_hierarchy_changes_iterator (const xcb_input_xi_change_hierarchy_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_xi_set_client_pointer_checked (xcb_connection_t      *c,
+                                         xcb_window_t           window,
+                                         xcb_input_device_id_t  deviceid);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_xi_set_client_pointer (xcb_connection_t      *c,
+                                 xcb_window_t           window,
+                                 xcb_input_device_id_t  deviceid);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_xi_get_client_pointer_cookie_t
+xcb_input_xi_get_client_pointer (xcb_connection_t *c,
+                                 xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_xi_get_client_pointer_cookie_t
+xcb_input_xi_get_client_pointer_unchecked (xcb_connection_t *c,
+                                           xcb_window_t      window);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_xi_get_client_pointer_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_xi_get_client_pointer_reply_t *
+xcb_input_xi_get_client_pointer_reply (xcb_connection_t                          *c,
+                                       xcb_input_xi_get_client_pointer_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e);
+
+int
+xcb_input_event_mask_sizeof (const void  *_buffer);
+
+uint32_t *
+xcb_input_event_mask_mask (const xcb_input_event_mask_t *R);
+
+int
+xcb_input_event_mask_mask_length (const xcb_input_event_mask_t *R);
+
+xcb_generic_iterator_t
+xcb_input_event_mask_mask_end (const xcb_input_event_mask_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_event_mask_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_event_mask_t)
+ */
+void
+xcb_input_event_mask_next (xcb_input_event_mask_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_event_mask_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_event_mask_end (xcb_input_event_mask_iterator_t i);
+
+int
+xcb_input_xi_select_events_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_xi_select_events_checked (xcb_connection_t             *c,
+                                    xcb_window_t                  window,
+                                    uint16_t                      num_mask,
+                                    const xcb_input_event_mask_t *masks);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_xi_select_events (xcb_connection_t             *c,
+                            xcb_window_t                  window,
+                            uint16_t                      num_mask,
+                            const xcb_input_event_mask_t *masks);
+
+int
+xcb_input_xi_select_events_masks_length (const xcb_input_xi_select_events_request_t *R);
+
+xcb_input_event_mask_iterator_t
+xcb_input_xi_select_events_masks_iterator (const xcb_input_xi_select_events_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_xi_query_version_cookie_t
+xcb_input_xi_query_version (xcb_connection_t *c,
+                            uint16_t          major_version,
+                            uint16_t          minor_version);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_xi_query_version_cookie_t
+xcb_input_xi_query_version_unchecked (xcb_connection_t *c,
+                                      uint16_t          major_version,
+                                      uint16_t          minor_version);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_xi_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_xi_query_version_reply_t *
+xcb_input_xi_query_version_reply (xcb_connection_t                     *c,
+                                  xcb_input_xi_query_version_cookie_t   cookie  /**< */,
+                                  xcb_generic_error_t                 **e);
+
+int
+xcb_input_button_class_sizeof (const void  *_buffer);
+
+uint32_t *
+xcb_input_button_class_state (const xcb_input_button_class_t *R);
+
+int
+xcb_input_button_class_state_length (const xcb_input_button_class_t *R);
+
+xcb_generic_iterator_t
+xcb_input_button_class_state_end (const xcb_input_button_class_t *R);
+
+xcb_atom_t *
+xcb_input_button_class_labels (const xcb_input_button_class_t *R);
+
+int
+xcb_input_button_class_labels_length (const xcb_input_button_class_t *R);
+
+xcb_generic_iterator_t
+xcb_input_button_class_labels_end (const xcb_input_button_class_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_button_class_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_button_class_t)
+ */
+void
+xcb_input_button_class_next (xcb_input_button_class_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_button_class_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_button_class_end (xcb_input_button_class_iterator_t i);
+
+int
+xcb_input_key_class_sizeof (const void  *_buffer);
+
+uint32_t *
+xcb_input_key_class_keys (const xcb_input_key_class_t *R);
+
+int
+xcb_input_key_class_keys_length (const xcb_input_key_class_t *R);
+
+xcb_generic_iterator_t
+xcb_input_key_class_keys_end (const xcb_input_key_class_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_key_class_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_key_class_t)
+ */
+void
+xcb_input_key_class_next (xcb_input_key_class_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_key_class_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_key_class_end (xcb_input_key_class_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_scroll_class_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_scroll_class_t)
+ */
+void
+xcb_input_scroll_class_next (xcb_input_scroll_class_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_scroll_class_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_scroll_class_end (xcb_input_scroll_class_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_touch_class_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_touch_class_t)
+ */
+void
+xcb_input_touch_class_next (xcb_input_touch_class_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_touch_class_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_touch_class_end (xcb_input_touch_class_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_gesture_class_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_gesture_class_t)
+ */
+void
+xcb_input_gesture_class_next (xcb_input_gesture_class_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_gesture_class_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_gesture_class_end (xcb_input_gesture_class_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_valuator_class_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_valuator_class_t)
+ */
+void
+xcb_input_valuator_class_next (xcb_input_valuator_class_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_valuator_class_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_valuator_class_end (xcb_input_valuator_class_iterator_t i);
+
+uint32_t *
+xcb_input_device_class_data_key_keys (const xcb_input_device_class_data_t *S);
+
+int
+xcb_input_device_class_data_key_keys_length (const xcb_input_device_class_t *R,
+                                             const xcb_input_device_class_data_t *S);
+
+xcb_generic_iterator_t
+xcb_input_device_class_data_key_keys_end (const xcb_input_device_class_t *R,
+                                          const xcb_input_device_class_data_t *S);
+
+uint32_t *
+xcb_input_device_class_data_button_state (const xcb_input_device_class_data_t *S);
+
+int
+xcb_input_device_class_data_button_state_length (const xcb_input_device_class_t *R,
+                                                 const xcb_input_device_class_data_t *S);
+
+xcb_generic_iterator_t
+xcb_input_device_class_data_button_state_end (const xcb_input_device_class_t *R,
+                                              const xcb_input_device_class_data_t *S);
+
+xcb_atom_t *
+xcb_input_device_class_data_button_labels (const xcb_input_device_class_data_t *S);
+
+int
+xcb_input_device_class_data_button_labels_length (const xcb_input_device_class_t *R,
+                                                  const xcb_input_device_class_data_t *S);
+
+xcb_generic_iterator_t
+xcb_input_device_class_data_button_labels_end (const xcb_input_device_class_t *R,
+                                               const xcb_input_device_class_data_t *S);
+
+int
+xcb_input_device_class_data_serialize (void                                **_buffer,
+                                       uint16_t                              type,
+                                       const xcb_input_device_class_data_t  *_aux);
+
+int
+xcb_input_device_class_data_unpack (const void                     *_buffer,
+                                    uint16_t                        type,
+                                    xcb_input_device_class_data_t  *_aux);
+
+int
+xcb_input_device_class_data_sizeof (const void  *_buffer,
+                                    uint16_t     type);
+
+int
+xcb_input_device_class_sizeof (const void  *_buffer);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_device_class_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_device_class_t)
+ */
+void
+xcb_input_device_class_next (xcb_input_device_class_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_device_class_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_device_class_end (xcb_input_device_class_iterator_t i);
+
+int
+xcb_input_xi_device_info_sizeof (const void  *_buffer);
+
+char *
+xcb_input_xi_device_info_name (const xcb_input_xi_device_info_t *R);
+
+int
+xcb_input_xi_device_info_name_length (const xcb_input_xi_device_info_t *R);
+
+xcb_generic_iterator_t
+xcb_input_xi_device_info_name_end (const xcb_input_xi_device_info_t *R);
+
+int
+xcb_input_xi_device_info_classes_length (const xcb_input_xi_device_info_t *R);
+
+xcb_input_device_class_iterator_t
+xcb_input_xi_device_info_classes_iterator (const xcb_input_xi_device_info_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_xi_device_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_xi_device_info_t)
+ */
+void
+xcb_input_xi_device_info_next (xcb_input_xi_device_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_xi_device_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_xi_device_info_end (xcb_input_xi_device_info_iterator_t i);
+
+int
+xcb_input_xi_query_device_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_xi_query_device_cookie_t
+xcb_input_xi_query_device (xcb_connection_t      *c,
+                           xcb_input_device_id_t  deviceid);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_xi_query_device_cookie_t
+xcb_input_xi_query_device_unchecked (xcb_connection_t      *c,
+                                     xcb_input_device_id_t  deviceid);
+
+int
+xcb_input_xi_query_device_infos_length (const xcb_input_xi_query_device_reply_t *R);
+
+xcb_input_xi_device_info_iterator_t
+xcb_input_xi_query_device_infos_iterator (const xcb_input_xi_query_device_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_xi_query_device_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_xi_query_device_reply_t *
+xcb_input_xi_query_device_reply (xcb_connection_t                    *c,
+                                 xcb_input_xi_query_device_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_xi_set_focus_checked (xcb_connection_t      *c,
+                                xcb_window_t           window,
+                                xcb_timestamp_t        time,
+                                xcb_input_device_id_t  deviceid);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_xi_set_focus (xcb_connection_t      *c,
+                        xcb_window_t           window,
+                        xcb_timestamp_t        time,
+                        xcb_input_device_id_t  deviceid);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_xi_get_focus_cookie_t
+xcb_input_xi_get_focus (xcb_connection_t      *c,
+                        xcb_input_device_id_t  deviceid);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_xi_get_focus_cookie_t
+xcb_input_xi_get_focus_unchecked (xcb_connection_t      *c,
+                                  xcb_input_device_id_t  deviceid);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_xi_get_focus_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_xi_get_focus_reply_t *
+xcb_input_xi_get_focus_reply (xcb_connection_t                 *c,
+                              xcb_input_xi_get_focus_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+int
+xcb_input_xi_grab_device_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_xi_grab_device_cookie_t
+xcb_input_xi_grab_device (xcb_connection_t      *c,
+                          xcb_window_t           window,
+                          xcb_timestamp_t        time,
+                          xcb_cursor_t           cursor,
+                          xcb_input_device_id_t  deviceid,
+                          uint8_t                mode,
+                          uint8_t                paired_device_mode,
+                          uint8_t                owner_events,
+                          uint16_t               mask_len,
+                          const uint32_t        *mask);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_xi_grab_device_cookie_t
+xcb_input_xi_grab_device_unchecked (xcb_connection_t      *c,
+                                    xcb_window_t           window,
+                                    xcb_timestamp_t        time,
+                                    xcb_cursor_t           cursor,
+                                    xcb_input_device_id_t  deviceid,
+                                    uint8_t                mode,
+                                    uint8_t                paired_device_mode,
+                                    uint8_t                owner_events,
+                                    uint16_t               mask_len,
+                                    const uint32_t        *mask);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_xi_grab_device_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_xi_grab_device_reply_t *
+xcb_input_xi_grab_device_reply (xcb_connection_t                   *c,
+                                xcb_input_xi_grab_device_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_xi_ungrab_device_checked (xcb_connection_t      *c,
+                                    xcb_timestamp_t        time,
+                                    xcb_input_device_id_t  deviceid);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_xi_ungrab_device (xcb_connection_t      *c,
+                            xcb_timestamp_t        time,
+                            xcb_input_device_id_t  deviceid);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_xi_allow_events_checked (xcb_connection_t      *c,
+                                   xcb_timestamp_t        time,
+                                   xcb_input_device_id_t  deviceid,
+                                   uint8_t                event_mode,
+                                   uint32_t               touchid,
+                                   xcb_window_t           grab_window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_xi_allow_events (xcb_connection_t      *c,
+                           xcb_timestamp_t        time,
+                           xcb_input_device_id_t  deviceid,
+                           uint8_t                event_mode,
+                           uint32_t               touchid,
+                           xcb_window_t           grab_window);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_grab_modifier_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_grab_modifier_info_t)
+ */
+void
+xcb_input_grab_modifier_info_next (xcb_input_grab_modifier_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_grab_modifier_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_grab_modifier_info_end (xcb_input_grab_modifier_info_iterator_t i);
+
+int
+xcb_input_xi_passive_grab_device_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_xi_passive_grab_device_cookie_t
+xcb_input_xi_passive_grab_device (xcb_connection_t      *c,
+                                  xcb_timestamp_t        time,
+                                  xcb_window_t           grab_window,
+                                  xcb_cursor_t           cursor,
+                                  uint32_t               detail,
+                                  xcb_input_device_id_t  deviceid,
+                                  uint16_t               num_modifiers,
+                                  uint16_t               mask_len,
+                                  uint8_t                grab_type,
+                                  uint8_t                grab_mode,
+                                  uint8_t                paired_device_mode,
+                                  uint8_t                owner_events,
+                                  const uint32_t        *mask,
+                                  const uint32_t        *modifiers);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_xi_passive_grab_device_cookie_t
+xcb_input_xi_passive_grab_device_unchecked (xcb_connection_t      *c,
+                                            xcb_timestamp_t        time,
+                                            xcb_window_t           grab_window,
+                                            xcb_cursor_t           cursor,
+                                            uint32_t               detail,
+                                            xcb_input_device_id_t  deviceid,
+                                            uint16_t               num_modifiers,
+                                            uint16_t               mask_len,
+                                            uint8_t                grab_type,
+                                            uint8_t                grab_mode,
+                                            uint8_t                paired_device_mode,
+                                            uint8_t                owner_events,
+                                            const uint32_t        *mask,
+                                            const uint32_t        *modifiers);
+
+xcb_input_grab_modifier_info_t *
+xcb_input_xi_passive_grab_device_modifiers (const xcb_input_xi_passive_grab_device_reply_t *R);
+
+int
+xcb_input_xi_passive_grab_device_modifiers_length (const xcb_input_xi_passive_grab_device_reply_t *R);
+
+xcb_input_grab_modifier_info_iterator_t
+xcb_input_xi_passive_grab_device_modifiers_iterator (const xcb_input_xi_passive_grab_device_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_xi_passive_grab_device_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_xi_passive_grab_device_reply_t *
+xcb_input_xi_passive_grab_device_reply (xcb_connection_t                           *c,
+                                        xcb_input_xi_passive_grab_device_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e);
+
+int
+xcb_input_xi_passive_ungrab_device_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_xi_passive_ungrab_device_checked (xcb_connection_t      *c,
+                                            xcb_window_t           grab_window,
+                                            uint32_t               detail,
+                                            xcb_input_device_id_t  deviceid,
+                                            uint16_t               num_modifiers,
+                                            uint8_t                grab_type,
+                                            const uint32_t        *modifiers);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_xi_passive_ungrab_device (xcb_connection_t      *c,
+                                    xcb_window_t           grab_window,
+                                    uint32_t               detail,
+                                    xcb_input_device_id_t  deviceid,
+                                    uint16_t               num_modifiers,
+                                    uint8_t                grab_type,
+                                    const uint32_t        *modifiers);
+
+uint32_t *
+xcb_input_xi_passive_ungrab_device_modifiers (const xcb_input_xi_passive_ungrab_device_request_t *R);
+
+int
+xcb_input_xi_passive_ungrab_device_modifiers_length (const xcb_input_xi_passive_ungrab_device_request_t *R);
+
+xcb_generic_iterator_t
+xcb_input_xi_passive_ungrab_device_modifiers_end (const xcb_input_xi_passive_ungrab_device_request_t *R);
+
+int
+xcb_input_xi_list_properties_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_xi_list_properties_cookie_t
+xcb_input_xi_list_properties (xcb_connection_t      *c,
+                              xcb_input_device_id_t  deviceid);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_xi_list_properties_cookie_t
+xcb_input_xi_list_properties_unchecked (xcb_connection_t      *c,
+                                        xcb_input_device_id_t  deviceid);
+
+xcb_atom_t *
+xcb_input_xi_list_properties_properties (const xcb_input_xi_list_properties_reply_t *R);
+
+int
+xcb_input_xi_list_properties_properties_length (const xcb_input_xi_list_properties_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_input_xi_list_properties_properties_end (const xcb_input_xi_list_properties_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_xi_list_properties_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_xi_list_properties_reply_t *
+xcb_input_xi_list_properties_reply (xcb_connection_t                       *c,
+                                    xcb_input_xi_list_properties_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e);
+
+uint8_t *
+xcb_input_xi_change_property_items_data_8 (const xcb_input_xi_change_property_items_t *S);
+
+int
+xcb_input_xi_change_property_items_data_8_length (const xcb_input_xi_change_property_request_t *R,
+                                                  const xcb_input_xi_change_property_items_t *S);
+
+xcb_generic_iterator_t
+xcb_input_xi_change_property_items_data_8_end (const xcb_input_xi_change_property_request_t *R,
+                                               const xcb_input_xi_change_property_items_t *S);
+
+uint16_t *
+xcb_input_xi_change_property_items_data_16 (const xcb_input_xi_change_property_items_t *S);
+
+int
+xcb_input_xi_change_property_items_data_16_length (const xcb_input_xi_change_property_request_t *R,
+                                                   const xcb_input_xi_change_property_items_t *S);
+
+xcb_generic_iterator_t
+xcb_input_xi_change_property_items_data_16_end (const xcb_input_xi_change_property_request_t *R,
+                                                const xcb_input_xi_change_property_items_t *S);
+
+uint32_t *
+xcb_input_xi_change_property_items_data_32 (const xcb_input_xi_change_property_items_t *S);
+
+int
+xcb_input_xi_change_property_items_data_32_length (const xcb_input_xi_change_property_request_t *R,
+                                                   const xcb_input_xi_change_property_items_t *S);
+
+xcb_generic_iterator_t
+xcb_input_xi_change_property_items_data_32_end (const xcb_input_xi_change_property_request_t *R,
+                                                const xcb_input_xi_change_property_items_t *S);
+
+int
+xcb_input_xi_change_property_items_serialize (void                                       **_buffer,
+                                              uint32_t                                     num_items,
+                                              uint8_t                                      format,
+                                              const xcb_input_xi_change_property_items_t  *_aux);
+
+int
+xcb_input_xi_change_property_items_unpack (const void                            *_buffer,
+                                           uint32_t                               num_items,
+                                           uint8_t                                format,
+                                           xcb_input_xi_change_property_items_t  *_aux);
+
+int
+xcb_input_xi_change_property_items_sizeof (const void  *_buffer,
+                                           uint32_t     num_items,
+                                           uint8_t      format);
+
+int
+xcb_input_xi_change_property_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_xi_change_property_checked (xcb_connection_t      *c,
+                                      xcb_input_device_id_t  deviceid,
+                                      uint8_t                mode,
+                                      uint8_t                format,
+                                      xcb_atom_t             property,
+                                      xcb_atom_t             type,
+                                      uint32_t               num_items,
+                                      const void            *items);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_xi_change_property (xcb_connection_t      *c,
+                              xcb_input_device_id_t  deviceid,
+                              uint8_t                mode,
+                              uint8_t                format,
+                              xcb_atom_t             property,
+                              xcb_atom_t             type,
+                              uint32_t               num_items,
+                              const void            *items);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_xi_change_property_aux_checked (xcb_connection_t                           *c,
+                                          xcb_input_device_id_t                       deviceid,
+                                          uint8_t                                     mode,
+                                          uint8_t                                     format,
+                                          xcb_atom_t                                  property,
+                                          xcb_atom_t                                  type,
+                                          uint32_t                                    num_items,
+                                          const xcb_input_xi_change_property_items_t *items);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_xi_change_property_aux (xcb_connection_t                           *c,
+                                  xcb_input_device_id_t                       deviceid,
+                                  uint8_t                                     mode,
+                                  uint8_t                                     format,
+                                  xcb_atom_t                                  property,
+                                  xcb_atom_t                                  type,
+                                  uint32_t                                    num_items,
+                                  const xcb_input_xi_change_property_items_t *items);
+
+void *
+xcb_input_xi_change_property_items (const xcb_input_xi_change_property_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_xi_delete_property_checked (xcb_connection_t      *c,
+                                      xcb_input_device_id_t  deviceid,
+                                      xcb_atom_t             property);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_xi_delete_property (xcb_connection_t      *c,
+                              xcb_input_device_id_t  deviceid,
+                              xcb_atom_t             property);
+
+uint8_t *
+xcb_input_xi_get_property_items_data_8 (const xcb_input_xi_get_property_items_t *S);
+
+int
+xcb_input_xi_get_property_items_data_8_length (const xcb_input_xi_get_property_reply_t *R,
+                                               const xcb_input_xi_get_property_items_t *S);
+
+xcb_generic_iterator_t
+xcb_input_xi_get_property_items_data_8_end (const xcb_input_xi_get_property_reply_t *R,
+                                            const xcb_input_xi_get_property_items_t *S);
+
+uint16_t *
+xcb_input_xi_get_property_items_data_16 (const xcb_input_xi_get_property_items_t *S);
+
+int
+xcb_input_xi_get_property_items_data_16_length (const xcb_input_xi_get_property_reply_t *R,
+                                                const xcb_input_xi_get_property_items_t *S);
+
+xcb_generic_iterator_t
+xcb_input_xi_get_property_items_data_16_end (const xcb_input_xi_get_property_reply_t *R,
+                                             const xcb_input_xi_get_property_items_t *S);
+
+uint32_t *
+xcb_input_xi_get_property_items_data_32 (const xcb_input_xi_get_property_items_t *S);
+
+int
+xcb_input_xi_get_property_items_data_32_length (const xcb_input_xi_get_property_reply_t *R,
+                                                const xcb_input_xi_get_property_items_t *S);
+
+xcb_generic_iterator_t
+xcb_input_xi_get_property_items_data_32_end (const xcb_input_xi_get_property_reply_t *R,
+                                             const xcb_input_xi_get_property_items_t *S);
+
+int
+xcb_input_xi_get_property_items_serialize (void                                    **_buffer,
+                                           uint32_t                                  num_items,
+                                           uint8_t                                   format,
+                                           const xcb_input_xi_get_property_items_t  *_aux);
+
+int
+xcb_input_xi_get_property_items_unpack (const void                         *_buffer,
+                                        uint32_t                            num_items,
+                                        uint8_t                             format,
+                                        xcb_input_xi_get_property_items_t  *_aux);
+
+int
+xcb_input_xi_get_property_items_sizeof (const void  *_buffer,
+                                        uint32_t     num_items,
+                                        uint8_t      format);
+
+int
+xcb_input_xi_get_property_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_xi_get_property_cookie_t
+xcb_input_xi_get_property (xcb_connection_t      *c,
+                           xcb_input_device_id_t  deviceid,
+                           uint8_t                _delete,
+                           xcb_atom_t             property,
+                           xcb_atom_t             type,
+                           uint32_t               offset,
+                           uint32_t               len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_xi_get_property_cookie_t
+xcb_input_xi_get_property_unchecked (xcb_connection_t      *c,
+                                     xcb_input_device_id_t  deviceid,
+                                     uint8_t                _delete,
+                                     xcb_atom_t             property,
+                                     xcb_atom_t             type,
+                                     uint32_t               offset,
+                                     uint32_t               len);
+
+void *
+xcb_input_xi_get_property_items (const xcb_input_xi_get_property_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_xi_get_property_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_xi_get_property_reply_t *
+xcb_input_xi_get_property_reply (xcb_connection_t                    *c,
+                                 xcb_input_xi_get_property_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e);
+
+int
+xcb_input_xi_get_selected_events_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_input_xi_get_selected_events_cookie_t
+xcb_input_xi_get_selected_events (xcb_connection_t *c,
+                                  xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_input_xi_get_selected_events_cookie_t
+xcb_input_xi_get_selected_events_unchecked (xcb_connection_t *c,
+                                            xcb_window_t      window);
+
+int
+xcb_input_xi_get_selected_events_masks_length (const xcb_input_xi_get_selected_events_reply_t *R);
+
+xcb_input_event_mask_iterator_t
+xcb_input_xi_get_selected_events_masks_iterator (const xcb_input_xi_get_selected_events_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_input_xi_get_selected_events_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_input_xi_get_selected_events_reply_t *
+xcb_input_xi_get_selected_events_reply (xcb_connection_t                           *c,
+                                        xcb_input_xi_get_selected_events_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_barrier_release_pointer_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_barrier_release_pointer_info_t)
+ */
+void
+xcb_input_barrier_release_pointer_info_next (xcb_input_barrier_release_pointer_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_barrier_release_pointer_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_barrier_release_pointer_info_end (xcb_input_barrier_release_pointer_info_iterator_t i);
+
+int
+xcb_input_xi_barrier_release_pointer_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_xi_barrier_release_pointer_checked (xcb_connection_t                               *c,
+                                              uint32_t                                        num_barriers,
+                                              const xcb_input_barrier_release_pointer_info_t *barriers);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_xi_barrier_release_pointer (xcb_connection_t                               *c,
+                                      uint32_t                                        num_barriers,
+                                      const xcb_input_barrier_release_pointer_info_t *barriers);
+
+xcb_input_barrier_release_pointer_info_t *
+xcb_input_xi_barrier_release_pointer_barriers (const xcb_input_xi_barrier_release_pointer_request_t *R);
+
+int
+xcb_input_xi_barrier_release_pointer_barriers_length (const xcb_input_xi_barrier_release_pointer_request_t *R);
+
+xcb_input_barrier_release_pointer_info_iterator_t
+xcb_input_xi_barrier_release_pointer_barriers_iterator (const xcb_input_xi_barrier_release_pointer_request_t *R);
+
+int
+xcb_input_device_changed_sizeof (const void  *_buffer);
+
+int
+xcb_input_device_changed_classes_length (const xcb_input_device_changed_event_t *R);
+
+xcb_input_device_class_iterator_t
+xcb_input_device_changed_classes_iterator (const xcb_input_device_changed_event_t *R);
+
+int
+xcb_input_key_press_sizeof (const void  *_buffer);
+
+uint32_t *
+xcb_input_key_press_button_mask (const xcb_input_key_press_event_t *R);
+
+int
+xcb_input_key_press_button_mask_length (const xcb_input_key_press_event_t *R);
+
+xcb_generic_iterator_t
+xcb_input_key_press_button_mask_end (const xcb_input_key_press_event_t *R);
+
+uint32_t *
+xcb_input_key_press_valuator_mask (const xcb_input_key_press_event_t *R);
+
+int
+xcb_input_key_press_valuator_mask_length (const xcb_input_key_press_event_t *R);
+
+xcb_generic_iterator_t
+xcb_input_key_press_valuator_mask_end (const xcb_input_key_press_event_t *R);
+
+xcb_input_fp3232_t *
+xcb_input_key_press_axisvalues (const xcb_input_key_press_event_t *R);
+
+int
+xcb_input_key_press_axisvalues_length (const xcb_input_key_press_event_t *R);
+
+xcb_input_fp3232_iterator_t
+xcb_input_key_press_axisvalues_iterator (const xcb_input_key_press_event_t *R);
+
+int
+xcb_input_key_release_sizeof (const void  *_buffer  /**< */);
+
+int
+xcb_input_button_press_sizeof (const void  *_buffer);
+
+uint32_t *
+xcb_input_button_press_button_mask (const xcb_input_button_press_event_t *R);
+
+int
+xcb_input_button_press_button_mask_length (const xcb_input_button_press_event_t *R);
+
+xcb_generic_iterator_t
+xcb_input_button_press_button_mask_end (const xcb_input_button_press_event_t *R);
+
+uint32_t *
+xcb_input_button_press_valuator_mask (const xcb_input_button_press_event_t *R);
+
+int
+xcb_input_button_press_valuator_mask_length (const xcb_input_button_press_event_t *R);
+
+xcb_generic_iterator_t
+xcb_input_button_press_valuator_mask_end (const xcb_input_button_press_event_t *R);
+
+xcb_input_fp3232_t *
+xcb_input_button_press_axisvalues (const xcb_input_button_press_event_t *R);
+
+int
+xcb_input_button_press_axisvalues_length (const xcb_input_button_press_event_t *R);
+
+xcb_input_fp3232_iterator_t
+xcb_input_button_press_axisvalues_iterator (const xcb_input_button_press_event_t *R);
+
+int
+xcb_input_button_release_sizeof (const void  *_buffer  /**< */);
+
+int
+xcb_input_motion_sizeof (const void  *_buffer  /**< */);
+
+int
+xcb_input_enter_sizeof (const void  *_buffer);
+
+uint32_t *
+xcb_input_enter_buttons (const xcb_input_enter_event_t *R);
+
+int
+xcb_input_enter_buttons_length (const xcb_input_enter_event_t *R);
+
+xcb_generic_iterator_t
+xcb_input_enter_buttons_end (const xcb_input_enter_event_t *R);
+
+int
+xcb_input_leave_sizeof (const void  *_buffer  /**< */);
+
+int
+xcb_input_focus_in_sizeof (const void  *_buffer  /**< */);
+
+int
+xcb_input_focus_out_sizeof (const void  *_buffer  /**< */);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_hierarchy_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_hierarchy_info_t)
+ */
+void
+xcb_input_hierarchy_info_next (xcb_input_hierarchy_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_hierarchy_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_hierarchy_info_end (xcb_input_hierarchy_info_iterator_t i);
+
+int
+xcb_input_hierarchy_sizeof (const void  *_buffer);
+
+xcb_input_hierarchy_info_t *
+xcb_input_hierarchy_infos (const xcb_input_hierarchy_event_t *R);
+
+int
+xcb_input_hierarchy_infos_length (const xcb_input_hierarchy_event_t *R);
+
+xcb_input_hierarchy_info_iterator_t
+xcb_input_hierarchy_infos_iterator (const xcb_input_hierarchy_event_t *R);
+
+int
+xcb_input_raw_key_press_sizeof (const void  *_buffer);
+
+uint32_t *
+xcb_input_raw_key_press_valuator_mask (const xcb_input_raw_key_press_event_t *R);
+
+int
+xcb_input_raw_key_press_valuator_mask_length (const xcb_input_raw_key_press_event_t *R);
+
+xcb_generic_iterator_t
+xcb_input_raw_key_press_valuator_mask_end (const xcb_input_raw_key_press_event_t *R);
+
+xcb_input_fp3232_t *
+xcb_input_raw_key_press_axisvalues (const xcb_input_raw_key_press_event_t *R);
+
+int
+xcb_input_raw_key_press_axisvalues_length (const xcb_input_raw_key_press_event_t *R);
+
+xcb_input_fp3232_iterator_t
+xcb_input_raw_key_press_axisvalues_iterator (const xcb_input_raw_key_press_event_t *R);
+
+xcb_input_fp3232_t *
+xcb_input_raw_key_press_axisvalues_raw (const xcb_input_raw_key_press_event_t *R);
+
+int
+xcb_input_raw_key_press_axisvalues_raw_length (const xcb_input_raw_key_press_event_t *R);
+
+xcb_input_fp3232_iterator_t
+xcb_input_raw_key_press_axisvalues_raw_iterator (const xcb_input_raw_key_press_event_t *R);
+
+int
+xcb_input_raw_key_release_sizeof (const void  *_buffer  /**< */);
+
+int
+xcb_input_raw_button_press_sizeof (const void  *_buffer);
+
+uint32_t *
+xcb_input_raw_button_press_valuator_mask (const xcb_input_raw_button_press_event_t *R);
+
+int
+xcb_input_raw_button_press_valuator_mask_length (const xcb_input_raw_button_press_event_t *R);
+
+xcb_generic_iterator_t
+xcb_input_raw_button_press_valuator_mask_end (const xcb_input_raw_button_press_event_t *R);
+
+xcb_input_fp3232_t *
+xcb_input_raw_button_press_axisvalues (const xcb_input_raw_button_press_event_t *R);
+
+int
+xcb_input_raw_button_press_axisvalues_length (const xcb_input_raw_button_press_event_t *R);
+
+xcb_input_fp3232_iterator_t
+xcb_input_raw_button_press_axisvalues_iterator (const xcb_input_raw_button_press_event_t *R);
+
+xcb_input_fp3232_t *
+xcb_input_raw_button_press_axisvalues_raw (const xcb_input_raw_button_press_event_t *R);
+
+int
+xcb_input_raw_button_press_axisvalues_raw_length (const xcb_input_raw_button_press_event_t *R);
+
+xcb_input_fp3232_iterator_t
+xcb_input_raw_button_press_axisvalues_raw_iterator (const xcb_input_raw_button_press_event_t *R);
+
+int
+xcb_input_raw_button_release_sizeof (const void  *_buffer  /**< */);
+
+int
+xcb_input_raw_motion_sizeof (const void  *_buffer  /**< */);
+
+int
+xcb_input_touch_begin_sizeof (const void  *_buffer);
+
+uint32_t *
+xcb_input_touch_begin_button_mask (const xcb_input_touch_begin_event_t *R);
+
+int
+xcb_input_touch_begin_button_mask_length (const xcb_input_touch_begin_event_t *R);
+
+xcb_generic_iterator_t
+xcb_input_touch_begin_button_mask_end (const xcb_input_touch_begin_event_t *R);
+
+uint32_t *
+xcb_input_touch_begin_valuator_mask (const xcb_input_touch_begin_event_t *R);
+
+int
+xcb_input_touch_begin_valuator_mask_length (const xcb_input_touch_begin_event_t *R);
+
+xcb_generic_iterator_t
+xcb_input_touch_begin_valuator_mask_end (const xcb_input_touch_begin_event_t *R);
+
+xcb_input_fp3232_t *
+xcb_input_touch_begin_axisvalues (const xcb_input_touch_begin_event_t *R);
+
+int
+xcb_input_touch_begin_axisvalues_length (const xcb_input_touch_begin_event_t *R);
+
+xcb_input_fp3232_iterator_t
+xcb_input_touch_begin_axisvalues_iterator (const xcb_input_touch_begin_event_t *R);
+
+int
+xcb_input_touch_update_sizeof (const void  *_buffer  /**< */);
+
+int
+xcb_input_touch_end_sizeof (const void  *_buffer  /**< */);
+
+int
+xcb_input_raw_touch_begin_sizeof (const void  *_buffer);
+
+uint32_t *
+xcb_input_raw_touch_begin_valuator_mask (const xcb_input_raw_touch_begin_event_t *R);
+
+int
+xcb_input_raw_touch_begin_valuator_mask_length (const xcb_input_raw_touch_begin_event_t *R);
+
+xcb_generic_iterator_t
+xcb_input_raw_touch_begin_valuator_mask_end (const xcb_input_raw_touch_begin_event_t *R);
+
+xcb_input_fp3232_t *
+xcb_input_raw_touch_begin_axisvalues (const xcb_input_raw_touch_begin_event_t *R);
+
+int
+xcb_input_raw_touch_begin_axisvalues_length (const xcb_input_raw_touch_begin_event_t *R);
+
+xcb_input_fp3232_iterator_t
+xcb_input_raw_touch_begin_axisvalues_iterator (const xcb_input_raw_touch_begin_event_t *R);
+
+xcb_input_fp3232_t *
+xcb_input_raw_touch_begin_axisvalues_raw (const xcb_input_raw_touch_begin_event_t *R);
+
+int
+xcb_input_raw_touch_begin_axisvalues_raw_length (const xcb_input_raw_touch_begin_event_t *R);
+
+xcb_input_fp3232_iterator_t
+xcb_input_raw_touch_begin_axisvalues_raw_iterator (const xcb_input_raw_touch_begin_event_t *R);
+
+int
+xcb_input_raw_touch_update_sizeof (const void  *_buffer  /**< */);
+
+int
+xcb_input_raw_touch_end_sizeof (const void  *_buffer  /**< */);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_input_event_for_send_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_input_event_for_send_t)
+ */
+void
+xcb_input_event_for_send_next (xcb_input_event_for_send_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_input_event_for_send_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_input_event_for_send_end (xcb_input_event_for_send_iterator_t i);
+
+int
+xcb_input_send_extension_event_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_input_send_extension_event_checked (xcb_connection_t                 *c,
+                                        xcb_window_t                      destination,
+                                        uint8_t                           device_id,
+                                        uint8_t                           propagate,
+                                        uint16_t                          num_classes,
+                                        uint8_t                           num_events,
+                                        const xcb_input_event_for_send_t *events,
+                                        const xcb_input_event_class_t    *classes);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_input_send_extension_event (xcb_connection_t                 *c,
+                                xcb_window_t                      destination,
+                                uint8_t                           device_id,
+                                uint8_t                           propagate,
+                                uint16_t                          num_classes,
+                                uint8_t                           num_events,
+                                const xcb_input_event_for_send_t *events,
+                                const xcb_input_event_class_t    *classes);
+
+xcb_input_event_for_send_t *
+xcb_input_send_extension_event_events (const xcb_input_send_extension_event_request_t *R);
+
+int
+xcb_input_send_extension_event_events_length (const xcb_input_send_extension_event_request_t *R);
+
+xcb_input_event_for_send_iterator_t
+xcb_input_send_extension_event_events_iterator (const xcb_input_send_extension_event_request_t *R);
+
+xcb_input_event_class_t *
+xcb_input_send_extension_event_classes (const xcb_input_send_extension_event_request_t *R);
+
+int
+xcb_input_send_extension_event_classes_length (const xcb_input_send_extension_event_request_t *R);
+
+xcb_generic_iterator_t
+xcb_input_send_extension_event_classes_end (const xcb_input_send_extension_event_request_t *R);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/xkb.h b/depends/libxcb/include/xcb/xkb.h
new file mode 100644
index 0000000..056585b
--- /dev/null
+++ b/depends/libxcb/include/xcb/xkb.h
@@ -0,0 +1,7106 @@
+/*
+ * This file generated automatically from xkb.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_xkb_API XCB xkb API
+ * @brief xkb XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __XKB_H
+#define __XKB_H
+
+#include "xcb.h"
+#include "xproto.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_XKB_MAJOR_VERSION 1
+#define XCB_XKB_MINOR_VERSION 0
+
+extern xcb_extension_t xcb_xkb_id;
+
+typedef enum xcb_xkb_const_t {
+    XCB_XKB_CONST_MAX_LEGAL_KEY_CODE = 255,
+    XCB_XKB_CONST_PER_KEY_BIT_ARRAY_SIZE = 32,
+    XCB_XKB_CONST_KEY_NAME_LENGTH = 4
+} xcb_xkb_const_t;
+
+typedef enum xcb_xkb_event_type_t {
+    XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY = 1,
+    XCB_XKB_EVENT_TYPE_MAP_NOTIFY = 2,
+    XCB_XKB_EVENT_TYPE_STATE_NOTIFY = 4,
+    XCB_XKB_EVENT_TYPE_CONTROLS_NOTIFY = 8,
+    XCB_XKB_EVENT_TYPE_INDICATOR_STATE_NOTIFY = 16,
+    XCB_XKB_EVENT_TYPE_INDICATOR_MAP_NOTIFY = 32,
+    XCB_XKB_EVENT_TYPE_NAMES_NOTIFY = 64,
+    XCB_XKB_EVENT_TYPE_COMPAT_MAP_NOTIFY = 128,
+    XCB_XKB_EVENT_TYPE_BELL_NOTIFY = 256,
+    XCB_XKB_EVENT_TYPE_ACTION_MESSAGE = 512,
+    XCB_XKB_EVENT_TYPE_ACCESS_X_NOTIFY = 1024,
+    XCB_XKB_EVENT_TYPE_EXTENSION_DEVICE_NOTIFY = 2048
+} xcb_xkb_event_type_t;
+
+typedef enum xcb_xkb_nkn_detail_t {
+    XCB_XKB_NKN_DETAIL_KEYCODES = 1,
+    XCB_XKB_NKN_DETAIL_GEOMETRY = 2,
+    XCB_XKB_NKN_DETAIL_DEVICE_ID = 4
+} xcb_xkb_nkn_detail_t;
+
+typedef enum xcb_xkb_axn_detail_t {
+    XCB_XKB_AXN_DETAIL_SK_PRESS = 1,
+    XCB_XKB_AXN_DETAIL_SK_ACCEPT = 2,
+    XCB_XKB_AXN_DETAIL_SK_REJECT = 4,
+    XCB_XKB_AXN_DETAIL_SK_RELEASE = 8,
+    XCB_XKB_AXN_DETAIL_BK_ACCEPT = 16,
+    XCB_XKB_AXN_DETAIL_BK_REJECT = 32,
+    XCB_XKB_AXN_DETAIL_AXK_WARNING = 64
+} xcb_xkb_axn_detail_t;
+
+typedef enum xcb_xkb_map_part_t {
+    XCB_XKB_MAP_PART_KEY_TYPES = 1,
+    XCB_XKB_MAP_PART_KEY_SYMS = 2,
+    XCB_XKB_MAP_PART_MODIFIER_MAP = 4,
+    XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS = 8,
+    XCB_XKB_MAP_PART_KEY_ACTIONS = 16,
+    XCB_XKB_MAP_PART_KEY_BEHAVIORS = 32,
+    XCB_XKB_MAP_PART_VIRTUAL_MODS = 64,
+    XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP = 128
+} xcb_xkb_map_part_t;
+
+typedef enum xcb_xkb_set_map_flags_t {
+    XCB_XKB_SET_MAP_FLAGS_RESIZE_TYPES = 1,
+    XCB_XKB_SET_MAP_FLAGS_RECOMPUTE_ACTIONS = 2
+} xcb_xkb_set_map_flags_t;
+
+typedef enum xcb_xkb_state_part_t {
+    XCB_XKB_STATE_PART_MODIFIER_STATE = 1,
+    XCB_XKB_STATE_PART_MODIFIER_BASE = 2,
+    XCB_XKB_STATE_PART_MODIFIER_LATCH = 4,
+    XCB_XKB_STATE_PART_MODIFIER_LOCK = 8,
+    XCB_XKB_STATE_PART_GROUP_STATE = 16,
+    XCB_XKB_STATE_PART_GROUP_BASE = 32,
+    XCB_XKB_STATE_PART_GROUP_LATCH = 64,
+    XCB_XKB_STATE_PART_GROUP_LOCK = 128,
+    XCB_XKB_STATE_PART_COMPAT_STATE = 256,
+    XCB_XKB_STATE_PART_GRAB_MODS = 512,
+    XCB_XKB_STATE_PART_COMPAT_GRAB_MODS = 1024,
+    XCB_XKB_STATE_PART_LOOKUP_MODS = 2048,
+    XCB_XKB_STATE_PART_COMPAT_LOOKUP_MODS = 4096,
+    XCB_XKB_STATE_PART_POINTER_BUTTONS = 8192
+} xcb_xkb_state_part_t;
+
+typedef enum xcb_xkb_bool_ctrl_t {
+    XCB_XKB_BOOL_CTRL_REPEAT_KEYS = 1,
+    XCB_XKB_BOOL_CTRL_SLOW_KEYS = 2,
+    XCB_XKB_BOOL_CTRL_BOUNCE_KEYS = 4,
+    XCB_XKB_BOOL_CTRL_STICKY_KEYS = 8,
+    XCB_XKB_BOOL_CTRL_MOUSE_KEYS = 16,
+    XCB_XKB_BOOL_CTRL_MOUSE_KEYS_ACCEL = 32,
+    XCB_XKB_BOOL_CTRL_ACCESS_X_KEYS = 64,
+    XCB_XKB_BOOL_CTRL_ACCESS_X_TIMEOUT_MASK = 128,
+    XCB_XKB_BOOL_CTRL_ACCESS_X_FEEDBACK_MASK = 256,
+    XCB_XKB_BOOL_CTRL_AUDIBLE_BELL_MASK = 512,
+    XCB_XKB_BOOL_CTRL_OVERLAY_1_MASK = 1024,
+    XCB_XKB_BOOL_CTRL_OVERLAY_2_MASK = 2048,
+    XCB_XKB_BOOL_CTRL_IGNORE_GROUP_LOCK_MASK = 4096
+} xcb_xkb_bool_ctrl_t;
+
+typedef enum xcb_xkb_control_t {
+    XCB_XKB_CONTROL_GROUPS_WRAP = 134217728,
+    XCB_XKB_CONTROL_INTERNAL_MODS = 268435456,
+    XCB_XKB_CONTROL_IGNORE_LOCK_MODS = 536870912,
+    XCB_XKB_CONTROL_PER_KEY_REPEAT = 1073741824,
+    XCB_XKB_CONTROL_CONTROLS_ENABLED = 2147483648
+} xcb_xkb_control_t;
+
+typedef enum xcb_xkb_ax_option_t {
+    XCB_XKB_AX_OPTION_SK_PRESS_FB = 1,
+    XCB_XKB_AX_OPTION_SK_ACCEPT_FB = 2,
+    XCB_XKB_AX_OPTION_FEATURE_FB = 4,
+    XCB_XKB_AX_OPTION_SLOW_WARN_FB = 8,
+    XCB_XKB_AX_OPTION_INDICATOR_FB = 16,
+    XCB_XKB_AX_OPTION_STICKY_KEYS_FB = 32,
+    XCB_XKB_AX_OPTION_TWO_KEYS = 64,
+    XCB_XKB_AX_OPTION_LATCH_TO_LOCK = 128,
+    XCB_XKB_AX_OPTION_SK_RELEASE_FB = 256,
+    XCB_XKB_AX_OPTION_SK_REJECT_FB = 512,
+    XCB_XKB_AX_OPTION_BK_REJECT_FB = 1024,
+    XCB_XKB_AX_OPTION_DUMB_BELL = 2048
+} xcb_xkb_ax_option_t;
+
+typedef uint16_t xcb_xkb_device_spec_t;
+
+/**
+ * @brief xcb_xkb_device_spec_iterator_t
+ **/
+typedef struct xcb_xkb_device_spec_iterator_t {
+    xcb_xkb_device_spec_t *data;
+    int                    rem;
+    int                    index;
+} xcb_xkb_device_spec_iterator_t;
+
+typedef enum xcb_xkb_led_class_result_t {
+    XCB_XKB_LED_CLASS_RESULT_KBD_FEEDBACK_CLASS = 0,
+    XCB_XKB_LED_CLASS_RESULT_LED_FEEDBACK_CLASS = 4
+} xcb_xkb_led_class_result_t;
+
+typedef enum xcb_xkb_led_class_t {
+    XCB_XKB_LED_CLASS_KBD_FEEDBACK_CLASS = 0,
+    XCB_XKB_LED_CLASS_LED_FEEDBACK_CLASS = 4,
+    XCB_XKB_LED_CLASS_DFLT_XI_CLASS = 768,
+    XCB_XKB_LED_CLASS_ALL_XI_CLASSES = 1280
+} xcb_xkb_led_class_t;
+
+typedef uint16_t xcb_xkb_led_class_spec_t;
+
+/**
+ * @brief xcb_xkb_led_class_spec_iterator_t
+ **/
+typedef struct xcb_xkb_led_class_spec_iterator_t {
+    xcb_xkb_led_class_spec_t *data;
+    int                       rem;
+    int                       index;
+} xcb_xkb_led_class_spec_iterator_t;
+
+typedef enum xcb_xkb_bell_class_result_t {
+    XCB_XKB_BELL_CLASS_RESULT_KBD_FEEDBACK_CLASS = 0,
+    XCB_XKB_BELL_CLASS_RESULT_BELL_FEEDBACK_CLASS = 5
+} xcb_xkb_bell_class_result_t;
+
+typedef enum xcb_xkb_bell_class_t {
+    XCB_XKB_BELL_CLASS_KBD_FEEDBACK_CLASS = 0,
+    XCB_XKB_BELL_CLASS_BELL_FEEDBACK_CLASS = 5,
+    XCB_XKB_BELL_CLASS_DFLT_XI_CLASS = 768
+} xcb_xkb_bell_class_t;
+
+typedef uint16_t xcb_xkb_bell_class_spec_t;
+
+/**
+ * @brief xcb_xkb_bell_class_spec_iterator_t
+ **/
+typedef struct xcb_xkb_bell_class_spec_iterator_t {
+    xcb_xkb_bell_class_spec_t *data;
+    int                        rem;
+    int                        index;
+} xcb_xkb_bell_class_spec_iterator_t;
+
+typedef enum xcb_xkb_id_t {
+    XCB_XKB_ID_USE_CORE_KBD = 256,
+    XCB_XKB_ID_USE_CORE_PTR = 512,
+    XCB_XKB_ID_DFLT_XI_CLASS = 768,
+    XCB_XKB_ID_DFLT_XI_ID = 1024,
+    XCB_XKB_ID_ALL_XI_CLASS = 1280,
+    XCB_XKB_ID_ALL_XI_ID = 1536,
+    XCB_XKB_ID_XI_NONE = 65280
+} xcb_xkb_id_t;
+
+typedef uint16_t xcb_xkb_id_spec_t;
+
+/**
+ * @brief xcb_xkb_id_spec_iterator_t
+ **/
+typedef struct xcb_xkb_id_spec_iterator_t {
+    xcb_xkb_id_spec_t *data;
+    int                rem;
+    int                index;
+} xcb_xkb_id_spec_iterator_t;
+
+typedef enum xcb_xkb_group_t {
+    XCB_XKB_GROUP_1 = 0,
+    XCB_XKB_GROUP_2 = 1,
+    XCB_XKB_GROUP_3 = 2,
+    XCB_XKB_GROUP_4 = 3
+} xcb_xkb_group_t;
+
+typedef enum xcb_xkb_groups_t {
+    XCB_XKB_GROUPS_ANY = 254,
+    XCB_XKB_GROUPS_ALL = 255
+} xcb_xkb_groups_t;
+
+typedef enum xcb_xkb_set_of_group_t {
+    XCB_XKB_SET_OF_GROUP_GROUP_1 = 1,
+    XCB_XKB_SET_OF_GROUP_GROUP_2 = 2,
+    XCB_XKB_SET_OF_GROUP_GROUP_3 = 4,
+    XCB_XKB_SET_OF_GROUP_GROUP_4 = 8
+} xcb_xkb_set_of_group_t;
+
+typedef enum xcb_xkb_set_of_groups_t {
+    XCB_XKB_SET_OF_GROUPS_ANY = 128
+} xcb_xkb_set_of_groups_t;
+
+typedef enum xcb_xkb_groups_wrap_t {
+    XCB_XKB_GROUPS_WRAP_WRAP_INTO_RANGE = 0,
+    XCB_XKB_GROUPS_WRAP_CLAMP_INTO_RANGE = 64,
+    XCB_XKB_GROUPS_WRAP_REDIRECT_INTO_RANGE = 128
+} xcb_xkb_groups_wrap_t;
+
+typedef enum xcb_xkb_v_mods_high_t {
+    XCB_XKB_V_MODS_HIGH_15 = 128,
+    XCB_XKB_V_MODS_HIGH_14 = 64,
+    XCB_XKB_V_MODS_HIGH_13 = 32,
+    XCB_XKB_V_MODS_HIGH_12 = 16,
+    XCB_XKB_V_MODS_HIGH_11 = 8,
+    XCB_XKB_V_MODS_HIGH_10 = 4,
+    XCB_XKB_V_MODS_HIGH_9 = 2,
+    XCB_XKB_V_MODS_HIGH_8 = 1
+} xcb_xkb_v_mods_high_t;
+
+typedef enum xcb_xkb_v_mods_low_t {
+    XCB_XKB_V_MODS_LOW_7 = 128,
+    XCB_XKB_V_MODS_LOW_6 = 64,
+    XCB_XKB_V_MODS_LOW_5 = 32,
+    XCB_XKB_V_MODS_LOW_4 = 16,
+    XCB_XKB_V_MODS_LOW_3 = 8,
+    XCB_XKB_V_MODS_LOW_2 = 4,
+    XCB_XKB_V_MODS_LOW_1 = 2,
+    XCB_XKB_V_MODS_LOW_0 = 1
+} xcb_xkb_v_mods_low_t;
+
+typedef enum xcb_xkb_v_mod_t {
+    XCB_XKB_V_MOD_15 = 32768,
+    XCB_XKB_V_MOD_14 = 16384,
+    XCB_XKB_V_MOD_13 = 8192,
+    XCB_XKB_V_MOD_12 = 4096,
+    XCB_XKB_V_MOD_11 = 2048,
+    XCB_XKB_V_MOD_10 = 1024,
+    XCB_XKB_V_MOD_9 = 512,
+    XCB_XKB_V_MOD_8 = 256,
+    XCB_XKB_V_MOD_7 = 128,
+    XCB_XKB_V_MOD_6 = 64,
+    XCB_XKB_V_MOD_5 = 32,
+    XCB_XKB_V_MOD_4 = 16,
+    XCB_XKB_V_MOD_3 = 8,
+    XCB_XKB_V_MOD_2 = 4,
+    XCB_XKB_V_MOD_1 = 2,
+    XCB_XKB_V_MOD_0 = 1
+} xcb_xkb_v_mod_t;
+
+typedef enum xcb_xkb_explicit_t {
+    XCB_XKB_EXPLICIT_V_MOD_MAP = 128,
+    XCB_XKB_EXPLICIT_BEHAVIOR = 64,
+    XCB_XKB_EXPLICIT_AUTO_REPEAT = 32,
+    XCB_XKB_EXPLICIT_INTERPRET = 16,
+    XCB_XKB_EXPLICIT_KEY_TYPE_4 = 8,
+    XCB_XKB_EXPLICIT_KEY_TYPE_3 = 4,
+    XCB_XKB_EXPLICIT_KEY_TYPE_2 = 2,
+    XCB_XKB_EXPLICIT_KEY_TYPE_1 = 1
+} xcb_xkb_explicit_t;
+
+typedef enum xcb_xkb_sym_interpret_match_t {
+    XCB_XKB_SYM_INTERPRET_MATCH_NONE_OF = 0,
+    XCB_XKB_SYM_INTERPRET_MATCH_ANY_OF_OR_NONE = 1,
+    XCB_XKB_SYM_INTERPRET_MATCH_ANY_OF = 2,
+    XCB_XKB_SYM_INTERPRET_MATCH_ALL_OF = 3,
+    XCB_XKB_SYM_INTERPRET_MATCH_EXACTLY = 4
+} xcb_xkb_sym_interpret_match_t;
+
+typedef enum xcb_xkb_sym_interp_match_t {
+    XCB_XKB_SYM_INTERP_MATCH_LEVEL_ONE_ONLY = 128,
+    XCB_XKB_SYM_INTERP_MATCH_OP_MASK = 127
+} xcb_xkb_sym_interp_match_t;
+
+typedef enum xcb_xkb_im_flag_t {
+    XCB_XKB_IM_FLAG_NO_EXPLICIT = 128,
+    XCB_XKB_IM_FLAG_NO_AUTOMATIC = 64,
+    XCB_XKB_IM_FLAG_LED_DRIVES_KB = 32
+} xcb_xkb_im_flag_t;
+
+typedef enum xcb_xkb_im_mods_which_t {
+    XCB_XKB_IM_MODS_WHICH_USE_COMPAT = 16,
+    XCB_XKB_IM_MODS_WHICH_USE_EFFECTIVE = 8,
+    XCB_XKB_IM_MODS_WHICH_USE_LOCKED = 4,
+    XCB_XKB_IM_MODS_WHICH_USE_LATCHED = 2,
+    XCB_XKB_IM_MODS_WHICH_USE_BASE = 1
+} xcb_xkb_im_mods_which_t;
+
+typedef enum xcb_xkb_im_groups_which_t {
+    XCB_XKB_IM_GROUPS_WHICH_USE_COMPAT = 16,
+    XCB_XKB_IM_GROUPS_WHICH_USE_EFFECTIVE = 8,
+    XCB_XKB_IM_GROUPS_WHICH_USE_LOCKED = 4,
+    XCB_XKB_IM_GROUPS_WHICH_USE_LATCHED = 2,
+    XCB_XKB_IM_GROUPS_WHICH_USE_BASE = 1
+} xcb_xkb_im_groups_which_t;
+
+/**
+ * @brief xcb_xkb_indicator_map_t
+ **/
+typedef struct xcb_xkb_indicator_map_t {
+    uint8_t  flags;
+    uint8_t  whichGroups;
+    uint8_t  groups;
+    uint8_t  whichMods;
+    uint8_t  mods;
+    uint8_t  realMods;
+    uint16_t vmods;
+    uint32_t ctrls;
+} xcb_xkb_indicator_map_t;
+
+/**
+ * @brief xcb_xkb_indicator_map_iterator_t
+ **/
+typedef struct xcb_xkb_indicator_map_iterator_t {
+    xcb_xkb_indicator_map_t *data;
+    int                      rem;
+    int                      index;
+} xcb_xkb_indicator_map_iterator_t;
+
+typedef enum xcb_xkb_cm_detail_t {
+    XCB_XKB_CM_DETAIL_SYM_INTERP = 1,
+    XCB_XKB_CM_DETAIL_GROUP_COMPAT = 2
+} xcb_xkb_cm_detail_t;
+
+typedef enum xcb_xkb_name_detail_t {
+    XCB_XKB_NAME_DETAIL_KEYCODES = 1,
+    XCB_XKB_NAME_DETAIL_GEOMETRY = 2,
+    XCB_XKB_NAME_DETAIL_SYMBOLS = 4,
+    XCB_XKB_NAME_DETAIL_PHYS_SYMBOLS = 8,
+    XCB_XKB_NAME_DETAIL_TYPES = 16,
+    XCB_XKB_NAME_DETAIL_COMPAT = 32,
+    XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES = 64,
+    XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES = 128,
+    XCB_XKB_NAME_DETAIL_INDICATOR_NAMES = 256,
+    XCB_XKB_NAME_DETAIL_KEY_NAMES = 512,
+    XCB_XKB_NAME_DETAIL_KEY_ALIASES = 1024,
+    XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES = 2048,
+    XCB_XKB_NAME_DETAIL_GROUP_NAMES = 4096,
+    XCB_XKB_NAME_DETAIL_RG_NAMES = 8192
+} xcb_xkb_name_detail_t;
+
+typedef enum xcb_xkb_gbn_detail_t {
+    XCB_XKB_GBN_DETAIL_TYPES = 1,
+    XCB_XKB_GBN_DETAIL_COMPAT_MAP = 2,
+    XCB_XKB_GBN_DETAIL_CLIENT_SYMBOLS = 4,
+    XCB_XKB_GBN_DETAIL_SERVER_SYMBOLS = 8,
+    XCB_XKB_GBN_DETAIL_INDICATOR_MAPS = 16,
+    XCB_XKB_GBN_DETAIL_KEY_NAMES = 32,
+    XCB_XKB_GBN_DETAIL_GEOMETRY = 64,
+    XCB_XKB_GBN_DETAIL_OTHER_NAMES = 128
+} xcb_xkb_gbn_detail_t;
+
+typedef enum xcb_xkb_xi_feature_t {
+    XCB_XKB_XI_FEATURE_KEYBOARDS = 1,
+    XCB_XKB_XI_FEATURE_BUTTON_ACTIONS = 2,
+    XCB_XKB_XI_FEATURE_INDICATOR_NAMES = 4,
+    XCB_XKB_XI_FEATURE_INDICATOR_MAPS = 8,
+    XCB_XKB_XI_FEATURE_INDICATOR_STATE = 16
+} xcb_xkb_xi_feature_t;
+
+typedef enum xcb_xkb_per_client_flag_t {
+    XCB_XKB_PER_CLIENT_FLAG_DETECTABLE_AUTO_REPEAT = 1,
+    XCB_XKB_PER_CLIENT_FLAG_GRABS_USE_XKB_STATE = 2,
+    XCB_XKB_PER_CLIENT_FLAG_AUTO_RESET_CONTROLS = 4,
+    XCB_XKB_PER_CLIENT_FLAG_LOOKUP_STATE_WHEN_GRABBED = 8,
+    XCB_XKB_PER_CLIENT_FLAG_SEND_EVENT_USES_XKB_STATE = 16
+} xcb_xkb_per_client_flag_t;
+
+/**
+ * @brief xcb_xkb_mod_def_t
+ **/
+typedef struct xcb_xkb_mod_def_t {
+    uint8_t  mask;
+    uint8_t  realMods;
+    uint16_t vmods;
+} xcb_xkb_mod_def_t;
+
+/**
+ * @brief xcb_xkb_mod_def_iterator_t
+ **/
+typedef struct xcb_xkb_mod_def_iterator_t {
+    xcb_xkb_mod_def_t *data;
+    int                rem;
+    int                index;
+} xcb_xkb_mod_def_iterator_t;
+
+/**
+ * @brief xcb_xkb_key_name_t
+ **/
+typedef struct xcb_xkb_key_name_t {
+    char name[4];
+} xcb_xkb_key_name_t;
+
+/**
+ * @brief xcb_xkb_key_name_iterator_t
+ **/
+typedef struct xcb_xkb_key_name_iterator_t {
+    xcb_xkb_key_name_t *data;
+    int                 rem;
+    int                 index;
+} xcb_xkb_key_name_iterator_t;
+
+/**
+ * @brief xcb_xkb_key_alias_t
+ **/
+typedef struct xcb_xkb_key_alias_t {
+    char real[4];
+    char alias[4];
+} xcb_xkb_key_alias_t;
+
+/**
+ * @brief xcb_xkb_key_alias_iterator_t
+ **/
+typedef struct xcb_xkb_key_alias_iterator_t {
+    xcb_xkb_key_alias_t *data;
+    int                  rem;
+    int                  index;
+} xcb_xkb_key_alias_iterator_t;
+
+/**
+ * @brief xcb_xkb_counted_string_16_t
+ **/
+typedef struct xcb_xkb_counted_string_16_t {
+    uint16_t length;
+} xcb_xkb_counted_string_16_t;
+
+/**
+ * @brief xcb_xkb_counted_string_16_iterator_t
+ **/
+typedef struct xcb_xkb_counted_string_16_iterator_t {
+    xcb_xkb_counted_string_16_t *data;
+    int                          rem;
+    int                          index;
+} xcb_xkb_counted_string_16_iterator_t;
+
+/**
+ * @brief xcb_xkb_kt_map_entry_t
+ **/
+typedef struct xcb_xkb_kt_map_entry_t {
+    uint8_t  active;
+    uint8_t  mods_mask;
+    uint8_t  level;
+    uint8_t  mods_mods;
+    uint16_t mods_vmods;
+    uint8_t  pad0[2];
+} xcb_xkb_kt_map_entry_t;
+
+/**
+ * @brief xcb_xkb_kt_map_entry_iterator_t
+ **/
+typedef struct xcb_xkb_kt_map_entry_iterator_t {
+    xcb_xkb_kt_map_entry_t *data;
+    int                     rem;
+    int                     index;
+} xcb_xkb_kt_map_entry_iterator_t;
+
+/**
+ * @brief xcb_xkb_key_type_t
+ **/
+typedef struct xcb_xkb_key_type_t {
+    uint8_t  mods_mask;
+    uint8_t  mods_mods;
+    uint16_t mods_vmods;
+    uint8_t  numLevels;
+    uint8_t  nMapEntries;
+    uint8_t  hasPreserve;
+    uint8_t  pad0;
+} xcb_xkb_key_type_t;
+
+/**
+ * @brief xcb_xkb_key_type_iterator_t
+ **/
+typedef struct xcb_xkb_key_type_iterator_t {
+    xcb_xkb_key_type_t *data;
+    int                 rem;
+    int                 index;
+} xcb_xkb_key_type_iterator_t;
+
+/**
+ * @brief xcb_xkb_key_sym_map_t
+ **/
+typedef struct xcb_xkb_key_sym_map_t {
+    uint8_t  kt_index[4];
+    uint8_t  groupInfo;
+    uint8_t  width;
+    uint16_t nSyms;
+} xcb_xkb_key_sym_map_t;
+
+/**
+ * @brief xcb_xkb_key_sym_map_iterator_t
+ **/
+typedef struct xcb_xkb_key_sym_map_iterator_t {
+    xcb_xkb_key_sym_map_t *data;
+    int                    rem;
+    int                    index;
+} xcb_xkb_key_sym_map_iterator_t;
+
+/**
+ * @brief xcb_xkb_common_behavior_t
+ **/
+typedef struct xcb_xkb_common_behavior_t {
+    uint8_t type;
+    uint8_t data;
+} xcb_xkb_common_behavior_t;
+
+/**
+ * @brief xcb_xkb_common_behavior_iterator_t
+ **/
+typedef struct xcb_xkb_common_behavior_iterator_t {
+    xcb_xkb_common_behavior_t *data;
+    int                        rem;
+    int                        index;
+} xcb_xkb_common_behavior_iterator_t;
+
+/**
+ * @brief xcb_xkb_default_behavior_t
+ **/
+typedef struct xcb_xkb_default_behavior_t {
+    uint8_t type;
+    uint8_t pad0;
+} xcb_xkb_default_behavior_t;
+
+/**
+ * @brief xcb_xkb_default_behavior_iterator_t
+ **/
+typedef struct xcb_xkb_default_behavior_iterator_t {
+    xcb_xkb_default_behavior_t *data;
+    int                         rem;
+    int                         index;
+} xcb_xkb_default_behavior_iterator_t;
+
+/**
+ * @brief xcb_xkb_lock_behavior_t
+ **/
+typedef struct xcb_xkb_lock_behavior_t {
+    uint8_t type;
+    uint8_t pad0;
+} xcb_xkb_lock_behavior_t;
+
+/**
+ * @brief xcb_xkb_lock_behavior_iterator_t
+ **/
+typedef struct xcb_xkb_lock_behavior_iterator_t {
+    xcb_xkb_lock_behavior_t *data;
+    int                      rem;
+    int                      index;
+} xcb_xkb_lock_behavior_iterator_t;
+
+/**
+ * @brief xcb_xkb_radio_group_behavior_t
+ **/
+typedef struct xcb_xkb_radio_group_behavior_t {
+    uint8_t type;
+    uint8_t group;
+} xcb_xkb_radio_group_behavior_t;
+
+/**
+ * @brief xcb_xkb_radio_group_behavior_iterator_t
+ **/
+typedef struct xcb_xkb_radio_group_behavior_iterator_t {
+    xcb_xkb_radio_group_behavior_t *data;
+    int                             rem;
+    int                             index;
+} xcb_xkb_radio_group_behavior_iterator_t;
+
+/**
+ * @brief xcb_xkb_overlay_behavior_t
+ **/
+typedef struct xcb_xkb_overlay_behavior_t {
+    uint8_t       type;
+    xcb_keycode_t key;
+} xcb_xkb_overlay_behavior_t;
+
+/**
+ * @brief xcb_xkb_overlay_behavior_iterator_t
+ **/
+typedef struct xcb_xkb_overlay_behavior_iterator_t {
+    xcb_xkb_overlay_behavior_t *data;
+    int                         rem;
+    int                         index;
+} xcb_xkb_overlay_behavior_iterator_t;
+
+/**
+ * @brief xcb_xkb_permament_lock_behavior_t
+ **/
+typedef struct xcb_xkb_permament_lock_behavior_t {
+    uint8_t type;
+    uint8_t pad0;
+} xcb_xkb_permament_lock_behavior_t;
+
+/**
+ * @brief xcb_xkb_permament_lock_behavior_iterator_t
+ **/
+typedef struct xcb_xkb_permament_lock_behavior_iterator_t {
+    xcb_xkb_permament_lock_behavior_t *data;
+    int                                rem;
+    int                                index;
+} xcb_xkb_permament_lock_behavior_iterator_t;
+
+/**
+ * @brief xcb_xkb_permament_radio_group_behavior_t
+ **/
+typedef struct xcb_xkb_permament_radio_group_behavior_t {
+    uint8_t type;
+    uint8_t group;
+} xcb_xkb_permament_radio_group_behavior_t;
+
+/**
+ * @brief xcb_xkb_permament_radio_group_behavior_iterator_t
+ **/
+typedef struct xcb_xkb_permament_radio_group_behavior_iterator_t {
+    xcb_xkb_permament_radio_group_behavior_t *data;
+    int                                       rem;
+    int                                       index;
+} xcb_xkb_permament_radio_group_behavior_iterator_t;
+
+/**
+ * @brief xcb_xkb_permament_overlay_behavior_t
+ **/
+typedef struct xcb_xkb_permament_overlay_behavior_t {
+    uint8_t       type;
+    xcb_keycode_t key;
+} xcb_xkb_permament_overlay_behavior_t;
+
+/**
+ * @brief xcb_xkb_permament_overlay_behavior_iterator_t
+ **/
+typedef struct xcb_xkb_permament_overlay_behavior_iterator_t {
+    xcb_xkb_permament_overlay_behavior_t *data;
+    int                                   rem;
+    int                                   index;
+} xcb_xkb_permament_overlay_behavior_iterator_t;
+
+/**
+ * @brief xcb_xkb_behavior_t
+ **/
+typedef union xcb_xkb_behavior_t {
+    xcb_xkb_common_behavior_t                common;
+    xcb_xkb_default_behavior_t               _default;
+    xcb_xkb_lock_behavior_t                  lock;
+    xcb_xkb_radio_group_behavior_t           radioGroup;
+    xcb_xkb_overlay_behavior_t               overlay1;
+    xcb_xkb_overlay_behavior_t               overlay2;
+    xcb_xkb_permament_lock_behavior_t        permamentLock;
+    xcb_xkb_permament_radio_group_behavior_t permamentRadioGroup;
+    xcb_xkb_permament_overlay_behavior_t     permamentOverlay1;
+    xcb_xkb_permament_overlay_behavior_t     permamentOverlay2;
+    uint8_t                                  type;
+} xcb_xkb_behavior_t;
+
+/**
+ * @brief xcb_xkb_behavior_iterator_t
+ **/
+typedef struct xcb_xkb_behavior_iterator_t {
+    xcb_xkb_behavior_t *data;
+    int                 rem;
+    int                 index;
+} xcb_xkb_behavior_iterator_t;
+
+typedef enum xcb_xkb_behavior_type_t {
+    XCB_XKB_BEHAVIOR_TYPE_DEFAULT = 0,
+    XCB_XKB_BEHAVIOR_TYPE_LOCK = 1,
+    XCB_XKB_BEHAVIOR_TYPE_RADIO_GROUP = 2,
+    XCB_XKB_BEHAVIOR_TYPE_OVERLAY_1 = 3,
+    XCB_XKB_BEHAVIOR_TYPE_OVERLAY_2 = 4,
+    XCB_XKB_BEHAVIOR_TYPE_PERMAMENT_LOCK = 129,
+    XCB_XKB_BEHAVIOR_TYPE_PERMAMENT_RADIO_GROUP = 130,
+    XCB_XKB_BEHAVIOR_TYPE_PERMAMENT_OVERLAY_1 = 131,
+    XCB_XKB_BEHAVIOR_TYPE_PERMAMENT_OVERLAY_2 = 132
+} xcb_xkb_behavior_type_t;
+
+/**
+ * @brief xcb_xkb_set_behavior_t
+ **/
+typedef struct xcb_xkb_set_behavior_t {
+    xcb_keycode_t      keycode;
+    xcb_xkb_behavior_t behavior;
+    uint8_t            pad0;
+} xcb_xkb_set_behavior_t;
+
+/**
+ * @brief xcb_xkb_set_behavior_iterator_t
+ **/
+typedef struct xcb_xkb_set_behavior_iterator_t {
+    xcb_xkb_set_behavior_t *data;
+    int                     rem;
+    int                     index;
+} xcb_xkb_set_behavior_iterator_t;
+
+/**
+ * @brief xcb_xkb_set_explicit_t
+ **/
+typedef struct xcb_xkb_set_explicit_t {
+    xcb_keycode_t keycode;
+    uint8_t       explicit;
+} xcb_xkb_set_explicit_t;
+
+/**
+ * @brief xcb_xkb_set_explicit_iterator_t
+ **/
+typedef struct xcb_xkb_set_explicit_iterator_t {
+    xcb_xkb_set_explicit_t *data;
+    int                     rem;
+    int                     index;
+} xcb_xkb_set_explicit_iterator_t;
+
+/**
+ * @brief xcb_xkb_key_mod_map_t
+ **/
+typedef struct xcb_xkb_key_mod_map_t {
+    xcb_keycode_t keycode;
+    uint8_t       mods;
+} xcb_xkb_key_mod_map_t;
+
+/**
+ * @brief xcb_xkb_key_mod_map_iterator_t
+ **/
+typedef struct xcb_xkb_key_mod_map_iterator_t {
+    xcb_xkb_key_mod_map_t *data;
+    int                    rem;
+    int                    index;
+} xcb_xkb_key_mod_map_iterator_t;
+
+/**
+ * @brief xcb_xkb_key_v_mod_map_t
+ **/
+typedef struct xcb_xkb_key_v_mod_map_t {
+    xcb_keycode_t keycode;
+    uint8_t       pad0;
+    uint16_t      vmods;
+} xcb_xkb_key_v_mod_map_t;
+
+/**
+ * @brief xcb_xkb_key_v_mod_map_iterator_t
+ **/
+typedef struct xcb_xkb_key_v_mod_map_iterator_t {
+    xcb_xkb_key_v_mod_map_t *data;
+    int                      rem;
+    int                      index;
+} xcb_xkb_key_v_mod_map_iterator_t;
+
+/**
+ * @brief xcb_xkb_kt_set_map_entry_t
+ **/
+typedef struct xcb_xkb_kt_set_map_entry_t {
+    uint8_t  level;
+    uint8_t  realMods;
+    uint16_t virtualMods;
+} xcb_xkb_kt_set_map_entry_t;
+
+/**
+ * @brief xcb_xkb_kt_set_map_entry_iterator_t
+ **/
+typedef struct xcb_xkb_kt_set_map_entry_iterator_t {
+    xcb_xkb_kt_set_map_entry_t *data;
+    int                         rem;
+    int                         index;
+} xcb_xkb_kt_set_map_entry_iterator_t;
+
+/**
+ * @brief xcb_xkb_set_key_type_t
+ **/
+typedef struct xcb_xkb_set_key_type_t {
+    uint8_t  mask;
+    uint8_t  realMods;
+    uint16_t virtualMods;
+    uint8_t  numLevels;
+    uint8_t  nMapEntries;
+    uint8_t  preserve;
+    uint8_t  pad0;
+} xcb_xkb_set_key_type_t;
+
+/**
+ * @brief xcb_xkb_set_key_type_iterator_t
+ **/
+typedef struct xcb_xkb_set_key_type_iterator_t {
+    xcb_xkb_set_key_type_t *data;
+    int                     rem;
+    int                     index;
+} xcb_xkb_set_key_type_iterator_t;
+
+typedef char xcb_xkb_string8_t;
+
+/**
+ * @brief xcb_xkb_string8_iterator_t
+ **/
+typedef struct xcb_xkb_string8_iterator_t {
+    xcb_xkb_string8_t *data;
+    int                rem;
+    int                index;
+} xcb_xkb_string8_iterator_t;
+
+/**
+ * @brief xcb_xkb_outline_t
+ **/
+typedef struct xcb_xkb_outline_t {
+    uint8_t nPoints;
+    uint8_t cornerRadius;
+    uint8_t pad0[2];
+} xcb_xkb_outline_t;
+
+/**
+ * @brief xcb_xkb_outline_iterator_t
+ **/
+typedef struct xcb_xkb_outline_iterator_t {
+    xcb_xkb_outline_t *data;
+    int                rem;
+    int                index;
+} xcb_xkb_outline_iterator_t;
+
+/**
+ * @brief xcb_xkb_shape_t
+ **/
+typedef struct xcb_xkb_shape_t {
+    xcb_atom_t name;
+    uint8_t    nOutlines;
+    uint8_t    primaryNdx;
+    uint8_t    approxNdx;
+    uint8_t    pad0;
+} xcb_xkb_shape_t;
+
+/**
+ * @brief xcb_xkb_shape_iterator_t
+ **/
+typedef struct xcb_xkb_shape_iterator_t {
+    xcb_xkb_shape_t *data;
+    int              rem;
+    int              index;
+} xcb_xkb_shape_iterator_t;
+
+/**
+ * @brief xcb_xkb_key_t
+ **/
+typedef struct xcb_xkb_key_t {
+    xcb_xkb_string8_t name[4];
+    int16_t           gap;
+    uint8_t           shapeNdx;
+    uint8_t           colorNdx;
+} xcb_xkb_key_t;
+
+/**
+ * @brief xcb_xkb_key_iterator_t
+ **/
+typedef struct xcb_xkb_key_iterator_t {
+    xcb_xkb_key_t *data;
+    int            rem;
+    int            index;
+} xcb_xkb_key_iterator_t;
+
+/**
+ * @brief xcb_xkb_overlay_key_t
+ **/
+typedef struct xcb_xkb_overlay_key_t {
+    xcb_xkb_string8_t over[4];
+    xcb_xkb_string8_t under[4];
+} xcb_xkb_overlay_key_t;
+
+/**
+ * @brief xcb_xkb_overlay_key_iterator_t
+ **/
+typedef struct xcb_xkb_overlay_key_iterator_t {
+    xcb_xkb_overlay_key_t *data;
+    int                    rem;
+    int                    index;
+} xcb_xkb_overlay_key_iterator_t;
+
+/**
+ * @brief xcb_xkb_overlay_row_t
+ **/
+typedef struct xcb_xkb_overlay_row_t {
+    uint8_t rowUnder;
+    uint8_t nKeys;
+    uint8_t pad0[2];
+} xcb_xkb_overlay_row_t;
+
+/**
+ * @brief xcb_xkb_overlay_row_iterator_t
+ **/
+typedef struct xcb_xkb_overlay_row_iterator_t {
+    xcb_xkb_overlay_row_t *data;
+    int                    rem;
+    int                    index;
+} xcb_xkb_overlay_row_iterator_t;
+
+/**
+ * @brief xcb_xkb_overlay_t
+ **/
+typedef struct xcb_xkb_overlay_t {
+    xcb_atom_t name;
+    uint8_t    nRows;
+    uint8_t    pad0[3];
+} xcb_xkb_overlay_t;
+
+/**
+ * @brief xcb_xkb_overlay_iterator_t
+ **/
+typedef struct xcb_xkb_overlay_iterator_t {
+    xcb_xkb_overlay_t *data;
+    int                rem;
+    int                index;
+} xcb_xkb_overlay_iterator_t;
+
+/**
+ * @brief xcb_xkb_row_t
+ **/
+typedef struct xcb_xkb_row_t {
+    int16_t top;
+    int16_t left;
+    uint8_t nKeys;
+    uint8_t vertical;
+    uint8_t pad0[2];
+} xcb_xkb_row_t;
+
+/**
+ * @brief xcb_xkb_row_iterator_t
+ **/
+typedef struct xcb_xkb_row_iterator_t {
+    xcb_xkb_row_t *data;
+    int            rem;
+    int            index;
+} xcb_xkb_row_iterator_t;
+
+typedef enum xcb_xkb_doodad_type_t {
+    XCB_XKB_DOODAD_TYPE_OUTLINE = 1,
+    XCB_XKB_DOODAD_TYPE_SOLID = 2,
+    XCB_XKB_DOODAD_TYPE_TEXT = 3,
+    XCB_XKB_DOODAD_TYPE_INDICATOR = 4,
+    XCB_XKB_DOODAD_TYPE_LOGO = 5
+} xcb_xkb_doodad_type_t;
+
+/**
+ * @brief xcb_xkb_listing_t
+ **/
+typedef struct xcb_xkb_listing_t {
+    uint16_t flags;
+    uint16_t length;
+} xcb_xkb_listing_t;
+
+/**
+ * @brief xcb_xkb_listing_iterator_t
+ **/
+typedef struct xcb_xkb_listing_iterator_t {
+    xcb_xkb_listing_t *data;
+    int                rem;
+    int                index;
+} xcb_xkb_listing_iterator_t;
+
+/**
+ * @brief xcb_xkb_device_led_info_t
+ **/
+typedef struct xcb_xkb_device_led_info_t {
+    xcb_xkb_led_class_spec_t ledClass;
+    xcb_xkb_id_spec_t        ledID;
+    uint32_t                 namesPresent;
+    uint32_t                 mapsPresent;
+    uint32_t                 physIndicators;
+    uint32_t                 state;
+} xcb_xkb_device_led_info_t;
+
+/**
+ * @brief xcb_xkb_device_led_info_iterator_t
+ **/
+typedef struct xcb_xkb_device_led_info_iterator_t {
+    xcb_xkb_device_led_info_t *data;
+    int                        rem;
+    int                        index;
+} xcb_xkb_device_led_info_iterator_t;
+
+typedef enum xcb_xkb_error_t {
+    XCB_XKB_ERROR_BAD_DEVICE = 255,
+    XCB_XKB_ERROR_BAD_CLASS = 254,
+    XCB_XKB_ERROR_BAD_ID = 253
+} xcb_xkb_error_t;
+
+/** Opcode for xcb_xkb_keyboard. */
+#define XCB_XKB_KEYBOARD 0
+
+/**
+ * @brief xcb_xkb_keyboard_error_t
+ **/
+typedef struct xcb_xkb_keyboard_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t value;
+    uint16_t minorOpcode;
+    uint8_t  majorOpcode;
+    uint8_t  pad0[21];
+} xcb_xkb_keyboard_error_t;
+
+typedef enum xcb_xkb_sa_t {
+    XCB_XKB_SA_CLEAR_LOCKS = 1,
+    XCB_XKB_SA_LATCH_TO_LOCK = 2,
+    XCB_XKB_SA_USE_MOD_MAP_MODS = 4,
+    XCB_XKB_SA_GROUP_ABSOLUTE = 4
+} xcb_xkb_sa_t;
+
+typedef enum xcb_xkb_sa_type_t {
+    XCB_XKB_SA_TYPE_NO_ACTION = 0,
+    XCB_XKB_SA_TYPE_SET_MODS = 1,
+    XCB_XKB_SA_TYPE_LATCH_MODS = 2,
+    XCB_XKB_SA_TYPE_LOCK_MODS = 3,
+    XCB_XKB_SA_TYPE_SET_GROUP = 4,
+    XCB_XKB_SA_TYPE_LATCH_GROUP = 5,
+    XCB_XKB_SA_TYPE_LOCK_GROUP = 6,
+    XCB_XKB_SA_TYPE_MOVE_PTR = 7,
+    XCB_XKB_SA_TYPE_PTR_BTN = 8,
+    XCB_XKB_SA_TYPE_LOCK_PTR_BTN = 9,
+    XCB_XKB_SA_TYPE_SET_PTR_DFLT = 10,
+    XCB_XKB_SA_TYPE_ISO_LOCK = 11,
+    XCB_XKB_SA_TYPE_TERMINATE = 12,
+    XCB_XKB_SA_TYPE_SWITCH_SCREEN = 13,
+    XCB_XKB_SA_TYPE_SET_CONTROLS = 14,
+    XCB_XKB_SA_TYPE_LOCK_CONTROLS = 15,
+    XCB_XKB_SA_TYPE_ACTION_MESSAGE = 16,
+    XCB_XKB_SA_TYPE_REDIRECT_KEY = 17,
+    XCB_XKB_SA_TYPE_DEVICE_BTN = 18,
+    XCB_XKB_SA_TYPE_LOCK_DEVICE_BTN = 19,
+    XCB_XKB_SA_TYPE_DEVICE_VALUATOR = 20
+} xcb_xkb_sa_type_t;
+
+/**
+ * @brief xcb_xkb_sa_no_action_t
+ **/
+typedef struct xcb_xkb_sa_no_action_t {
+    uint8_t type;
+    uint8_t pad0[7];
+} xcb_xkb_sa_no_action_t;
+
+/**
+ * @brief xcb_xkb_sa_no_action_iterator_t
+ **/
+typedef struct xcb_xkb_sa_no_action_iterator_t {
+    xcb_xkb_sa_no_action_t *data;
+    int                     rem;
+    int                     index;
+} xcb_xkb_sa_no_action_iterator_t;
+
+/**
+ * @brief xcb_xkb_sa_set_mods_t
+ **/
+typedef struct xcb_xkb_sa_set_mods_t {
+    uint8_t type;
+    uint8_t flags;
+    uint8_t mask;
+    uint8_t realMods;
+    uint8_t vmodsHigh;
+    uint8_t vmodsLow;
+    uint8_t pad0[2];
+} xcb_xkb_sa_set_mods_t;
+
+/**
+ * @brief xcb_xkb_sa_set_mods_iterator_t
+ **/
+typedef struct xcb_xkb_sa_set_mods_iterator_t {
+    xcb_xkb_sa_set_mods_t *data;
+    int                    rem;
+    int                    index;
+} xcb_xkb_sa_set_mods_iterator_t;
+
+/**
+ * @brief xcb_xkb_sa_latch_mods_t
+ **/
+typedef struct xcb_xkb_sa_latch_mods_t {
+    uint8_t type;
+    uint8_t flags;
+    uint8_t mask;
+    uint8_t realMods;
+    uint8_t vmodsHigh;
+    uint8_t vmodsLow;
+    uint8_t pad0[2];
+} xcb_xkb_sa_latch_mods_t;
+
+/**
+ * @brief xcb_xkb_sa_latch_mods_iterator_t
+ **/
+typedef struct xcb_xkb_sa_latch_mods_iterator_t {
+    xcb_xkb_sa_latch_mods_t *data;
+    int                      rem;
+    int                      index;
+} xcb_xkb_sa_latch_mods_iterator_t;
+
+/**
+ * @brief xcb_xkb_sa_lock_mods_t
+ **/
+typedef struct xcb_xkb_sa_lock_mods_t {
+    uint8_t type;
+    uint8_t flags;
+    uint8_t mask;
+    uint8_t realMods;
+    uint8_t vmodsHigh;
+    uint8_t vmodsLow;
+    uint8_t pad0[2];
+} xcb_xkb_sa_lock_mods_t;
+
+/**
+ * @brief xcb_xkb_sa_lock_mods_iterator_t
+ **/
+typedef struct xcb_xkb_sa_lock_mods_iterator_t {
+    xcb_xkb_sa_lock_mods_t *data;
+    int                     rem;
+    int                     index;
+} xcb_xkb_sa_lock_mods_iterator_t;
+
+/**
+ * @brief xcb_xkb_sa_set_group_t
+ **/
+typedef struct xcb_xkb_sa_set_group_t {
+    uint8_t type;
+    uint8_t flags;
+    int8_t  group;
+    uint8_t pad0[5];
+} xcb_xkb_sa_set_group_t;
+
+/**
+ * @brief xcb_xkb_sa_set_group_iterator_t
+ **/
+typedef struct xcb_xkb_sa_set_group_iterator_t {
+    xcb_xkb_sa_set_group_t *data;
+    int                     rem;
+    int                     index;
+} xcb_xkb_sa_set_group_iterator_t;
+
+/**
+ * @brief xcb_xkb_sa_latch_group_t
+ **/
+typedef struct xcb_xkb_sa_latch_group_t {
+    uint8_t type;
+    uint8_t flags;
+    int8_t  group;
+    uint8_t pad0[5];
+} xcb_xkb_sa_latch_group_t;
+
+/**
+ * @brief xcb_xkb_sa_latch_group_iterator_t
+ **/
+typedef struct xcb_xkb_sa_latch_group_iterator_t {
+    xcb_xkb_sa_latch_group_t *data;
+    int                       rem;
+    int                       index;
+} xcb_xkb_sa_latch_group_iterator_t;
+
+/**
+ * @brief xcb_xkb_sa_lock_group_t
+ **/
+typedef struct xcb_xkb_sa_lock_group_t {
+    uint8_t type;
+    uint8_t flags;
+    int8_t  group;
+    uint8_t pad0[5];
+} xcb_xkb_sa_lock_group_t;
+
+/**
+ * @brief xcb_xkb_sa_lock_group_iterator_t
+ **/
+typedef struct xcb_xkb_sa_lock_group_iterator_t {
+    xcb_xkb_sa_lock_group_t *data;
+    int                      rem;
+    int                      index;
+} xcb_xkb_sa_lock_group_iterator_t;
+
+typedef enum xcb_xkb_sa_move_ptr_flag_t {
+    XCB_XKB_SA_MOVE_PTR_FLAG_NO_ACCELERATION = 1,
+    XCB_XKB_SA_MOVE_PTR_FLAG_MOVE_ABSOLUTE_X = 2,
+    XCB_XKB_SA_MOVE_PTR_FLAG_MOVE_ABSOLUTE_Y = 4
+} xcb_xkb_sa_move_ptr_flag_t;
+
+/**
+ * @brief xcb_xkb_sa_move_ptr_t
+ **/
+typedef struct xcb_xkb_sa_move_ptr_t {
+    uint8_t type;
+    uint8_t flags;
+    int8_t  xHigh;
+    uint8_t xLow;
+    int8_t  yHigh;
+    uint8_t yLow;
+    uint8_t pad0[2];
+} xcb_xkb_sa_move_ptr_t;
+
+/**
+ * @brief xcb_xkb_sa_move_ptr_iterator_t
+ **/
+typedef struct xcb_xkb_sa_move_ptr_iterator_t {
+    xcb_xkb_sa_move_ptr_t *data;
+    int                    rem;
+    int                    index;
+} xcb_xkb_sa_move_ptr_iterator_t;
+
+/**
+ * @brief xcb_xkb_sa_ptr_btn_t
+ **/
+typedef struct xcb_xkb_sa_ptr_btn_t {
+    uint8_t type;
+    uint8_t flags;
+    uint8_t count;
+    uint8_t button;
+    uint8_t pad0[4];
+} xcb_xkb_sa_ptr_btn_t;
+
+/**
+ * @brief xcb_xkb_sa_ptr_btn_iterator_t
+ **/
+typedef struct xcb_xkb_sa_ptr_btn_iterator_t {
+    xcb_xkb_sa_ptr_btn_t *data;
+    int                   rem;
+    int                   index;
+} xcb_xkb_sa_ptr_btn_iterator_t;
+
+/**
+ * @brief xcb_xkb_sa_lock_ptr_btn_t
+ **/
+typedef struct xcb_xkb_sa_lock_ptr_btn_t {
+    uint8_t type;
+    uint8_t flags;
+    uint8_t pad0;
+    uint8_t button;
+    uint8_t pad1[4];
+} xcb_xkb_sa_lock_ptr_btn_t;
+
+/**
+ * @brief xcb_xkb_sa_lock_ptr_btn_iterator_t
+ **/
+typedef struct xcb_xkb_sa_lock_ptr_btn_iterator_t {
+    xcb_xkb_sa_lock_ptr_btn_t *data;
+    int                        rem;
+    int                        index;
+} xcb_xkb_sa_lock_ptr_btn_iterator_t;
+
+typedef enum xcb_xkb_sa_set_ptr_dflt_flag_t {
+    XCB_XKB_SA_SET_PTR_DFLT_FLAG_DFLT_BTN_ABSOLUTE = 4,
+    XCB_XKB_SA_SET_PTR_DFLT_FLAG_AFFECT_DFLT_BUTTON = 1
+} xcb_xkb_sa_set_ptr_dflt_flag_t;
+
+/**
+ * @brief xcb_xkb_sa_set_ptr_dflt_t
+ **/
+typedef struct xcb_xkb_sa_set_ptr_dflt_t {
+    uint8_t type;
+    uint8_t flags;
+    uint8_t affect;
+    int8_t  value;
+    uint8_t pad0[4];
+} xcb_xkb_sa_set_ptr_dflt_t;
+
+/**
+ * @brief xcb_xkb_sa_set_ptr_dflt_iterator_t
+ **/
+typedef struct xcb_xkb_sa_set_ptr_dflt_iterator_t {
+    xcb_xkb_sa_set_ptr_dflt_t *data;
+    int                        rem;
+    int                        index;
+} xcb_xkb_sa_set_ptr_dflt_iterator_t;
+
+typedef enum xcb_xkb_sa_iso_lock_flag_t {
+    XCB_XKB_SA_ISO_LOCK_FLAG_NO_LOCK = 1,
+    XCB_XKB_SA_ISO_LOCK_FLAG_NO_UNLOCK = 2,
+    XCB_XKB_SA_ISO_LOCK_FLAG_USE_MOD_MAP_MODS = 4,
+    XCB_XKB_SA_ISO_LOCK_FLAG_GROUP_ABSOLUTE = 4,
+    XCB_XKB_SA_ISO_LOCK_FLAG_ISO_DFLT_IS_GROUP = 8
+} xcb_xkb_sa_iso_lock_flag_t;
+
+typedef enum xcb_xkb_sa_iso_lock_no_affect_t {
+    XCB_XKB_SA_ISO_LOCK_NO_AFFECT_CTRLS = 8,
+    XCB_XKB_SA_ISO_LOCK_NO_AFFECT_PTR = 16,
+    XCB_XKB_SA_ISO_LOCK_NO_AFFECT_GROUP = 32,
+    XCB_XKB_SA_ISO_LOCK_NO_AFFECT_MODS = 64
+} xcb_xkb_sa_iso_lock_no_affect_t;
+
+/**
+ * @brief xcb_xkb_sa_iso_lock_t
+ **/
+typedef struct xcb_xkb_sa_iso_lock_t {
+    uint8_t type;
+    uint8_t flags;
+    uint8_t mask;
+    uint8_t realMods;
+    int8_t  group;
+    uint8_t affect;
+    uint8_t vmodsHigh;
+    uint8_t vmodsLow;
+} xcb_xkb_sa_iso_lock_t;
+
+/**
+ * @brief xcb_xkb_sa_iso_lock_iterator_t
+ **/
+typedef struct xcb_xkb_sa_iso_lock_iterator_t {
+    xcb_xkb_sa_iso_lock_t *data;
+    int                    rem;
+    int                    index;
+} xcb_xkb_sa_iso_lock_iterator_t;
+
+/**
+ * @brief xcb_xkb_sa_terminate_t
+ **/
+typedef struct xcb_xkb_sa_terminate_t {
+    uint8_t type;
+    uint8_t pad0[7];
+} xcb_xkb_sa_terminate_t;
+
+/**
+ * @brief xcb_xkb_sa_terminate_iterator_t
+ **/
+typedef struct xcb_xkb_sa_terminate_iterator_t {
+    xcb_xkb_sa_terminate_t *data;
+    int                     rem;
+    int                     index;
+} xcb_xkb_sa_terminate_iterator_t;
+
+typedef enum xcb_xkb_switch_screen_flag_t {
+    XCB_XKB_SWITCH_SCREEN_FLAG_APPLICATION = 1,
+    XCB_XKB_SWITCH_SCREEN_FLAG_ABSOLUTE = 4
+} xcb_xkb_switch_screen_flag_t;
+
+/**
+ * @brief xcb_xkb_sa_switch_screen_t
+ **/
+typedef struct xcb_xkb_sa_switch_screen_t {
+    uint8_t type;
+    uint8_t flags;
+    int8_t  newScreen;
+    uint8_t pad0[5];
+} xcb_xkb_sa_switch_screen_t;
+
+/**
+ * @brief xcb_xkb_sa_switch_screen_iterator_t
+ **/
+typedef struct xcb_xkb_sa_switch_screen_iterator_t {
+    xcb_xkb_sa_switch_screen_t *data;
+    int                         rem;
+    int                         index;
+} xcb_xkb_sa_switch_screen_iterator_t;
+
+typedef enum xcb_xkb_bool_ctrls_high_t {
+    XCB_XKB_BOOL_CTRLS_HIGH_ACCESS_X_FEEDBACK = 1,
+    XCB_XKB_BOOL_CTRLS_HIGH_AUDIBLE_BELL = 2,
+    XCB_XKB_BOOL_CTRLS_HIGH_OVERLAY_1 = 4,
+    XCB_XKB_BOOL_CTRLS_HIGH_OVERLAY_2 = 8,
+    XCB_XKB_BOOL_CTRLS_HIGH_IGNORE_GROUP_LOCK = 16
+} xcb_xkb_bool_ctrls_high_t;
+
+typedef enum xcb_xkb_bool_ctrls_low_t {
+    XCB_XKB_BOOL_CTRLS_LOW_REPEAT_KEYS = 1,
+    XCB_XKB_BOOL_CTRLS_LOW_SLOW_KEYS = 2,
+    XCB_XKB_BOOL_CTRLS_LOW_BOUNCE_KEYS = 4,
+    XCB_XKB_BOOL_CTRLS_LOW_STICKY_KEYS = 8,
+    XCB_XKB_BOOL_CTRLS_LOW_MOUSE_KEYS = 16,
+    XCB_XKB_BOOL_CTRLS_LOW_MOUSE_KEYS_ACCEL = 32,
+    XCB_XKB_BOOL_CTRLS_LOW_ACCESS_X_KEYS = 64,
+    XCB_XKB_BOOL_CTRLS_LOW_ACCESS_X_TIMEOUT = 128
+} xcb_xkb_bool_ctrls_low_t;
+
+/**
+ * @brief xcb_xkb_sa_set_controls_t
+ **/
+typedef struct xcb_xkb_sa_set_controls_t {
+    uint8_t type;
+    uint8_t pad0[3];
+    uint8_t boolCtrlsHigh;
+    uint8_t boolCtrlsLow;
+    uint8_t pad1[2];
+} xcb_xkb_sa_set_controls_t;
+
+/**
+ * @brief xcb_xkb_sa_set_controls_iterator_t
+ **/
+typedef struct xcb_xkb_sa_set_controls_iterator_t {
+    xcb_xkb_sa_set_controls_t *data;
+    int                        rem;
+    int                        index;
+} xcb_xkb_sa_set_controls_iterator_t;
+
+/**
+ * @brief xcb_xkb_sa_lock_controls_t
+ **/
+typedef struct xcb_xkb_sa_lock_controls_t {
+    uint8_t type;
+    uint8_t pad0[3];
+    uint8_t boolCtrlsHigh;
+    uint8_t boolCtrlsLow;
+    uint8_t pad1[2];
+} xcb_xkb_sa_lock_controls_t;
+
+/**
+ * @brief xcb_xkb_sa_lock_controls_iterator_t
+ **/
+typedef struct xcb_xkb_sa_lock_controls_iterator_t {
+    xcb_xkb_sa_lock_controls_t *data;
+    int                         rem;
+    int                         index;
+} xcb_xkb_sa_lock_controls_iterator_t;
+
+typedef enum xcb_xkb_action_message_flag_t {
+    XCB_XKB_ACTION_MESSAGE_FLAG_ON_PRESS = 1,
+    XCB_XKB_ACTION_MESSAGE_FLAG_ON_RELEASE = 2,
+    XCB_XKB_ACTION_MESSAGE_FLAG_GEN_KEY_EVENT = 4
+} xcb_xkb_action_message_flag_t;
+
+/**
+ * @brief xcb_xkb_sa_action_message_t
+ **/
+typedef struct xcb_xkb_sa_action_message_t {
+    uint8_t type;
+    uint8_t flags;
+    uint8_t message[6];
+} xcb_xkb_sa_action_message_t;
+
+/**
+ * @brief xcb_xkb_sa_action_message_iterator_t
+ **/
+typedef struct xcb_xkb_sa_action_message_iterator_t {
+    xcb_xkb_sa_action_message_t *data;
+    int                          rem;
+    int                          index;
+} xcb_xkb_sa_action_message_iterator_t;
+
+/**
+ * @brief xcb_xkb_sa_redirect_key_t
+ **/
+typedef struct xcb_xkb_sa_redirect_key_t {
+    uint8_t       type;
+    xcb_keycode_t newkey;
+    uint8_t       mask;
+    uint8_t       realModifiers;
+    uint8_t       vmodsMaskHigh;
+    uint8_t       vmodsMaskLow;
+    uint8_t       vmodsHigh;
+    uint8_t       vmodsLow;
+} xcb_xkb_sa_redirect_key_t;
+
+/**
+ * @brief xcb_xkb_sa_redirect_key_iterator_t
+ **/
+typedef struct xcb_xkb_sa_redirect_key_iterator_t {
+    xcb_xkb_sa_redirect_key_t *data;
+    int                        rem;
+    int                        index;
+} xcb_xkb_sa_redirect_key_iterator_t;
+
+/**
+ * @brief xcb_xkb_sa_device_btn_t
+ **/
+typedef struct xcb_xkb_sa_device_btn_t {
+    uint8_t type;
+    uint8_t flags;
+    uint8_t count;
+    uint8_t button;
+    uint8_t device;
+    uint8_t pad0[3];
+} xcb_xkb_sa_device_btn_t;
+
+/**
+ * @brief xcb_xkb_sa_device_btn_iterator_t
+ **/
+typedef struct xcb_xkb_sa_device_btn_iterator_t {
+    xcb_xkb_sa_device_btn_t *data;
+    int                      rem;
+    int                      index;
+} xcb_xkb_sa_device_btn_iterator_t;
+
+typedef enum xcb_xkb_lock_device_flags_t {
+    XCB_XKB_LOCK_DEVICE_FLAGS_NO_LOCK = 1,
+    XCB_XKB_LOCK_DEVICE_FLAGS_NO_UNLOCK = 2
+} xcb_xkb_lock_device_flags_t;
+
+/**
+ * @brief xcb_xkb_sa_lock_device_btn_t
+ **/
+typedef struct xcb_xkb_sa_lock_device_btn_t {
+    uint8_t type;
+    uint8_t flags;
+    uint8_t pad0;
+    uint8_t button;
+    uint8_t device;
+    uint8_t pad1[3];
+} xcb_xkb_sa_lock_device_btn_t;
+
+/**
+ * @brief xcb_xkb_sa_lock_device_btn_iterator_t
+ **/
+typedef struct xcb_xkb_sa_lock_device_btn_iterator_t {
+    xcb_xkb_sa_lock_device_btn_t *data;
+    int                           rem;
+    int                           index;
+} xcb_xkb_sa_lock_device_btn_iterator_t;
+
+typedef enum xcb_xkb_sa_val_what_t {
+    XCB_XKB_SA_VAL_WHAT_IGNORE_VAL = 0,
+    XCB_XKB_SA_VAL_WHAT_SET_VAL_MIN = 1,
+    XCB_XKB_SA_VAL_WHAT_SET_VAL_CENTER = 2,
+    XCB_XKB_SA_VAL_WHAT_SET_VAL_MAX = 3,
+    XCB_XKB_SA_VAL_WHAT_SET_VAL_RELATIVE = 4,
+    XCB_XKB_SA_VAL_WHAT_SET_VAL_ABSOLUTE = 5
+} xcb_xkb_sa_val_what_t;
+
+/**
+ * @brief xcb_xkb_sa_device_valuator_t
+ **/
+typedef struct xcb_xkb_sa_device_valuator_t {
+    uint8_t type;
+    uint8_t device;
+    uint8_t val1what;
+    uint8_t val1index;
+    uint8_t val1value;
+    uint8_t val2what;
+    uint8_t val2index;
+    uint8_t val2value;
+} xcb_xkb_sa_device_valuator_t;
+
+/**
+ * @brief xcb_xkb_sa_device_valuator_iterator_t
+ **/
+typedef struct xcb_xkb_sa_device_valuator_iterator_t {
+    xcb_xkb_sa_device_valuator_t *data;
+    int                           rem;
+    int                           index;
+} xcb_xkb_sa_device_valuator_iterator_t;
+
+/**
+ * @brief xcb_xkb_si_action_t
+ **/
+typedef struct xcb_xkb_si_action_t {
+    uint8_t type;
+    uint8_t data[7];
+} xcb_xkb_si_action_t;
+
+/**
+ * @brief xcb_xkb_si_action_iterator_t
+ **/
+typedef struct xcb_xkb_si_action_iterator_t {
+    xcb_xkb_si_action_t *data;
+    int                  rem;
+    int                  index;
+} xcb_xkb_si_action_iterator_t;
+
+/**
+ * @brief xcb_xkb_sym_interpret_t
+ **/
+typedef struct xcb_xkb_sym_interpret_t {
+    xcb_keysym_t        sym;
+    uint8_t             mods;
+    uint8_t             match;
+    uint8_t             virtualMod;
+    uint8_t             flags;
+    xcb_xkb_si_action_t action;
+} xcb_xkb_sym_interpret_t;
+
+/**
+ * @brief xcb_xkb_sym_interpret_iterator_t
+ **/
+typedef struct xcb_xkb_sym_interpret_iterator_t {
+    xcb_xkb_sym_interpret_t *data;
+    int                      rem;
+    int                      index;
+} xcb_xkb_sym_interpret_iterator_t;
+
+/**
+ * @brief xcb_xkb_action_t
+ **/
+typedef union xcb_xkb_action_t {
+    xcb_xkb_sa_no_action_t       noaction;
+    xcb_xkb_sa_set_mods_t        setmods;
+    xcb_xkb_sa_latch_mods_t      latchmods;
+    xcb_xkb_sa_lock_mods_t       lockmods;
+    xcb_xkb_sa_set_group_t       setgroup;
+    xcb_xkb_sa_latch_group_t     latchgroup;
+    xcb_xkb_sa_lock_group_t      lockgroup;
+    xcb_xkb_sa_move_ptr_t        moveptr;
+    xcb_xkb_sa_ptr_btn_t         ptrbtn;
+    xcb_xkb_sa_lock_ptr_btn_t    lockptrbtn;
+    xcb_xkb_sa_set_ptr_dflt_t    setptrdflt;
+    xcb_xkb_sa_iso_lock_t        isolock;
+    xcb_xkb_sa_terminate_t       terminate;
+    xcb_xkb_sa_switch_screen_t   switchscreen;
+    xcb_xkb_sa_set_controls_t    setcontrols;
+    xcb_xkb_sa_lock_controls_t   lockcontrols;
+    xcb_xkb_sa_action_message_t  message;
+    xcb_xkb_sa_redirect_key_t    redirect;
+    xcb_xkb_sa_device_btn_t      devbtn;
+    xcb_xkb_sa_lock_device_btn_t lockdevbtn;
+    xcb_xkb_sa_device_valuator_t devval;
+    uint8_t                      type;
+} xcb_xkb_action_t;
+
+/**
+ * @brief xcb_xkb_action_iterator_t
+ **/
+typedef struct xcb_xkb_action_iterator_t {
+    xcb_xkb_action_t *data;
+    int               rem;
+    int               index;
+} xcb_xkb_action_iterator_t;
+
+/**
+ * @brief xcb_xkb_use_extension_cookie_t
+ **/
+typedef struct xcb_xkb_use_extension_cookie_t {
+    unsigned int sequence;
+} xcb_xkb_use_extension_cookie_t;
+
+/** Opcode for xcb_xkb_use_extension. */
+#define XCB_XKB_USE_EXTENSION 0
+
+/**
+ * @brief xcb_xkb_use_extension_request_t
+ **/
+typedef struct xcb_xkb_use_extension_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint16_t wantedMajor;
+    uint16_t wantedMinor;
+} xcb_xkb_use_extension_request_t;
+
+/**
+ * @brief xcb_xkb_use_extension_reply_t
+ **/
+typedef struct xcb_xkb_use_extension_reply_t {
+    uint8_t  response_type;
+    uint8_t  supported;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t serverMajor;
+    uint16_t serverMinor;
+    uint8_t  pad0[20];
+} xcb_xkb_use_extension_reply_t;
+
+/**
+ * @brief xcb_xkb_select_events_details_t
+ **/
+typedef struct xcb_xkb_select_events_details_t {
+    uint16_t affectNewKeyboard;
+    uint16_t newKeyboardDetails;
+    uint16_t affectState;
+    uint16_t stateDetails;
+    uint32_t affectCtrls;
+    uint32_t ctrlDetails;
+    uint32_t affectIndicatorState;
+    uint32_t indicatorStateDetails;
+    uint32_t affectIndicatorMap;
+    uint32_t indicatorMapDetails;
+    uint16_t affectNames;
+    uint16_t namesDetails;
+    uint8_t  affectCompat;
+    uint8_t  compatDetails;
+    uint8_t  affectBell;
+    uint8_t  bellDetails;
+    uint8_t  affectMsgDetails;
+    uint8_t  msgDetails;
+    uint16_t affectAccessX;
+    uint16_t accessXDetails;
+    uint16_t affectExtDev;
+    uint16_t extdevDetails;
+} xcb_xkb_select_events_details_t;
+
+/** Opcode for xcb_xkb_select_events. */
+#define XCB_XKB_SELECT_EVENTS 1
+
+/**
+ * @brief xcb_xkb_select_events_request_t
+ **/
+typedef struct xcb_xkb_select_events_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_xkb_device_spec_t deviceSpec;
+    uint16_t              affectWhich;
+    uint16_t              clear;
+    uint16_t              selectAll;
+    uint16_t              affectMap;
+    uint16_t              map;
+} xcb_xkb_select_events_request_t;
+
+/** Opcode for xcb_xkb_bell. */
+#define XCB_XKB_BELL 3
+
+/**
+ * @brief xcb_xkb_bell_request_t
+ **/
+typedef struct xcb_xkb_bell_request_t {
+    uint8_t                   major_opcode;
+    uint8_t                   minor_opcode;
+    uint16_t                  length;
+    xcb_xkb_device_spec_t     deviceSpec;
+    xcb_xkb_bell_class_spec_t bellClass;
+    xcb_xkb_id_spec_t         bellID;
+    int8_t                    percent;
+    uint8_t                   forceSound;
+    uint8_t                   eventOnly;
+    uint8_t                   pad0;
+    int16_t                   pitch;
+    int16_t                   duration;
+    uint8_t                   pad1[2];
+    xcb_atom_t                name;
+    xcb_window_t              window;
+} xcb_xkb_bell_request_t;
+
+/**
+ * @brief xcb_xkb_get_state_cookie_t
+ **/
+typedef struct xcb_xkb_get_state_cookie_t {
+    unsigned int sequence;
+} xcb_xkb_get_state_cookie_t;
+
+/** Opcode for xcb_xkb_get_state. */
+#define XCB_XKB_GET_STATE 4
+
+/**
+ * @brief xcb_xkb_get_state_request_t
+ **/
+typedef struct xcb_xkb_get_state_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_xkb_device_spec_t deviceSpec;
+    uint8_t               pad0[2];
+} xcb_xkb_get_state_request_t;
+
+/**
+ * @brief xcb_xkb_get_state_reply_t
+ **/
+typedef struct xcb_xkb_get_state_reply_t {
+    uint8_t  response_type;
+    uint8_t  deviceID;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  mods;
+    uint8_t  baseMods;
+    uint8_t  latchedMods;
+    uint8_t  lockedMods;
+    uint8_t  group;
+    uint8_t  lockedGroup;
+    int16_t  baseGroup;
+    int16_t  latchedGroup;
+    uint8_t  compatState;
+    uint8_t  grabMods;
+    uint8_t  compatGrabMods;
+    uint8_t  lookupMods;
+    uint8_t  compatLookupMods;
+    uint8_t  pad0;
+    uint16_t ptrBtnState;
+    uint8_t  pad1[6];
+} xcb_xkb_get_state_reply_t;
+
+/** Opcode for xcb_xkb_latch_lock_state. */
+#define XCB_XKB_LATCH_LOCK_STATE 5
+
+/**
+ * @brief xcb_xkb_latch_lock_state_request_t
+ **/
+typedef struct xcb_xkb_latch_lock_state_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_xkb_device_spec_t deviceSpec;
+    uint8_t               affectModLocks;
+    uint8_t               modLocks;
+    uint8_t               lockGroup;
+    uint8_t               groupLock;
+    uint8_t               affectModLatches;
+    uint8_t               pad0;
+    uint8_t               pad1;
+    uint8_t               latchGroup;
+    uint16_t              groupLatch;
+} xcb_xkb_latch_lock_state_request_t;
+
+/**
+ * @brief xcb_xkb_get_controls_cookie_t
+ **/
+typedef struct xcb_xkb_get_controls_cookie_t {
+    unsigned int sequence;
+} xcb_xkb_get_controls_cookie_t;
+
+/** Opcode for xcb_xkb_get_controls. */
+#define XCB_XKB_GET_CONTROLS 6
+
+/**
+ * @brief xcb_xkb_get_controls_request_t
+ **/
+typedef struct xcb_xkb_get_controls_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_xkb_device_spec_t deviceSpec;
+    uint8_t               pad0[2];
+} xcb_xkb_get_controls_request_t;
+
+/**
+ * @brief xcb_xkb_get_controls_reply_t
+ **/
+typedef struct xcb_xkb_get_controls_reply_t {
+    uint8_t  response_type;
+    uint8_t  deviceID;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  mouseKeysDfltBtn;
+    uint8_t  numGroups;
+    uint8_t  groupsWrap;
+    uint8_t  internalModsMask;
+    uint8_t  ignoreLockModsMask;
+    uint8_t  internalModsRealMods;
+    uint8_t  ignoreLockModsRealMods;
+    uint8_t  pad0;
+    uint16_t internalModsVmods;
+    uint16_t ignoreLockModsVmods;
+    uint16_t repeatDelay;
+    uint16_t repeatInterval;
+    uint16_t slowKeysDelay;
+    uint16_t debounceDelay;
+    uint16_t mouseKeysDelay;
+    uint16_t mouseKeysInterval;
+    uint16_t mouseKeysTimeToMax;
+    uint16_t mouseKeysMaxSpeed;
+    int16_t  mouseKeysCurve;
+    uint16_t accessXOption;
+    uint16_t accessXTimeout;
+    uint16_t accessXTimeoutOptionsMask;
+    uint16_t accessXTimeoutOptionsValues;
+    uint8_t  pad1[2];
+    uint32_t accessXTimeoutMask;
+    uint32_t accessXTimeoutValues;
+    uint32_t enabledControls;
+    uint8_t  perKeyRepeat[32];
+} xcb_xkb_get_controls_reply_t;
+
+/** Opcode for xcb_xkb_set_controls. */
+#define XCB_XKB_SET_CONTROLS 7
+
+/**
+ * @brief xcb_xkb_set_controls_request_t
+ **/
+typedef struct xcb_xkb_set_controls_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_xkb_device_spec_t deviceSpec;
+    uint8_t               affectInternalRealMods;
+    uint8_t               internalRealMods;
+    uint8_t               affectIgnoreLockRealMods;
+    uint8_t               ignoreLockRealMods;
+    uint16_t              affectInternalVirtualMods;
+    uint16_t              internalVirtualMods;
+    uint16_t              affectIgnoreLockVirtualMods;
+    uint16_t              ignoreLockVirtualMods;
+    uint8_t               mouseKeysDfltBtn;
+    uint8_t               groupsWrap;
+    uint16_t              accessXOptions;
+    uint8_t               pad0[2];
+    uint32_t              affectEnabledControls;
+    uint32_t              enabledControls;
+    uint32_t              changeControls;
+    uint16_t              repeatDelay;
+    uint16_t              repeatInterval;
+    uint16_t              slowKeysDelay;
+    uint16_t              debounceDelay;
+    uint16_t              mouseKeysDelay;
+    uint16_t              mouseKeysInterval;
+    uint16_t              mouseKeysTimeToMax;
+    uint16_t              mouseKeysMaxSpeed;
+    int16_t               mouseKeysCurve;
+    uint16_t              accessXTimeout;
+    uint32_t              accessXTimeoutMask;
+    uint32_t              accessXTimeoutValues;
+    uint16_t              accessXTimeoutOptionsMask;
+    uint16_t              accessXTimeoutOptionsValues;
+    uint8_t               perKeyRepeat[32];
+} xcb_xkb_set_controls_request_t;
+
+/**
+ * @brief xcb_xkb_get_map_cookie_t
+ **/
+typedef struct xcb_xkb_get_map_cookie_t {
+    unsigned int sequence;
+} xcb_xkb_get_map_cookie_t;
+
+/** Opcode for xcb_xkb_get_map. */
+#define XCB_XKB_GET_MAP 8
+
+/**
+ * @brief xcb_xkb_get_map_request_t
+ **/
+typedef struct xcb_xkb_get_map_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_xkb_device_spec_t deviceSpec;
+    uint16_t              full;
+    uint16_t              partial;
+    uint8_t               firstType;
+    uint8_t               nTypes;
+    xcb_keycode_t         firstKeySym;
+    uint8_t               nKeySyms;
+    xcb_keycode_t         firstKeyAction;
+    uint8_t               nKeyActions;
+    xcb_keycode_t         firstKeyBehavior;
+    uint8_t               nKeyBehaviors;
+    uint16_t              virtualMods;
+    xcb_keycode_t         firstKeyExplicit;
+    uint8_t               nKeyExplicit;
+    xcb_keycode_t         firstModMapKey;
+    uint8_t               nModMapKeys;
+    xcb_keycode_t         firstVModMapKey;
+    uint8_t               nVModMapKeys;
+    uint8_t               pad0[2];
+} xcb_xkb_get_map_request_t;
+
+/**
+ * @brief xcb_xkb_get_map_map_t
+ **/
+typedef struct xcb_xkb_get_map_map_t {
+    xcb_xkb_key_type_t      *types_rtrn;
+    xcb_xkb_key_sym_map_t   *syms_rtrn;
+    uint8_t                 *acts_rtrn_count;
+    uint8_t                 *pad2;
+    xcb_xkb_action_t        *acts_rtrn_acts;
+    xcb_xkb_set_behavior_t  *behaviors_rtrn;
+    uint8_t                 *vmods_rtrn;
+    uint8_t                 *pad3;
+    xcb_xkb_set_explicit_t  *explicit_rtrn;
+    uint8_t                 *pad4;
+    xcb_xkb_key_mod_map_t   *modmap_rtrn;
+    uint8_t                 *pad5;
+    xcb_xkb_key_v_mod_map_t *vmodmap_rtrn;
+} xcb_xkb_get_map_map_t;
+
+/**
+ * @brief xcb_xkb_get_map_reply_t
+ **/
+typedef struct xcb_xkb_get_map_reply_t {
+    uint8_t       response_type;
+    uint8_t       deviceID;
+    uint16_t      sequence;
+    uint32_t      length;
+    uint8_t       pad0[2];
+    xcb_keycode_t minKeyCode;
+    xcb_keycode_t maxKeyCode;
+    uint16_t      present;
+    uint8_t       firstType;
+    uint8_t       nTypes;
+    uint8_t       totalTypes;
+    xcb_keycode_t firstKeySym;
+    uint16_t      totalSyms;
+    uint8_t       nKeySyms;
+    xcb_keycode_t firstKeyAction;
+    uint16_t      totalActions;
+    uint8_t       nKeyActions;
+    xcb_keycode_t firstKeyBehavior;
+    uint8_t       nKeyBehaviors;
+    uint8_t       totalKeyBehaviors;
+    xcb_keycode_t firstKeyExplicit;
+    uint8_t       nKeyExplicit;
+    uint8_t       totalKeyExplicit;
+    xcb_keycode_t firstModMapKey;
+    uint8_t       nModMapKeys;
+    uint8_t       totalModMapKeys;
+    xcb_keycode_t firstVModMapKey;
+    uint8_t       nVModMapKeys;
+    uint8_t       totalVModMapKeys;
+    uint8_t       pad1;
+    uint16_t      virtualMods;
+} xcb_xkb_get_map_reply_t;
+
+/**
+ * @brief xcb_xkb_set_map_values_t
+ **/
+typedef struct xcb_xkb_set_map_values_t {
+    xcb_xkb_set_key_type_t  *types;
+    xcb_xkb_key_sym_map_t   *syms;
+    uint8_t                 *actionsCount;
+    xcb_xkb_action_t        *actions;
+    xcb_xkb_set_behavior_t  *behaviors;
+    uint8_t                 *vmods;
+    xcb_xkb_set_explicit_t  *explicit;
+    xcb_xkb_key_mod_map_t   *modmap;
+    xcb_xkb_key_v_mod_map_t *vmodmap;
+} xcb_xkb_set_map_values_t;
+
+/** Opcode for xcb_xkb_set_map. */
+#define XCB_XKB_SET_MAP 9
+
+/**
+ * @brief xcb_xkb_set_map_request_t
+ **/
+typedef struct xcb_xkb_set_map_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_xkb_device_spec_t deviceSpec;
+    uint16_t              present;
+    uint16_t              flags;
+    xcb_keycode_t         minKeyCode;
+    xcb_keycode_t         maxKeyCode;
+    uint8_t               firstType;
+    uint8_t               nTypes;
+    xcb_keycode_t         firstKeySym;
+    uint8_t               nKeySyms;
+    uint16_t              totalSyms;
+    xcb_keycode_t         firstKeyAction;
+    uint8_t               nKeyActions;
+    uint16_t              totalActions;
+    xcb_keycode_t         firstKeyBehavior;
+    uint8_t               nKeyBehaviors;
+    uint8_t               totalKeyBehaviors;
+    xcb_keycode_t         firstKeyExplicit;
+    uint8_t               nKeyExplicit;
+    uint8_t               totalKeyExplicit;
+    xcb_keycode_t         firstModMapKey;
+    uint8_t               nModMapKeys;
+    uint8_t               totalModMapKeys;
+    xcb_keycode_t         firstVModMapKey;
+    uint8_t               nVModMapKeys;
+    uint8_t               totalVModMapKeys;
+    uint16_t              virtualMods;
+} xcb_xkb_set_map_request_t;
+
+/**
+ * @brief xcb_xkb_get_compat_map_cookie_t
+ **/
+typedef struct xcb_xkb_get_compat_map_cookie_t {
+    unsigned int sequence;
+} xcb_xkb_get_compat_map_cookie_t;
+
+/** Opcode for xcb_xkb_get_compat_map. */
+#define XCB_XKB_GET_COMPAT_MAP 10
+
+/**
+ * @brief xcb_xkb_get_compat_map_request_t
+ **/
+typedef struct xcb_xkb_get_compat_map_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_xkb_device_spec_t deviceSpec;
+    uint8_t               groups;
+    uint8_t               getAllSI;
+    uint16_t              firstSI;
+    uint16_t              nSI;
+} xcb_xkb_get_compat_map_request_t;
+
+/**
+ * @brief xcb_xkb_get_compat_map_reply_t
+ **/
+typedef struct xcb_xkb_get_compat_map_reply_t {
+    uint8_t  response_type;
+    uint8_t  deviceID;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  groupsRtrn;
+    uint8_t  pad0;
+    uint16_t firstSIRtrn;
+    uint16_t nSIRtrn;
+    uint16_t nTotalSI;
+    uint8_t  pad1[16];
+} xcb_xkb_get_compat_map_reply_t;
+
+/** Opcode for xcb_xkb_set_compat_map. */
+#define XCB_XKB_SET_COMPAT_MAP 11
+
+/**
+ * @brief xcb_xkb_set_compat_map_request_t
+ **/
+typedef struct xcb_xkb_set_compat_map_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_xkb_device_spec_t deviceSpec;
+    uint8_t               pad0;
+    uint8_t               recomputeActions;
+    uint8_t               truncateSI;
+    uint8_t               groups;
+    uint16_t              firstSI;
+    uint16_t              nSI;
+    uint8_t               pad1[2];
+} xcb_xkb_set_compat_map_request_t;
+
+/**
+ * @brief xcb_xkb_get_indicator_state_cookie_t
+ **/
+typedef struct xcb_xkb_get_indicator_state_cookie_t {
+    unsigned int sequence;
+} xcb_xkb_get_indicator_state_cookie_t;
+
+/** Opcode for xcb_xkb_get_indicator_state. */
+#define XCB_XKB_GET_INDICATOR_STATE 12
+
+/**
+ * @brief xcb_xkb_get_indicator_state_request_t
+ **/
+typedef struct xcb_xkb_get_indicator_state_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_xkb_device_spec_t deviceSpec;
+    uint8_t               pad0[2];
+} xcb_xkb_get_indicator_state_request_t;
+
+/**
+ * @brief xcb_xkb_get_indicator_state_reply_t
+ **/
+typedef struct xcb_xkb_get_indicator_state_reply_t {
+    uint8_t  response_type;
+    uint8_t  deviceID;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t state;
+    uint8_t  pad0[20];
+} xcb_xkb_get_indicator_state_reply_t;
+
+/**
+ * @brief xcb_xkb_get_indicator_map_cookie_t
+ **/
+typedef struct xcb_xkb_get_indicator_map_cookie_t {
+    unsigned int sequence;
+} xcb_xkb_get_indicator_map_cookie_t;
+
+/** Opcode for xcb_xkb_get_indicator_map. */
+#define XCB_XKB_GET_INDICATOR_MAP 13
+
+/**
+ * @brief xcb_xkb_get_indicator_map_request_t
+ **/
+typedef struct xcb_xkb_get_indicator_map_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_xkb_device_spec_t deviceSpec;
+    uint8_t               pad0[2];
+    uint32_t              which;
+} xcb_xkb_get_indicator_map_request_t;
+
+/**
+ * @brief xcb_xkb_get_indicator_map_reply_t
+ **/
+typedef struct xcb_xkb_get_indicator_map_reply_t {
+    uint8_t  response_type;
+    uint8_t  deviceID;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t which;
+    uint32_t realIndicators;
+    uint8_t  nIndicators;
+    uint8_t  pad0[15];
+} xcb_xkb_get_indicator_map_reply_t;
+
+/** Opcode for xcb_xkb_set_indicator_map. */
+#define XCB_XKB_SET_INDICATOR_MAP 14
+
+/**
+ * @brief xcb_xkb_set_indicator_map_request_t
+ **/
+typedef struct xcb_xkb_set_indicator_map_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_xkb_device_spec_t deviceSpec;
+    uint8_t               pad0[2];
+    uint32_t              which;
+} xcb_xkb_set_indicator_map_request_t;
+
+/**
+ * @brief xcb_xkb_get_named_indicator_cookie_t
+ **/
+typedef struct xcb_xkb_get_named_indicator_cookie_t {
+    unsigned int sequence;
+} xcb_xkb_get_named_indicator_cookie_t;
+
+/** Opcode for xcb_xkb_get_named_indicator. */
+#define XCB_XKB_GET_NAMED_INDICATOR 15
+
+/**
+ * @brief xcb_xkb_get_named_indicator_request_t
+ **/
+typedef struct xcb_xkb_get_named_indicator_request_t {
+    uint8_t                  major_opcode;
+    uint8_t                  minor_opcode;
+    uint16_t                 length;
+    xcb_xkb_device_spec_t    deviceSpec;
+    xcb_xkb_led_class_spec_t ledClass;
+    xcb_xkb_id_spec_t        ledID;
+    uint8_t                  pad0[2];
+    xcb_atom_t               indicator;
+} xcb_xkb_get_named_indicator_request_t;
+
+/**
+ * @brief xcb_xkb_get_named_indicator_reply_t
+ **/
+typedef struct xcb_xkb_get_named_indicator_reply_t {
+    uint8_t    response_type;
+    uint8_t    deviceID;
+    uint16_t   sequence;
+    uint32_t   length;
+    xcb_atom_t indicator;
+    uint8_t    found;
+    uint8_t    on;
+    uint8_t    realIndicator;
+    uint8_t    ndx;
+    uint8_t    map_flags;
+    uint8_t    map_whichGroups;
+    uint8_t    map_groups;
+    uint8_t    map_whichMods;
+    uint8_t    map_mods;
+    uint8_t    map_realMods;
+    uint16_t   map_vmod;
+    uint32_t   map_ctrls;
+    uint8_t    supported;
+    uint8_t    pad0[3];
+} xcb_xkb_get_named_indicator_reply_t;
+
+/** Opcode for xcb_xkb_set_named_indicator. */
+#define XCB_XKB_SET_NAMED_INDICATOR 16
+
+/**
+ * @brief xcb_xkb_set_named_indicator_request_t
+ **/
+typedef struct xcb_xkb_set_named_indicator_request_t {
+    uint8_t                  major_opcode;
+    uint8_t                  minor_opcode;
+    uint16_t                 length;
+    xcb_xkb_device_spec_t    deviceSpec;
+    xcb_xkb_led_class_spec_t ledClass;
+    xcb_xkb_id_spec_t        ledID;
+    uint8_t                  pad0[2];
+    xcb_atom_t               indicator;
+    uint8_t                  setState;
+    uint8_t                  on;
+    uint8_t                  setMap;
+    uint8_t                  createMap;
+    uint8_t                  pad1;
+    uint8_t                  map_flags;
+    uint8_t                  map_whichGroups;
+    uint8_t                  map_groups;
+    uint8_t                  map_whichMods;
+    uint8_t                  map_realMods;
+    uint16_t                 map_vmods;
+    uint32_t                 map_ctrls;
+} xcb_xkb_set_named_indicator_request_t;
+
+/**
+ * @brief xcb_xkb_get_names_cookie_t
+ **/
+typedef struct xcb_xkb_get_names_cookie_t {
+    unsigned int sequence;
+} xcb_xkb_get_names_cookie_t;
+
+/** Opcode for xcb_xkb_get_names. */
+#define XCB_XKB_GET_NAMES 17
+
+/**
+ * @brief xcb_xkb_get_names_request_t
+ **/
+typedef struct xcb_xkb_get_names_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_xkb_device_spec_t deviceSpec;
+    uint8_t               pad0[2];
+    uint32_t              which;
+} xcb_xkb_get_names_request_t;
+
+/**
+ * @brief xcb_xkb_get_names_value_list_t
+ **/
+typedef struct xcb_xkb_get_names_value_list_t {
+    xcb_atom_t           keycodesName;
+    xcb_atom_t           geometryName;
+    xcb_atom_t           symbolsName;
+    xcb_atom_t           physSymbolsName;
+    xcb_atom_t           typesName;
+    xcb_atom_t           compatName;
+    xcb_atom_t          *typeNames;
+    uint8_t             *nLevelsPerType;
+    uint8_t             *pad1;
+    xcb_atom_t          *ktLevelNames;
+    xcb_atom_t          *indicatorNames;
+    xcb_atom_t          *virtualModNames;
+    xcb_atom_t          *groups;
+    xcb_xkb_key_name_t  *keyNames;
+    xcb_xkb_key_alias_t *keyAliases;
+    xcb_atom_t          *radioGroupNames;
+} xcb_xkb_get_names_value_list_t;
+
+/**
+ * @brief xcb_xkb_get_names_reply_t
+ **/
+typedef struct xcb_xkb_get_names_reply_t {
+    uint8_t       response_type;
+    uint8_t       deviceID;
+    uint16_t      sequence;
+    uint32_t      length;
+    uint32_t      which;
+    xcb_keycode_t minKeyCode;
+    xcb_keycode_t maxKeyCode;
+    uint8_t       nTypes;
+    uint8_t       groupNames;
+    uint16_t      virtualMods;
+    xcb_keycode_t firstKey;
+    uint8_t       nKeys;
+    uint32_t      indicators;
+    uint8_t       nRadioGroups;
+    uint8_t       nKeyAliases;
+    uint16_t      nKTLevels;
+    uint8_t       pad0[4];
+} xcb_xkb_get_names_reply_t;
+
+/**
+ * @brief xcb_xkb_set_names_values_t
+ **/
+typedef struct xcb_xkb_set_names_values_t {
+    xcb_atom_t           keycodesName;
+    xcb_atom_t           geometryName;
+    xcb_atom_t           symbolsName;
+    xcb_atom_t           physSymbolsName;
+    xcb_atom_t           typesName;
+    xcb_atom_t           compatName;
+    xcb_atom_t          *typeNames;
+    uint8_t             *nLevelsPerType;
+    xcb_atom_t          *ktLevelNames;
+    xcb_atom_t          *indicatorNames;
+    xcb_atom_t          *virtualModNames;
+    xcb_atom_t          *groups;
+    xcb_xkb_key_name_t  *keyNames;
+    xcb_xkb_key_alias_t *keyAliases;
+    xcb_atom_t          *radioGroupNames;
+} xcb_xkb_set_names_values_t;
+
+/** Opcode for xcb_xkb_set_names. */
+#define XCB_XKB_SET_NAMES 18
+
+/**
+ * @brief xcb_xkb_set_names_request_t
+ **/
+typedef struct xcb_xkb_set_names_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_xkb_device_spec_t deviceSpec;
+    uint16_t              virtualMods;
+    uint32_t              which;
+    uint8_t               firstType;
+    uint8_t               nTypes;
+    uint8_t               firstKTLevelt;
+    uint8_t               nKTLevels;
+    uint32_t              indicators;
+    uint8_t               groupNames;
+    uint8_t               nRadioGroups;
+    xcb_keycode_t         firstKey;
+    uint8_t               nKeys;
+    uint8_t               nKeyAliases;
+    uint8_t               pad0;
+    uint16_t              totalKTLevelNames;
+} xcb_xkb_set_names_request_t;
+
+/**
+ * @brief xcb_xkb_per_client_flags_cookie_t
+ **/
+typedef struct xcb_xkb_per_client_flags_cookie_t {
+    unsigned int sequence;
+} xcb_xkb_per_client_flags_cookie_t;
+
+/** Opcode for xcb_xkb_per_client_flags. */
+#define XCB_XKB_PER_CLIENT_FLAGS 21
+
+/**
+ * @brief xcb_xkb_per_client_flags_request_t
+ **/
+typedef struct xcb_xkb_per_client_flags_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_xkb_device_spec_t deviceSpec;
+    uint8_t               pad0[2];
+    uint32_t              change;
+    uint32_t              value;
+    uint32_t              ctrlsToChange;
+    uint32_t              autoCtrls;
+    uint32_t              autoCtrlsValues;
+} xcb_xkb_per_client_flags_request_t;
+
+/**
+ * @brief xcb_xkb_per_client_flags_reply_t
+ **/
+typedef struct xcb_xkb_per_client_flags_reply_t {
+    uint8_t  response_type;
+    uint8_t  deviceID;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t supported;
+    uint32_t value;
+    uint32_t autoCtrls;
+    uint32_t autoCtrlsValues;
+    uint8_t  pad0[8];
+} xcb_xkb_per_client_flags_reply_t;
+
+/**
+ * @brief xcb_xkb_list_components_cookie_t
+ **/
+typedef struct xcb_xkb_list_components_cookie_t {
+    unsigned int sequence;
+} xcb_xkb_list_components_cookie_t;
+
+/** Opcode for xcb_xkb_list_components. */
+#define XCB_XKB_LIST_COMPONENTS 22
+
+/**
+ * @brief xcb_xkb_list_components_request_t
+ **/
+typedef struct xcb_xkb_list_components_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_xkb_device_spec_t deviceSpec;
+    uint16_t              maxNames;
+} xcb_xkb_list_components_request_t;
+
+/**
+ * @brief xcb_xkb_list_components_reply_t
+ **/
+typedef struct xcb_xkb_list_components_reply_t {
+    uint8_t  response_type;
+    uint8_t  deviceID;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t nKeymaps;
+    uint16_t nKeycodes;
+    uint16_t nTypes;
+    uint16_t nCompatMaps;
+    uint16_t nSymbols;
+    uint16_t nGeometries;
+    uint16_t extra;
+    uint8_t  pad0[10];
+} xcb_xkb_list_components_reply_t;
+
+/**
+ * @brief xcb_xkb_get_kbd_by_name_cookie_t
+ **/
+typedef struct xcb_xkb_get_kbd_by_name_cookie_t {
+    unsigned int sequence;
+} xcb_xkb_get_kbd_by_name_cookie_t;
+
+/** Opcode for xcb_xkb_get_kbd_by_name. */
+#define XCB_XKB_GET_KBD_BY_NAME 23
+
+/**
+ * @brief xcb_xkb_get_kbd_by_name_request_t
+ **/
+typedef struct xcb_xkb_get_kbd_by_name_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_xkb_device_spec_t deviceSpec;
+    uint16_t              need;
+    uint16_t              want;
+    uint8_t               load;
+    uint8_t               pad0;
+} xcb_xkb_get_kbd_by_name_request_t;
+
+/**
+ * @brief xcb_xkb_get_kbd_by_name_replies_types_map_t
+ **/
+typedef struct xcb_xkb_get_kbd_by_name_replies_types_map_t {
+    xcb_xkb_key_type_t      *types_rtrn;
+    xcb_xkb_key_sym_map_t   *syms_rtrn;
+    uint8_t                 *acts_rtrn_count;
+    xcb_xkb_action_t        *acts_rtrn_acts;
+    xcb_xkb_set_behavior_t  *behaviors_rtrn;
+    uint8_t                 *vmods_rtrn;
+    xcb_xkb_set_explicit_t  *explicit_rtrn;
+    xcb_xkb_key_mod_map_t   *modmap_rtrn;
+    xcb_xkb_key_v_mod_map_t *vmodmap_rtrn;
+} xcb_xkb_get_kbd_by_name_replies_types_map_t;
+
+/**
+ * @brief xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t
+ **/
+typedef struct xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t {
+    xcb_atom_t           keycodesName;
+    xcb_atom_t           geometryName;
+    xcb_atom_t           symbolsName;
+    xcb_atom_t           physSymbolsName;
+    xcb_atom_t           typesName;
+    xcb_atom_t           compatName;
+    xcb_atom_t          *typeNames;
+    uint8_t             *nLevelsPerType;
+    xcb_atom_t          *ktLevelNames;
+    xcb_atom_t          *indicatorNames;
+    xcb_atom_t          *virtualModNames;
+    xcb_atom_t          *groups;
+    xcb_xkb_key_name_t  *keyNames;
+    xcb_xkb_key_alias_t *keyAliases;
+    xcb_atom_t          *radioGroupNames;
+} xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t;
+
+/**
+ * @brief xcb_xkb_get_kbd_by_name_replies_t
+ **/
+typedef struct xcb_xkb_get_kbd_by_name_replies_t {
+    struct {
+        uint8_t                                                 getmap_type;
+        uint8_t                                                 typeDeviceID;
+        uint16_t                                                getmap_sequence;
+        uint32_t                                                getmap_length;
+        uint8_t                                                 pad1[2];
+        xcb_keycode_t                                           typeMinKeyCode;
+        xcb_keycode_t                                           typeMaxKeyCode;
+        uint16_t                                                present;
+        uint8_t                                                 firstType;
+        uint8_t                                                 nTypes;
+        uint8_t                                                 totalTypes;
+        xcb_keycode_t                                           firstKeySym;
+        uint16_t                                                totalSyms;
+        uint8_t                                                 nKeySyms;
+        xcb_keycode_t                                           firstKeyAction;
+        uint16_t                                                totalActions;
+        uint8_t                                                 nKeyActions;
+        xcb_keycode_t                                           firstKeyBehavior;
+        uint8_t                                                 nKeyBehaviors;
+        uint8_t                                                 totalKeyBehaviors;
+        xcb_keycode_t                                           firstKeyExplicit;
+        uint8_t                                                 nKeyExplicit;
+        uint8_t                                                 totalKeyExplicit;
+        xcb_keycode_t                                           firstModMapKey;
+        uint8_t                                                 nModMapKeys;
+        uint8_t                                                 totalModMapKeys;
+        xcb_keycode_t                                           firstVModMapKey;
+        uint8_t                                                 nVModMapKeys;
+        uint8_t                                                 totalVModMapKeys;
+        uint8_t                                                 pad2;
+        uint16_t                                                virtualMods;
+        xcb_xkb_get_kbd_by_name_replies_types_map_t             map;
+    } types;
+    struct {
+        uint8_t                                                 compatmap_type;
+        uint8_t                                                 compatDeviceID;
+        uint16_t                                                compatmap_sequence;
+        uint32_t                                                compatmap_length;
+        uint8_t                                                 groupsRtrn;
+        uint8_t                                                 pad7;
+        uint16_t                                                firstSIRtrn;
+        uint16_t                                                nSIRtrn;
+        uint16_t                                                nTotalSI;
+        uint8_t                                                 pad8[16];
+        xcb_xkb_sym_interpret_t                                *si_rtrn;
+        xcb_xkb_mod_def_t                                      *group_rtrn;
+    } compat_map;
+    struct {
+        uint8_t                                                 indicatormap_type;
+        uint8_t                                                 indicatorDeviceID;
+        uint16_t                                                indicatormap_sequence;
+        uint32_t                                                indicatormap_length;
+        uint32_t                                                which;
+        uint32_t                                                realIndicators;
+        uint8_t                                                 nIndicators;
+        uint8_t                                                 pad9[15];
+        xcb_xkb_indicator_map_t                                *maps;
+    } indicator_maps;
+    struct {
+        uint8_t                                                 keyname_type;
+        uint8_t                                                 keyDeviceID;
+        uint16_t                                                keyname_sequence;
+        uint32_t                                                keyname_length;
+        uint32_t                                                which;
+        xcb_keycode_t                                           keyMinKeyCode;
+        xcb_keycode_t                                           keyMaxKeyCode;
+        uint8_t                                                 nTypes;
+        uint8_t                                                 groupNames;
+        uint16_t                                                virtualMods;
+        xcb_keycode_t                                           firstKey;
+        uint8_t                                                 nKeys;
+        uint32_t                                                indicators;
+        uint8_t                                                 nRadioGroups;
+        uint8_t                                                 nKeyAliases;
+        uint16_t                                                nKTLevels;
+        uint8_t                                                 pad10[4];
+        xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t  valueList;
+    } key_names;
+    struct {
+        uint8_t                                                 geometry_type;
+        uint8_t                                                 geometryDeviceID;
+        uint16_t                                                geometry_sequence;
+        uint32_t                                                geometry_length;
+        xcb_atom_t                                              name;
+        uint8_t                                                 geometryFound;
+        uint8_t                                                 pad12;
+        uint16_t                                                widthMM;
+        uint16_t                                                heightMM;
+        uint16_t                                                nProperties;
+        uint16_t                                                nColors;
+        uint16_t                                                nShapes;
+        uint16_t                                                nSections;
+        uint16_t                                                nDoodads;
+        uint16_t                                                nKeyAliases;
+        uint8_t                                                 baseColorNdx;
+        uint8_t                                                 labelColorNdx;
+        xcb_xkb_counted_string_16_t                            *labelFont;
+    } geometry;
+} xcb_xkb_get_kbd_by_name_replies_t;
+
+xcb_xkb_get_kbd_by_name_replies_types_map_t *
+xcb_xkb_get_kbd_by_name_replies_types_map (const xcb_xkb_get_kbd_by_name_replies_t *R);
+
+/**
+ * @brief xcb_xkb_get_kbd_by_name_reply_t
+ **/
+typedef struct xcb_xkb_get_kbd_by_name_reply_t {
+    uint8_t       response_type;
+    uint8_t       deviceID;
+    uint16_t      sequence;
+    uint32_t      length;
+    xcb_keycode_t minKeyCode;
+    xcb_keycode_t maxKeyCode;
+    uint8_t       loaded;
+    uint8_t       newKeyboard;
+    uint16_t      found;
+    uint16_t      reported;
+    uint8_t       pad0[16];
+} xcb_xkb_get_kbd_by_name_reply_t;
+
+/**
+ * @brief xcb_xkb_get_device_info_cookie_t
+ **/
+typedef struct xcb_xkb_get_device_info_cookie_t {
+    unsigned int sequence;
+} xcb_xkb_get_device_info_cookie_t;
+
+/** Opcode for xcb_xkb_get_device_info. */
+#define XCB_XKB_GET_DEVICE_INFO 24
+
+/**
+ * @brief xcb_xkb_get_device_info_request_t
+ **/
+typedef struct xcb_xkb_get_device_info_request_t {
+    uint8_t                  major_opcode;
+    uint8_t                  minor_opcode;
+    uint16_t                 length;
+    xcb_xkb_device_spec_t    deviceSpec;
+    uint16_t                 wanted;
+    uint8_t                  allButtons;
+    uint8_t                  firstButton;
+    uint8_t                  nButtons;
+    uint8_t                  pad0;
+    xcb_xkb_led_class_spec_t ledClass;
+    xcb_xkb_id_spec_t        ledID;
+} xcb_xkb_get_device_info_request_t;
+
+/**
+ * @brief xcb_xkb_get_device_info_reply_t
+ **/
+typedef struct xcb_xkb_get_device_info_reply_t {
+    uint8_t    response_type;
+    uint8_t    deviceID;
+    uint16_t   sequence;
+    uint32_t   length;
+    uint16_t   present;
+    uint16_t   supported;
+    uint16_t   unsupported;
+    uint16_t   nDeviceLedFBs;
+    uint8_t    firstBtnWanted;
+    uint8_t    nBtnsWanted;
+    uint8_t    firstBtnRtrn;
+    uint8_t    nBtnsRtrn;
+    uint8_t    totalBtns;
+    uint8_t    hasOwnState;
+    uint16_t   dfltKbdFB;
+    uint16_t   dfltLedFB;
+    uint8_t    pad0[2];
+    xcb_atom_t devType;
+    uint16_t   nameLen;
+} xcb_xkb_get_device_info_reply_t;
+
+/** Opcode for xcb_xkb_set_device_info. */
+#define XCB_XKB_SET_DEVICE_INFO 25
+
+/**
+ * @brief xcb_xkb_set_device_info_request_t
+ **/
+typedef struct xcb_xkb_set_device_info_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_xkb_device_spec_t deviceSpec;
+    uint8_t               firstBtn;
+    uint8_t               nBtns;
+    uint16_t              change;
+    uint16_t              nDeviceLedFBs;
+} xcb_xkb_set_device_info_request_t;
+
+/**
+ * @brief xcb_xkb_set_debugging_flags_cookie_t
+ **/
+typedef struct xcb_xkb_set_debugging_flags_cookie_t {
+    unsigned int sequence;
+} xcb_xkb_set_debugging_flags_cookie_t;
+
+/** Opcode for xcb_xkb_set_debugging_flags. */
+#define XCB_XKB_SET_DEBUGGING_FLAGS 101
+
+/**
+ * @brief xcb_xkb_set_debugging_flags_request_t
+ **/
+typedef struct xcb_xkb_set_debugging_flags_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint16_t msgLength;
+    uint8_t  pad0[2];
+    uint32_t affectFlags;
+    uint32_t flags;
+    uint32_t affectCtrls;
+    uint32_t ctrls;
+} xcb_xkb_set_debugging_flags_request_t;
+
+/**
+ * @brief xcb_xkb_set_debugging_flags_reply_t
+ **/
+typedef struct xcb_xkb_set_debugging_flags_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t currentFlags;
+    uint32_t currentCtrls;
+    uint32_t supportedFlags;
+    uint32_t supportedCtrls;
+    uint8_t  pad1[8];
+} xcb_xkb_set_debugging_flags_reply_t;
+
+/** Opcode for xcb_xkb_new_keyboard_notify. */
+#define XCB_XKB_NEW_KEYBOARD_NOTIFY 0
+
+/**
+ * @brief xcb_xkb_new_keyboard_notify_event_t
+ **/
+typedef struct xcb_xkb_new_keyboard_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         xkbType;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    uint8_t         deviceID;
+    uint8_t         oldDeviceID;
+    xcb_keycode_t   minKeyCode;
+    xcb_keycode_t   maxKeyCode;
+    xcb_keycode_t   oldMinKeyCode;
+    xcb_keycode_t   oldMaxKeyCode;
+    uint8_t         requestMajor;
+    uint8_t         requestMinor;
+    uint16_t        changed;
+    uint8_t         pad0[14];
+} xcb_xkb_new_keyboard_notify_event_t;
+
+/** Opcode for xcb_xkb_map_notify. */
+#define XCB_XKB_MAP_NOTIFY 1
+
+/**
+ * @brief xcb_xkb_map_notify_event_t
+ **/
+typedef struct xcb_xkb_map_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         xkbType;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    uint8_t         deviceID;
+    uint8_t         ptrBtnActions;
+    uint16_t        changed;
+    xcb_keycode_t   minKeyCode;
+    xcb_keycode_t   maxKeyCode;
+    uint8_t         firstType;
+    uint8_t         nTypes;
+    xcb_keycode_t   firstKeySym;
+    uint8_t         nKeySyms;
+    xcb_keycode_t   firstKeyAct;
+    uint8_t         nKeyActs;
+    xcb_keycode_t   firstKeyBehavior;
+    uint8_t         nKeyBehavior;
+    xcb_keycode_t   firstKeyExplicit;
+    uint8_t         nKeyExplicit;
+    xcb_keycode_t   firstModMapKey;
+    uint8_t         nModMapKeys;
+    xcb_keycode_t   firstVModMapKey;
+    uint8_t         nVModMapKeys;
+    uint16_t        virtualMods;
+    uint8_t         pad0[2];
+} xcb_xkb_map_notify_event_t;
+
+/** Opcode for xcb_xkb_state_notify. */
+#define XCB_XKB_STATE_NOTIFY 2
+
+/**
+ * @brief xcb_xkb_state_notify_event_t
+ **/
+typedef struct xcb_xkb_state_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         xkbType;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    uint8_t         deviceID;
+    uint8_t         mods;
+    uint8_t         baseMods;
+    uint8_t         latchedMods;
+    uint8_t         lockedMods;
+    uint8_t         group;
+    int16_t         baseGroup;
+    int16_t         latchedGroup;
+    uint8_t         lockedGroup;
+    uint8_t         compatState;
+    uint8_t         grabMods;
+    uint8_t         compatGrabMods;
+    uint8_t         lookupMods;
+    uint8_t         compatLoockupMods;
+    uint16_t        ptrBtnState;
+    uint16_t        changed;
+    xcb_keycode_t   keycode;
+    uint8_t         eventType;
+    uint8_t         requestMajor;
+    uint8_t         requestMinor;
+} xcb_xkb_state_notify_event_t;
+
+/** Opcode for xcb_xkb_controls_notify. */
+#define XCB_XKB_CONTROLS_NOTIFY 3
+
+/**
+ * @brief xcb_xkb_controls_notify_event_t
+ **/
+typedef struct xcb_xkb_controls_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         xkbType;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    uint8_t         deviceID;
+    uint8_t         numGroups;
+    uint8_t         pad0[2];
+    uint32_t        changedControls;
+    uint32_t        enabledControls;
+    uint32_t        enabledControlChanges;
+    xcb_keycode_t   keycode;
+    uint8_t         eventType;
+    uint8_t         requestMajor;
+    uint8_t         requestMinor;
+    uint8_t         pad1[4];
+} xcb_xkb_controls_notify_event_t;
+
+/** Opcode for xcb_xkb_indicator_state_notify. */
+#define XCB_XKB_INDICATOR_STATE_NOTIFY 4
+
+/**
+ * @brief xcb_xkb_indicator_state_notify_event_t
+ **/
+typedef struct xcb_xkb_indicator_state_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         xkbType;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    uint8_t         deviceID;
+    uint8_t         pad0[3];
+    uint32_t        state;
+    uint32_t        stateChanged;
+    uint8_t         pad1[12];
+} xcb_xkb_indicator_state_notify_event_t;
+
+/** Opcode for xcb_xkb_indicator_map_notify. */
+#define XCB_XKB_INDICATOR_MAP_NOTIFY 5
+
+/**
+ * @brief xcb_xkb_indicator_map_notify_event_t
+ **/
+typedef struct xcb_xkb_indicator_map_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         xkbType;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    uint8_t         deviceID;
+    uint8_t         pad0[3];
+    uint32_t        state;
+    uint32_t        mapChanged;
+    uint8_t         pad1[12];
+} xcb_xkb_indicator_map_notify_event_t;
+
+/** Opcode for xcb_xkb_names_notify. */
+#define XCB_XKB_NAMES_NOTIFY 6
+
+/**
+ * @brief xcb_xkb_names_notify_event_t
+ **/
+typedef struct xcb_xkb_names_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         xkbType;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    uint8_t         deviceID;
+    uint8_t         pad0;
+    uint16_t        changed;
+    uint8_t         firstType;
+    uint8_t         nTypes;
+    uint8_t         firstLevelName;
+    uint8_t         nLevelNames;
+    uint8_t         pad1;
+    uint8_t         nRadioGroups;
+    uint8_t         nKeyAliases;
+    uint8_t         changedGroupNames;
+    uint16_t        changedVirtualMods;
+    xcb_keycode_t   firstKey;
+    uint8_t         nKeys;
+    uint32_t        changedIndicators;
+    uint8_t         pad2[4];
+} xcb_xkb_names_notify_event_t;
+
+/** Opcode for xcb_xkb_compat_map_notify. */
+#define XCB_XKB_COMPAT_MAP_NOTIFY 7
+
+/**
+ * @brief xcb_xkb_compat_map_notify_event_t
+ **/
+typedef struct xcb_xkb_compat_map_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         xkbType;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    uint8_t         deviceID;
+    uint8_t         changedGroups;
+    uint16_t        firstSI;
+    uint16_t        nSI;
+    uint16_t        nTotalSI;
+    uint8_t         pad0[16];
+} xcb_xkb_compat_map_notify_event_t;
+
+/** Opcode for xcb_xkb_bell_notify. */
+#define XCB_XKB_BELL_NOTIFY 8
+
+/**
+ * @brief xcb_xkb_bell_notify_event_t
+ **/
+typedef struct xcb_xkb_bell_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         xkbType;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    uint8_t         deviceID;
+    uint8_t         bellClass;
+    uint8_t         bellID;
+    uint8_t         percent;
+    uint16_t        pitch;
+    uint16_t        duration;
+    xcb_atom_t      name;
+    xcb_window_t    window;
+    uint8_t         eventOnly;
+    uint8_t         pad0[7];
+} xcb_xkb_bell_notify_event_t;
+
+/** Opcode for xcb_xkb_action_message. */
+#define XCB_XKB_ACTION_MESSAGE 9
+
+/**
+ * @brief xcb_xkb_action_message_event_t
+ **/
+typedef struct xcb_xkb_action_message_event_t {
+    uint8_t           response_type;
+    uint8_t           xkbType;
+    uint16_t          sequence;
+    xcb_timestamp_t   time;
+    uint8_t           deviceID;
+    xcb_keycode_t     keycode;
+    uint8_t           press;
+    uint8_t           keyEventFollows;
+    uint8_t           mods;
+    uint8_t           group;
+    xcb_xkb_string8_t message[8];
+    uint8_t           pad0[10];
+} xcb_xkb_action_message_event_t;
+
+/** Opcode for xcb_xkb_access_x_notify. */
+#define XCB_XKB_ACCESS_X_NOTIFY 10
+
+/**
+ * @brief xcb_xkb_access_x_notify_event_t
+ **/
+typedef struct xcb_xkb_access_x_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         xkbType;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    uint8_t         deviceID;
+    xcb_keycode_t   keycode;
+    uint16_t        detailt;
+    uint16_t        slowKeysDelay;
+    uint16_t        debounceDelay;
+    uint8_t         pad0[16];
+} xcb_xkb_access_x_notify_event_t;
+
+/** Opcode for xcb_xkb_extension_device_notify. */
+#define XCB_XKB_EXTENSION_DEVICE_NOTIFY 11
+
+/**
+ * @brief xcb_xkb_extension_device_notify_event_t
+ **/
+typedef struct xcb_xkb_extension_device_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         xkbType;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    uint8_t         deviceID;
+    uint8_t         pad0;
+    uint16_t        reason;
+    uint16_t        ledClass;
+    uint16_t        ledID;
+    uint32_t        ledsDefined;
+    uint32_t        ledState;
+    uint8_t         firstButton;
+    uint8_t         nButtons;
+    uint16_t        supported;
+    uint16_t        unsupported;
+    uint8_t         pad1[2];
+} xcb_xkb_extension_device_notify_event_t;
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_device_spec_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_device_spec_t)
+ */
+void
+xcb_xkb_device_spec_next (xcb_xkb_device_spec_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_device_spec_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_device_spec_end (xcb_xkb_device_spec_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_led_class_spec_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_led_class_spec_t)
+ */
+void
+xcb_xkb_led_class_spec_next (xcb_xkb_led_class_spec_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_led_class_spec_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_led_class_spec_end (xcb_xkb_led_class_spec_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_bell_class_spec_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_bell_class_spec_t)
+ */
+void
+xcb_xkb_bell_class_spec_next (xcb_xkb_bell_class_spec_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_bell_class_spec_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_bell_class_spec_end (xcb_xkb_bell_class_spec_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_id_spec_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_id_spec_t)
+ */
+void
+xcb_xkb_id_spec_next (xcb_xkb_id_spec_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_id_spec_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_id_spec_end (xcb_xkb_id_spec_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_indicator_map_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_indicator_map_t)
+ */
+void
+xcb_xkb_indicator_map_next (xcb_xkb_indicator_map_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_indicator_map_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_indicator_map_end (xcb_xkb_indicator_map_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_mod_def_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_mod_def_t)
+ */
+void
+xcb_xkb_mod_def_next (xcb_xkb_mod_def_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_mod_def_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_mod_def_end (xcb_xkb_mod_def_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_key_name_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_key_name_t)
+ */
+void
+xcb_xkb_key_name_next (xcb_xkb_key_name_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_key_name_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_key_name_end (xcb_xkb_key_name_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_key_alias_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_key_alias_t)
+ */
+void
+xcb_xkb_key_alias_next (xcb_xkb_key_alias_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_key_alias_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_key_alias_end (xcb_xkb_key_alias_iterator_t i);
+
+int
+xcb_xkb_counted_string_16_sizeof (const void  *_buffer);
+
+char *
+xcb_xkb_counted_string_16_string (const xcb_xkb_counted_string_16_t *R);
+
+int
+xcb_xkb_counted_string_16_string_length (const xcb_xkb_counted_string_16_t *R);
+
+xcb_generic_iterator_t
+xcb_xkb_counted_string_16_string_end (const xcb_xkb_counted_string_16_t *R);
+
+void *
+xcb_xkb_counted_string_16_alignment_pad (const xcb_xkb_counted_string_16_t *R);
+
+int
+xcb_xkb_counted_string_16_alignment_pad_length (const xcb_xkb_counted_string_16_t *R);
+
+xcb_generic_iterator_t
+xcb_xkb_counted_string_16_alignment_pad_end (const xcb_xkb_counted_string_16_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_counted_string_16_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_counted_string_16_t)
+ */
+void
+xcb_xkb_counted_string_16_next (xcb_xkb_counted_string_16_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_counted_string_16_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_counted_string_16_end (xcb_xkb_counted_string_16_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_kt_map_entry_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_kt_map_entry_t)
+ */
+void
+xcb_xkb_kt_map_entry_next (xcb_xkb_kt_map_entry_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_kt_map_entry_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_kt_map_entry_end (xcb_xkb_kt_map_entry_iterator_t i);
+
+int
+xcb_xkb_key_type_sizeof (const void  *_buffer);
+
+xcb_xkb_kt_map_entry_t *
+xcb_xkb_key_type_map (const xcb_xkb_key_type_t *R);
+
+int
+xcb_xkb_key_type_map_length (const xcb_xkb_key_type_t *R);
+
+xcb_xkb_kt_map_entry_iterator_t
+xcb_xkb_key_type_map_iterator (const xcb_xkb_key_type_t *R);
+
+xcb_xkb_mod_def_t *
+xcb_xkb_key_type_preserve (const xcb_xkb_key_type_t *R);
+
+int
+xcb_xkb_key_type_preserve_length (const xcb_xkb_key_type_t *R);
+
+xcb_xkb_mod_def_iterator_t
+xcb_xkb_key_type_preserve_iterator (const xcb_xkb_key_type_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_key_type_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_key_type_t)
+ */
+void
+xcb_xkb_key_type_next (xcb_xkb_key_type_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_key_type_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_key_type_end (xcb_xkb_key_type_iterator_t i);
+
+int
+xcb_xkb_key_sym_map_sizeof (const void  *_buffer);
+
+xcb_keysym_t *
+xcb_xkb_key_sym_map_syms (const xcb_xkb_key_sym_map_t *R);
+
+int
+xcb_xkb_key_sym_map_syms_length (const xcb_xkb_key_sym_map_t *R);
+
+xcb_generic_iterator_t
+xcb_xkb_key_sym_map_syms_end (const xcb_xkb_key_sym_map_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_key_sym_map_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_key_sym_map_t)
+ */
+void
+xcb_xkb_key_sym_map_next (xcb_xkb_key_sym_map_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_key_sym_map_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_key_sym_map_end (xcb_xkb_key_sym_map_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_common_behavior_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_common_behavior_t)
+ */
+void
+xcb_xkb_common_behavior_next (xcb_xkb_common_behavior_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_common_behavior_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_common_behavior_end (xcb_xkb_common_behavior_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_default_behavior_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_default_behavior_t)
+ */
+void
+xcb_xkb_default_behavior_next (xcb_xkb_default_behavior_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_default_behavior_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_default_behavior_end (xcb_xkb_default_behavior_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_lock_behavior_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_lock_behavior_t)
+ */
+void
+xcb_xkb_lock_behavior_next (xcb_xkb_lock_behavior_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_lock_behavior_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_lock_behavior_end (xcb_xkb_lock_behavior_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_radio_group_behavior_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_radio_group_behavior_t)
+ */
+void
+xcb_xkb_radio_group_behavior_next (xcb_xkb_radio_group_behavior_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_radio_group_behavior_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_radio_group_behavior_end (xcb_xkb_radio_group_behavior_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_overlay_behavior_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_overlay_behavior_t)
+ */
+void
+xcb_xkb_overlay_behavior_next (xcb_xkb_overlay_behavior_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_overlay_behavior_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_overlay_behavior_end (xcb_xkb_overlay_behavior_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_permament_lock_behavior_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_permament_lock_behavior_t)
+ */
+void
+xcb_xkb_permament_lock_behavior_next (xcb_xkb_permament_lock_behavior_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_permament_lock_behavior_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_permament_lock_behavior_end (xcb_xkb_permament_lock_behavior_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_permament_radio_group_behavior_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_permament_radio_group_behavior_t)
+ */
+void
+xcb_xkb_permament_radio_group_behavior_next (xcb_xkb_permament_radio_group_behavior_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_permament_radio_group_behavior_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_permament_radio_group_behavior_end (xcb_xkb_permament_radio_group_behavior_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_permament_overlay_behavior_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_permament_overlay_behavior_t)
+ */
+void
+xcb_xkb_permament_overlay_behavior_next (xcb_xkb_permament_overlay_behavior_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_permament_overlay_behavior_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_permament_overlay_behavior_end (xcb_xkb_permament_overlay_behavior_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_behavior_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_behavior_t)
+ */
+void
+xcb_xkb_behavior_next (xcb_xkb_behavior_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_behavior_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_behavior_end (xcb_xkb_behavior_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_set_behavior_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_set_behavior_t)
+ */
+void
+xcb_xkb_set_behavior_next (xcb_xkb_set_behavior_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_set_behavior_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_set_behavior_end (xcb_xkb_set_behavior_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_set_explicit_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_set_explicit_t)
+ */
+void
+xcb_xkb_set_explicit_next (xcb_xkb_set_explicit_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_set_explicit_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_set_explicit_end (xcb_xkb_set_explicit_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_key_mod_map_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_key_mod_map_t)
+ */
+void
+xcb_xkb_key_mod_map_next (xcb_xkb_key_mod_map_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_key_mod_map_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_key_mod_map_end (xcb_xkb_key_mod_map_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_key_v_mod_map_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_key_v_mod_map_t)
+ */
+void
+xcb_xkb_key_v_mod_map_next (xcb_xkb_key_v_mod_map_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_key_v_mod_map_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_key_v_mod_map_end (xcb_xkb_key_v_mod_map_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_kt_set_map_entry_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_kt_set_map_entry_t)
+ */
+void
+xcb_xkb_kt_set_map_entry_next (xcb_xkb_kt_set_map_entry_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_kt_set_map_entry_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_kt_set_map_entry_end (xcb_xkb_kt_set_map_entry_iterator_t i);
+
+int
+xcb_xkb_set_key_type_sizeof (const void  *_buffer);
+
+xcb_xkb_kt_set_map_entry_t *
+xcb_xkb_set_key_type_entries (const xcb_xkb_set_key_type_t *R);
+
+int
+xcb_xkb_set_key_type_entries_length (const xcb_xkb_set_key_type_t *R);
+
+xcb_xkb_kt_set_map_entry_iterator_t
+xcb_xkb_set_key_type_entries_iterator (const xcb_xkb_set_key_type_t *R);
+
+xcb_xkb_kt_set_map_entry_t *
+xcb_xkb_set_key_type_preserve_entries (const xcb_xkb_set_key_type_t *R);
+
+int
+xcb_xkb_set_key_type_preserve_entries_length (const xcb_xkb_set_key_type_t *R);
+
+xcb_xkb_kt_set_map_entry_iterator_t
+xcb_xkb_set_key_type_preserve_entries_iterator (const xcb_xkb_set_key_type_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_set_key_type_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_set_key_type_t)
+ */
+void
+xcb_xkb_set_key_type_next (xcb_xkb_set_key_type_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_set_key_type_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_set_key_type_end (xcb_xkb_set_key_type_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_string8_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_string8_t)
+ */
+void
+xcb_xkb_string8_next (xcb_xkb_string8_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_string8_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_string8_end (xcb_xkb_string8_iterator_t i);
+
+int
+xcb_xkb_outline_sizeof (const void  *_buffer);
+
+xcb_point_t *
+xcb_xkb_outline_points (const xcb_xkb_outline_t *R);
+
+int
+xcb_xkb_outline_points_length (const xcb_xkb_outline_t *R);
+
+xcb_point_iterator_t
+xcb_xkb_outline_points_iterator (const xcb_xkb_outline_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_outline_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_outline_t)
+ */
+void
+xcb_xkb_outline_next (xcb_xkb_outline_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_outline_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_outline_end (xcb_xkb_outline_iterator_t i);
+
+int
+xcb_xkb_shape_sizeof (const void  *_buffer);
+
+int
+xcb_xkb_shape_outlines_length (const xcb_xkb_shape_t *R);
+
+xcb_xkb_outline_iterator_t
+xcb_xkb_shape_outlines_iterator (const xcb_xkb_shape_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_shape_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_shape_t)
+ */
+void
+xcb_xkb_shape_next (xcb_xkb_shape_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_shape_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_shape_end (xcb_xkb_shape_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_key_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_key_t)
+ */
+void
+xcb_xkb_key_next (xcb_xkb_key_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_key_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_key_end (xcb_xkb_key_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_overlay_key_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_overlay_key_t)
+ */
+void
+xcb_xkb_overlay_key_next (xcb_xkb_overlay_key_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_overlay_key_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_overlay_key_end (xcb_xkb_overlay_key_iterator_t i);
+
+int
+xcb_xkb_overlay_row_sizeof (const void  *_buffer);
+
+xcb_xkb_overlay_key_t *
+xcb_xkb_overlay_row_keys (const xcb_xkb_overlay_row_t *R);
+
+int
+xcb_xkb_overlay_row_keys_length (const xcb_xkb_overlay_row_t *R);
+
+xcb_xkb_overlay_key_iterator_t
+xcb_xkb_overlay_row_keys_iterator (const xcb_xkb_overlay_row_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_overlay_row_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_overlay_row_t)
+ */
+void
+xcb_xkb_overlay_row_next (xcb_xkb_overlay_row_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_overlay_row_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_overlay_row_end (xcb_xkb_overlay_row_iterator_t i);
+
+int
+xcb_xkb_overlay_sizeof (const void  *_buffer);
+
+int
+xcb_xkb_overlay_rows_length (const xcb_xkb_overlay_t *R);
+
+xcb_xkb_overlay_row_iterator_t
+xcb_xkb_overlay_rows_iterator (const xcb_xkb_overlay_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_overlay_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_overlay_t)
+ */
+void
+xcb_xkb_overlay_next (xcb_xkb_overlay_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_overlay_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_overlay_end (xcb_xkb_overlay_iterator_t i);
+
+int
+xcb_xkb_row_sizeof (const void  *_buffer);
+
+xcb_xkb_key_t *
+xcb_xkb_row_keys (const xcb_xkb_row_t *R);
+
+int
+xcb_xkb_row_keys_length (const xcb_xkb_row_t *R);
+
+xcb_xkb_key_iterator_t
+xcb_xkb_row_keys_iterator (const xcb_xkb_row_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_row_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_row_t)
+ */
+void
+xcb_xkb_row_next (xcb_xkb_row_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_row_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_row_end (xcb_xkb_row_iterator_t i);
+
+int
+xcb_xkb_listing_sizeof (const void  *_buffer);
+
+xcb_xkb_string8_t *
+xcb_xkb_listing_string (const xcb_xkb_listing_t *R);
+
+int
+xcb_xkb_listing_string_length (const xcb_xkb_listing_t *R);
+
+xcb_generic_iterator_t
+xcb_xkb_listing_string_end (const xcb_xkb_listing_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_listing_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_listing_t)
+ */
+void
+xcb_xkb_listing_next (xcb_xkb_listing_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_listing_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_listing_end (xcb_xkb_listing_iterator_t i);
+
+int
+xcb_xkb_device_led_info_sizeof (const void  *_buffer);
+
+xcb_atom_t *
+xcb_xkb_device_led_info_names (const xcb_xkb_device_led_info_t *R);
+
+int
+xcb_xkb_device_led_info_names_length (const xcb_xkb_device_led_info_t *R);
+
+xcb_generic_iterator_t
+xcb_xkb_device_led_info_names_end (const xcb_xkb_device_led_info_t *R);
+
+xcb_xkb_indicator_map_t *
+xcb_xkb_device_led_info_maps (const xcb_xkb_device_led_info_t *R);
+
+int
+xcb_xkb_device_led_info_maps_length (const xcb_xkb_device_led_info_t *R);
+
+xcb_xkb_indicator_map_iterator_t
+xcb_xkb_device_led_info_maps_iterator (const xcb_xkb_device_led_info_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_device_led_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_device_led_info_t)
+ */
+void
+xcb_xkb_device_led_info_next (xcb_xkb_device_led_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_device_led_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_device_led_info_end (xcb_xkb_device_led_info_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_no_action_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_no_action_t)
+ */
+void
+xcb_xkb_sa_no_action_next (xcb_xkb_sa_no_action_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_no_action_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_no_action_end (xcb_xkb_sa_no_action_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_set_mods_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_set_mods_t)
+ */
+void
+xcb_xkb_sa_set_mods_next (xcb_xkb_sa_set_mods_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_set_mods_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_set_mods_end (xcb_xkb_sa_set_mods_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_latch_mods_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_latch_mods_t)
+ */
+void
+xcb_xkb_sa_latch_mods_next (xcb_xkb_sa_latch_mods_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_latch_mods_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_latch_mods_end (xcb_xkb_sa_latch_mods_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_lock_mods_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_lock_mods_t)
+ */
+void
+xcb_xkb_sa_lock_mods_next (xcb_xkb_sa_lock_mods_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_lock_mods_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_lock_mods_end (xcb_xkb_sa_lock_mods_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_set_group_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_set_group_t)
+ */
+void
+xcb_xkb_sa_set_group_next (xcb_xkb_sa_set_group_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_set_group_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_set_group_end (xcb_xkb_sa_set_group_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_latch_group_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_latch_group_t)
+ */
+void
+xcb_xkb_sa_latch_group_next (xcb_xkb_sa_latch_group_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_latch_group_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_latch_group_end (xcb_xkb_sa_latch_group_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_lock_group_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_lock_group_t)
+ */
+void
+xcb_xkb_sa_lock_group_next (xcb_xkb_sa_lock_group_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_lock_group_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_lock_group_end (xcb_xkb_sa_lock_group_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_move_ptr_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_move_ptr_t)
+ */
+void
+xcb_xkb_sa_move_ptr_next (xcb_xkb_sa_move_ptr_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_move_ptr_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_move_ptr_end (xcb_xkb_sa_move_ptr_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_ptr_btn_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_ptr_btn_t)
+ */
+void
+xcb_xkb_sa_ptr_btn_next (xcb_xkb_sa_ptr_btn_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_ptr_btn_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_ptr_btn_end (xcb_xkb_sa_ptr_btn_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_lock_ptr_btn_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_lock_ptr_btn_t)
+ */
+void
+xcb_xkb_sa_lock_ptr_btn_next (xcb_xkb_sa_lock_ptr_btn_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_lock_ptr_btn_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_lock_ptr_btn_end (xcb_xkb_sa_lock_ptr_btn_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_set_ptr_dflt_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_set_ptr_dflt_t)
+ */
+void
+xcb_xkb_sa_set_ptr_dflt_next (xcb_xkb_sa_set_ptr_dflt_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_set_ptr_dflt_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_set_ptr_dflt_end (xcb_xkb_sa_set_ptr_dflt_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_iso_lock_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_iso_lock_t)
+ */
+void
+xcb_xkb_sa_iso_lock_next (xcb_xkb_sa_iso_lock_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_iso_lock_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_iso_lock_end (xcb_xkb_sa_iso_lock_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_terminate_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_terminate_t)
+ */
+void
+xcb_xkb_sa_terminate_next (xcb_xkb_sa_terminate_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_terminate_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_terminate_end (xcb_xkb_sa_terminate_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_switch_screen_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_switch_screen_t)
+ */
+void
+xcb_xkb_sa_switch_screen_next (xcb_xkb_sa_switch_screen_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_switch_screen_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_switch_screen_end (xcb_xkb_sa_switch_screen_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_set_controls_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_set_controls_t)
+ */
+void
+xcb_xkb_sa_set_controls_next (xcb_xkb_sa_set_controls_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_set_controls_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_set_controls_end (xcb_xkb_sa_set_controls_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_lock_controls_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_lock_controls_t)
+ */
+void
+xcb_xkb_sa_lock_controls_next (xcb_xkb_sa_lock_controls_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_lock_controls_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_lock_controls_end (xcb_xkb_sa_lock_controls_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_action_message_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_action_message_t)
+ */
+void
+xcb_xkb_sa_action_message_next (xcb_xkb_sa_action_message_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_action_message_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_action_message_end (xcb_xkb_sa_action_message_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_redirect_key_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_redirect_key_t)
+ */
+void
+xcb_xkb_sa_redirect_key_next (xcb_xkb_sa_redirect_key_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_redirect_key_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_redirect_key_end (xcb_xkb_sa_redirect_key_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_device_btn_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_device_btn_t)
+ */
+void
+xcb_xkb_sa_device_btn_next (xcb_xkb_sa_device_btn_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_device_btn_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_device_btn_end (xcb_xkb_sa_device_btn_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_lock_device_btn_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_lock_device_btn_t)
+ */
+void
+xcb_xkb_sa_lock_device_btn_next (xcb_xkb_sa_lock_device_btn_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_lock_device_btn_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_lock_device_btn_end (xcb_xkb_sa_lock_device_btn_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sa_device_valuator_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sa_device_valuator_t)
+ */
+void
+xcb_xkb_sa_device_valuator_next (xcb_xkb_sa_device_valuator_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sa_device_valuator_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sa_device_valuator_end (xcb_xkb_sa_device_valuator_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_si_action_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_si_action_t)
+ */
+void
+xcb_xkb_si_action_next (xcb_xkb_si_action_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_si_action_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_si_action_end (xcb_xkb_si_action_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_sym_interpret_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_sym_interpret_t)
+ */
+void
+xcb_xkb_sym_interpret_next (xcb_xkb_sym_interpret_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_sym_interpret_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_sym_interpret_end (xcb_xkb_sym_interpret_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xkb_action_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xkb_action_t)
+ */
+void
+xcb_xkb_action_next (xcb_xkb_action_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xkb_action_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xkb_action_end (xcb_xkb_action_iterator_t i);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xkb_use_extension_cookie_t
+xcb_xkb_use_extension (xcb_connection_t *c,
+                       uint16_t          wantedMajor,
+                       uint16_t          wantedMinor);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xkb_use_extension_cookie_t
+xcb_xkb_use_extension_unchecked (xcb_connection_t *c,
+                                 uint16_t          wantedMajor,
+                                 uint16_t          wantedMinor);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xkb_use_extension_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xkb_use_extension_reply_t *
+xcb_xkb_use_extension_reply (xcb_connection_t                *c,
+                             xcb_xkb_use_extension_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+int
+xcb_xkb_select_events_details_serialize (void                                  **_buffer,
+                                         uint16_t                                affectWhich,
+                                         uint16_t                                clear,
+                                         uint16_t                                selectAll,
+                                         const xcb_xkb_select_events_details_t  *_aux);
+
+int
+xcb_xkb_select_events_details_unpack (const void                       *_buffer,
+                                      uint16_t                          affectWhich,
+                                      uint16_t                          clear,
+                                      uint16_t                          selectAll,
+                                      xcb_xkb_select_events_details_t  *_aux);
+
+int
+xcb_xkb_select_events_details_sizeof (const void  *_buffer,
+                                      uint16_t     affectWhich,
+                                      uint16_t     clear,
+                                      uint16_t     selectAll);
+
+int
+xcb_xkb_select_events_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xkb_select_events_checked (xcb_connection_t      *c,
+                               xcb_xkb_device_spec_t  deviceSpec,
+                               uint16_t               affectWhich,
+                               uint16_t               clear,
+                               uint16_t               selectAll,
+                               uint16_t               affectMap,
+                               uint16_t               map,
+                               const void            *details);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xkb_select_events (xcb_connection_t      *c,
+                       xcb_xkb_device_spec_t  deviceSpec,
+                       uint16_t               affectWhich,
+                       uint16_t               clear,
+                       uint16_t               selectAll,
+                       uint16_t               affectMap,
+                       uint16_t               map,
+                       const void            *details);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xkb_select_events_aux_checked (xcb_connection_t                      *c,
+                                   xcb_xkb_device_spec_t                  deviceSpec,
+                                   uint16_t                               affectWhich,
+                                   uint16_t                               clear,
+                                   uint16_t                               selectAll,
+                                   uint16_t                               affectMap,
+                                   uint16_t                               map,
+                                   const xcb_xkb_select_events_details_t *details);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xkb_select_events_aux (xcb_connection_t                      *c,
+                           xcb_xkb_device_spec_t                  deviceSpec,
+                           uint16_t                               affectWhich,
+                           uint16_t                               clear,
+                           uint16_t                               selectAll,
+                           uint16_t                               affectMap,
+                           uint16_t                               map,
+                           const xcb_xkb_select_events_details_t *details);
+
+void *
+xcb_xkb_select_events_details (const xcb_xkb_select_events_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xkb_bell_checked (xcb_connection_t          *c,
+                      xcb_xkb_device_spec_t      deviceSpec,
+                      xcb_xkb_bell_class_spec_t  bellClass,
+                      xcb_xkb_id_spec_t          bellID,
+                      int8_t                     percent,
+                      uint8_t                    forceSound,
+                      uint8_t                    eventOnly,
+                      int16_t                    pitch,
+                      int16_t                    duration,
+                      xcb_atom_t                 name,
+                      xcb_window_t               window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xkb_bell (xcb_connection_t          *c,
+              xcb_xkb_device_spec_t      deviceSpec,
+              xcb_xkb_bell_class_spec_t  bellClass,
+              xcb_xkb_id_spec_t          bellID,
+              int8_t                     percent,
+              uint8_t                    forceSound,
+              uint8_t                    eventOnly,
+              int16_t                    pitch,
+              int16_t                    duration,
+              xcb_atom_t                 name,
+              xcb_window_t               window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xkb_get_state_cookie_t
+xcb_xkb_get_state (xcb_connection_t      *c,
+                   xcb_xkb_device_spec_t  deviceSpec);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xkb_get_state_cookie_t
+xcb_xkb_get_state_unchecked (xcb_connection_t      *c,
+                             xcb_xkb_device_spec_t  deviceSpec);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xkb_get_state_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xkb_get_state_reply_t *
+xcb_xkb_get_state_reply (xcb_connection_t            *c,
+                         xcb_xkb_get_state_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xkb_latch_lock_state_checked (xcb_connection_t      *c,
+                                  xcb_xkb_device_spec_t  deviceSpec,
+                                  uint8_t                affectModLocks,
+                                  uint8_t                modLocks,
+                                  uint8_t                lockGroup,
+                                  uint8_t                groupLock,
+                                  uint8_t                affectModLatches,
+                                  uint8_t                latchGroup,
+                                  uint16_t               groupLatch);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xkb_latch_lock_state (xcb_connection_t      *c,
+                          xcb_xkb_device_spec_t  deviceSpec,
+                          uint8_t                affectModLocks,
+                          uint8_t                modLocks,
+                          uint8_t                lockGroup,
+                          uint8_t                groupLock,
+                          uint8_t                affectModLatches,
+                          uint8_t                latchGroup,
+                          uint16_t               groupLatch);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xkb_get_controls_cookie_t
+xcb_xkb_get_controls (xcb_connection_t      *c,
+                      xcb_xkb_device_spec_t  deviceSpec);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xkb_get_controls_cookie_t
+xcb_xkb_get_controls_unchecked (xcb_connection_t      *c,
+                                xcb_xkb_device_spec_t  deviceSpec);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xkb_get_controls_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xkb_get_controls_reply_t *
+xcb_xkb_get_controls_reply (xcb_connection_t               *c,
+                            xcb_xkb_get_controls_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xkb_set_controls_checked (xcb_connection_t      *c,
+                              xcb_xkb_device_spec_t  deviceSpec,
+                              uint8_t                affectInternalRealMods,
+                              uint8_t                internalRealMods,
+                              uint8_t                affectIgnoreLockRealMods,
+                              uint8_t                ignoreLockRealMods,
+                              uint16_t               affectInternalVirtualMods,
+                              uint16_t               internalVirtualMods,
+                              uint16_t               affectIgnoreLockVirtualMods,
+                              uint16_t               ignoreLockVirtualMods,
+                              uint8_t                mouseKeysDfltBtn,
+                              uint8_t                groupsWrap,
+                              uint16_t               accessXOptions,
+                              uint32_t               affectEnabledControls,
+                              uint32_t               enabledControls,
+                              uint32_t               changeControls,
+                              uint16_t               repeatDelay,
+                              uint16_t               repeatInterval,
+                              uint16_t               slowKeysDelay,
+                              uint16_t               debounceDelay,
+                              uint16_t               mouseKeysDelay,
+                              uint16_t               mouseKeysInterval,
+                              uint16_t               mouseKeysTimeToMax,
+                              uint16_t               mouseKeysMaxSpeed,
+                              int16_t                mouseKeysCurve,
+                              uint16_t               accessXTimeout,
+                              uint32_t               accessXTimeoutMask,
+                              uint32_t               accessXTimeoutValues,
+                              uint16_t               accessXTimeoutOptionsMask,
+                              uint16_t               accessXTimeoutOptionsValues,
+                              const uint8_t         *perKeyRepeat);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xkb_set_controls (xcb_connection_t      *c,
+                      xcb_xkb_device_spec_t  deviceSpec,
+                      uint8_t                affectInternalRealMods,
+                      uint8_t                internalRealMods,
+                      uint8_t                affectIgnoreLockRealMods,
+                      uint8_t                ignoreLockRealMods,
+                      uint16_t               affectInternalVirtualMods,
+                      uint16_t               internalVirtualMods,
+                      uint16_t               affectIgnoreLockVirtualMods,
+                      uint16_t               ignoreLockVirtualMods,
+                      uint8_t                mouseKeysDfltBtn,
+                      uint8_t                groupsWrap,
+                      uint16_t               accessXOptions,
+                      uint32_t               affectEnabledControls,
+                      uint32_t               enabledControls,
+                      uint32_t               changeControls,
+                      uint16_t               repeatDelay,
+                      uint16_t               repeatInterval,
+                      uint16_t               slowKeysDelay,
+                      uint16_t               debounceDelay,
+                      uint16_t               mouseKeysDelay,
+                      uint16_t               mouseKeysInterval,
+                      uint16_t               mouseKeysTimeToMax,
+                      uint16_t               mouseKeysMaxSpeed,
+                      int16_t                mouseKeysCurve,
+                      uint16_t               accessXTimeout,
+                      uint32_t               accessXTimeoutMask,
+                      uint32_t               accessXTimeoutValues,
+                      uint16_t               accessXTimeoutOptionsMask,
+                      uint16_t               accessXTimeoutOptionsValues,
+                      const uint8_t         *perKeyRepeat);
+
+int
+xcb_xkb_get_map_map_types_rtrn_length (const xcb_xkb_get_map_reply_t *R,
+                                       const xcb_xkb_get_map_map_t *S);
+
+xcb_xkb_key_type_iterator_t
+xcb_xkb_get_map_map_types_rtrn_iterator (const xcb_xkb_get_map_reply_t *R,
+                                         const xcb_xkb_get_map_map_t *S);
+
+int
+xcb_xkb_get_map_map_syms_rtrn_length (const xcb_xkb_get_map_reply_t *R,
+                                      const xcb_xkb_get_map_map_t *S);
+
+xcb_xkb_key_sym_map_iterator_t
+xcb_xkb_get_map_map_syms_rtrn_iterator (const xcb_xkb_get_map_reply_t *R,
+                                        const xcb_xkb_get_map_map_t *S);
+
+uint8_t *
+xcb_xkb_get_map_map_acts_rtrn_count (const xcb_xkb_get_map_map_t *S);
+
+int
+xcb_xkb_get_map_map_acts_rtrn_count_length (const xcb_xkb_get_map_reply_t *R,
+                                            const xcb_xkb_get_map_map_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_get_map_map_acts_rtrn_count_end (const xcb_xkb_get_map_reply_t *R,
+                                         const xcb_xkb_get_map_map_t *S);
+
+xcb_xkb_action_t *
+xcb_xkb_get_map_map_acts_rtrn_acts (const xcb_xkb_get_map_map_t *S);
+
+int
+xcb_xkb_get_map_map_acts_rtrn_acts_length (const xcb_xkb_get_map_reply_t *R,
+                                           const xcb_xkb_get_map_map_t *S);
+
+xcb_xkb_action_iterator_t
+xcb_xkb_get_map_map_acts_rtrn_acts_iterator (const xcb_xkb_get_map_reply_t *R,
+                                             const xcb_xkb_get_map_map_t *S);
+
+xcb_xkb_set_behavior_t *
+xcb_xkb_get_map_map_behaviors_rtrn (const xcb_xkb_get_map_map_t *S);
+
+int
+xcb_xkb_get_map_map_behaviors_rtrn_length (const xcb_xkb_get_map_reply_t *R,
+                                           const xcb_xkb_get_map_map_t *S);
+
+xcb_xkb_set_behavior_iterator_t
+xcb_xkb_get_map_map_behaviors_rtrn_iterator (const xcb_xkb_get_map_reply_t *R,
+                                             const xcb_xkb_get_map_map_t *S);
+
+uint8_t *
+xcb_xkb_get_map_map_vmods_rtrn (const xcb_xkb_get_map_map_t *S);
+
+int
+xcb_xkb_get_map_map_vmods_rtrn_length (const xcb_xkb_get_map_reply_t *R,
+                                       const xcb_xkb_get_map_map_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_get_map_map_vmods_rtrn_end (const xcb_xkb_get_map_reply_t *R,
+                                    const xcb_xkb_get_map_map_t *S);
+
+xcb_xkb_set_explicit_t *
+xcb_xkb_get_map_map_explicit_rtrn (const xcb_xkb_get_map_map_t *S);
+
+int
+xcb_xkb_get_map_map_explicit_rtrn_length (const xcb_xkb_get_map_reply_t *R,
+                                          const xcb_xkb_get_map_map_t *S);
+
+xcb_xkb_set_explicit_iterator_t
+xcb_xkb_get_map_map_explicit_rtrn_iterator (const xcb_xkb_get_map_reply_t *R,
+                                            const xcb_xkb_get_map_map_t *S);
+
+xcb_xkb_key_mod_map_t *
+xcb_xkb_get_map_map_modmap_rtrn (const xcb_xkb_get_map_map_t *S);
+
+int
+xcb_xkb_get_map_map_modmap_rtrn_length (const xcb_xkb_get_map_reply_t *R,
+                                        const xcb_xkb_get_map_map_t *S);
+
+xcb_xkb_key_mod_map_iterator_t
+xcb_xkb_get_map_map_modmap_rtrn_iterator (const xcb_xkb_get_map_reply_t *R,
+                                          const xcb_xkb_get_map_map_t *S);
+
+xcb_xkb_key_v_mod_map_t *
+xcb_xkb_get_map_map_vmodmap_rtrn (const xcb_xkb_get_map_map_t *S);
+
+int
+xcb_xkb_get_map_map_vmodmap_rtrn_length (const xcb_xkb_get_map_reply_t *R,
+                                         const xcb_xkb_get_map_map_t *S);
+
+xcb_xkb_key_v_mod_map_iterator_t
+xcb_xkb_get_map_map_vmodmap_rtrn_iterator (const xcb_xkb_get_map_reply_t *R,
+                                           const xcb_xkb_get_map_map_t *S);
+
+int
+xcb_xkb_get_map_map_serialize (void                        **_buffer,
+                               uint8_t                       nTypes,
+                               uint8_t                       nKeySyms,
+                               uint8_t                       nKeyActions,
+                               uint16_t                      totalActions,
+                               uint8_t                       totalKeyBehaviors,
+                               uint16_t                      virtualMods,
+                               uint8_t                       totalKeyExplicit,
+                               uint8_t                       totalModMapKeys,
+                               uint8_t                       totalVModMapKeys,
+                               uint16_t                      present,
+                               const xcb_xkb_get_map_map_t  *_aux);
+
+int
+xcb_xkb_get_map_map_unpack (const void             *_buffer,
+                            uint8_t                 nTypes,
+                            uint8_t                 nKeySyms,
+                            uint8_t                 nKeyActions,
+                            uint16_t                totalActions,
+                            uint8_t                 totalKeyBehaviors,
+                            uint16_t                virtualMods,
+                            uint8_t                 totalKeyExplicit,
+                            uint8_t                 totalModMapKeys,
+                            uint8_t                 totalVModMapKeys,
+                            uint16_t                present,
+                            xcb_xkb_get_map_map_t  *_aux);
+
+int
+xcb_xkb_get_map_map_sizeof (const void  *_buffer,
+                            uint8_t      nTypes,
+                            uint8_t      nKeySyms,
+                            uint8_t      nKeyActions,
+                            uint16_t     totalActions,
+                            uint8_t      totalKeyBehaviors,
+                            uint16_t     virtualMods,
+                            uint8_t      totalKeyExplicit,
+                            uint8_t      totalModMapKeys,
+                            uint8_t      totalVModMapKeys,
+                            uint16_t     present);
+
+int
+xcb_xkb_get_map_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xkb_get_map_cookie_t
+xcb_xkb_get_map (xcb_connection_t      *c,
+                 xcb_xkb_device_spec_t  deviceSpec,
+                 uint16_t               full,
+                 uint16_t               partial,
+                 uint8_t                firstType,
+                 uint8_t                nTypes,
+                 xcb_keycode_t          firstKeySym,
+                 uint8_t                nKeySyms,
+                 xcb_keycode_t          firstKeyAction,
+                 uint8_t                nKeyActions,
+                 xcb_keycode_t          firstKeyBehavior,
+                 uint8_t                nKeyBehaviors,
+                 uint16_t               virtualMods,
+                 xcb_keycode_t          firstKeyExplicit,
+                 uint8_t                nKeyExplicit,
+                 xcb_keycode_t          firstModMapKey,
+                 uint8_t                nModMapKeys,
+                 xcb_keycode_t          firstVModMapKey,
+                 uint8_t                nVModMapKeys);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xkb_get_map_cookie_t
+xcb_xkb_get_map_unchecked (xcb_connection_t      *c,
+                           xcb_xkb_device_spec_t  deviceSpec,
+                           uint16_t               full,
+                           uint16_t               partial,
+                           uint8_t                firstType,
+                           uint8_t                nTypes,
+                           xcb_keycode_t          firstKeySym,
+                           uint8_t                nKeySyms,
+                           xcb_keycode_t          firstKeyAction,
+                           uint8_t                nKeyActions,
+                           xcb_keycode_t          firstKeyBehavior,
+                           uint8_t                nKeyBehaviors,
+                           uint16_t               virtualMods,
+                           xcb_keycode_t          firstKeyExplicit,
+                           uint8_t                nKeyExplicit,
+                           xcb_keycode_t          firstModMapKey,
+                           uint8_t                nModMapKeys,
+                           xcb_keycode_t          firstVModMapKey,
+                           uint8_t                nVModMapKeys);
+
+void *
+xcb_xkb_get_map_map (const xcb_xkb_get_map_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xkb_get_map_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xkb_get_map_reply_t *
+xcb_xkb_get_map_reply (xcb_connection_t          *c,
+                       xcb_xkb_get_map_cookie_t   cookie  /**< */,
+                       xcb_generic_error_t      **e);
+
+int
+xcb_xkb_set_map_values_types_length (const xcb_xkb_set_map_request_t *R,
+                                     const xcb_xkb_set_map_values_t *S);
+
+xcb_xkb_set_key_type_iterator_t
+xcb_xkb_set_map_values_types_iterator (const xcb_xkb_set_map_request_t *R,
+                                       const xcb_xkb_set_map_values_t *S);
+
+int
+xcb_xkb_set_map_values_syms_length (const xcb_xkb_set_map_request_t *R,
+                                    const xcb_xkb_set_map_values_t *S);
+
+xcb_xkb_key_sym_map_iterator_t
+xcb_xkb_set_map_values_syms_iterator (const xcb_xkb_set_map_request_t *R,
+                                      const xcb_xkb_set_map_values_t *S);
+
+uint8_t *
+xcb_xkb_set_map_values_actions_count (const xcb_xkb_set_map_values_t *S);
+
+int
+xcb_xkb_set_map_values_actions_count_length (const xcb_xkb_set_map_request_t *R,
+                                             const xcb_xkb_set_map_values_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_set_map_values_actions_count_end (const xcb_xkb_set_map_request_t *R,
+                                          const xcb_xkb_set_map_values_t *S);
+
+xcb_xkb_action_t *
+xcb_xkb_set_map_values_actions (const xcb_xkb_set_map_values_t *S);
+
+int
+xcb_xkb_set_map_values_actions_length (const xcb_xkb_set_map_request_t *R,
+                                       const xcb_xkb_set_map_values_t *S);
+
+xcb_xkb_action_iterator_t
+xcb_xkb_set_map_values_actions_iterator (const xcb_xkb_set_map_request_t *R,
+                                         const xcb_xkb_set_map_values_t *S);
+
+xcb_xkb_set_behavior_t *
+xcb_xkb_set_map_values_behaviors (const xcb_xkb_set_map_values_t *S);
+
+int
+xcb_xkb_set_map_values_behaviors_length (const xcb_xkb_set_map_request_t *R,
+                                         const xcb_xkb_set_map_values_t *S);
+
+xcb_xkb_set_behavior_iterator_t
+xcb_xkb_set_map_values_behaviors_iterator (const xcb_xkb_set_map_request_t *R,
+                                           const xcb_xkb_set_map_values_t *S);
+
+uint8_t *
+xcb_xkb_set_map_values_vmods (const xcb_xkb_set_map_values_t *S);
+
+int
+xcb_xkb_set_map_values_vmods_length (const xcb_xkb_set_map_request_t *R,
+                                     const xcb_xkb_set_map_values_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_set_map_values_vmods_end (const xcb_xkb_set_map_request_t *R,
+                                  const xcb_xkb_set_map_values_t *S);
+
+xcb_xkb_set_explicit_t *
+xcb_xkb_set_map_values_explicit (const xcb_xkb_set_map_values_t *S);
+
+int
+xcb_xkb_set_map_values_explicit_length (const xcb_xkb_set_map_request_t *R,
+                                        const xcb_xkb_set_map_values_t *S);
+
+xcb_xkb_set_explicit_iterator_t
+xcb_xkb_set_map_values_explicit_iterator (const xcb_xkb_set_map_request_t *R,
+                                          const xcb_xkb_set_map_values_t *S);
+
+xcb_xkb_key_mod_map_t *
+xcb_xkb_set_map_values_modmap (const xcb_xkb_set_map_values_t *S);
+
+int
+xcb_xkb_set_map_values_modmap_length (const xcb_xkb_set_map_request_t *R,
+                                      const xcb_xkb_set_map_values_t *S);
+
+xcb_xkb_key_mod_map_iterator_t
+xcb_xkb_set_map_values_modmap_iterator (const xcb_xkb_set_map_request_t *R,
+                                        const xcb_xkb_set_map_values_t *S);
+
+xcb_xkb_key_v_mod_map_t *
+xcb_xkb_set_map_values_vmodmap (const xcb_xkb_set_map_values_t *S);
+
+int
+xcb_xkb_set_map_values_vmodmap_length (const xcb_xkb_set_map_request_t *R,
+                                       const xcb_xkb_set_map_values_t *S);
+
+xcb_xkb_key_v_mod_map_iterator_t
+xcb_xkb_set_map_values_vmodmap_iterator (const xcb_xkb_set_map_request_t *R,
+                                         const xcb_xkb_set_map_values_t *S);
+
+int
+xcb_xkb_set_map_values_serialize (void                           **_buffer,
+                                  uint8_t                          nTypes,
+                                  uint8_t                          nKeySyms,
+                                  uint8_t                          nKeyActions,
+                                  uint16_t                         totalActions,
+                                  uint8_t                          totalKeyBehaviors,
+                                  uint16_t                         virtualMods,
+                                  uint8_t                          totalKeyExplicit,
+                                  uint8_t                          totalModMapKeys,
+                                  uint8_t                          totalVModMapKeys,
+                                  uint16_t                         present,
+                                  const xcb_xkb_set_map_values_t  *_aux);
+
+int
+xcb_xkb_set_map_values_unpack (const void                *_buffer,
+                               uint8_t                    nTypes,
+                               uint8_t                    nKeySyms,
+                               uint8_t                    nKeyActions,
+                               uint16_t                   totalActions,
+                               uint8_t                    totalKeyBehaviors,
+                               uint16_t                   virtualMods,
+                               uint8_t                    totalKeyExplicit,
+                               uint8_t                    totalModMapKeys,
+                               uint8_t                    totalVModMapKeys,
+                               uint16_t                   present,
+                               xcb_xkb_set_map_values_t  *_aux);
+
+int
+xcb_xkb_set_map_values_sizeof (const void  *_buffer,
+                               uint8_t      nTypes,
+                               uint8_t      nKeySyms,
+                               uint8_t      nKeyActions,
+                               uint16_t     totalActions,
+                               uint8_t      totalKeyBehaviors,
+                               uint16_t     virtualMods,
+                               uint8_t      totalKeyExplicit,
+                               uint8_t      totalModMapKeys,
+                               uint8_t      totalVModMapKeys,
+                               uint16_t     present);
+
+int
+xcb_xkb_set_map_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xkb_set_map_checked (xcb_connection_t      *c,
+                         xcb_xkb_device_spec_t  deviceSpec,
+                         uint16_t               present,
+                         uint16_t               flags,
+                         xcb_keycode_t          minKeyCode,
+                         xcb_keycode_t          maxKeyCode,
+                         uint8_t                firstType,
+                         uint8_t                nTypes,
+                         xcb_keycode_t          firstKeySym,
+                         uint8_t                nKeySyms,
+                         uint16_t               totalSyms,
+                         xcb_keycode_t          firstKeyAction,
+                         uint8_t                nKeyActions,
+                         uint16_t               totalActions,
+                         xcb_keycode_t          firstKeyBehavior,
+                         uint8_t                nKeyBehaviors,
+                         uint8_t                totalKeyBehaviors,
+                         xcb_keycode_t          firstKeyExplicit,
+                         uint8_t                nKeyExplicit,
+                         uint8_t                totalKeyExplicit,
+                         xcb_keycode_t          firstModMapKey,
+                         uint8_t                nModMapKeys,
+                         uint8_t                totalModMapKeys,
+                         xcb_keycode_t          firstVModMapKey,
+                         uint8_t                nVModMapKeys,
+                         uint8_t                totalVModMapKeys,
+                         uint16_t               virtualMods,
+                         const void            *values);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xkb_set_map (xcb_connection_t      *c,
+                 xcb_xkb_device_spec_t  deviceSpec,
+                 uint16_t               present,
+                 uint16_t               flags,
+                 xcb_keycode_t          minKeyCode,
+                 xcb_keycode_t          maxKeyCode,
+                 uint8_t                firstType,
+                 uint8_t                nTypes,
+                 xcb_keycode_t          firstKeySym,
+                 uint8_t                nKeySyms,
+                 uint16_t               totalSyms,
+                 xcb_keycode_t          firstKeyAction,
+                 uint8_t                nKeyActions,
+                 uint16_t               totalActions,
+                 xcb_keycode_t          firstKeyBehavior,
+                 uint8_t                nKeyBehaviors,
+                 uint8_t                totalKeyBehaviors,
+                 xcb_keycode_t          firstKeyExplicit,
+                 uint8_t                nKeyExplicit,
+                 uint8_t                totalKeyExplicit,
+                 xcb_keycode_t          firstModMapKey,
+                 uint8_t                nModMapKeys,
+                 uint8_t                totalModMapKeys,
+                 xcb_keycode_t          firstVModMapKey,
+                 uint8_t                nVModMapKeys,
+                 uint8_t                totalVModMapKeys,
+                 uint16_t               virtualMods,
+                 const void            *values);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xkb_set_map_aux_checked (xcb_connection_t               *c,
+                             xcb_xkb_device_spec_t           deviceSpec,
+                             uint16_t                        present,
+                             uint16_t                        flags,
+                             xcb_keycode_t                   minKeyCode,
+                             xcb_keycode_t                   maxKeyCode,
+                             uint8_t                         firstType,
+                             uint8_t                         nTypes,
+                             xcb_keycode_t                   firstKeySym,
+                             uint8_t                         nKeySyms,
+                             uint16_t                        totalSyms,
+                             xcb_keycode_t                   firstKeyAction,
+                             uint8_t                         nKeyActions,
+                             uint16_t                        totalActions,
+                             xcb_keycode_t                   firstKeyBehavior,
+                             uint8_t                         nKeyBehaviors,
+                             uint8_t                         totalKeyBehaviors,
+                             xcb_keycode_t                   firstKeyExplicit,
+                             uint8_t                         nKeyExplicit,
+                             uint8_t                         totalKeyExplicit,
+                             xcb_keycode_t                   firstModMapKey,
+                             uint8_t                         nModMapKeys,
+                             uint8_t                         totalModMapKeys,
+                             xcb_keycode_t                   firstVModMapKey,
+                             uint8_t                         nVModMapKeys,
+                             uint8_t                         totalVModMapKeys,
+                             uint16_t                        virtualMods,
+                             const xcb_xkb_set_map_values_t *values);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xkb_set_map_aux (xcb_connection_t               *c,
+                     xcb_xkb_device_spec_t           deviceSpec,
+                     uint16_t                        present,
+                     uint16_t                        flags,
+                     xcb_keycode_t                   minKeyCode,
+                     xcb_keycode_t                   maxKeyCode,
+                     uint8_t                         firstType,
+                     uint8_t                         nTypes,
+                     xcb_keycode_t                   firstKeySym,
+                     uint8_t                         nKeySyms,
+                     uint16_t                        totalSyms,
+                     xcb_keycode_t                   firstKeyAction,
+                     uint8_t                         nKeyActions,
+                     uint16_t                        totalActions,
+                     xcb_keycode_t                   firstKeyBehavior,
+                     uint8_t                         nKeyBehaviors,
+                     uint8_t                         totalKeyBehaviors,
+                     xcb_keycode_t                   firstKeyExplicit,
+                     uint8_t                         nKeyExplicit,
+                     uint8_t                         totalKeyExplicit,
+                     xcb_keycode_t                   firstModMapKey,
+                     uint8_t                         nModMapKeys,
+                     uint8_t                         totalModMapKeys,
+                     xcb_keycode_t                   firstVModMapKey,
+                     uint8_t                         nVModMapKeys,
+                     uint8_t                         totalVModMapKeys,
+                     uint16_t                        virtualMods,
+                     const xcb_xkb_set_map_values_t *values);
+
+void *
+xcb_xkb_set_map_values (const xcb_xkb_set_map_request_t *R);
+
+int
+xcb_xkb_get_compat_map_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xkb_get_compat_map_cookie_t
+xcb_xkb_get_compat_map (xcb_connection_t      *c,
+                        xcb_xkb_device_spec_t  deviceSpec,
+                        uint8_t                groups,
+                        uint8_t                getAllSI,
+                        uint16_t               firstSI,
+                        uint16_t               nSI);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xkb_get_compat_map_cookie_t
+xcb_xkb_get_compat_map_unchecked (xcb_connection_t      *c,
+                                  xcb_xkb_device_spec_t  deviceSpec,
+                                  uint8_t                groups,
+                                  uint8_t                getAllSI,
+                                  uint16_t               firstSI,
+                                  uint16_t               nSI);
+
+xcb_xkb_sym_interpret_t *
+xcb_xkb_get_compat_map_si_rtrn (const xcb_xkb_get_compat_map_reply_t *R);
+
+int
+xcb_xkb_get_compat_map_si_rtrn_length (const xcb_xkb_get_compat_map_reply_t *R);
+
+xcb_xkb_sym_interpret_iterator_t
+xcb_xkb_get_compat_map_si_rtrn_iterator (const xcb_xkb_get_compat_map_reply_t *R);
+
+xcb_xkb_mod_def_t *
+xcb_xkb_get_compat_map_group_rtrn (const xcb_xkb_get_compat_map_reply_t *R);
+
+int
+xcb_xkb_get_compat_map_group_rtrn_length (const xcb_xkb_get_compat_map_reply_t *R);
+
+xcb_xkb_mod_def_iterator_t
+xcb_xkb_get_compat_map_group_rtrn_iterator (const xcb_xkb_get_compat_map_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xkb_get_compat_map_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xkb_get_compat_map_reply_t *
+xcb_xkb_get_compat_map_reply (xcb_connection_t                 *c,
+                              xcb_xkb_get_compat_map_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+int
+xcb_xkb_set_compat_map_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xkb_set_compat_map_checked (xcb_connection_t              *c,
+                                xcb_xkb_device_spec_t          deviceSpec,
+                                uint8_t                        recomputeActions,
+                                uint8_t                        truncateSI,
+                                uint8_t                        groups,
+                                uint16_t                       firstSI,
+                                uint16_t                       nSI,
+                                const xcb_xkb_sym_interpret_t *si,
+                                const xcb_xkb_mod_def_t       *groupMaps);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xkb_set_compat_map (xcb_connection_t              *c,
+                        xcb_xkb_device_spec_t          deviceSpec,
+                        uint8_t                        recomputeActions,
+                        uint8_t                        truncateSI,
+                        uint8_t                        groups,
+                        uint16_t                       firstSI,
+                        uint16_t                       nSI,
+                        const xcb_xkb_sym_interpret_t *si,
+                        const xcb_xkb_mod_def_t       *groupMaps);
+
+xcb_xkb_sym_interpret_t *
+xcb_xkb_set_compat_map_si (const xcb_xkb_set_compat_map_request_t *R);
+
+int
+xcb_xkb_set_compat_map_si_length (const xcb_xkb_set_compat_map_request_t *R);
+
+xcb_xkb_sym_interpret_iterator_t
+xcb_xkb_set_compat_map_si_iterator (const xcb_xkb_set_compat_map_request_t *R);
+
+xcb_xkb_mod_def_t *
+xcb_xkb_set_compat_map_group_maps (const xcb_xkb_set_compat_map_request_t *R);
+
+int
+xcb_xkb_set_compat_map_group_maps_length (const xcb_xkb_set_compat_map_request_t *R);
+
+xcb_xkb_mod_def_iterator_t
+xcb_xkb_set_compat_map_group_maps_iterator (const xcb_xkb_set_compat_map_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xkb_get_indicator_state_cookie_t
+xcb_xkb_get_indicator_state (xcb_connection_t      *c,
+                             xcb_xkb_device_spec_t  deviceSpec);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xkb_get_indicator_state_cookie_t
+xcb_xkb_get_indicator_state_unchecked (xcb_connection_t      *c,
+                                       xcb_xkb_device_spec_t  deviceSpec);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xkb_get_indicator_state_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xkb_get_indicator_state_reply_t *
+xcb_xkb_get_indicator_state_reply (xcb_connection_t                      *c,
+                                   xcb_xkb_get_indicator_state_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e);
+
+int
+xcb_xkb_get_indicator_map_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xkb_get_indicator_map_cookie_t
+xcb_xkb_get_indicator_map (xcb_connection_t      *c,
+                           xcb_xkb_device_spec_t  deviceSpec,
+                           uint32_t               which);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xkb_get_indicator_map_cookie_t
+xcb_xkb_get_indicator_map_unchecked (xcb_connection_t      *c,
+                                     xcb_xkb_device_spec_t  deviceSpec,
+                                     uint32_t               which);
+
+xcb_xkb_indicator_map_t *
+xcb_xkb_get_indicator_map_maps (const xcb_xkb_get_indicator_map_reply_t *R);
+
+int
+xcb_xkb_get_indicator_map_maps_length (const xcb_xkb_get_indicator_map_reply_t *R);
+
+xcb_xkb_indicator_map_iterator_t
+xcb_xkb_get_indicator_map_maps_iterator (const xcb_xkb_get_indicator_map_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xkb_get_indicator_map_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xkb_get_indicator_map_reply_t *
+xcb_xkb_get_indicator_map_reply (xcb_connection_t                    *c,
+                                 xcb_xkb_get_indicator_map_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e);
+
+int
+xcb_xkb_set_indicator_map_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xkb_set_indicator_map_checked (xcb_connection_t              *c,
+                                   xcb_xkb_device_spec_t          deviceSpec,
+                                   uint32_t                       which,
+                                   const xcb_xkb_indicator_map_t *maps);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xkb_set_indicator_map (xcb_connection_t              *c,
+                           xcb_xkb_device_spec_t          deviceSpec,
+                           uint32_t                       which,
+                           const xcb_xkb_indicator_map_t *maps);
+
+xcb_xkb_indicator_map_t *
+xcb_xkb_set_indicator_map_maps (const xcb_xkb_set_indicator_map_request_t *R);
+
+int
+xcb_xkb_set_indicator_map_maps_length (const xcb_xkb_set_indicator_map_request_t *R);
+
+xcb_xkb_indicator_map_iterator_t
+xcb_xkb_set_indicator_map_maps_iterator (const xcb_xkb_set_indicator_map_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xkb_get_named_indicator_cookie_t
+xcb_xkb_get_named_indicator (xcb_connection_t         *c,
+                             xcb_xkb_device_spec_t     deviceSpec,
+                             xcb_xkb_led_class_spec_t  ledClass,
+                             xcb_xkb_id_spec_t         ledID,
+                             xcb_atom_t                indicator);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xkb_get_named_indicator_cookie_t
+xcb_xkb_get_named_indicator_unchecked (xcb_connection_t         *c,
+                                       xcb_xkb_device_spec_t     deviceSpec,
+                                       xcb_xkb_led_class_spec_t  ledClass,
+                                       xcb_xkb_id_spec_t         ledID,
+                                       xcb_atom_t                indicator);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xkb_get_named_indicator_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xkb_get_named_indicator_reply_t *
+xcb_xkb_get_named_indicator_reply (xcb_connection_t                      *c,
+                                   xcb_xkb_get_named_indicator_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xkb_set_named_indicator_checked (xcb_connection_t         *c,
+                                     xcb_xkb_device_spec_t     deviceSpec,
+                                     xcb_xkb_led_class_spec_t  ledClass,
+                                     xcb_xkb_id_spec_t         ledID,
+                                     xcb_atom_t                indicator,
+                                     uint8_t                   setState,
+                                     uint8_t                   on,
+                                     uint8_t                   setMap,
+                                     uint8_t                   createMap,
+                                     uint8_t                   map_flags,
+                                     uint8_t                   map_whichGroups,
+                                     uint8_t                   map_groups,
+                                     uint8_t                   map_whichMods,
+                                     uint8_t                   map_realMods,
+                                     uint16_t                  map_vmods,
+                                     uint32_t                  map_ctrls);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xkb_set_named_indicator (xcb_connection_t         *c,
+                             xcb_xkb_device_spec_t     deviceSpec,
+                             xcb_xkb_led_class_spec_t  ledClass,
+                             xcb_xkb_id_spec_t         ledID,
+                             xcb_atom_t                indicator,
+                             uint8_t                   setState,
+                             uint8_t                   on,
+                             uint8_t                   setMap,
+                             uint8_t                   createMap,
+                             uint8_t                   map_flags,
+                             uint8_t                   map_whichGroups,
+                             uint8_t                   map_groups,
+                             uint8_t                   map_whichMods,
+                             uint8_t                   map_realMods,
+                             uint16_t                  map_vmods,
+                             uint32_t                  map_ctrls);
+
+xcb_atom_t *
+xcb_xkb_get_names_value_list_type_names (const xcb_xkb_get_names_value_list_t *S);
+
+int
+xcb_xkb_get_names_value_list_type_names_length (const xcb_xkb_get_names_reply_t *R,
+                                                const xcb_xkb_get_names_value_list_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_get_names_value_list_type_names_end (const xcb_xkb_get_names_reply_t *R,
+                                             const xcb_xkb_get_names_value_list_t *S);
+
+uint8_t *
+xcb_xkb_get_names_value_list_n_levels_per_type (const xcb_xkb_get_names_value_list_t *S);
+
+int
+xcb_xkb_get_names_value_list_n_levels_per_type_length (const xcb_xkb_get_names_reply_t *R,
+                                                       const xcb_xkb_get_names_value_list_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_get_names_value_list_n_levels_per_type_end (const xcb_xkb_get_names_reply_t *R,
+                                                    const xcb_xkb_get_names_value_list_t *S);
+
+xcb_atom_t *
+xcb_xkb_get_names_value_list_kt_level_names (const xcb_xkb_get_names_value_list_t *S);
+
+int
+xcb_xkb_get_names_value_list_kt_level_names_length (const xcb_xkb_get_names_reply_t *R,
+                                                    const xcb_xkb_get_names_value_list_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_get_names_value_list_kt_level_names_end (const xcb_xkb_get_names_reply_t *R,
+                                                 const xcb_xkb_get_names_value_list_t *S);
+
+xcb_atom_t *
+xcb_xkb_get_names_value_list_indicator_names (const xcb_xkb_get_names_value_list_t *S);
+
+int
+xcb_xkb_get_names_value_list_indicator_names_length (const xcb_xkb_get_names_reply_t *R,
+                                                     const xcb_xkb_get_names_value_list_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_get_names_value_list_indicator_names_end (const xcb_xkb_get_names_reply_t *R,
+                                                  const xcb_xkb_get_names_value_list_t *S);
+
+xcb_atom_t *
+xcb_xkb_get_names_value_list_virtual_mod_names (const xcb_xkb_get_names_value_list_t *S);
+
+int
+xcb_xkb_get_names_value_list_virtual_mod_names_length (const xcb_xkb_get_names_reply_t *R,
+                                                       const xcb_xkb_get_names_value_list_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_get_names_value_list_virtual_mod_names_end (const xcb_xkb_get_names_reply_t *R,
+                                                    const xcb_xkb_get_names_value_list_t *S);
+
+xcb_atom_t *
+xcb_xkb_get_names_value_list_groups (const xcb_xkb_get_names_value_list_t *S);
+
+int
+xcb_xkb_get_names_value_list_groups_length (const xcb_xkb_get_names_reply_t *R,
+                                            const xcb_xkb_get_names_value_list_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_get_names_value_list_groups_end (const xcb_xkb_get_names_reply_t *R,
+                                         const xcb_xkb_get_names_value_list_t *S);
+
+xcb_xkb_key_name_t *
+xcb_xkb_get_names_value_list_key_names (const xcb_xkb_get_names_value_list_t *S);
+
+int
+xcb_xkb_get_names_value_list_key_names_length (const xcb_xkb_get_names_reply_t *R,
+                                               const xcb_xkb_get_names_value_list_t *S);
+
+xcb_xkb_key_name_iterator_t
+xcb_xkb_get_names_value_list_key_names_iterator (const xcb_xkb_get_names_reply_t *R,
+                                                 const xcb_xkb_get_names_value_list_t *S);
+
+xcb_xkb_key_alias_t *
+xcb_xkb_get_names_value_list_key_aliases (const xcb_xkb_get_names_value_list_t *S);
+
+int
+xcb_xkb_get_names_value_list_key_aliases_length (const xcb_xkb_get_names_reply_t *R,
+                                                 const xcb_xkb_get_names_value_list_t *S);
+
+xcb_xkb_key_alias_iterator_t
+xcb_xkb_get_names_value_list_key_aliases_iterator (const xcb_xkb_get_names_reply_t *R,
+                                                   const xcb_xkb_get_names_value_list_t *S);
+
+xcb_atom_t *
+xcb_xkb_get_names_value_list_radio_group_names (const xcb_xkb_get_names_value_list_t *S);
+
+int
+xcb_xkb_get_names_value_list_radio_group_names_length (const xcb_xkb_get_names_reply_t *R,
+                                                       const xcb_xkb_get_names_value_list_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_get_names_value_list_radio_group_names_end (const xcb_xkb_get_names_reply_t *R,
+                                                    const xcb_xkb_get_names_value_list_t *S);
+
+int
+xcb_xkb_get_names_value_list_serialize (void                                 **_buffer,
+                                        uint8_t                                nTypes,
+                                        uint32_t                               indicators,
+                                        uint16_t                               virtualMods,
+                                        uint8_t                                groupNames,
+                                        uint8_t                                nKeys,
+                                        uint8_t                                nKeyAliases,
+                                        uint8_t                                nRadioGroups,
+                                        uint32_t                               which,
+                                        const xcb_xkb_get_names_value_list_t  *_aux);
+
+int
+xcb_xkb_get_names_value_list_unpack (const void                      *_buffer,
+                                     uint8_t                          nTypes,
+                                     uint32_t                         indicators,
+                                     uint16_t                         virtualMods,
+                                     uint8_t                          groupNames,
+                                     uint8_t                          nKeys,
+                                     uint8_t                          nKeyAliases,
+                                     uint8_t                          nRadioGroups,
+                                     uint32_t                         which,
+                                     xcb_xkb_get_names_value_list_t  *_aux);
+
+int
+xcb_xkb_get_names_value_list_sizeof (const void  *_buffer,
+                                     uint8_t      nTypes,
+                                     uint32_t     indicators,
+                                     uint16_t     virtualMods,
+                                     uint8_t      groupNames,
+                                     uint8_t      nKeys,
+                                     uint8_t      nKeyAliases,
+                                     uint8_t      nRadioGroups,
+                                     uint32_t     which);
+
+int
+xcb_xkb_get_names_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xkb_get_names_cookie_t
+xcb_xkb_get_names (xcb_connection_t      *c,
+                   xcb_xkb_device_spec_t  deviceSpec,
+                   uint32_t               which);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xkb_get_names_cookie_t
+xcb_xkb_get_names_unchecked (xcb_connection_t      *c,
+                             xcb_xkb_device_spec_t  deviceSpec,
+                             uint32_t               which);
+
+void *
+xcb_xkb_get_names_value_list (const xcb_xkb_get_names_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xkb_get_names_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xkb_get_names_reply_t *
+xcb_xkb_get_names_reply (xcb_connection_t            *c,
+                         xcb_xkb_get_names_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e);
+
+xcb_atom_t *
+xcb_xkb_set_names_values_type_names (const xcb_xkb_set_names_values_t *S);
+
+int
+xcb_xkb_set_names_values_type_names_length (const xcb_xkb_set_names_request_t *R,
+                                            const xcb_xkb_set_names_values_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_set_names_values_type_names_end (const xcb_xkb_set_names_request_t *R,
+                                         const xcb_xkb_set_names_values_t *S);
+
+uint8_t *
+xcb_xkb_set_names_values_n_levels_per_type (const xcb_xkb_set_names_values_t *S);
+
+int
+xcb_xkb_set_names_values_n_levels_per_type_length (const xcb_xkb_set_names_request_t *R,
+                                                   const xcb_xkb_set_names_values_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_set_names_values_n_levels_per_type_end (const xcb_xkb_set_names_request_t *R,
+                                                const xcb_xkb_set_names_values_t *S);
+
+xcb_atom_t *
+xcb_xkb_set_names_values_kt_level_names (const xcb_xkb_set_names_values_t *S);
+
+int
+xcb_xkb_set_names_values_kt_level_names_length (const xcb_xkb_set_names_request_t *R,
+                                                const xcb_xkb_set_names_values_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_set_names_values_kt_level_names_end (const xcb_xkb_set_names_request_t *R,
+                                             const xcb_xkb_set_names_values_t *S);
+
+xcb_atom_t *
+xcb_xkb_set_names_values_indicator_names (const xcb_xkb_set_names_values_t *S);
+
+int
+xcb_xkb_set_names_values_indicator_names_length (const xcb_xkb_set_names_request_t *R,
+                                                 const xcb_xkb_set_names_values_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_set_names_values_indicator_names_end (const xcb_xkb_set_names_request_t *R,
+                                              const xcb_xkb_set_names_values_t *S);
+
+xcb_atom_t *
+xcb_xkb_set_names_values_virtual_mod_names (const xcb_xkb_set_names_values_t *S);
+
+int
+xcb_xkb_set_names_values_virtual_mod_names_length (const xcb_xkb_set_names_request_t *R,
+                                                   const xcb_xkb_set_names_values_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_set_names_values_virtual_mod_names_end (const xcb_xkb_set_names_request_t *R,
+                                                const xcb_xkb_set_names_values_t *S);
+
+xcb_atom_t *
+xcb_xkb_set_names_values_groups (const xcb_xkb_set_names_values_t *S);
+
+int
+xcb_xkb_set_names_values_groups_length (const xcb_xkb_set_names_request_t *R,
+                                        const xcb_xkb_set_names_values_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_set_names_values_groups_end (const xcb_xkb_set_names_request_t *R,
+                                     const xcb_xkb_set_names_values_t *S);
+
+xcb_xkb_key_name_t *
+xcb_xkb_set_names_values_key_names (const xcb_xkb_set_names_values_t *S);
+
+int
+xcb_xkb_set_names_values_key_names_length (const xcb_xkb_set_names_request_t *R,
+                                           const xcb_xkb_set_names_values_t *S);
+
+xcb_xkb_key_name_iterator_t
+xcb_xkb_set_names_values_key_names_iterator (const xcb_xkb_set_names_request_t *R,
+                                             const xcb_xkb_set_names_values_t *S);
+
+xcb_xkb_key_alias_t *
+xcb_xkb_set_names_values_key_aliases (const xcb_xkb_set_names_values_t *S);
+
+int
+xcb_xkb_set_names_values_key_aliases_length (const xcb_xkb_set_names_request_t *R,
+                                             const xcb_xkb_set_names_values_t *S);
+
+xcb_xkb_key_alias_iterator_t
+xcb_xkb_set_names_values_key_aliases_iterator (const xcb_xkb_set_names_request_t *R,
+                                               const xcb_xkb_set_names_values_t *S);
+
+xcb_atom_t *
+xcb_xkb_set_names_values_radio_group_names (const xcb_xkb_set_names_values_t *S);
+
+int
+xcb_xkb_set_names_values_radio_group_names_length (const xcb_xkb_set_names_request_t *R,
+                                                   const xcb_xkb_set_names_values_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_set_names_values_radio_group_names_end (const xcb_xkb_set_names_request_t *R,
+                                                const xcb_xkb_set_names_values_t *S);
+
+int
+xcb_xkb_set_names_values_serialize (void                             **_buffer,
+                                    uint8_t                            nTypes,
+                                    uint32_t                           indicators,
+                                    uint16_t                           virtualMods,
+                                    uint8_t                            groupNames,
+                                    uint8_t                            nKeys,
+                                    uint8_t                            nKeyAliases,
+                                    uint8_t                            nRadioGroups,
+                                    uint32_t                           which,
+                                    const xcb_xkb_set_names_values_t  *_aux);
+
+int
+xcb_xkb_set_names_values_unpack (const void                  *_buffer,
+                                 uint8_t                      nTypes,
+                                 uint32_t                     indicators,
+                                 uint16_t                     virtualMods,
+                                 uint8_t                      groupNames,
+                                 uint8_t                      nKeys,
+                                 uint8_t                      nKeyAliases,
+                                 uint8_t                      nRadioGroups,
+                                 uint32_t                     which,
+                                 xcb_xkb_set_names_values_t  *_aux);
+
+int
+xcb_xkb_set_names_values_sizeof (const void  *_buffer,
+                                 uint8_t      nTypes,
+                                 uint32_t     indicators,
+                                 uint16_t     virtualMods,
+                                 uint8_t      groupNames,
+                                 uint8_t      nKeys,
+                                 uint8_t      nKeyAliases,
+                                 uint8_t      nRadioGroups,
+                                 uint32_t     which);
+
+int
+xcb_xkb_set_names_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xkb_set_names_checked (xcb_connection_t      *c,
+                           xcb_xkb_device_spec_t  deviceSpec,
+                           uint16_t               virtualMods,
+                           uint32_t               which,
+                           uint8_t                firstType,
+                           uint8_t                nTypes,
+                           uint8_t                firstKTLevelt,
+                           uint8_t                nKTLevels,
+                           uint32_t               indicators,
+                           uint8_t                groupNames,
+                           uint8_t                nRadioGroups,
+                           xcb_keycode_t          firstKey,
+                           uint8_t                nKeys,
+                           uint8_t                nKeyAliases,
+                           uint16_t               totalKTLevelNames,
+                           const void            *values);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xkb_set_names (xcb_connection_t      *c,
+                   xcb_xkb_device_spec_t  deviceSpec,
+                   uint16_t               virtualMods,
+                   uint32_t               which,
+                   uint8_t                firstType,
+                   uint8_t                nTypes,
+                   uint8_t                firstKTLevelt,
+                   uint8_t                nKTLevels,
+                   uint32_t               indicators,
+                   uint8_t                groupNames,
+                   uint8_t                nRadioGroups,
+                   xcb_keycode_t          firstKey,
+                   uint8_t                nKeys,
+                   uint8_t                nKeyAliases,
+                   uint16_t               totalKTLevelNames,
+                   const void            *values);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xkb_set_names_aux_checked (xcb_connection_t                 *c,
+                               xcb_xkb_device_spec_t             deviceSpec,
+                               uint16_t                          virtualMods,
+                               uint32_t                          which,
+                               uint8_t                           firstType,
+                               uint8_t                           nTypes,
+                               uint8_t                           firstKTLevelt,
+                               uint8_t                           nKTLevels,
+                               uint32_t                          indicators,
+                               uint8_t                           groupNames,
+                               uint8_t                           nRadioGroups,
+                               xcb_keycode_t                     firstKey,
+                               uint8_t                           nKeys,
+                               uint8_t                           nKeyAliases,
+                               uint16_t                          totalKTLevelNames,
+                               const xcb_xkb_set_names_values_t *values);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xkb_set_names_aux (xcb_connection_t                 *c,
+                       xcb_xkb_device_spec_t             deviceSpec,
+                       uint16_t                          virtualMods,
+                       uint32_t                          which,
+                       uint8_t                           firstType,
+                       uint8_t                           nTypes,
+                       uint8_t                           firstKTLevelt,
+                       uint8_t                           nKTLevels,
+                       uint32_t                          indicators,
+                       uint8_t                           groupNames,
+                       uint8_t                           nRadioGroups,
+                       xcb_keycode_t                     firstKey,
+                       uint8_t                           nKeys,
+                       uint8_t                           nKeyAliases,
+                       uint16_t                          totalKTLevelNames,
+                       const xcb_xkb_set_names_values_t *values);
+
+void *
+xcb_xkb_set_names_values (const xcb_xkb_set_names_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xkb_per_client_flags_cookie_t
+xcb_xkb_per_client_flags (xcb_connection_t      *c,
+                          xcb_xkb_device_spec_t  deviceSpec,
+                          uint32_t               change,
+                          uint32_t               value,
+                          uint32_t               ctrlsToChange,
+                          uint32_t               autoCtrls,
+                          uint32_t               autoCtrlsValues);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xkb_per_client_flags_cookie_t
+xcb_xkb_per_client_flags_unchecked (xcb_connection_t      *c,
+                                    xcb_xkb_device_spec_t  deviceSpec,
+                                    uint32_t               change,
+                                    uint32_t               value,
+                                    uint32_t               ctrlsToChange,
+                                    uint32_t               autoCtrls,
+                                    uint32_t               autoCtrlsValues);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xkb_per_client_flags_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xkb_per_client_flags_reply_t *
+xcb_xkb_per_client_flags_reply (xcb_connection_t                   *c,
+                                xcb_xkb_per_client_flags_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e);
+
+int
+xcb_xkb_list_components_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xkb_list_components_cookie_t
+xcb_xkb_list_components (xcb_connection_t      *c,
+                         xcb_xkb_device_spec_t  deviceSpec,
+                         uint16_t               maxNames);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xkb_list_components_cookie_t
+xcb_xkb_list_components_unchecked (xcb_connection_t      *c,
+                                   xcb_xkb_device_spec_t  deviceSpec,
+                                   uint16_t               maxNames);
+
+int
+xcb_xkb_list_components_keymaps_length (const xcb_xkb_list_components_reply_t *R);
+
+xcb_xkb_listing_iterator_t
+xcb_xkb_list_components_keymaps_iterator (const xcb_xkb_list_components_reply_t *R);
+
+int
+xcb_xkb_list_components_keycodes_length (const xcb_xkb_list_components_reply_t *R);
+
+xcb_xkb_listing_iterator_t
+xcb_xkb_list_components_keycodes_iterator (const xcb_xkb_list_components_reply_t *R);
+
+int
+xcb_xkb_list_components_types_length (const xcb_xkb_list_components_reply_t *R);
+
+xcb_xkb_listing_iterator_t
+xcb_xkb_list_components_types_iterator (const xcb_xkb_list_components_reply_t *R);
+
+int
+xcb_xkb_list_components_compat_maps_length (const xcb_xkb_list_components_reply_t *R);
+
+xcb_xkb_listing_iterator_t
+xcb_xkb_list_components_compat_maps_iterator (const xcb_xkb_list_components_reply_t *R);
+
+int
+xcb_xkb_list_components_symbols_length (const xcb_xkb_list_components_reply_t *R);
+
+xcb_xkb_listing_iterator_t
+xcb_xkb_list_components_symbols_iterator (const xcb_xkb_list_components_reply_t *R);
+
+int
+xcb_xkb_list_components_geometries_length (const xcb_xkb_list_components_reply_t *R);
+
+xcb_xkb_listing_iterator_t
+xcb_xkb_list_components_geometries_iterator (const xcb_xkb_list_components_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xkb_list_components_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xkb_list_components_reply_t *
+xcb_xkb_list_components_reply (xcb_connection_t                  *c,
+                               xcb_xkb_list_components_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_types_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                             const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_key_type_iterator_t
+xcb_xkb_get_kbd_by_name_replies_types_map_types_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                               const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_syms_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                            const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_key_sym_map_iterator_t
+xcb_xkb_get_kbd_by_name_replies_types_map_syms_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                              const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+uint8_t *
+xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count (const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                  const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                               const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_action_t *
+xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts (const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                 const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_action_iterator_t
+xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                   const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_set_behavior_t *
+xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                 const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_set_behavior_iterator_t
+xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                   const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+uint8_t *
+xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                             const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                          const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_set_explicit_t *
+xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_set_explicit_iterator_t
+xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                  const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_key_mod_map_t *
+xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                              const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_key_mod_map_iterator_t
+xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_key_v_mod_map_t *
+xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                               const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_key_v_mod_map_iterator_t
+xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                 const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void                                              **_buffer,
+                                                     uint8_t                                             nTypes,
+                                                     uint8_t                                             nKeySyms,
+                                                     uint8_t                                             nKeyActions,
+                                                     uint16_t                                            totalActions,
+                                                     uint8_t                                             totalKeyBehaviors,
+                                                     uint16_t                                            virtualMods,
+                                                     uint8_t                                             totalKeyExplicit,
+                                                     uint8_t                                             totalModMapKeys,
+                                                     uint8_t                                             totalVModMapKeys,
+                                                     uint16_t                                            present,
+                                                     const xcb_xkb_get_kbd_by_name_replies_types_map_t  *_aux);
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_unpack (const void                                   *_buffer,
+                                                  uint8_t                                       nTypes,
+                                                  uint8_t                                       nKeySyms,
+                                                  uint8_t                                       nKeyActions,
+                                                  uint16_t                                      totalActions,
+                                                  uint8_t                                       totalKeyBehaviors,
+                                                  uint16_t                                      virtualMods,
+                                                  uint8_t                                       totalKeyExplicit,
+                                                  uint8_t                                       totalModMapKeys,
+                                                  uint8_t                                       totalVModMapKeys,
+                                                  uint16_t                                      present,
+                                                  xcb_xkb_get_kbd_by_name_replies_types_map_t  *_aux);
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_sizeof (const void  *_buffer,
+                                                  uint8_t      nTypes,
+                                                  uint8_t      nKeySyms,
+                                                  uint8_t      nKeyActions,
+                                                  uint16_t     totalActions,
+                                                  uint8_t      totalKeyBehaviors,
+                                                  uint16_t     virtualMods,
+                                                  uint8_t      totalKeyExplicit,
+                                                  uint8_t      totalModMapKeys,
+                                                  uint8_t      totalVModMapKeys,
+                                                  uint16_t     present);
+
+xcb_atom_t *
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names (const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                        const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                     const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+uint8_t *
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type (const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                               const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                            const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_atom_t *
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names (const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                            const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                         const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_atom_t *
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names (const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                             const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                          const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_atom_t *
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names (const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                               const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                            const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_atom_t *
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups (const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                    const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                 const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_key_name_t *
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names (const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                       const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_key_name_iterator_t
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                         const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_key_alias_t *
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases (const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                         const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_key_alias_iterator_t
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                           const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_atom_t *
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names (const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                               const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_generic_iterator_t
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                            const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void                                                         **_buffer,
+                                                                uint8_t                                                        nTypes,
+                                                                uint32_t                                                       indicators,
+                                                                uint16_t                                                       virtualMods,
+                                                                uint8_t                                                        groupNames,
+                                                                uint8_t                                                        nKeys,
+                                                                uint8_t                                                        nKeyAliases,
+                                                                uint8_t                                                        nRadioGroups,
+                                                                uint32_t                                                       which,
+                                                                const xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t  *_aux);
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack (const void                                              *_buffer,
+                                                             uint8_t                                                  nTypes,
+                                                             uint32_t                                                 indicators,
+                                                             uint16_t                                                 virtualMods,
+                                                             uint8_t                                                  groupNames,
+                                                             uint8_t                                                  nKeys,
+                                                             uint8_t                                                  nKeyAliases,
+                                                             uint8_t                                                  nRadioGroups,
+                                                             uint32_t                                                 which,
+                                                             xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t  *_aux);
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_sizeof (const void  *_buffer,
+                                                             uint8_t      nTypes,
+                                                             uint32_t     indicators,
+                                                             uint16_t     virtualMods,
+                                                             uint8_t      groupNames,
+                                                             uint8_t      nKeys,
+                                                             uint8_t      nKeyAliases,
+                                                             uint8_t      nRadioGroups,
+                                                             uint32_t     which);
+
+xcb_xkb_sym_interpret_t *
+xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                           const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_sym_interpret_iterator_t
+xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                             const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_mod_def_t *
+xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                              const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_mod_def_iterator_t
+xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_indicator_map_t *
+xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps (const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+int
+xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                            const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_indicator_map_iterator_t
+xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                              const xcb_xkb_get_kbd_by_name_replies_t *S);
+
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t *
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list (const xcb_xkb_get_kbd_by_name_replies_t *R);
+
+xcb_xkb_counted_string_16_t *
+xcb_xkb_get_kbd_by_name_replies_geometry_label_font (const xcb_xkb_get_kbd_by_name_replies_t *R);
+
+int
+xcb_xkb_get_kbd_by_name_replies_serialize (void                                    **_buffer,
+                                           uint16_t                                  reported,
+                                           const xcb_xkb_get_kbd_by_name_replies_t  *_aux);
+
+int
+xcb_xkb_get_kbd_by_name_replies_unpack (const void                         *_buffer,
+                                        uint16_t                            reported,
+                                        xcb_xkb_get_kbd_by_name_replies_t  *_aux);
+
+int
+xcb_xkb_get_kbd_by_name_replies_sizeof (const void  *_buffer,
+                                        uint16_t     reported);
+
+int
+xcb_xkb_get_kbd_by_name_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xkb_get_kbd_by_name_cookie_t
+xcb_xkb_get_kbd_by_name (xcb_connection_t      *c,
+                         xcb_xkb_device_spec_t  deviceSpec,
+                         uint16_t               need,
+                         uint16_t               want,
+                         uint8_t                load);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xkb_get_kbd_by_name_cookie_t
+xcb_xkb_get_kbd_by_name_unchecked (xcb_connection_t      *c,
+                                   xcb_xkb_device_spec_t  deviceSpec,
+                                   uint16_t               need,
+                                   uint16_t               want,
+                                   uint8_t                load);
+
+void *
+xcb_xkb_get_kbd_by_name_replies (const xcb_xkb_get_kbd_by_name_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xkb_get_kbd_by_name_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xkb_get_kbd_by_name_reply_t *
+xcb_xkb_get_kbd_by_name_reply (xcb_connection_t                  *c,
+                               xcb_xkb_get_kbd_by_name_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+int
+xcb_xkb_get_device_info_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xkb_get_device_info_cookie_t
+xcb_xkb_get_device_info (xcb_connection_t         *c,
+                         xcb_xkb_device_spec_t     deviceSpec,
+                         uint16_t                  wanted,
+                         uint8_t                   allButtons,
+                         uint8_t                   firstButton,
+                         uint8_t                   nButtons,
+                         xcb_xkb_led_class_spec_t  ledClass,
+                         xcb_xkb_id_spec_t         ledID);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xkb_get_device_info_cookie_t
+xcb_xkb_get_device_info_unchecked (xcb_connection_t         *c,
+                                   xcb_xkb_device_spec_t     deviceSpec,
+                                   uint16_t                  wanted,
+                                   uint8_t                   allButtons,
+                                   uint8_t                   firstButton,
+                                   uint8_t                   nButtons,
+                                   xcb_xkb_led_class_spec_t  ledClass,
+                                   xcb_xkb_id_spec_t         ledID);
+
+xcb_xkb_string8_t *
+xcb_xkb_get_device_info_name (const xcb_xkb_get_device_info_reply_t *R);
+
+int
+xcb_xkb_get_device_info_name_length (const xcb_xkb_get_device_info_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_xkb_get_device_info_name_end (const xcb_xkb_get_device_info_reply_t *R);
+
+xcb_xkb_action_t *
+xcb_xkb_get_device_info_btn_actions (const xcb_xkb_get_device_info_reply_t *R);
+
+int
+xcb_xkb_get_device_info_btn_actions_length (const xcb_xkb_get_device_info_reply_t *R);
+
+xcb_xkb_action_iterator_t
+xcb_xkb_get_device_info_btn_actions_iterator (const xcb_xkb_get_device_info_reply_t *R);
+
+int
+xcb_xkb_get_device_info_leds_length (const xcb_xkb_get_device_info_reply_t *R);
+
+xcb_xkb_device_led_info_iterator_t
+xcb_xkb_get_device_info_leds_iterator (const xcb_xkb_get_device_info_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xkb_get_device_info_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xkb_get_device_info_reply_t *
+xcb_xkb_get_device_info_reply (xcb_connection_t                  *c,
+                               xcb_xkb_get_device_info_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+int
+xcb_xkb_set_device_info_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xkb_set_device_info_checked (xcb_connection_t                *c,
+                                 xcb_xkb_device_spec_t            deviceSpec,
+                                 uint8_t                          firstBtn,
+                                 uint8_t                          nBtns,
+                                 uint16_t                         change,
+                                 uint16_t                         nDeviceLedFBs,
+                                 const xcb_xkb_action_t          *btnActions,
+                                 const xcb_xkb_device_led_info_t *leds);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xkb_set_device_info (xcb_connection_t                *c,
+                         xcb_xkb_device_spec_t            deviceSpec,
+                         uint8_t                          firstBtn,
+                         uint8_t                          nBtns,
+                         uint16_t                         change,
+                         uint16_t                         nDeviceLedFBs,
+                         const xcb_xkb_action_t          *btnActions,
+                         const xcb_xkb_device_led_info_t *leds);
+
+xcb_xkb_action_t *
+xcb_xkb_set_device_info_btn_actions (const xcb_xkb_set_device_info_request_t *R);
+
+int
+xcb_xkb_set_device_info_btn_actions_length (const xcb_xkb_set_device_info_request_t *R);
+
+xcb_xkb_action_iterator_t
+xcb_xkb_set_device_info_btn_actions_iterator (const xcb_xkb_set_device_info_request_t *R);
+
+int
+xcb_xkb_set_device_info_leds_length (const xcb_xkb_set_device_info_request_t *R);
+
+xcb_xkb_device_led_info_iterator_t
+xcb_xkb_set_device_info_leds_iterator (const xcb_xkb_set_device_info_request_t *R);
+
+int
+xcb_xkb_set_debugging_flags_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xkb_set_debugging_flags_cookie_t
+xcb_xkb_set_debugging_flags (xcb_connection_t        *c,
+                             uint16_t                 msgLength,
+                             uint32_t                 affectFlags,
+                             uint32_t                 flags,
+                             uint32_t                 affectCtrls,
+                             uint32_t                 ctrls,
+                             const xcb_xkb_string8_t *message);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xkb_set_debugging_flags_cookie_t
+xcb_xkb_set_debugging_flags_unchecked (xcb_connection_t        *c,
+                                       uint16_t                 msgLength,
+                                       uint32_t                 affectFlags,
+                                       uint32_t                 flags,
+                                       uint32_t                 affectCtrls,
+                                       uint32_t                 ctrls,
+                                       const xcb_xkb_string8_t *message);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xkb_set_debugging_flags_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xkb_set_debugging_flags_reply_t *
+xcb_xkb_set_debugging_flags_reply (xcb_connection_t                      *c,
+                                   xcb_xkb_set_debugging_flags_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/xprint.h b/depends/libxcb/include/xcb/xprint.h
new file mode 100644
index 0000000..0825bbc
--- /dev/null
+++ b/depends/libxcb/include/xcb/xprint.h
@@ -0,0 +1,1895 @@
+/*
+ * This file generated automatically from xprint.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_XPrint_API XCB XPrint API
+ * @brief XPrint XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __XPRINT_H
+#define __XPRINT_H
+
+#include "xcb.h"
+#include "xproto.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_XPRINT_MAJOR_VERSION 1
+#define XCB_XPRINT_MINOR_VERSION 0
+
+extern xcb_extension_t xcb_x_print_id;
+
+typedef char xcb_x_print_string8_t;
+
+/**
+ * @brief xcb_x_print_string8_iterator_t
+ **/
+typedef struct xcb_x_print_string8_iterator_t {
+    xcb_x_print_string8_t *data;
+    int                    rem;
+    int                    index;
+} xcb_x_print_string8_iterator_t;
+
+/**
+ * @brief xcb_x_print_printer_t
+ **/
+typedef struct xcb_x_print_printer_t {
+    uint32_t nameLen;
+    uint32_t descLen;
+} xcb_x_print_printer_t;
+
+/**
+ * @brief xcb_x_print_printer_iterator_t
+ **/
+typedef struct xcb_x_print_printer_iterator_t {
+    xcb_x_print_printer_t *data;
+    int                    rem;
+    int                    index;
+} xcb_x_print_printer_iterator_t;
+
+typedef uint32_t xcb_x_print_pcontext_t;
+
+/**
+ * @brief xcb_x_print_pcontext_iterator_t
+ **/
+typedef struct xcb_x_print_pcontext_iterator_t {
+    xcb_x_print_pcontext_t *data;
+    int                     rem;
+    int                     index;
+} xcb_x_print_pcontext_iterator_t;
+
+typedef enum xcb_x_print_get_doc_t {
+    XCB_X_PRINT_GET_DOC_FINISHED = 0,
+    XCB_X_PRINT_GET_DOC_SECOND_CONSUMER = 1
+} xcb_x_print_get_doc_t;
+
+typedef enum xcb_x_print_ev_mask_t {
+    XCB_X_PRINT_EV_MASK_NO_EVENT_MASK = 0,
+    XCB_X_PRINT_EV_MASK_PRINT_MASK = 1,
+    XCB_X_PRINT_EV_MASK_ATTRIBUTE_MASK = 2
+} xcb_x_print_ev_mask_t;
+
+typedef enum xcb_x_print_detail_t {
+    XCB_X_PRINT_DETAIL_START_JOB_NOTIFY = 1,
+    XCB_X_PRINT_DETAIL_END_JOB_NOTIFY = 2,
+    XCB_X_PRINT_DETAIL_START_DOC_NOTIFY = 3,
+    XCB_X_PRINT_DETAIL_END_DOC_NOTIFY = 4,
+    XCB_X_PRINT_DETAIL_START_PAGE_NOTIFY = 5,
+    XCB_X_PRINT_DETAIL_END_PAGE_NOTIFY = 6
+} xcb_x_print_detail_t;
+
+typedef enum xcb_x_print_attr_t {
+    XCB_X_PRINT_ATTR_JOB_ATTR = 1,
+    XCB_X_PRINT_ATTR_DOC_ATTR = 2,
+    XCB_X_PRINT_ATTR_PAGE_ATTR = 3,
+    XCB_X_PRINT_ATTR_PRINTER_ATTR = 4,
+    XCB_X_PRINT_ATTR_SERVER_ATTR = 5,
+    XCB_X_PRINT_ATTR_MEDIUM_ATTR = 6,
+    XCB_X_PRINT_ATTR_SPOOLER_ATTR = 7
+} xcb_x_print_attr_t;
+
+/**
+ * @brief xcb_x_print_print_query_version_cookie_t
+ **/
+typedef struct xcb_x_print_print_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_x_print_print_query_version_cookie_t;
+
+/** Opcode for xcb_x_print_print_query_version. */
+#define XCB_X_PRINT_PRINT_QUERY_VERSION 0
+
+/**
+ * @brief xcb_x_print_print_query_version_request_t
+ **/
+typedef struct xcb_x_print_print_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_x_print_print_query_version_request_t;
+
+/**
+ * @brief xcb_x_print_print_query_version_reply_t
+ **/
+typedef struct xcb_x_print_print_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t major_version;
+    uint16_t minor_version;
+} xcb_x_print_print_query_version_reply_t;
+
+/**
+ * @brief xcb_x_print_print_get_printer_list_cookie_t
+ **/
+typedef struct xcb_x_print_print_get_printer_list_cookie_t {
+    unsigned int sequence;
+} xcb_x_print_print_get_printer_list_cookie_t;
+
+/** Opcode for xcb_x_print_print_get_printer_list. */
+#define XCB_X_PRINT_PRINT_GET_PRINTER_LIST 1
+
+/**
+ * @brief xcb_x_print_print_get_printer_list_request_t
+ **/
+typedef struct xcb_x_print_print_get_printer_list_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t printerNameLen;
+    uint32_t localeLen;
+} xcb_x_print_print_get_printer_list_request_t;
+
+/**
+ * @brief xcb_x_print_print_get_printer_list_reply_t
+ **/
+typedef struct xcb_x_print_print_get_printer_list_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t listCount;
+    uint8_t  pad1[20];
+} xcb_x_print_print_get_printer_list_reply_t;
+
+/** Opcode for xcb_x_print_print_rehash_printer_list. */
+#define XCB_X_PRINT_PRINT_REHASH_PRINTER_LIST 20
+
+/**
+ * @brief xcb_x_print_print_rehash_printer_list_request_t
+ **/
+typedef struct xcb_x_print_print_rehash_printer_list_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_x_print_print_rehash_printer_list_request_t;
+
+/** Opcode for xcb_x_print_create_context. */
+#define XCB_X_PRINT_CREATE_CONTEXT 2
+
+/**
+ * @brief xcb_x_print_create_context_request_t
+ **/
+typedef struct xcb_x_print_create_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t context_id;
+    uint32_t printerNameLen;
+    uint32_t localeLen;
+} xcb_x_print_create_context_request_t;
+
+/** Opcode for xcb_x_print_print_set_context. */
+#define XCB_X_PRINT_PRINT_SET_CONTEXT 3
+
+/**
+ * @brief xcb_x_print_print_set_context_request_t
+ **/
+typedef struct xcb_x_print_print_set_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t context;
+} xcb_x_print_print_set_context_request_t;
+
+/**
+ * @brief xcb_x_print_print_get_context_cookie_t
+ **/
+typedef struct xcb_x_print_print_get_context_cookie_t {
+    unsigned int sequence;
+} xcb_x_print_print_get_context_cookie_t;
+
+/** Opcode for xcb_x_print_print_get_context. */
+#define XCB_X_PRINT_PRINT_GET_CONTEXT 4
+
+/**
+ * @brief xcb_x_print_print_get_context_request_t
+ **/
+typedef struct xcb_x_print_print_get_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_x_print_print_get_context_request_t;
+
+/**
+ * @brief xcb_x_print_print_get_context_reply_t
+ **/
+typedef struct xcb_x_print_print_get_context_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t context;
+} xcb_x_print_print_get_context_reply_t;
+
+/** Opcode for xcb_x_print_print_destroy_context. */
+#define XCB_X_PRINT_PRINT_DESTROY_CONTEXT 5
+
+/**
+ * @brief xcb_x_print_print_destroy_context_request_t
+ **/
+typedef struct xcb_x_print_print_destroy_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t context;
+} xcb_x_print_print_destroy_context_request_t;
+
+/**
+ * @brief xcb_x_print_print_get_screen_of_context_cookie_t
+ **/
+typedef struct xcb_x_print_print_get_screen_of_context_cookie_t {
+    unsigned int sequence;
+} xcb_x_print_print_get_screen_of_context_cookie_t;
+
+/** Opcode for xcb_x_print_print_get_screen_of_context. */
+#define XCB_X_PRINT_PRINT_GET_SCREEN_OF_CONTEXT 6
+
+/**
+ * @brief xcb_x_print_print_get_screen_of_context_request_t
+ **/
+typedef struct xcb_x_print_print_get_screen_of_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_x_print_print_get_screen_of_context_request_t;
+
+/**
+ * @brief xcb_x_print_print_get_screen_of_context_reply_t
+ **/
+typedef struct xcb_x_print_print_get_screen_of_context_reply_t {
+    uint8_t      response_type;
+    uint8_t      pad0;
+    uint16_t     sequence;
+    uint32_t     length;
+    xcb_window_t root;
+} xcb_x_print_print_get_screen_of_context_reply_t;
+
+/** Opcode for xcb_x_print_print_start_job. */
+#define XCB_X_PRINT_PRINT_START_JOB 7
+
+/**
+ * @brief xcb_x_print_print_start_job_request_t
+ **/
+typedef struct xcb_x_print_print_start_job_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  output_mode;
+} xcb_x_print_print_start_job_request_t;
+
+/** Opcode for xcb_x_print_print_end_job. */
+#define XCB_X_PRINT_PRINT_END_JOB 8
+
+/**
+ * @brief xcb_x_print_print_end_job_request_t
+ **/
+typedef struct xcb_x_print_print_end_job_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  cancel;
+} xcb_x_print_print_end_job_request_t;
+
+/** Opcode for xcb_x_print_print_start_doc. */
+#define XCB_X_PRINT_PRINT_START_DOC 9
+
+/**
+ * @brief xcb_x_print_print_start_doc_request_t
+ **/
+typedef struct xcb_x_print_print_start_doc_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  driver_mode;
+} xcb_x_print_print_start_doc_request_t;
+
+/** Opcode for xcb_x_print_print_end_doc. */
+#define XCB_X_PRINT_PRINT_END_DOC 10
+
+/**
+ * @brief xcb_x_print_print_end_doc_request_t
+ **/
+typedef struct xcb_x_print_print_end_doc_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  cancel;
+} xcb_x_print_print_end_doc_request_t;
+
+/** Opcode for xcb_x_print_print_put_document_data. */
+#define XCB_X_PRINT_PRINT_PUT_DOCUMENT_DATA 11
+
+/**
+ * @brief xcb_x_print_print_put_document_data_request_t
+ **/
+typedef struct xcb_x_print_print_put_document_data_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    uint32_t       len_data;
+    uint16_t       len_fmt;
+    uint16_t       len_options;
+} xcb_x_print_print_put_document_data_request_t;
+
+/**
+ * @brief xcb_x_print_print_get_document_data_cookie_t
+ **/
+typedef struct xcb_x_print_print_get_document_data_cookie_t {
+    unsigned int sequence;
+} xcb_x_print_print_get_document_data_cookie_t;
+
+/** Opcode for xcb_x_print_print_get_document_data. */
+#define XCB_X_PRINT_PRINT_GET_DOCUMENT_DATA 12
+
+/**
+ * @brief xcb_x_print_print_get_document_data_request_t
+ **/
+typedef struct xcb_x_print_print_get_document_data_request_t {
+    uint8_t                major_opcode;
+    uint8_t                minor_opcode;
+    uint16_t               length;
+    xcb_x_print_pcontext_t context;
+    uint32_t               max_bytes;
+} xcb_x_print_print_get_document_data_request_t;
+
+/**
+ * @brief xcb_x_print_print_get_document_data_reply_t
+ **/
+typedef struct xcb_x_print_print_get_document_data_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t status_code;
+    uint32_t finished_flag;
+    uint32_t dataLen;
+    uint8_t  pad1[12];
+} xcb_x_print_print_get_document_data_reply_t;
+
+/** Opcode for xcb_x_print_print_start_page. */
+#define XCB_X_PRINT_PRINT_START_PAGE 13
+
+/**
+ * @brief xcb_x_print_print_start_page_request_t
+ **/
+typedef struct xcb_x_print_print_start_page_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_x_print_print_start_page_request_t;
+
+/** Opcode for xcb_x_print_print_end_page. */
+#define XCB_X_PRINT_PRINT_END_PAGE 14
+
+/**
+ * @brief xcb_x_print_print_end_page_request_t
+ **/
+typedef struct xcb_x_print_print_end_page_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  cancel;
+    uint8_t  pad0[3];
+} xcb_x_print_print_end_page_request_t;
+
+/** Opcode for xcb_x_print_print_select_input. */
+#define XCB_X_PRINT_PRINT_SELECT_INPUT 15
+
+/**
+ * @brief xcb_x_print_print_select_input_request_t
+ **/
+typedef struct xcb_x_print_print_select_input_request_t {
+    uint8_t                major_opcode;
+    uint8_t                minor_opcode;
+    uint16_t               length;
+    xcb_x_print_pcontext_t context;
+    uint32_t               event_mask;
+} xcb_x_print_print_select_input_request_t;
+
+/**
+ * @brief xcb_x_print_print_input_selected_cookie_t
+ **/
+typedef struct xcb_x_print_print_input_selected_cookie_t {
+    unsigned int sequence;
+} xcb_x_print_print_input_selected_cookie_t;
+
+/** Opcode for xcb_x_print_print_input_selected. */
+#define XCB_X_PRINT_PRINT_INPUT_SELECTED 16
+
+/**
+ * @brief xcb_x_print_print_input_selected_request_t
+ **/
+typedef struct xcb_x_print_print_input_selected_request_t {
+    uint8_t                major_opcode;
+    uint8_t                minor_opcode;
+    uint16_t               length;
+    xcb_x_print_pcontext_t context;
+} xcb_x_print_print_input_selected_request_t;
+
+/**
+ * @brief xcb_x_print_print_input_selected_reply_t
+ **/
+typedef struct xcb_x_print_print_input_selected_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t event_mask;
+    uint32_t all_events_mask;
+} xcb_x_print_print_input_selected_reply_t;
+
+/**
+ * @brief xcb_x_print_print_get_attributes_cookie_t
+ **/
+typedef struct xcb_x_print_print_get_attributes_cookie_t {
+    unsigned int sequence;
+} xcb_x_print_print_get_attributes_cookie_t;
+
+/** Opcode for xcb_x_print_print_get_attributes. */
+#define XCB_X_PRINT_PRINT_GET_ATTRIBUTES 17
+
+/**
+ * @brief xcb_x_print_print_get_attributes_request_t
+ **/
+typedef struct xcb_x_print_print_get_attributes_request_t {
+    uint8_t                major_opcode;
+    uint8_t                minor_opcode;
+    uint16_t               length;
+    xcb_x_print_pcontext_t context;
+    uint8_t                pool;
+    uint8_t                pad0[3];
+} xcb_x_print_print_get_attributes_request_t;
+
+/**
+ * @brief xcb_x_print_print_get_attributes_reply_t
+ **/
+typedef struct xcb_x_print_print_get_attributes_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t stringLen;
+    uint8_t  pad1[20];
+} xcb_x_print_print_get_attributes_reply_t;
+
+/**
+ * @brief xcb_x_print_print_get_one_attributes_cookie_t
+ **/
+typedef struct xcb_x_print_print_get_one_attributes_cookie_t {
+    unsigned int sequence;
+} xcb_x_print_print_get_one_attributes_cookie_t;
+
+/** Opcode for xcb_x_print_print_get_one_attributes. */
+#define XCB_X_PRINT_PRINT_GET_ONE_ATTRIBUTES 19
+
+/**
+ * @brief xcb_x_print_print_get_one_attributes_request_t
+ **/
+typedef struct xcb_x_print_print_get_one_attributes_request_t {
+    uint8_t                major_opcode;
+    uint8_t                minor_opcode;
+    uint16_t               length;
+    xcb_x_print_pcontext_t context;
+    uint32_t               nameLen;
+    uint8_t                pool;
+    uint8_t                pad0[3];
+} xcb_x_print_print_get_one_attributes_request_t;
+
+/**
+ * @brief xcb_x_print_print_get_one_attributes_reply_t
+ **/
+typedef struct xcb_x_print_print_get_one_attributes_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t valueLen;
+    uint8_t  pad1[20];
+} xcb_x_print_print_get_one_attributes_reply_t;
+
+/** Opcode for xcb_x_print_print_set_attributes. */
+#define XCB_X_PRINT_PRINT_SET_ATTRIBUTES 18
+
+/**
+ * @brief xcb_x_print_print_set_attributes_request_t
+ **/
+typedef struct xcb_x_print_print_set_attributes_request_t {
+    uint8_t                major_opcode;
+    uint8_t                minor_opcode;
+    uint16_t               length;
+    xcb_x_print_pcontext_t context;
+    uint32_t               stringLen;
+    uint8_t                pool;
+    uint8_t                rule;
+    uint8_t                pad0[2];
+} xcb_x_print_print_set_attributes_request_t;
+
+/**
+ * @brief xcb_x_print_print_get_page_dimensions_cookie_t
+ **/
+typedef struct xcb_x_print_print_get_page_dimensions_cookie_t {
+    unsigned int sequence;
+} xcb_x_print_print_get_page_dimensions_cookie_t;
+
+/** Opcode for xcb_x_print_print_get_page_dimensions. */
+#define XCB_X_PRINT_PRINT_GET_PAGE_DIMENSIONS 21
+
+/**
+ * @brief xcb_x_print_print_get_page_dimensions_request_t
+ **/
+typedef struct xcb_x_print_print_get_page_dimensions_request_t {
+    uint8_t                major_opcode;
+    uint8_t                minor_opcode;
+    uint16_t               length;
+    xcb_x_print_pcontext_t context;
+} xcb_x_print_print_get_page_dimensions_request_t;
+
+/**
+ * @brief xcb_x_print_print_get_page_dimensions_reply_t
+ **/
+typedef struct xcb_x_print_print_get_page_dimensions_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t width;
+    uint16_t height;
+    uint16_t offset_x;
+    uint16_t offset_y;
+    uint16_t reproducible_width;
+    uint16_t reproducible_height;
+} xcb_x_print_print_get_page_dimensions_reply_t;
+
+/**
+ * @brief xcb_x_print_print_query_screens_cookie_t
+ **/
+typedef struct xcb_x_print_print_query_screens_cookie_t {
+    unsigned int sequence;
+} xcb_x_print_print_query_screens_cookie_t;
+
+/** Opcode for xcb_x_print_print_query_screens. */
+#define XCB_X_PRINT_PRINT_QUERY_SCREENS 22
+
+/**
+ * @brief xcb_x_print_print_query_screens_request_t
+ **/
+typedef struct xcb_x_print_print_query_screens_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_x_print_print_query_screens_request_t;
+
+/**
+ * @brief xcb_x_print_print_query_screens_reply_t
+ **/
+typedef struct xcb_x_print_print_query_screens_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t listCount;
+    uint8_t  pad1[20];
+} xcb_x_print_print_query_screens_reply_t;
+
+/**
+ * @brief xcb_x_print_print_set_image_resolution_cookie_t
+ **/
+typedef struct xcb_x_print_print_set_image_resolution_cookie_t {
+    unsigned int sequence;
+} xcb_x_print_print_set_image_resolution_cookie_t;
+
+/** Opcode for xcb_x_print_print_set_image_resolution. */
+#define XCB_X_PRINT_PRINT_SET_IMAGE_RESOLUTION 23
+
+/**
+ * @brief xcb_x_print_print_set_image_resolution_request_t
+ **/
+typedef struct xcb_x_print_print_set_image_resolution_request_t {
+    uint8_t                major_opcode;
+    uint8_t                minor_opcode;
+    uint16_t               length;
+    xcb_x_print_pcontext_t context;
+    uint16_t               image_resolution;
+} xcb_x_print_print_set_image_resolution_request_t;
+
+/**
+ * @brief xcb_x_print_print_set_image_resolution_reply_t
+ **/
+typedef struct xcb_x_print_print_set_image_resolution_reply_t {
+    uint8_t  response_type;
+    uint8_t  status;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t previous_resolutions;
+} xcb_x_print_print_set_image_resolution_reply_t;
+
+/**
+ * @brief xcb_x_print_print_get_image_resolution_cookie_t
+ **/
+typedef struct xcb_x_print_print_get_image_resolution_cookie_t {
+    unsigned int sequence;
+} xcb_x_print_print_get_image_resolution_cookie_t;
+
+/** Opcode for xcb_x_print_print_get_image_resolution. */
+#define XCB_X_PRINT_PRINT_GET_IMAGE_RESOLUTION 24
+
+/**
+ * @brief xcb_x_print_print_get_image_resolution_request_t
+ **/
+typedef struct xcb_x_print_print_get_image_resolution_request_t {
+    uint8_t                major_opcode;
+    uint8_t                minor_opcode;
+    uint16_t               length;
+    xcb_x_print_pcontext_t context;
+} xcb_x_print_print_get_image_resolution_request_t;
+
+/**
+ * @brief xcb_x_print_print_get_image_resolution_reply_t
+ **/
+typedef struct xcb_x_print_print_get_image_resolution_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t image_resolution;
+} xcb_x_print_print_get_image_resolution_reply_t;
+
+/** Opcode for xcb_x_print_notify. */
+#define XCB_X_PRINT_NOTIFY 0
+
+/**
+ * @brief xcb_x_print_notify_event_t
+ **/
+typedef struct xcb_x_print_notify_event_t {
+    uint8_t                response_type;
+    uint8_t                detail;
+    uint16_t               sequence;
+    xcb_x_print_pcontext_t context;
+    uint8_t                cancel;
+} xcb_x_print_notify_event_t;
+
+/** Opcode for xcb_x_print_attribut_notify. */
+#define XCB_X_PRINT_ATTRIBUT_NOTIFY 1
+
+/**
+ * @brief xcb_x_print_attribut_notify_event_t
+ **/
+typedef struct xcb_x_print_attribut_notify_event_t {
+    uint8_t                response_type;
+    uint8_t                detail;
+    uint16_t               sequence;
+    xcb_x_print_pcontext_t context;
+} xcb_x_print_attribut_notify_event_t;
+
+/** Opcode for xcb_x_print_bad_context. */
+#define XCB_X_PRINT_BAD_CONTEXT 0
+
+/**
+ * @brief xcb_x_print_bad_context_error_t
+ **/
+typedef struct xcb_x_print_bad_context_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_x_print_bad_context_error_t;
+
+/** Opcode for xcb_x_print_bad_sequence. */
+#define XCB_X_PRINT_BAD_SEQUENCE 1
+
+/**
+ * @brief xcb_x_print_bad_sequence_error_t
+ **/
+typedef struct xcb_x_print_bad_sequence_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_x_print_bad_sequence_error_t;
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_x_print_string8_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_x_print_string8_t)
+ */
+void
+xcb_x_print_string8_next (xcb_x_print_string8_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_x_print_string8_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_x_print_string8_end (xcb_x_print_string8_iterator_t i);
+
+int
+xcb_x_print_printer_serialize (void                        **_buffer,
+                               const xcb_x_print_printer_t  *_aux,
+                               const xcb_x_print_string8_t  *name,
+                               const xcb_x_print_string8_t  *description);
+
+int
+xcb_x_print_printer_unserialize (const void              *_buffer,
+                                 xcb_x_print_printer_t  **_aux);
+
+int
+xcb_x_print_printer_sizeof (const void  *_buffer);
+
+xcb_x_print_string8_t *
+xcb_x_print_printer_name (const xcb_x_print_printer_t *R);
+
+int
+xcb_x_print_printer_name_length (const xcb_x_print_printer_t *R);
+
+xcb_generic_iterator_t
+xcb_x_print_printer_name_end (const xcb_x_print_printer_t *R);
+
+xcb_x_print_string8_t *
+xcb_x_print_printer_description (const xcb_x_print_printer_t *R);
+
+int
+xcb_x_print_printer_description_length (const xcb_x_print_printer_t *R);
+
+xcb_generic_iterator_t
+xcb_x_print_printer_description_end (const xcb_x_print_printer_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_x_print_printer_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_x_print_printer_t)
+ */
+void
+xcb_x_print_printer_next (xcb_x_print_printer_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_x_print_printer_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_x_print_printer_end (xcb_x_print_printer_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_x_print_pcontext_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_x_print_pcontext_t)
+ */
+void
+xcb_x_print_pcontext_next (xcb_x_print_pcontext_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_x_print_pcontext_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_x_print_pcontext_end (xcb_x_print_pcontext_iterator_t i);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_x_print_print_query_version_cookie_t
+xcb_x_print_print_query_version (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_x_print_print_query_version_cookie_t
+xcb_x_print_print_query_version_unchecked (xcb_connection_t *c);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_x_print_print_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_x_print_print_query_version_reply_t *
+xcb_x_print_print_query_version_reply (xcb_connection_t                          *c,
+                                       xcb_x_print_print_query_version_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e);
+
+int
+xcb_x_print_print_get_printer_list_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_x_print_print_get_printer_list_cookie_t
+xcb_x_print_print_get_printer_list (xcb_connection_t            *c,
+                                    uint32_t                     printerNameLen,
+                                    uint32_t                     localeLen,
+                                    const xcb_x_print_string8_t *printer_name,
+                                    const xcb_x_print_string8_t *locale);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_x_print_print_get_printer_list_cookie_t
+xcb_x_print_print_get_printer_list_unchecked (xcb_connection_t            *c,
+                                              uint32_t                     printerNameLen,
+                                              uint32_t                     localeLen,
+                                              const xcb_x_print_string8_t *printer_name,
+                                              const xcb_x_print_string8_t *locale);
+
+int
+xcb_x_print_print_get_printer_list_printers_length (const xcb_x_print_print_get_printer_list_reply_t *R);
+
+xcb_x_print_printer_iterator_t
+xcb_x_print_print_get_printer_list_printers_iterator (const xcb_x_print_print_get_printer_list_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_x_print_print_get_printer_list_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_x_print_print_get_printer_list_reply_t *
+xcb_x_print_print_get_printer_list_reply (xcb_connection_t                             *c,
+                                          xcb_x_print_print_get_printer_list_cookie_t   cookie  /**< */,
+                                          xcb_generic_error_t                         **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_x_print_print_rehash_printer_list_checked (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_x_print_print_rehash_printer_list (xcb_connection_t *c);
+
+int
+xcb_x_print_create_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_x_print_create_context_checked (xcb_connection_t            *c,
+                                    uint32_t                     context_id,
+                                    uint32_t                     printerNameLen,
+                                    uint32_t                     localeLen,
+                                    const xcb_x_print_string8_t *printerName,
+                                    const xcb_x_print_string8_t *locale);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_x_print_create_context (xcb_connection_t            *c,
+                            uint32_t                     context_id,
+                            uint32_t                     printerNameLen,
+                            uint32_t                     localeLen,
+                            const xcb_x_print_string8_t *printerName,
+                            const xcb_x_print_string8_t *locale);
+
+xcb_x_print_string8_t *
+xcb_x_print_create_context_printer_name (const xcb_x_print_create_context_request_t *R);
+
+int
+xcb_x_print_create_context_printer_name_length (const xcb_x_print_create_context_request_t *R);
+
+xcb_generic_iterator_t
+xcb_x_print_create_context_printer_name_end (const xcb_x_print_create_context_request_t *R);
+
+xcb_x_print_string8_t *
+xcb_x_print_create_context_locale (const xcb_x_print_create_context_request_t *R);
+
+int
+xcb_x_print_create_context_locale_length (const xcb_x_print_create_context_request_t *R);
+
+xcb_generic_iterator_t
+xcb_x_print_create_context_locale_end (const xcb_x_print_create_context_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_x_print_print_set_context_checked (xcb_connection_t *c,
+                                       uint32_t          context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_x_print_print_set_context (xcb_connection_t *c,
+                               uint32_t          context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_x_print_print_get_context_cookie_t
+xcb_x_print_print_get_context (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_x_print_print_get_context_cookie_t
+xcb_x_print_print_get_context_unchecked (xcb_connection_t *c);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_x_print_print_get_context_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_x_print_print_get_context_reply_t *
+xcb_x_print_print_get_context_reply (xcb_connection_t                        *c,
+                                     xcb_x_print_print_get_context_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_x_print_print_destroy_context_checked (xcb_connection_t *c,
+                                           uint32_t          context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_x_print_print_destroy_context (xcb_connection_t *c,
+                                   uint32_t          context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_x_print_print_get_screen_of_context_cookie_t
+xcb_x_print_print_get_screen_of_context (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_x_print_print_get_screen_of_context_cookie_t
+xcb_x_print_print_get_screen_of_context_unchecked (xcb_connection_t *c);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_x_print_print_get_screen_of_context_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_x_print_print_get_screen_of_context_reply_t *
+xcb_x_print_print_get_screen_of_context_reply (xcb_connection_t                                  *c,
+                                               xcb_x_print_print_get_screen_of_context_cookie_t   cookie  /**< */,
+                                               xcb_generic_error_t                              **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_x_print_print_start_job_checked (xcb_connection_t *c,
+                                     uint8_t           output_mode);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_x_print_print_start_job (xcb_connection_t *c,
+                             uint8_t           output_mode);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_x_print_print_end_job_checked (xcb_connection_t *c,
+                                   uint8_t           cancel);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_x_print_print_end_job (xcb_connection_t *c,
+                           uint8_t           cancel);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_x_print_print_start_doc_checked (xcb_connection_t *c,
+                                     uint8_t           driver_mode);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_x_print_print_start_doc (xcb_connection_t *c,
+                             uint8_t           driver_mode);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_x_print_print_end_doc_checked (xcb_connection_t *c,
+                                   uint8_t           cancel);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_x_print_print_end_doc (xcb_connection_t *c,
+                           uint8_t           cancel);
+
+int
+xcb_x_print_print_put_document_data_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_x_print_print_put_document_data_checked (xcb_connection_t            *c,
+                                             xcb_drawable_t               drawable,
+                                             uint32_t                     len_data,
+                                             uint16_t                     len_fmt,
+                                             uint16_t                     len_options,
+                                             const uint8_t               *data,
+                                             const xcb_x_print_string8_t *doc_format,
+                                             const xcb_x_print_string8_t *options);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_x_print_print_put_document_data (xcb_connection_t            *c,
+                                     xcb_drawable_t               drawable,
+                                     uint32_t                     len_data,
+                                     uint16_t                     len_fmt,
+                                     uint16_t                     len_options,
+                                     const uint8_t               *data,
+                                     const xcb_x_print_string8_t *doc_format,
+                                     const xcb_x_print_string8_t *options);
+
+uint8_t *
+xcb_x_print_print_put_document_data_data (const xcb_x_print_print_put_document_data_request_t *R);
+
+int
+xcb_x_print_print_put_document_data_data_length (const xcb_x_print_print_put_document_data_request_t *R);
+
+xcb_generic_iterator_t
+xcb_x_print_print_put_document_data_data_end (const xcb_x_print_print_put_document_data_request_t *R);
+
+xcb_x_print_string8_t *
+xcb_x_print_print_put_document_data_doc_format (const xcb_x_print_print_put_document_data_request_t *R);
+
+int
+xcb_x_print_print_put_document_data_doc_format_length (const xcb_x_print_print_put_document_data_request_t *R);
+
+xcb_generic_iterator_t
+xcb_x_print_print_put_document_data_doc_format_end (const xcb_x_print_print_put_document_data_request_t *R);
+
+xcb_x_print_string8_t *
+xcb_x_print_print_put_document_data_options (const xcb_x_print_print_put_document_data_request_t *R);
+
+int
+xcb_x_print_print_put_document_data_options_length (const xcb_x_print_print_put_document_data_request_t *R);
+
+xcb_generic_iterator_t
+xcb_x_print_print_put_document_data_options_end (const xcb_x_print_print_put_document_data_request_t *R);
+
+int
+xcb_x_print_print_get_document_data_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_x_print_print_get_document_data_cookie_t
+xcb_x_print_print_get_document_data (xcb_connection_t       *c,
+                                     xcb_x_print_pcontext_t  context,
+                                     uint32_t                max_bytes);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_x_print_print_get_document_data_cookie_t
+xcb_x_print_print_get_document_data_unchecked (xcb_connection_t       *c,
+                                               xcb_x_print_pcontext_t  context,
+                                               uint32_t                max_bytes);
+
+uint8_t *
+xcb_x_print_print_get_document_data_data (const xcb_x_print_print_get_document_data_reply_t *R);
+
+int
+xcb_x_print_print_get_document_data_data_length (const xcb_x_print_print_get_document_data_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_x_print_print_get_document_data_data_end (const xcb_x_print_print_get_document_data_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_x_print_print_get_document_data_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_x_print_print_get_document_data_reply_t *
+xcb_x_print_print_get_document_data_reply (xcb_connection_t                              *c,
+                                           xcb_x_print_print_get_document_data_cookie_t   cookie  /**< */,
+                                           xcb_generic_error_t                          **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_x_print_print_start_page_checked (xcb_connection_t *c,
+                                      xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_x_print_print_start_page (xcb_connection_t *c,
+                              xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_x_print_print_end_page_checked (xcb_connection_t *c,
+                                    uint8_t           cancel);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_x_print_print_end_page (xcb_connection_t *c,
+                            uint8_t           cancel);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_x_print_print_select_input_checked (xcb_connection_t       *c,
+                                        xcb_x_print_pcontext_t  context,
+                                        uint32_t                event_mask);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_x_print_print_select_input (xcb_connection_t       *c,
+                                xcb_x_print_pcontext_t  context,
+                                uint32_t                event_mask);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_x_print_print_input_selected_cookie_t
+xcb_x_print_print_input_selected (xcb_connection_t       *c,
+                                  xcb_x_print_pcontext_t  context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_x_print_print_input_selected_cookie_t
+xcb_x_print_print_input_selected_unchecked (xcb_connection_t       *c,
+                                            xcb_x_print_pcontext_t  context);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_x_print_print_input_selected_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_x_print_print_input_selected_reply_t *
+xcb_x_print_print_input_selected_reply (xcb_connection_t                           *c,
+                                        xcb_x_print_print_input_selected_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e);
+
+int
+xcb_x_print_print_get_attributes_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_x_print_print_get_attributes_cookie_t
+xcb_x_print_print_get_attributes (xcb_connection_t       *c,
+                                  xcb_x_print_pcontext_t  context,
+                                  uint8_t                 pool);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_x_print_print_get_attributes_cookie_t
+xcb_x_print_print_get_attributes_unchecked (xcb_connection_t       *c,
+                                            xcb_x_print_pcontext_t  context,
+                                            uint8_t                 pool);
+
+xcb_x_print_string8_t *
+xcb_x_print_print_get_attributes_attributes (const xcb_x_print_print_get_attributes_reply_t *R);
+
+int
+xcb_x_print_print_get_attributes_attributes_length (const xcb_x_print_print_get_attributes_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_x_print_print_get_attributes_attributes_end (const xcb_x_print_print_get_attributes_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_x_print_print_get_attributes_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_x_print_print_get_attributes_reply_t *
+xcb_x_print_print_get_attributes_reply (xcb_connection_t                           *c,
+                                        xcb_x_print_print_get_attributes_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e);
+
+int
+xcb_x_print_print_get_one_attributes_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_x_print_print_get_one_attributes_cookie_t
+xcb_x_print_print_get_one_attributes (xcb_connection_t            *c,
+                                      xcb_x_print_pcontext_t       context,
+                                      uint32_t                     nameLen,
+                                      uint8_t                      pool,
+                                      const xcb_x_print_string8_t *name);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_x_print_print_get_one_attributes_cookie_t
+xcb_x_print_print_get_one_attributes_unchecked (xcb_connection_t            *c,
+                                                xcb_x_print_pcontext_t       context,
+                                                uint32_t                     nameLen,
+                                                uint8_t                      pool,
+                                                const xcb_x_print_string8_t *name);
+
+xcb_x_print_string8_t *
+xcb_x_print_print_get_one_attributes_value (const xcb_x_print_print_get_one_attributes_reply_t *R);
+
+int
+xcb_x_print_print_get_one_attributes_value_length (const xcb_x_print_print_get_one_attributes_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_x_print_print_get_one_attributes_value_end (const xcb_x_print_print_get_one_attributes_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_x_print_print_get_one_attributes_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_x_print_print_get_one_attributes_reply_t *
+xcb_x_print_print_get_one_attributes_reply (xcb_connection_t                               *c,
+                                            xcb_x_print_print_get_one_attributes_cookie_t   cookie  /**< */,
+                                            xcb_generic_error_t                           **e);
+
+int
+xcb_x_print_print_set_attributes_sizeof (const void  *_buffer,
+                                         uint32_t     attributes_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_x_print_print_set_attributes_checked (xcb_connection_t            *c,
+                                          xcb_x_print_pcontext_t       context,
+                                          uint32_t                     stringLen,
+                                          uint8_t                      pool,
+                                          uint8_t                      rule,
+                                          uint32_t                     attributes_len,
+                                          const xcb_x_print_string8_t *attributes);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_x_print_print_set_attributes (xcb_connection_t            *c,
+                                  xcb_x_print_pcontext_t       context,
+                                  uint32_t                     stringLen,
+                                  uint8_t                      pool,
+                                  uint8_t                      rule,
+                                  uint32_t                     attributes_len,
+                                  const xcb_x_print_string8_t *attributes);
+
+xcb_x_print_string8_t *
+xcb_x_print_print_set_attributes_attributes (const xcb_x_print_print_set_attributes_request_t *R);
+
+int
+xcb_x_print_print_set_attributes_attributes_length (const xcb_x_print_print_set_attributes_request_t *R);
+
+xcb_generic_iterator_t
+xcb_x_print_print_set_attributes_attributes_end (const xcb_x_print_print_set_attributes_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_x_print_print_get_page_dimensions_cookie_t
+xcb_x_print_print_get_page_dimensions (xcb_connection_t       *c,
+                                       xcb_x_print_pcontext_t  context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_x_print_print_get_page_dimensions_cookie_t
+xcb_x_print_print_get_page_dimensions_unchecked (xcb_connection_t       *c,
+                                                 xcb_x_print_pcontext_t  context);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_x_print_print_get_page_dimensions_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_x_print_print_get_page_dimensions_reply_t *
+xcb_x_print_print_get_page_dimensions_reply (xcb_connection_t                                *c,
+                                             xcb_x_print_print_get_page_dimensions_cookie_t   cookie  /**< */,
+                                             xcb_generic_error_t                            **e);
+
+int
+xcb_x_print_print_query_screens_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_x_print_print_query_screens_cookie_t
+xcb_x_print_print_query_screens (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_x_print_print_query_screens_cookie_t
+xcb_x_print_print_query_screens_unchecked (xcb_connection_t *c);
+
+xcb_window_t *
+xcb_x_print_print_query_screens_roots (const xcb_x_print_print_query_screens_reply_t *R);
+
+int
+xcb_x_print_print_query_screens_roots_length (const xcb_x_print_print_query_screens_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_x_print_print_query_screens_roots_end (const xcb_x_print_print_query_screens_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_x_print_print_query_screens_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_x_print_print_query_screens_reply_t *
+xcb_x_print_print_query_screens_reply (xcb_connection_t                          *c,
+                                       xcb_x_print_print_query_screens_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_x_print_print_set_image_resolution_cookie_t
+xcb_x_print_print_set_image_resolution (xcb_connection_t       *c,
+                                        xcb_x_print_pcontext_t  context,
+                                        uint16_t                image_resolution);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_x_print_print_set_image_resolution_cookie_t
+xcb_x_print_print_set_image_resolution_unchecked (xcb_connection_t       *c,
+                                                  xcb_x_print_pcontext_t  context,
+                                                  uint16_t                image_resolution);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_x_print_print_set_image_resolution_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_x_print_print_set_image_resolution_reply_t *
+xcb_x_print_print_set_image_resolution_reply (xcb_connection_t                                 *c,
+                                              xcb_x_print_print_set_image_resolution_cookie_t   cookie  /**< */,
+                                              xcb_generic_error_t                             **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_x_print_print_get_image_resolution_cookie_t
+xcb_x_print_print_get_image_resolution (xcb_connection_t       *c,
+                                        xcb_x_print_pcontext_t  context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_x_print_print_get_image_resolution_cookie_t
+xcb_x_print_print_get_image_resolution_unchecked (xcb_connection_t       *c,
+                                                  xcb_x_print_pcontext_t  context);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_x_print_print_get_image_resolution_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_x_print_print_get_image_resolution_reply_t *
+xcb_x_print_print_get_image_resolution_reply (xcb_connection_t                                 *c,
+                                              xcb_x_print_print_get_image_resolution_cookie_t   cookie  /**< */,
+                                              xcb_generic_error_t                             **e);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/xproto.h b/depends/libxcb/include/xcb/xproto.h
new file mode 100644
index 0000000..4d87b72
--- /dev/null
+++ b/depends/libxcb/include/xcb/xproto.h
@@ -0,0 +1,12696 @@
+/*
+ * This file generated automatically from xproto.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB__API XCB  API
+ * @brief  XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __XPROTO_H
+#define __XPROTO_H
+
+#include "xcb.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief xcb_char2b_t
+ **/
+typedef struct xcb_char2b_t {
+    uint8_t byte1;
+    uint8_t byte2;
+} xcb_char2b_t;
+
+/**
+ * @brief xcb_char2b_iterator_t
+ **/
+typedef struct xcb_char2b_iterator_t {
+    xcb_char2b_t *data;
+    int           rem;
+    int           index;
+} xcb_char2b_iterator_t;
+
+typedef uint32_t xcb_window_t;
+
+/**
+ * @brief xcb_window_iterator_t
+ **/
+typedef struct xcb_window_iterator_t {
+    xcb_window_t *data;
+    int           rem;
+    int           index;
+} xcb_window_iterator_t;
+
+typedef uint32_t xcb_pixmap_t;
+
+/**
+ * @brief xcb_pixmap_iterator_t
+ **/
+typedef struct xcb_pixmap_iterator_t {
+    xcb_pixmap_t *data;
+    int           rem;
+    int           index;
+} xcb_pixmap_iterator_t;
+
+typedef uint32_t xcb_cursor_t;
+
+/**
+ * @brief xcb_cursor_iterator_t
+ **/
+typedef struct xcb_cursor_iterator_t {
+    xcb_cursor_t *data;
+    int           rem;
+    int           index;
+} xcb_cursor_iterator_t;
+
+typedef uint32_t xcb_font_t;
+
+/**
+ * @brief xcb_font_iterator_t
+ **/
+typedef struct xcb_font_iterator_t {
+    xcb_font_t *data;
+    int         rem;
+    int         index;
+} xcb_font_iterator_t;
+
+typedef uint32_t xcb_gcontext_t;
+
+/**
+ * @brief xcb_gcontext_iterator_t
+ **/
+typedef struct xcb_gcontext_iterator_t {
+    xcb_gcontext_t *data;
+    int             rem;
+    int             index;
+} xcb_gcontext_iterator_t;
+
+typedef uint32_t xcb_colormap_t;
+
+/**
+ * @brief xcb_colormap_iterator_t
+ **/
+typedef struct xcb_colormap_iterator_t {
+    xcb_colormap_t *data;
+    int             rem;
+    int             index;
+} xcb_colormap_iterator_t;
+
+typedef uint32_t xcb_atom_t;
+
+/**
+ * @brief xcb_atom_iterator_t
+ **/
+typedef struct xcb_atom_iterator_t {
+    xcb_atom_t *data;
+    int         rem;
+    int         index;
+} xcb_atom_iterator_t;
+
+typedef uint32_t xcb_drawable_t;
+
+/**
+ * @brief xcb_drawable_iterator_t
+ **/
+typedef struct xcb_drawable_iterator_t {
+    xcb_drawable_t *data;
+    int             rem;
+    int             index;
+} xcb_drawable_iterator_t;
+
+typedef uint32_t xcb_fontable_t;
+
+/**
+ * @brief xcb_fontable_iterator_t
+ **/
+typedef struct xcb_fontable_iterator_t {
+    xcb_fontable_t *data;
+    int             rem;
+    int             index;
+} xcb_fontable_iterator_t;
+
+typedef uint32_t xcb_bool32_t;
+
+/**
+ * @brief xcb_bool32_iterator_t
+ **/
+typedef struct xcb_bool32_iterator_t {
+    xcb_bool32_t *data;
+    int           rem;
+    int           index;
+} xcb_bool32_iterator_t;
+
+typedef uint32_t xcb_visualid_t;
+
+/**
+ * @brief xcb_visualid_iterator_t
+ **/
+typedef struct xcb_visualid_iterator_t {
+    xcb_visualid_t *data;
+    int             rem;
+    int             index;
+} xcb_visualid_iterator_t;
+
+typedef uint32_t xcb_timestamp_t;
+
+/**
+ * @brief xcb_timestamp_iterator_t
+ **/
+typedef struct xcb_timestamp_iterator_t {
+    xcb_timestamp_t *data;
+    int              rem;
+    int              index;
+} xcb_timestamp_iterator_t;
+
+typedef uint32_t xcb_keysym_t;
+
+/**
+ * @brief xcb_keysym_iterator_t
+ **/
+typedef struct xcb_keysym_iterator_t {
+    xcb_keysym_t *data;
+    int           rem;
+    int           index;
+} xcb_keysym_iterator_t;
+
+typedef uint8_t xcb_keycode_t;
+
+/**
+ * @brief xcb_keycode_iterator_t
+ **/
+typedef struct xcb_keycode_iterator_t {
+    xcb_keycode_t *data;
+    int            rem;
+    int            index;
+} xcb_keycode_iterator_t;
+
+typedef uint32_t xcb_keycode32_t;
+
+/**
+ * @brief xcb_keycode32_iterator_t
+ **/
+typedef struct xcb_keycode32_iterator_t {
+    xcb_keycode32_t *data;
+    int              rem;
+    int              index;
+} xcb_keycode32_iterator_t;
+
+typedef uint8_t xcb_button_t;
+
+/**
+ * @brief xcb_button_iterator_t
+ **/
+typedef struct xcb_button_iterator_t {
+    xcb_button_t *data;
+    int           rem;
+    int           index;
+} xcb_button_iterator_t;
+
+/**
+ * @brief xcb_point_t
+ **/
+typedef struct xcb_point_t {
+    int16_t x;
+    int16_t y;
+} xcb_point_t;
+
+/**
+ * @brief xcb_point_iterator_t
+ **/
+typedef struct xcb_point_iterator_t {
+    xcb_point_t *data;
+    int          rem;
+    int          index;
+} xcb_point_iterator_t;
+
+/**
+ * @brief xcb_rectangle_t
+ **/
+typedef struct xcb_rectangle_t {
+    int16_t  x;
+    int16_t  y;
+    uint16_t width;
+    uint16_t height;
+} xcb_rectangle_t;
+
+/**
+ * @brief xcb_rectangle_iterator_t
+ **/
+typedef struct xcb_rectangle_iterator_t {
+    xcb_rectangle_t *data;
+    int              rem;
+    int              index;
+} xcb_rectangle_iterator_t;
+
+/**
+ * @brief xcb_arc_t
+ **/
+typedef struct xcb_arc_t {
+    int16_t  x;
+    int16_t  y;
+    uint16_t width;
+    uint16_t height;
+    int16_t  angle1;
+    int16_t  angle2;
+} xcb_arc_t;
+
+/**
+ * @brief xcb_arc_iterator_t
+ **/
+typedef struct xcb_arc_iterator_t {
+    xcb_arc_t *data;
+    int        rem;
+    int        index;
+} xcb_arc_iterator_t;
+
+/**
+ * @brief xcb_format_t
+ **/
+typedef struct xcb_format_t {
+    uint8_t depth;
+    uint8_t bits_per_pixel;
+    uint8_t scanline_pad;
+    uint8_t pad0[5];
+} xcb_format_t;
+
+/**
+ * @brief xcb_format_iterator_t
+ **/
+typedef struct xcb_format_iterator_t {
+    xcb_format_t *data;
+    int           rem;
+    int           index;
+} xcb_format_iterator_t;
+
+typedef enum xcb_visual_class_t {
+    XCB_VISUAL_CLASS_STATIC_GRAY = 0,
+    XCB_VISUAL_CLASS_GRAY_SCALE = 1,
+    XCB_VISUAL_CLASS_STATIC_COLOR = 2,
+    XCB_VISUAL_CLASS_PSEUDO_COLOR = 3,
+    XCB_VISUAL_CLASS_TRUE_COLOR = 4,
+    XCB_VISUAL_CLASS_DIRECT_COLOR = 5
+} xcb_visual_class_t;
+
+/**
+ * @brief xcb_visualtype_t
+ **/
+typedef struct xcb_visualtype_t {
+    xcb_visualid_t visual_id;
+    uint8_t        _class;
+    uint8_t        bits_per_rgb_value;
+    uint16_t       colormap_entries;
+    uint32_t       red_mask;
+    uint32_t       green_mask;
+    uint32_t       blue_mask;
+    uint8_t        pad0[4];
+} xcb_visualtype_t;
+
+/**
+ * @brief xcb_visualtype_iterator_t
+ **/
+typedef struct xcb_visualtype_iterator_t {
+    xcb_visualtype_t *data;
+    int               rem;
+    int               index;
+} xcb_visualtype_iterator_t;
+
+/**
+ * @brief xcb_depth_t
+ **/
+typedef struct xcb_depth_t {
+    uint8_t  depth;
+    uint8_t  pad0;
+    uint16_t visuals_len;
+    uint8_t  pad1[4];
+} xcb_depth_t;
+
+/**
+ * @brief xcb_depth_iterator_t
+ **/
+typedef struct xcb_depth_iterator_t {
+    xcb_depth_t *data;
+    int          rem;
+    int          index;
+} xcb_depth_iterator_t;
+
+typedef enum xcb_event_mask_t {
+    XCB_EVENT_MASK_NO_EVENT = 0,
+    XCB_EVENT_MASK_KEY_PRESS = 1,
+    XCB_EVENT_MASK_KEY_RELEASE = 2,
+    XCB_EVENT_MASK_BUTTON_PRESS = 4,
+    XCB_EVENT_MASK_BUTTON_RELEASE = 8,
+    XCB_EVENT_MASK_ENTER_WINDOW = 16,
+    XCB_EVENT_MASK_LEAVE_WINDOW = 32,
+    XCB_EVENT_MASK_POINTER_MOTION = 64,
+    XCB_EVENT_MASK_POINTER_MOTION_HINT = 128,
+    XCB_EVENT_MASK_BUTTON_1_MOTION = 256,
+    XCB_EVENT_MASK_BUTTON_2_MOTION = 512,
+    XCB_EVENT_MASK_BUTTON_3_MOTION = 1024,
+    XCB_EVENT_MASK_BUTTON_4_MOTION = 2048,
+    XCB_EVENT_MASK_BUTTON_5_MOTION = 4096,
+    XCB_EVENT_MASK_BUTTON_MOTION = 8192,
+    XCB_EVENT_MASK_KEYMAP_STATE = 16384,
+    XCB_EVENT_MASK_EXPOSURE = 32768,
+    XCB_EVENT_MASK_VISIBILITY_CHANGE = 65536,
+    XCB_EVENT_MASK_STRUCTURE_NOTIFY = 131072,
+    XCB_EVENT_MASK_RESIZE_REDIRECT = 262144,
+    XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY = 524288,
+    XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT = 1048576,
+    XCB_EVENT_MASK_FOCUS_CHANGE = 2097152,
+    XCB_EVENT_MASK_PROPERTY_CHANGE = 4194304,
+    XCB_EVENT_MASK_COLOR_MAP_CHANGE = 8388608,
+    XCB_EVENT_MASK_OWNER_GRAB_BUTTON = 16777216
+} xcb_event_mask_t;
+
+typedef enum xcb_backing_store_t {
+    XCB_BACKING_STORE_NOT_USEFUL = 0,
+    XCB_BACKING_STORE_WHEN_MAPPED = 1,
+    XCB_BACKING_STORE_ALWAYS = 2
+} xcb_backing_store_t;
+
+/**
+ * @brief xcb_screen_t
+ **/
+typedef struct xcb_screen_t {
+    xcb_window_t   root;
+    xcb_colormap_t default_colormap;
+    uint32_t       white_pixel;
+    uint32_t       black_pixel;
+    uint32_t       current_input_masks;
+    uint16_t       width_in_pixels;
+    uint16_t       height_in_pixels;
+    uint16_t       width_in_millimeters;
+    uint16_t       height_in_millimeters;
+    uint16_t       min_installed_maps;
+    uint16_t       max_installed_maps;
+    xcb_visualid_t root_visual;
+    uint8_t        backing_stores;
+    uint8_t        save_unders;
+    uint8_t        root_depth;
+    uint8_t        allowed_depths_len;
+} xcb_screen_t;
+
+/**
+ * @brief xcb_screen_iterator_t
+ **/
+typedef struct xcb_screen_iterator_t {
+    xcb_screen_t *data;
+    int           rem;
+    int           index;
+} xcb_screen_iterator_t;
+
+/**
+ * @brief xcb_setup_request_t
+ **/
+typedef struct xcb_setup_request_t {
+    uint8_t  byte_order;
+    uint8_t  pad0;
+    uint16_t protocol_major_version;
+    uint16_t protocol_minor_version;
+    uint16_t authorization_protocol_name_len;
+    uint16_t authorization_protocol_data_len;
+    uint8_t  pad1[2];
+} xcb_setup_request_t;
+
+/**
+ * @brief xcb_setup_request_iterator_t
+ **/
+typedef struct xcb_setup_request_iterator_t {
+    xcb_setup_request_t *data;
+    int                  rem;
+    int                  index;
+} xcb_setup_request_iterator_t;
+
+/**
+ * @brief xcb_setup_failed_t
+ **/
+typedef struct xcb_setup_failed_t {
+    uint8_t  status;
+    uint8_t  reason_len;
+    uint16_t protocol_major_version;
+    uint16_t protocol_minor_version;
+    uint16_t length;
+} xcb_setup_failed_t;
+
+/**
+ * @brief xcb_setup_failed_iterator_t
+ **/
+typedef struct xcb_setup_failed_iterator_t {
+    xcb_setup_failed_t *data;
+    int                 rem;
+    int                 index;
+} xcb_setup_failed_iterator_t;
+
+/**
+ * @brief xcb_setup_authenticate_t
+ **/
+typedef struct xcb_setup_authenticate_t {
+    uint8_t  status;
+    uint8_t  pad0[5];
+    uint16_t length;
+} xcb_setup_authenticate_t;
+
+/**
+ * @brief xcb_setup_authenticate_iterator_t
+ **/
+typedef struct xcb_setup_authenticate_iterator_t {
+    xcb_setup_authenticate_t *data;
+    int                       rem;
+    int                       index;
+} xcb_setup_authenticate_iterator_t;
+
+typedef enum xcb_image_order_t {
+    XCB_IMAGE_ORDER_LSB_FIRST = 0,
+    XCB_IMAGE_ORDER_MSB_FIRST = 1
+} xcb_image_order_t;
+
+/**
+ * @brief xcb_setup_t
+ **/
+typedef struct xcb_setup_t {
+    uint8_t       status;
+    uint8_t       pad0;
+    uint16_t      protocol_major_version;
+    uint16_t      protocol_minor_version;
+    uint16_t      length;
+    uint32_t      release_number;
+    uint32_t      resource_id_base;
+    uint32_t      resource_id_mask;
+    uint32_t      motion_buffer_size;
+    uint16_t      vendor_len;
+    uint16_t      maximum_request_length;
+    uint8_t       roots_len;
+    uint8_t       pixmap_formats_len;
+    uint8_t       image_byte_order;
+    uint8_t       bitmap_format_bit_order;
+    uint8_t       bitmap_format_scanline_unit;
+    uint8_t       bitmap_format_scanline_pad;
+    xcb_keycode_t min_keycode;
+    xcb_keycode_t max_keycode;
+    uint8_t       pad1[4];
+} xcb_setup_t;
+
+/**
+ * @brief xcb_setup_iterator_t
+ **/
+typedef struct xcb_setup_iterator_t {
+    xcb_setup_t *data;
+    int          rem;
+    int          index;
+} xcb_setup_iterator_t;
+
+typedef enum xcb_mod_mask_t {
+    XCB_MOD_MASK_SHIFT = 1,
+    XCB_MOD_MASK_LOCK = 2,
+    XCB_MOD_MASK_CONTROL = 4,
+    XCB_MOD_MASK_1 = 8,
+    XCB_MOD_MASK_2 = 16,
+    XCB_MOD_MASK_3 = 32,
+    XCB_MOD_MASK_4 = 64,
+    XCB_MOD_MASK_5 = 128,
+    XCB_MOD_MASK_ANY = 32768
+} xcb_mod_mask_t;
+
+typedef enum xcb_key_but_mask_t {
+    XCB_KEY_BUT_MASK_SHIFT = 1,
+    XCB_KEY_BUT_MASK_LOCK = 2,
+    XCB_KEY_BUT_MASK_CONTROL = 4,
+    XCB_KEY_BUT_MASK_MOD_1 = 8,
+    XCB_KEY_BUT_MASK_MOD_2 = 16,
+    XCB_KEY_BUT_MASK_MOD_3 = 32,
+    XCB_KEY_BUT_MASK_MOD_4 = 64,
+    XCB_KEY_BUT_MASK_MOD_5 = 128,
+    XCB_KEY_BUT_MASK_BUTTON_1 = 256,
+    XCB_KEY_BUT_MASK_BUTTON_2 = 512,
+    XCB_KEY_BUT_MASK_BUTTON_3 = 1024,
+    XCB_KEY_BUT_MASK_BUTTON_4 = 2048,
+    XCB_KEY_BUT_MASK_BUTTON_5 = 4096
+} xcb_key_but_mask_t;
+
+typedef enum xcb_window_enum_t {
+    XCB_WINDOW_NONE = 0
+} xcb_window_enum_t;
+
+/** Opcode for xcb_key_press. */
+#define XCB_KEY_PRESS 2
+
+/**
+ * @brief xcb_key_press_event_t
+ **/
+typedef struct xcb_key_press_event_t {
+    uint8_t         response_type;
+    xcb_keycode_t   detail;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    xcb_window_t    root;
+    xcb_window_t    event;
+    xcb_window_t    child;
+    int16_t         root_x;
+    int16_t         root_y;
+    int16_t         event_x;
+    int16_t         event_y;
+    uint16_t        state;
+    uint8_t         same_screen;
+    uint8_t         pad0;
+} xcb_key_press_event_t;
+
+/** Opcode for xcb_key_release. */
+#define XCB_KEY_RELEASE 3
+
+typedef xcb_key_press_event_t xcb_key_release_event_t;
+
+typedef enum xcb_button_mask_t {
+    XCB_BUTTON_MASK_1 = 256,
+    XCB_BUTTON_MASK_2 = 512,
+    XCB_BUTTON_MASK_3 = 1024,
+    XCB_BUTTON_MASK_4 = 2048,
+    XCB_BUTTON_MASK_5 = 4096,
+    XCB_BUTTON_MASK_ANY = 32768
+} xcb_button_mask_t;
+
+/** Opcode for xcb_button_press. */
+#define XCB_BUTTON_PRESS 4
+
+/**
+ * @brief xcb_button_press_event_t
+ **/
+typedef struct xcb_button_press_event_t {
+    uint8_t         response_type;
+    xcb_button_t    detail;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    xcb_window_t    root;
+    xcb_window_t    event;
+    xcb_window_t    child;
+    int16_t         root_x;
+    int16_t         root_y;
+    int16_t         event_x;
+    int16_t         event_y;
+    uint16_t        state;
+    uint8_t         same_screen;
+    uint8_t         pad0;
+} xcb_button_press_event_t;
+
+/** Opcode for xcb_button_release. */
+#define XCB_BUTTON_RELEASE 5
+
+typedef xcb_button_press_event_t xcb_button_release_event_t;
+
+typedef enum xcb_motion_t {
+    XCB_MOTION_NORMAL = 0,
+    XCB_MOTION_HINT = 1
+} xcb_motion_t;
+
+/** Opcode for xcb_motion_notify. */
+#define XCB_MOTION_NOTIFY 6
+
+/**
+ * @brief xcb_motion_notify_event_t
+ **/
+typedef struct xcb_motion_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         detail;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    xcb_window_t    root;
+    xcb_window_t    event;
+    xcb_window_t    child;
+    int16_t         root_x;
+    int16_t         root_y;
+    int16_t         event_x;
+    int16_t         event_y;
+    uint16_t        state;
+    uint8_t         same_screen;
+    uint8_t         pad0;
+} xcb_motion_notify_event_t;
+
+typedef enum xcb_notify_detail_t {
+    XCB_NOTIFY_DETAIL_ANCESTOR = 0,
+    XCB_NOTIFY_DETAIL_VIRTUAL = 1,
+    XCB_NOTIFY_DETAIL_INFERIOR = 2,
+    XCB_NOTIFY_DETAIL_NONLINEAR = 3,
+    XCB_NOTIFY_DETAIL_NONLINEAR_VIRTUAL = 4,
+    XCB_NOTIFY_DETAIL_POINTER = 5,
+    XCB_NOTIFY_DETAIL_POINTER_ROOT = 6,
+    XCB_NOTIFY_DETAIL_NONE = 7
+} xcb_notify_detail_t;
+
+typedef enum xcb_notify_mode_t {
+    XCB_NOTIFY_MODE_NORMAL = 0,
+    XCB_NOTIFY_MODE_GRAB = 1,
+    XCB_NOTIFY_MODE_UNGRAB = 2,
+    XCB_NOTIFY_MODE_WHILE_GRABBED = 3
+} xcb_notify_mode_t;
+
+/** Opcode for xcb_enter_notify. */
+#define XCB_ENTER_NOTIFY 7
+
+/**
+ * @brief xcb_enter_notify_event_t
+ **/
+typedef struct xcb_enter_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         detail;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    xcb_window_t    root;
+    xcb_window_t    event;
+    xcb_window_t    child;
+    int16_t         root_x;
+    int16_t         root_y;
+    int16_t         event_x;
+    int16_t         event_y;
+    uint16_t        state;
+    uint8_t         mode;
+    uint8_t         same_screen_focus;
+} xcb_enter_notify_event_t;
+
+/** Opcode for xcb_leave_notify. */
+#define XCB_LEAVE_NOTIFY 8
+
+typedef xcb_enter_notify_event_t xcb_leave_notify_event_t;
+
+/** Opcode for xcb_focus_in. */
+#define XCB_FOCUS_IN 9
+
+/**
+ * @brief xcb_focus_in_event_t
+ **/
+typedef struct xcb_focus_in_event_t {
+    uint8_t      response_type;
+    uint8_t      detail;
+    uint16_t     sequence;
+    xcb_window_t event;
+    uint8_t      mode;
+    uint8_t      pad0[3];
+} xcb_focus_in_event_t;
+
+/** Opcode for xcb_focus_out. */
+#define XCB_FOCUS_OUT 10
+
+typedef xcb_focus_in_event_t xcb_focus_out_event_t;
+
+/** Opcode for xcb_keymap_notify. */
+#define XCB_KEYMAP_NOTIFY 11
+
+/**
+ * @brief xcb_keymap_notify_event_t
+ **/
+typedef struct xcb_keymap_notify_event_t {
+    uint8_t response_type;
+    uint8_t keys[31];
+} xcb_keymap_notify_event_t;
+
+/** Opcode for xcb_expose. */
+#define XCB_EXPOSE 12
+
+/**
+ * @brief xcb_expose_event_t
+ **/
+typedef struct xcb_expose_event_t {
+    uint8_t      response_type;
+    uint8_t      pad0;
+    uint16_t     sequence;
+    xcb_window_t window;
+    uint16_t     x;
+    uint16_t     y;
+    uint16_t     width;
+    uint16_t     height;
+    uint16_t     count;
+    uint8_t      pad1[2];
+} xcb_expose_event_t;
+
+/** Opcode for xcb_graphics_exposure. */
+#define XCB_GRAPHICS_EXPOSURE 13
+
+/**
+ * @brief xcb_graphics_exposure_event_t
+ **/
+typedef struct xcb_graphics_exposure_event_t {
+    uint8_t        response_type;
+    uint8_t        pad0;
+    uint16_t       sequence;
+    xcb_drawable_t drawable;
+    uint16_t       x;
+    uint16_t       y;
+    uint16_t       width;
+    uint16_t       height;
+    uint16_t       minor_opcode;
+    uint16_t       count;
+    uint8_t        major_opcode;
+    uint8_t        pad1[3];
+} xcb_graphics_exposure_event_t;
+
+/** Opcode for xcb_no_exposure. */
+#define XCB_NO_EXPOSURE 14
+
+/**
+ * @brief xcb_no_exposure_event_t
+ **/
+typedef struct xcb_no_exposure_event_t {
+    uint8_t        response_type;
+    uint8_t        pad0;
+    uint16_t       sequence;
+    xcb_drawable_t drawable;
+    uint16_t       minor_opcode;
+    uint8_t        major_opcode;
+    uint8_t        pad1;
+} xcb_no_exposure_event_t;
+
+typedef enum xcb_visibility_t {
+    XCB_VISIBILITY_UNOBSCURED = 0,
+    XCB_VISIBILITY_PARTIALLY_OBSCURED = 1,
+    XCB_VISIBILITY_FULLY_OBSCURED = 2
+} xcb_visibility_t;
+
+/** Opcode for xcb_visibility_notify. */
+#define XCB_VISIBILITY_NOTIFY 15
+
+/**
+ * @brief xcb_visibility_notify_event_t
+ **/
+typedef struct xcb_visibility_notify_event_t {
+    uint8_t      response_type;
+    uint8_t      pad0;
+    uint16_t     sequence;
+    xcb_window_t window;
+    uint8_t      state;
+    uint8_t      pad1[3];
+} xcb_visibility_notify_event_t;
+
+/** Opcode for xcb_create_notify. */
+#define XCB_CREATE_NOTIFY 16
+
+/**
+ * @brief xcb_create_notify_event_t
+ **/
+typedef struct xcb_create_notify_event_t {
+    uint8_t      response_type;
+    uint8_t      pad0;
+    uint16_t     sequence;
+    xcb_window_t parent;
+    xcb_window_t window;
+    int16_t      x;
+    int16_t      y;
+    uint16_t     width;
+    uint16_t     height;
+    uint16_t     border_width;
+    uint8_t      override_redirect;
+    uint8_t      pad1;
+} xcb_create_notify_event_t;
+
+/** Opcode for xcb_destroy_notify. */
+#define XCB_DESTROY_NOTIFY 17
+
+/**
+ * @brief xcb_destroy_notify_event_t
+ **/
+typedef struct xcb_destroy_notify_event_t {
+    uint8_t      response_type;
+    uint8_t      pad0;
+    uint16_t     sequence;
+    xcb_window_t event;
+    xcb_window_t window;
+} xcb_destroy_notify_event_t;
+
+/** Opcode for xcb_unmap_notify. */
+#define XCB_UNMAP_NOTIFY 18
+
+/**
+ * @brief xcb_unmap_notify_event_t
+ **/
+typedef struct xcb_unmap_notify_event_t {
+    uint8_t      response_type;
+    uint8_t      pad0;
+    uint16_t     sequence;
+    xcb_window_t event;
+    xcb_window_t window;
+    uint8_t      from_configure;
+    uint8_t      pad1[3];
+} xcb_unmap_notify_event_t;
+
+/** Opcode for xcb_map_notify. */
+#define XCB_MAP_NOTIFY 19
+
+/**
+ * @brief xcb_map_notify_event_t
+ **/
+typedef struct xcb_map_notify_event_t {
+    uint8_t      response_type;
+    uint8_t      pad0;
+    uint16_t     sequence;
+    xcb_window_t event;
+    xcb_window_t window;
+    uint8_t      override_redirect;
+    uint8_t      pad1[3];
+} xcb_map_notify_event_t;
+
+/** Opcode for xcb_map_request. */
+#define XCB_MAP_REQUEST 20
+
+/**
+ * @brief xcb_map_request_event_t
+ **/
+typedef struct xcb_map_request_event_t {
+    uint8_t      response_type;
+    uint8_t      pad0;
+    uint16_t     sequence;
+    xcb_window_t parent;
+    xcb_window_t window;
+} xcb_map_request_event_t;
+
+/** Opcode for xcb_reparent_notify. */
+#define XCB_REPARENT_NOTIFY 21
+
+/**
+ * @brief xcb_reparent_notify_event_t
+ **/
+typedef struct xcb_reparent_notify_event_t {
+    uint8_t      response_type;
+    uint8_t      pad0;
+    uint16_t     sequence;
+    xcb_window_t event;
+    xcb_window_t window;
+    xcb_window_t parent;
+    int16_t      x;
+    int16_t      y;
+    uint8_t      override_redirect;
+    uint8_t      pad1[3];
+} xcb_reparent_notify_event_t;
+
+/** Opcode for xcb_configure_notify. */
+#define XCB_CONFIGURE_NOTIFY 22
+
+/**
+ * @brief xcb_configure_notify_event_t
+ **/
+typedef struct xcb_configure_notify_event_t {
+    uint8_t      response_type;
+    uint8_t      pad0;
+    uint16_t     sequence;
+    xcb_window_t event;
+    xcb_window_t window;
+    xcb_window_t above_sibling;
+    int16_t      x;
+    int16_t      y;
+    uint16_t     width;
+    uint16_t     height;
+    uint16_t     border_width;
+    uint8_t      override_redirect;
+    uint8_t      pad1;
+} xcb_configure_notify_event_t;
+
+/** Opcode for xcb_configure_request. */
+#define XCB_CONFIGURE_REQUEST 23
+
+/**
+ * @brief xcb_configure_request_event_t
+ **/
+typedef struct xcb_configure_request_event_t {
+    uint8_t      response_type;
+    uint8_t      stack_mode;
+    uint16_t     sequence;
+    xcb_window_t parent;
+    xcb_window_t window;
+    xcb_window_t sibling;
+    int16_t      x;
+    int16_t      y;
+    uint16_t     width;
+    uint16_t     height;
+    uint16_t     border_width;
+    uint16_t     value_mask;
+} xcb_configure_request_event_t;
+
+/** Opcode for xcb_gravity_notify. */
+#define XCB_GRAVITY_NOTIFY 24
+
+/**
+ * @brief xcb_gravity_notify_event_t
+ **/
+typedef struct xcb_gravity_notify_event_t {
+    uint8_t      response_type;
+    uint8_t      pad0;
+    uint16_t     sequence;
+    xcb_window_t event;
+    xcb_window_t window;
+    int16_t      x;
+    int16_t      y;
+} xcb_gravity_notify_event_t;
+
+/** Opcode for xcb_resize_request. */
+#define XCB_RESIZE_REQUEST 25
+
+/**
+ * @brief xcb_resize_request_event_t
+ **/
+typedef struct xcb_resize_request_event_t {
+    uint8_t      response_type;
+    uint8_t      pad0;
+    uint16_t     sequence;
+    xcb_window_t window;
+    uint16_t     width;
+    uint16_t     height;
+} xcb_resize_request_event_t;
+
+typedef enum xcb_place_t {
+    XCB_PLACE_ON_TOP = 0,
+/**< The window is now on top of all siblings. */
+
+    XCB_PLACE_ON_BOTTOM = 1
+/**< The window is now below all siblings. */
+
+} xcb_place_t;
+
+/** Opcode for xcb_circulate_notify. */
+#define XCB_CIRCULATE_NOTIFY 26
+
+/**
+ * @brief xcb_circulate_notify_event_t
+ **/
+typedef struct xcb_circulate_notify_event_t {
+    uint8_t      response_type;
+    uint8_t      pad0;
+    uint16_t     sequence;
+    xcb_window_t event;
+    xcb_window_t window;
+    uint8_t      pad1[4];
+    uint8_t      place;
+    uint8_t      pad2[3];
+} xcb_circulate_notify_event_t;
+
+/** Opcode for xcb_circulate_request. */
+#define XCB_CIRCULATE_REQUEST 27
+
+typedef xcb_circulate_notify_event_t xcb_circulate_request_event_t;
+
+typedef enum xcb_property_t {
+    XCB_PROPERTY_NEW_VALUE = 0,
+    XCB_PROPERTY_DELETE = 1
+} xcb_property_t;
+
+/** Opcode for xcb_property_notify. */
+#define XCB_PROPERTY_NOTIFY 28
+
+/**
+ * @brief xcb_property_notify_event_t
+ **/
+typedef struct xcb_property_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         pad0;
+    uint16_t        sequence;
+    xcb_window_t    window;
+    xcb_atom_t      atom;
+    xcb_timestamp_t time;
+    uint8_t         state;
+    uint8_t         pad1[3];
+} xcb_property_notify_event_t;
+
+/** Opcode for xcb_selection_clear. */
+#define XCB_SELECTION_CLEAR 29
+
+/**
+ * @brief xcb_selection_clear_event_t
+ **/
+typedef struct xcb_selection_clear_event_t {
+    uint8_t         response_type;
+    uint8_t         pad0;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    xcb_window_t    owner;
+    xcb_atom_t      selection;
+} xcb_selection_clear_event_t;
+
+typedef enum xcb_time_t {
+    XCB_TIME_CURRENT_TIME = 0
+} xcb_time_t;
+
+typedef enum xcb_atom_enum_t {
+    XCB_ATOM_NONE = 0,
+    XCB_ATOM_ANY = 0,
+    XCB_ATOM_PRIMARY = 1,
+    XCB_ATOM_SECONDARY = 2,
+    XCB_ATOM_ARC = 3,
+    XCB_ATOM_ATOM = 4,
+    XCB_ATOM_BITMAP = 5,
+    XCB_ATOM_CARDINAL = 6,
+    XCB_ATOM_COLORMAP = 7,
+    XCB_ATOM_CURSOR = 8,
+    XCB_ATOM_CUT_BUFFER0 = 9,
+    XCB_ATOM_CUT_BUFFER1 = 10,
+    XCB_ATOM_CUT_BUFFER2 = 11,
+    XCB_ATOM_CUT_BUFFER3 = 12,
+    XCB_ATOM_CUT_BUFFER4 = 13,
+    XCB_ATOM_CUT_BUFFER5 = 14,
+    XCB_ATOM_CUT_BUFFER6 = 15,
+    XCB_ATOM_CUT_BUFFER7 = 16,
+    XCB_ATOM_DRAWABLE = 17,
+    XCB_ATOM_FONT = 18,
+    XCB_ATOM_INTEGER = 19,
+    XCB_ATOM_PIXMAP = 20,
+    XCB_ATOM_POINT = 21,
+    XCB_ATOM_RECTANGLE = 22,
+    XCB_ATOM_RESOURCE_MANAGER = 23,
+    XCB_ATOM_RGB_COLOR_MAP = 24,
+    XCB_ATOM_RGB_BEST_MAP = 25,
+    XCB_ATOM_RGB_BLUE_MAP = 26,
+    XCB_ATOM_RGB_DEFAULT_MAP = 27,
+    XCB_ATOM_RGB_GRAY_MAP = 28,
+    XCB_ATOM_RGB_GREEN_MAP = 29,
+    XCB_ATOM_RGB_RED_MAP = 30,
+    XCB_ATOM_STRING = 31,
+    XCB_ATOM_VISUALID = 32,
+    XCB_ATOM_WINDOW = 33,
+    XCB_ATOM_WM_COMMAND = 34,
+    XCB_ATOM_WM_HINTS = 35,
+    XCB_ATOM_WM_CLIENT_MACHINE = 36,
+    XCB_ATOM_WM_ICON_NAME = 37,
+    XCB_ATOM_WM_ICON_SIZE = 38,
+    XCB_ATOM_WM_NAME = 39,
+    XCB_ATOM_WM_NORMAL_HINTS = 40,
+    XCB_ATOM_WM_SIZE_HINTS = 41,
+    XCB_ATOM_WM_ZOOM_HINTS = 42,
+    XCB_ATOM_MIN_SPACE = 43,
+    XCB_ATOM_NORM_SPACE = 44,
+    XCB_ATOM_MAX_SPACE = 45,
+    XCB_ATOM_END_SPACE = 46,
+    XCB_ATOM_SUPERSCRIPT_X = 47,
+    XCB_ATOM_SUPERSCRIPT_Y = 48,
+    XCB_ATOM_SUBSCRIPT_X = 49,
+    XCB_ATOM_SUBSCRIPT_Y = 50,
+    XCB_ATOM_UNDERLINE_POSITION = 51,
+    XCB_ATOM_UNDERLINE_THICKNESS = 52,
+    XCB_ATOM_STRIKEOUT_ASCENT = 53,
+    XCB_ATOM_STRIKEOUT_DESCENT = 54,
+    XCB_ATOM_ITALIC_ANGLE = 55,
+    XCB_ATOM_X_HEIGHT = 56,
+    XCB_ATOM_QUAD_WIDTH = 57,
+    XCB_ATOM_WEIGHT = 58,
+    XCB_ATOM_POINT_SIZE = 59,
+    XCB_ATOM_RESOLUTION = 60,
+    XCB_ATOM_COPYRIGHT = 61,
+    XCB_ATOM_NOTICE = 62,
+    XCB_ATOM_FONT_NAME = 63,
+    XCB_ATOM_FAMILY_NAME = 64,
+    XCB_ATOM_FULL_NAME = 65,
+    XCB_ATOM_CAP_HEIGHT = 66,
+    XCB_ATOM_WM_CLASS = 67,
+    XCB_ATOM_WM_TRANSIENT_FOR = 68
+} xcb_atom_enum_t;
+
+/** Opcode for xcb_selection_request. */
+#define XCB_SELECTION_REQUEST 30
+
+/**
+ * @brief xcb_selection_request_event_t
+ **/
+typedef struct xcb_selection_request_event_t {
+    uint8_t         response_type;
+    uint8_t         pad0;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    xcb_window_t    owner;
+    xcb_window_t    requestor;
+    xcb_atom_t      selection;
+    xcb_atom_t      target;
+    xcb_atom_t      property;
+} xcb_selection_request_event_t;
+
+/** Opcode for xcb_selection_notify. */
+#define XCB_SELECTION_NOTIFY 31
+
+/**
+ * @brief xcb_selection_notify_event_t
+ **/
+typedef struct xcb_selection_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         pad0;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    xcb_window_t    requestor;
+    xcb_atom_t      selection;
+    xcb_atom_t      target;
+    xcb_atom_t      property;
+} xcb_selection_notify_event_t;
+
+typedef enum xcb_colormap_state_t {
+    XCB_COLORMAP_STATE_UNINSTALLED = 0,
+/**< The colormap was uninstalled. */
+
+    XCB_COLORMAP_STATE_INSTALLED = 1
+/**< The colormap was installed. */
+
+} xcb_colormap_state_t;
+
+typedef enum xcb_colormap_enum_t {
+    XCB_COLORMAP_NONE = 0
+} xcb_colormap_enum_t;
+
+/** Opcode for xcb_colormap_notify. */
+#define XCB_COLORMAP_NOTIFY 32
+
+/**
+ * @brief xcb_colormap_notify_event_t
+ **/
+typedef struct xcb_colormap_notify_event_t {
+    uint8_t        response_type;
+    uint8_t        pad0;
+    uint16_t       sequence;
+    xcb_window_t   window;
+    xcb_colormap_t colormap;
+    uint8_t        _new;
+    uint8_t        state;
+    uint8_t        pad1[2];
+} xcb_colormap_notify_event_t;
+
+/**
+ * @brief xcb_client_message_data_t
+ **/
+typedef union xcb_client_message_data_t {
+    uint8_t  data8[20];
+    uint16_t data16[10];
+    uint32_t data32[5];
+} xcb_client_message_data_t;
+
+/**
+ * @brief xcb_client_message_data_iterator_t
+ **/
+typedef struct xcb_client_message_data_iterator_t {
+    xcb_client_message_data_t *data;
+    int                        rem;
+    int                        index;
+} xcb_client_message_data_iterator_t;
+
+/** Opcode for xcb_client_message. */
+#define XCB_CLIENT_MESSAGE 33
+
+/**
+ * @brief xcb_client_message_event_t
+ **/
+typedef struct xcb_client_message_event_t {
+    uint8_t                   response_type;
+    uint8_t                   format;
+    uint16_t                  sequence;
+    xcb_window_t              window;
+    xcb_atom_t                type;
+    xcb_client_message_data_t data;
+} xcb_client_message_event_t;
+
+typedef enum xcb_mapping_t {
+    XCB_MAPPING_MODIFIER = 0,
+    XCB_MAPPING_KEYBOARD = 1,
+    XCB_MAPPING_POINTER = 2
+} xcb_mapping_t;
+
+/** Opcode for xcb_mapping_notify. */
+#define XCB_MAPPING_NOTIFY 34
+
+/**
+ * @brief xcb_mapping_notify_event_t
+ **/
+typedef struct xcb_mapping_notify_event_t {
+    uint8_t       response_type;
+    uint8_t       pad0;
+    uint16_t      sequence;
+    uint8_t       request;
+    xcb_keycode_t first_keycode;
+    uint8_t       count;
+    uint8_t       pad1;
+} xcb_mapping_notify_event_t;
+
+/** Opcode for xcb_ge_generic. */
+#define XCB_GE_GENERIC 35
+
+/**
+ * @brief xcb_ge_generic_event_t
+ **/
+typedef struct xcb_ge_generic_event_t {
+    uint8_t  response_type;
+    uint8_t  extension;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t event_type;
+    uint8_t  pad0[22];
+    uint32_t full_sequence;
+} xcb_ge_generic_event_t;
+
+/** Opcode for xcb_request. */
+#define XCB_REQUEST 1
+
+/**
+ * @brief xcb_request_error_t
+ **/
+typedef struct xcb_request_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+} xcb_request_error_t;
+
+/** Opcode for xcb_value. */
+#define XCB_VALUE 2
+
+/**
+ * @brief xcb_value_error_t
+ **/
+typedef struct xcb_value_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+} xcb_value_error_t;
+
+/** Opcode for xcb_window. */
+#define XCB_WINDOW 3
+
+typedef xcb_value_error_t xcb_window_error_t;
+
+/** Opcode for xcb_pixmap. */
+#define XCB_PIXMAP 4
+
+typedef xcb_value_error_t xcb_pixmap_error_t;
+
+/** Opcode for xcb_atom. */
+#define XCB_ATOM 5
+
+typedef xcb_value_error_t xcb_atom_error_t;
+
+/** Opcode for xcb_cursor. */
+#define XCB_CURSOR 6
+
+typedef xcb_value_error_t xcb_cursor_error_t;
+
+/** Opcode for xcb_font. */
+#define XCB_FONT 7
+
+typedef xcb_value_error_t xcb_font_error_t;
+
+/** Opcode for xcb_match. */
+#define XCB_MATCH 8
+
+typedef xcb_request_error_t xcb_match_error_t;
+
+/** Opcode for xcb_drawable. */
+#define XCB_DRAWABLE 9
+
+typedef xcb_value_error_t xcb_drawable_error_t;
+
+/** Opcode for xcb_access. */
+#define XCB_ACCESS 10
+
+typedef xcb_request_error_t xcb_access_error_t;
+
+/** Opcode for xcb_alloc. */
+#define XCB_ALLOC 11
+
+typedef xcb_request_error_t xcb_alloc_error_t;
+
+/** Opcode for xcb_colormap. */
+#define XCB_COLORMAP 12
+
+typedef xcb_value_error_t xcb_colormap_error_t;
+
+/** Opcode for xcb_g_context. */
+#define XCB_G_CONTEXT 13
+
+typedef xcb_value_error_t xcb_g_context_error_t;
+
+/** Opcode for xcb_id_choice. */
+#define XCB_ID_CHOICE 14
+
+typedef xcb_value_error_t xcb_id_choice_error_t;
+
+/** Opcode for xcb_name. */
+#define XCB_NAME 15
+
+typedef xcb_request_error_t xcb_name_error_t;
+
+/** Opcode for xcb_length. */
+#define XCB_LENGTH 16
+
+typedef xcb_request_error_t xcb_length_error_t;
+
+/** Opcode for xcb_implementation. */
+#define XCB_IMPLEMENTATION 17
+
+typedef xcb_request_error_t xcb_implementation_error_t;
+
+typedef enum xcb_window_class_t {
+    XCB_WINDOW_CLASS_COPY_FROM_PARENT = 0,
+    XCB_WINDOW_CLASS_INPUT_OUTPUT = 1,
+    XCB_WINDOW_CLASS_INPUT_ONLY = 2
+} xcb_window_class_t;
+
+typedef enum xcb_cw_t {
+    XCB_CW_BACK_PIXMAP = 1,
+/**< Overrides the default background-pixmap. The background pixmap and window must
+have the same root and same depth. Any size pixmap can be used, although some
+sizes may be faster than others.
+
+If `XCB_BACK_PIXMAP_NONE` is specified, the window has no defined background.
+The server may fill the contents with the previous screen contents or with
+contents of its own choosing.
+
+If `XCB_BACK_PIXMAP_PARENT_RELATIVE` is specified, the parent's background is
+used, but the window must have the same depth as the parent (or a Match error
+results).   The parent's background is tracked, and the current version is
+used each time the window background is required. */
+
+    XCB_CW_BACK_PIXEL = 2,
+/**< Overrides `BackPixmap`. A pixmap of undefined size filled with the specified
+background pixel is used for the background. Range-checking is not performed,
+the background pixel is truncated to the appropriate number of bits. */
+
+    XCB_CW_BORDER_PIXMAP = 4,
+/**< Overrides the default border-pixmap. The border pixmap and window must have the
+same root and the same depth. Any size pixmap can be used, although some sizes
+may be faster than others.
+
+The special value `XCB_COPY_FROM_PARENT` means the parent's border pixmap is
+copied (subsequent changes to the parent's border attribute do not affect the
+child), but the window must have the same depth as the parent. */
+
+    XCB_CW_BORDER_PIXEL = 8,
+/**< Overrides `BorderPixmap`. A pixmap of undefined size filled with the specified
+border pixel is used for the border. Range checking is not performed on the
+border-pixel value, it is truncated to the appropriate number of bits. */
+
+    XCB_CW_BIT_GRAVITY = 16,
+/**< Defines which region of the window should be retained if the window is resized. */
+
+    XCB_CW_WIN_GRAVITY = 32,
+/**< Defines how the window should be repositioned if the parent is resized (see
+`ConfigureWindow`). */
+
+    XCB_CW_BACKING_STORE = 64,
+/**< A backing-store of `WhenMapped` advises the server that maintaining contents of
+obscured regions when the window is mapped would be beneficial. A backing-store
+of `Always` advises the server that maintaining contents even when the window
+is unmapped would be beneficial. In this case, the server may generate an
+exposure event when the window is created. A value of `NotUseful` advises the
+server that maintaining contents is unnecessary, although a server may still
+choose to maintain contents while the window is mapped. Note that if the server
+maintains contents, then the server should maintain complete contents not just
+the region within the parent boundaries, even if the window is larger than its
+parent. While the server maintains contents, exposure events will not normally
+be generated, but the server may stop maintaining contents at any time. */
+
+    XCB_CW_BACKING_PLANES = 128,
+/**< The backing-planes indicates (with bits set to 1) which bit planes of the
+window hold dynamic data that must be preserved in backing-stores and during
+save-unders. */
+
+    XCB_CW_BACKING_PIXEL = 256,
+/**< The backing-pixel specifies what value to use in planes not covered by
+backing-planes. The server is free to save only the specified bit planes in the
+backing-store or save-under and regenerate the remaining planes with the
+specified pixel value. Any bits beyond the specified depth of the window in
+these values are simply ignored. */
+
+    XCB_CW_OVERRIDE_REDIRECT = 512,
+/**< The override-redirect specifies whether map and configure requests on this
+window should override a SubstructureRedirect on the parent, typically to
+inform a window manager not to tamper with the window. */
+
+    XCB_CW_SAVE_UNDER = 1024,
+/**< If 1, the server is advised that when this window is mapped, saving the
+contents of windows it obscures would be beneficial. */
+
+    XCB_CW_EVENT_MASK = 2048,
+/**< The event-mask defines which events the client is interested in for this window
+(or for some event types, inferiors of the window). */
+
+    XCB_CW_DONT_PROPAGATE = 4096,
+/**< The do-not-propagate-mask defines which events should not be propagated to
+ancestor windows when no client has the event type selected in this window. */
+
+    XCB_CW_COLORMAP = 8192,
+/**< The colormap specifies the colormap that best reflects the true colors of the window. Servers
+capable of supporting multiple hardware colormaps may use this information, and window man-
+agers may use it for InstallColormap requests. The colormap must have the same visual type
+and root as the window (or a Match error results). If CopyFromParent is specified, the parent's
+colormap is copied (subsequent changes to the parent's colormap attribute do not affect the child).
+However, the window must have the same visual type as the parent (or a Match error results),
+and the parent must not have a colormap of None (or a Match error results). For an explanation
+of None, see FreeColormap request. The colormap is copied by sharing the colormap object
+between the child and the parent, not by making a complete copy of the colormap contents. */
+
+    XCB_CW_CURSOR = 16384
+/**< If a cursor is specified, it will be used whenever the pointer is in the window. If None is speci-
+fied, the parent's cursor will be used when the pointer is in the window, and any change in the
+parent's cursor will cause an immediate change in the displayed cursor. */
+
+} xcb_cw_t;
+
+typedef enum xcb_back_pixmap_t {
+    XCB_BACK_PIXMAP_NONE = 0,
+    XCB_BACK_PIXMAP_PARENT_RELATIVE = 1
+} xcb_back_pixmap_t;
+
+typedef enum xcb_gravity_t {
+    XCB_GRAVITY_BIT_FORGET = 0,
+    XCB_GRAVITY_WIN_UNMAP = 0,
+    XCB_GRAVITY_NORTH_WEST = 1,
+    XCB_GRAVITY_NORTH = 2,
+    XCB_GRAVITY_NORTH_EAST = 3,
+    XCB_GRAVITY_WEST = 4,
+    XCB_GRAVITY_CENTER = 5,
+    XCB_GRAVITY_EAST = 6,
+    XCB_GRAVITY_SOUTH_WEST = 7,
+    XCB_GRAVITY_SOUTH = 8,
+    XCB_GRAVITY_SOUTH_EAST = 9,
+    XCB_GRAVITY_STATIC = 10
+} xcb_gravity_t;
+
+/**
+ * @brief xcb_create_window_value_list_t
+ **/
+typedef struct xcb_create_window_value_list_t {
+    xcb_pixmap_t   background_pixmap;
+    uint32_t       background_pixel;
+    xcb_pixmap_t   border_pixmap;
+    uint32_t       border_pixel;
+    uint32_t       bit_gravity;
+    uint32_t       win_gravity;
+    uint32_t       backing_store;
+    uint32_t       backing_planes;
+    uint32_t       backing_pixel;
+    xcb_bool32_t   override_redirect;
+    xcb_bool32_t   save_under;
+    uint32_t       event_mask;
+    uint32_t       do_not_propogate_mask;
+    xcb_colormap_t colormap;
+    xcb_cursor_t   cursor;
+} xcb_create_window_value_list_t;
+
+/** Opcode for xcb_create_window. */
+#define XCB_CREATE_WINDOW 1
+
+/**
+ * @brief xcb_create_window_request_t
+ **/
+typedef struct xcb_create_window_request_t {
+    uint8_t        major_opcode;
+    uint8_t        depth;
+    uint16_t       length;
+    xcb_window_t   wid;
+    xcb_window_t   parent;
+    int16_t        x;
+    int16_t        y;
+    uint16_t       width;
+    uint16_t       height;
+    uint16_t       border_width;
+    uint16_t       _class;
+    xcb_visualid_t visual;
+    uint32_t       value_mask;
+} xcb_create_window_request_t;
+
+/**
+ * @brief xcb_change_window_attributes_value_list_t
+ **/
+typedef struct xcb_change_window_attributes_value_list_t {
+    xcb_pixmap_t   background_pixmap;
+    uint32_t       background_pixel;
+    xcb_pixmap_t   border_pixmap;
+    uint32_t       border_pixel;
+    uint32_t       bit_gravity;
+    uint32_t       win_gravity;
+    uint32_t       backing_store;
+    uint32_t       backing_planes;
+    uint32_t       backing_pixel;
+    xcb_bool32_t   override_redirect;
+    xcb_bool32_t   save_under;
+    uint32_t       event_mask;
+    uint32_t       do_not_propogate_mask;
+    xcb_colormap_t colormap;
+    xcb_cursor_t   cursor;
+} xcb_change_window_attributes_value_list_t;
+
+/** Opcode for xcb_change_window_attributes. */
+#define XCB_CHANGE_WINDOW_ATTRIBUTES 2
+
+/**
+ * @brief xcb_change_window_attributes_request_t
+ **/
+typedef struct xcb_change_window_attributes_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_window_t window;
+    uint32_t     value_mask;
+} xcb_change_window_attributes_request_t;
+
+typedef enum xcb_map_state_t {
+    XCB_MAP_STATE_UNMAPPED = 0,
+    XCB_MAP_STATE_UNVIEWABLE = 1,
+    XCB_MAP_STATE_VIEWABLE = 2
+} xcb_map_state_t;
+
+/**
+ * @brief xcb_get_window_attributes_cookie_t
+ **/
+typedef struct xcb_get_window_attributes_cookie_t {
+    unsigned int sequence;
+} xcb_get_window_attributes_cookie_t;
+
+/** Opcode for xcb_get_window_attributes. */
+#define XCB_GET_WINDOW_ATTRIBUTES 3
+
+/**
+ * @brief xcb_get_window_attributes_request_t
+ **/
+typedef struct xcb_get_window_attributes_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_get_window_attributes_request_t;
+
+/**
+ * @brief xcb_get_window_attributes_reply_t
+ **/
+typedef struct xcb_get_window_attributes_reply_t {
+    uint8_t        response_type;
+    uint8_t        backing_store;
+    uint16_t       sequence;
+    uint32_t       length;
+    xcb_visualid_t visual;
+    uint16_t       _class;
+    uint8_t        bit_gravity;
+    uint8_t        win_gravity;
+    uint32_t       backing_planes;
+    uint32_t       backing_pixel;
+    uint8_t        save_under;
+    uint8_t        map_is_installed;
+    uint8_t        map_state;
+    uint8_t        override_redirect;
+    xcb_colormap_t colormap;
+    uint32_t       all_event_masks;
+    uint32_t       your_event_mask;
+    uint16_t       do_not_propagate_mask;
+    uint8_t        pad0[2];
+} xcb_get_window_attributes_reply_t;
+
+/** Opcode for xcb_destroy_window. */
+#define XCB_DESTROY_WINDOW 4
+
+/**
+ * @brief xcb_destroy_window_request_t
+ **/
+typedef struct xcb_destroy_window_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_destroy_window_request_t;
+
+/** Opcode for xcb_destroy_subwindows. */
+#define XCB_DESTROY_SUBWINDOWS 5
+
+/**
+ * @brief xcb_destroy_subwindows_request_t
+ **/
+typedef struct xcb_destroy_subwindows_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_destroy_subwindows_request_t;
+
+typedef enum xcb_set_mode_t {
+    XCB_SET_MODE_INSERT = 0,
+    XCB_SET_MODE_DELETE = 1
+} xcb_set_mode_t;
+
+/** Opcode for xcb_change_save_set. */
+#define XCB_CHANGE_SAVE_SET 6
+
+/**
+ * @brief xcb_change_save_set_request_t
+ **/
+typedef struct xcb_change_save_set_request_t {
+    uint8_t      major_opcode;
+    uint8_t      mode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_change_save_set_request_t;
+
+/** Opcode for xcb_reparent_window. */
+#define XCB_REPARENT_WINDOW 7
+
+/**
+ * @brief xcb_reparent_window_request_t
+ **/
+typedef struct xcb_reparent_window_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_window_t window;
+    xcb_window_t parent;
+    int16_t      x;
+    int16_t      y;
+} xcb_reparent_window_request_t;
+
+/** Opcode for xcb_map_window. */
+#define XCB_MAP_WINDOW 8
+
+/**
+ * @brief xcb_map_window_request_t
+ **/
+typedef struct xcb_map_window_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_map_window_request_t;
+
+/** Opcode for xcb_map_subwindows. */
+#define XCB_MAP_SUBWINDOWS 9
+
+/**
+ * @brief xcb_map_subwindows_request_t
+ **/
+typedef struct xcb_map_subwindows_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_map_subwindows_request_t;
+
+/** Opcode for xcb_unmap_window. */
+#define XCB_UNMAP_WINDOW 10
+
+/**
+ * @brief xcb_unmap_window_request_t
+ **/
+typedef struct xcb_unmap_window_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_unmap_window_request_t;
+
+/** Opcode for xcb_unmap_subwindows. */
+#define XCB_UNMAP_SUBWINDOWS 11
+
+/**
+ * @brief xcb_unmap_subwindows_request_t
+ **/
+typedef struct xcb_unmap_subwindows_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_unmap_subwindows_request_t;
+
+typedef enum xcb_config_window_t {
+    XCB_CONFIG_WINDOW_X = 1,
+    XCB_CONFIG_WINDOW_Y = 2,
+    XCB_CONFIG_WINDOW_WIDTH = 4,
+    XCB_CONFIG_WINDOW_HEIGHT = 8,
+    XCB_CONFIG_WINDOW_BORDER_WIDTH = 16,
+    XCB_CONFIG_WINDOW_SIBLING = 32,
+    XCB_CONFIG_WINDOW_STACK_MODE = 64
+} xcb_config_window_t;
+
+typedef enum xcb_stack_mode_t {
+    XCB_STACK_MODE_ABOVE = 0,
+    XCB_STACK_MODE_BELOW = 1,
+    XCB_STACK_MODE_TOP_IF = 2,
+    XCB_STACK_MODE_BOTTOM_IF = 3,
+    XCB_STACK_MODE_OPPOSITE = 4
+} xcb_stack_mode_t;
+
+/**
+ * @brief xcb_configure_window_value_list_t
+ **/
+typedef struct xcb_configure_window_value_list_t {
+    int32_t      x;
+    int32_t      y;
+    uint32_t     width;
+    uint32_t     height;
+    uint32_t     border_width;
+    xcb_window_t sibling;
+    uint32_t     stack_mode;
+} xcb_configure_window_value_list_t;
+
+/** Opcode for xcb_configure_window. */
+#define XCB_CONFIGURE_WINDOW 12
+
+/**
+ * @brief xcb_configure_window_request_t
+ **/
+typedef struct xcb_configure_window_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_window_t window;
+    uint16_t     value_mask;
+    uint8_t      pad1[2];
+} xcb_configure_window_request_t;
+
+typedef enum xcb_circulate_t {
+    XCB_CIRCULATE_RAISE_LOWEST = 0,
+    XCB_CIRCULATE_LOWER_HIGHEST = 1
+} xcb_circulate_t;
+
+/** Opcode for xcb_circulate_window. */
+#define XCB_CIRCULATE_WINDOW 13
+
+/**
+ * @brief xcb_circulate_window_request_t
+ **/
+typedef struct xcb_circulate_window_request_t {
+    uint8_t      major_opcode;
+    uint8_t      direction;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_circulate_window_request_t;
+
+/**
+ * @brief xcb_get_geometry_cookie_t
+ **/
+typedef struct xcb_get_geometry_cookie_t {
+    unsigned int sequence;
+} xcb_get_geometry_cookie_t;
+
+/** Opcode for xcb_get_geometry. */
+#define XCB_GET_GEOMETRY 14
+
+/**
+ * @brief xcb_get_geometry_request_t
+ **/
+typedef struct xcb_get_geometry_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+} xcb_get_geometry_request_t;
+
+/**
+ * @brief xcb_get_geometry_reply_t
+ **/
+typedef struct xcb_get_geometry_reply_t {
+    uint8_t      response_type;
+    uint8_t      depth;
+    uint16_t     sequence;
+    uint32_t     length;
+    xcb_window_t root;
+    int16_t      x;
+    int16_t      y;
+    uint16_t     width;
+    uint16_t     height;
+    uint16_t     border_width;
+    uint8_t      pad0[2];
+} xcb_get_geometry_reply_t;
+
+/**
+ * @brief xcb_query_tree_cookie_t
+ **/
+typedef struct xcb_query_tree_cookie_t {
+    unsigned int sequence;
+} xcb_query_tree_cookie_t;
+
+/** Opcode for xcb_query_tree. */
+#define XCB_QUERY_TREE 15
+
+/**
+ * @brief xcb_query_tree_request_t
+ **/
+typedef struct xcb_query_tree_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_query_tree_request_t;
+
+/**
+ * @brief xcb_query_tree_reply_t
+ **/
+typedef struct xcb_query_tree_reply_t {
+    uint8_t      response_type;
+    uint8_t      pad0;
+    uint16_t     sequence;
+    uint32_t     length;
+    xcb_window_t root;
+    xcb_window_t parent;
+    uint16_t     children_len;
+    uint8_t      pad1[14];
+} xcb_query_tree_reply_t;
+
+/**
+ * @brief xcb_intern_atom_cookie_t
+ **/
+typedef struct xcb_intern_atom_cookie_t {
+    unsigned int sequence;
+} xcb_intern_atom_cookie_t;
+
+/** Opcode for xcb_intern_atom. */
+#define XCB_INTERN_ATOM 16
+
+/**
+ * @brief xcb_intern_atom_request_t
+ **/
+typedef struct xcb_intern_atom_request_t {
+    uint8_t  major_opcode;
+    uint8_t  only_if_exists;
+    uint16_t length;
+    uint16_t name_len;
+    uint8_t  pad0[2];
+} xcb_intern_atom_request_t;
+
+/**
+ * @brief xcb_intern_atom_reply_t
+ **/
+typedef struct xcb_intern_atom_reply_t {
+    uint8_t    response_type;
+    uint8_t    pad0;
+    uint16_t   sequence;
+    uint32_t   length;
+    xcb_atom_t atom;
+} xcb_intern_atom_reply_t;
+
+/**
+ * @brief xcb_get_atom_name_cookie_t
+ **/
+typedef struct xcb_get_atom_name_cookie_t {
+    unsigned int sequence;
+} xcb_get_atom_name_cookie_t;
+
+/** Opcode for xcb_get_atom_name. */
+#define XCB_GET_ATOM_NAME 17
+
+/**
+ * @brief xcb_get_atom_name_request_t
+ **/
+typedef struct xcb_get_atom_name_request_t {
+    uint8_t    major_opcode;
+    uint8_t    pad0;
+    uint16_t   length;
+    xcb_atom_t atom;
+} xcb_get_atom_name_request_t;
+
+/**
+ * @brief xcb_get_atom_name_reply_t
+ **/
+typedef struct xcb_get_atom_name_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t name_len;
+    uint8_t  pad1[22];
+} xcb_get_atom_name_reply_t;
+
+typedef enum xcb_prop_mode_t {
+    XCB_PROP_MODE_REPLACE = 0,
+/**< Discard the previous property value and store the new data. */
+
+    XCB_PROP_MODE_PREPEND = 1,
+/**< Insert the new data before the beginning of existing data. The `format` must
+match existing property value. If the property is undefined, it is treated as
+defined with the correct type and format with zero-length data. */
+
+    XCB_PROP_MODE_APPEND = 2
+/**< Insert the new data after the beginning of existing data. The `format` must
+match existing property value. If the property is undefined, it is treated as
+defined with the correct type and format with zero-length data. */
+
+} xcb_prop_mode_t;
+
+/** Opcode for xcb_change_property. */
+#define XCB_CHANGE_PROPERTY 18
+
+/**
+ * @brief xcb_change_property_request_t
+ **/
+typedef struct xcb_change_property_request_t {
+    uint8_t      major_opcode;
+    uint8_t      mode;
+    uint16_t     length;
+    xcb_window_t window;
+    xcb_atom_t   property;
+    xcb_atom_t   type;
+    uint8_t      format;
+    uint8_t      pad0[3];
+    uint32_t     data_len;
+} xcb_change_property_request_t;
+
+/** Opcode for xcb_delete_property. */
+#define XCB_DELETE_PROPERTY 19
+
+/**
+ * @brief xcb_delete_property_request_t
+ **/
+typedef struct xcb_delete_property_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_window_t window;
+    xcb_atom_t   property;
+} xcb_delete_property_request_t;
+
+typedef enum xcb_get_property_type_t {
+    XCB_GET_PROPERTY_TYPE_ANY = 0
+} xcb_get_property_type_t;
+
+/**
+ * @brief xcb_get_property_cookie_t
+ **/
+typedef struct xcb_get_property_cookie_t {
+    unsigned int sequence;
+} xcb_get_property_cookie_t;
+
+/** Opcode for xcb_get_property. */
+#define XCB_GET_PROPERTY 20
+
+/**
+ * @brief xcb_get_property_request_t
+ **/
+typedef struct xcb_get_property_request_t {
+    uint8_t      major_opcode;
+    uint8_t      _delete;
+    uint16_t     length;
+    xcb_window_t window;
+    xcb_atom_t   property;
+    xcb_atom_t   type;
+    uint32_t     long_offset;
+    uint32_t     long_length;
+} xcb_get_property_request_t;
+
+/**
+ * @brief xcb_get_property_reply_t
+ **/
+typedef struct xcb_get_property_reply_t {
+    uint8_t    response_type;
+    uint8_t    format;
+    uint16_t   sequence;
+    uint32_t   length;
+    xcb_atom_t type;
+    uint32_t   bytes_after;
+    uint32_t   value_len;
+    uint8_t    pad0[12];
+} xcb_get_property_reply_t;
+
+/**
+ * @brief xcb_list_properties_cookie_t
+ **/
+typedef struct xcb_list_properties_cookie_t {
+    unsigned int sequence;
+} xcb_list_properties_cookie_t;
+
+/** Opcode for xcb_list_properties. */
+#define XCB_LIST_PROPERTIES 21
+
+/**
+ * @brief xcb_list_properties_request_t
+ **/
+typedef struct xcb_list_properties_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_list_properties_request_t;
+
+/**
+ * @brief xcb_list_properties_reply_t
+ **/
+typedef struct xcb_list_properties_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t atoms_len;
+    uint8_t  pad1[22];
+} xcb_list_properties_reply_t;
+
+/** Opcode for xcb_set_selection_owner. */
+#define XCB_SET_SELECTION_OWNER 22
+
+/**
+ * @brief xcb_set_selection_owner_request_t
+ **/
+typedef struct xcb_set_selection_owner_request_t {
+    uint8_t         major_opcode;
+    uint8_t         pad0;
+    uint16_t        length;
+    xcb_window_t    owner;
+    xcb_atom_t      selection;
+    xcb_timestamp_t time;
+} xcb_set_selection_owner_request_t;
+
+/**
+ * @brief xcb_get_selection_owner_cookie_t
+ **/
+typedef struct xcb_get_selection_owner_cookie_t {
+    unsigned int sequence;
+} xcb_get_selection_owner_cookie_t;
+
+/** Opcode for xcb_get_selection_owner. */
+#define XCB_GET_SELECTION_OWNER 23
+
+/**
+ * @brief xcb_get_selection_owner_request_t
+ **/
+typedef struct xcb_get_selection_owner_request_t {
+    uint8_t    major_opcode;
+    uint8_t    pad0;
+    uint16_t   length;
+    xcb_atom_t selection;
+} xcb_get_selection_owner_request_t;
+
+/**
+ * @brief xcb_get_selection_owner_reply_t
+ **/
+typedef struct xcb_get_selection_owner_reply_t {
+    uint8_t      response_type;
+    uint8_t      pad0;
+    uint16_t     sequence;
+    uint32_t     length;
+    xcb_window_t owner;
+} xcb_get_selection_owner_reply_t;
+
+/** Opcode for xcb_convert_selection. */
+#define XCB_CONVERT_SELECTION 24
+
+/**
+ * @brief xcb_convert_selection_request_t
+ **/
+typedef struct xcb_convert_selection_request_t {
+    uint8_t         major_opcode;
+    uint8_t         pad0;
+    uint16_t        length;
+    xcb_window_t    requestor;
+    xcb_atom_t      selection;
+    xcb_atom_t      target;
+    xcb_atom_t      property;
+    xcb_timestamp_t time;
+} xcb_convert_selection_request_t;
+
+typedef enum xcb_send_event_dest_t {
+    XCB_SEND_EVENT_DEST_POINTER_WINDOW = 0,
+    XCB_SEND_EVENT_DEST_ITEM_FOCUS = 1
+} xcb_send_event_dest_t;
+
+/** Opcode for xcb_send_event. */
+#define XCB_SEND_EVENT 25
+
+/**
+ * @brief xcb_send_event_request_t
+ **/
+typedef struct xcb_send_event_request_t {
+    uint8_t      major_opcode;
+    uint8_t      propagate;
+    uint16_t     length;
+    xcb_window_t destination;
+    uint32_t     event_mask;
+    char         event[32];
+} xcb_send_event_request_t;
+
+typedef enum xcb_grab_mode_t {
+    XCB_GRAB_MODE_SYNC = 0,
+/**< The state of the keyboard appears to freeze: No further keyboard events are
+generated by the server until the grabbing client issues a releasing
+`AllowEvents` request or until the keyboard grab is released. */
+
+    XCB_GRAB_MODE_ASYNC = 1
+/**< Keyboard event processing continues normally. */
+
+} xcb_grab_mode_t;
+
+typedef enum xcb_grab_status_t {
+    XCB_GRAB_STATUS_SUCCESS = 0,
+    XCB_GRAB_STATUS_ALREADY_GRABBED = 1,
+    XCB_GRAB_STATUS_INVALID_TIME = 2,
+    XCB_GRAB_STATUS_NOT_VIEWABLE = 3,
+    XCB_GRAB_STATUS_FROZEN = 4
+} xcb_grab_status_t;
+
+typedef enum xcb_cursor_enum_t {
+    XCB_CURSOR_NONE = 0
+} xcb_cursor_enum_t;
+
+/**
+ * @brief xcb_grab_pointer_cookie_t
+ **/
+typedef struct xcb_grab_pointer_cookie_t {
+    unsigned int sequence;
+} xcb_grab_pointer_cookie_t;
+
+/** Opcode for xcb_grab_pointer. */
+#define XCB_GRAB_POINTER 26
+
+/**
+ * @brief xcb_grab_pointer_request_t
+ **/
+typedef struct xcb_grab_pointer_request_t {
+    uint8_t         major_opcode;
+    uint8_t         owner_events;
+    uint16_t        length;
+    xcb_window_t    grab_window;
+    uint16_t        event_mask;
+    uint8_t         pointer_mode;
+    uint8_t         keyboard_mode;
+    xcb_window_t    confine_to;
+    xcb_cursor_t    cursor;
+    xcb_timestamp_t time;
+} xcb_grab_pointer_request_t;
+
+/**
+ * @brief xcb_grab_pointer_reply_t
+ **/
+typedef struct xcb_grab_pointer_reply_t {
+    uint8_t  response_type;
+    uint8_t  status;
+    uint16_t sequence;
+    uint32_t length;
+} xcb_grab_pointer_reply_t;
+
+/** Opcode for xcb_ungrab_pointer. */
+#define XCB_UNGRAB_POINTER 27
+
+/**
+ * @brief xcb_ungrab_pointer_request_t
+ **/
+typedef struct xcb_ungrab_pointer_request_t {
+    uint8_t         major_opcode;
+    uint8_t         pad0;
+    uint16_t        length;
+    xcb_timestamp_t time;
+} xcb_ungrab_pointer_request_t;
+
+typedef enum xcb_button_index_t {
+    XCB_BUTTON_INDEX_ANY = 0,
+/**< Any of the following (or none): */
+
+    XCB_BUTTON_INDEX_1 = 1,
+/**< The left mouse button. */
+
+    XCB_BUTTON_INDEX_2 = 2,
+/**< The right mouse button. */
+
+    XCB_BUTTON_INDEX_3 = 3,
+/**< The middle mouse button. */
+
+    XCB_BUTTON_INDEX_4 = 4,
+/**< Scroll wheel. TODO: direction? */
+
+    XCB_BUTTON_INDEX_5 = 5
+/**< Scroll wheel. TODO: direction? */
+
+} xcb_button_index_t;
+
+/** Opcode for xcb_grab_button. */
+#define XCB_GRAB_BUTTON 28
+
+/**
+ * @brief xcb_grab_button_request_t
+ **/
+typedef struct xcb_grab_button_request_t {
+    uint8_t      major_opcode;
+    uint8_t      owner_events;
+    uint16_t     length;
+    xcb_window_t grab_window;
+    uint16_t     event_mask;
+    uint8_t      pointer_mode;
+    uint8_t      keyboard_mode;
+    xcb_window_t confine_to;
+    xcb_cursor_t cursor;
+    uint8_t      button;
+    uint8_t      pad0;
+    uint16_t     modifiers;
+} xcb_grab_button_request_t;
+
+/** Opcode for xcb_ungrab_button. */
+#define XCB_UNGRAB_BUTTON 29
+
+/**
+ * @brief xcb_ungrab_button_request_t
+ **/
+typedef struct xcb_ungrab_button_request_t {
+    uint8_t      major_opcode;
+    uint8_t      button;
+    uint16_t     length;
+    xcb_window_t grab_window;
+    uint16_t     modifiers;
+    uint8_t      pad0[2];
+} xcb_ungrab_button_request_t;
+
+/** Opcode for xcb_change_active_pointer_grab. */
+#define XCB_CHANGE_ACTIVE_POINTER_GRAB 30
+
+/**
+ * @brief xcb_change_active_pointer_grab_request_t
+ **/
+typedef struct xcb_change_active_pointer_grab_request_t {
+    uint8_t         major_opcode;
+    uint8_t         pad0;
+    uint16_t        length;
+    xcb_cursor_t    cursor;
+    xcb_timestamp_t time;
+    uint16_t        event_mask;
+    uint8_t         pad1[2];
+} xcb_change_active_pointer_grab_request_t;
+
+/**
+ * @brief xcb_grab_keyboard_cookie_t
+ **/
+typedef struct xcb_grab_keyboard_cookie_t {
+    unsigned int sequence;
+} xcb_grab_keyboard_cookie_t;
+
+/** Opcode for xcb_grab_keyboard. */
+#define XCB_GRAB_KEYBOARD 31
+
+/**
+ * @brief xcb_grab_keyboard_request_t
+ **/
+typedef struct xcb_grab_keyboard_request_t {
+    uint8_t         major_opcode;
+    uint8_t         owner_events;
+    uint16_t        length;
+    xcb_window_t    grab_window;
+    xcb_timestamp_t time;
+    uint8_t         pointer_mode;
+    uint8_t         keyboard_mode;
+    uint8_t         pad0[2];
+} xcb_grab_keyboard_request_t;
+
+/**
+ * @brief xcb_grab_keyboard_reply_t
+ **/
+typedef struct xcb_grab_keyboard_reply_t {
+    uint8_t  response_type;
+    uint8_t  status;
+    uint16_t sequence;
+    uint32_t length;
+} xcb_grab_keyboard_reply_t;
+
+/** Opcode for xcb_ungrab_keyboard. */
+#define XCB_UNGRAB_KEYBOARD 32
+
+/**
+ * @brief xcb_ungrab_keyboard_request_t
+ **/
+typedef struct xcb_ungrab_keyboard_request_t {
+    uint8_t         major_opcode;
+    uint8_t         pad0;
+    uint16_t        length;
+    xcb_timestamp_t time;
+} xcb_ungrab_keyboard_request_t;
+
+typedef enum xcb_grab_t {
+    XCB_GRAB_ANY = 0
+} xcb_grab_t;
+
+/** Opcode for xcb_grab_key. */
+#define XCB_GRAB_KEY 33
+
+/**
+ * @brief xcb_grab_key_request_t
+ **/
+typedef struct xcb_grab_key_request_t {
+    uint8_t       major_opcode;
+    uint8_t       owner_events;
+    uint16_t      length;
+    xcb_window_t  grab_window;
+    uint16_t      modifiers;
+    xcb_keycode_t key;
+    uint8_t       pointer_mode;
+    uint8_t       keyboard_mode;
+    uint8_t       pad0[3];
+} xcb_grab_key_request_t;
+
+/** Opcode for xcb_ungrab_key. */
+#define XCB_UNGRAB_KEY 34
+
+/**
+ * @brief xcb_ungrab_key_request_t
+ **/
+typedef struct xcb_ungrab_key_request_t {
+    uint8_t       major_opcode;
+    xcb_keycode_t key;
+    uint16_t      length;
+    xcb_window_t  grab_window;
+    uint16_t      modifiers;
+    uint8_t       pad0[2];
+} xcb_ungrab_key_request_t;
+
+typedef enum xcb_allow_t {
+    XCB_ALLOW_ASYNC_POINTER = 0,
+/**< For AsyncPointer, if the pointer is frozen by the client, pointer event
+processing continues normally. If the pointer is frozen twice by the client on
+behalf of two separate grabs, AsyncPointer thaws for both. AsyncPointer has no
+effect if the pointer is not frozen by the client, but the pointer need not be
+grabbed by the client.
+
+TODO: rewrite this in more understandable terms. */
+
+    XCB_ALLOW_SYNC_POINTER = 1,
+/**< For SyncPointer, if the pointer is frozen and actively grabbed by the client,
+pointer event processing continues normally until the next ButtonPress or
+ButtonRelease event is reported to the client, at which time the pointer again
+appears to freeze. However, if the reported event causes the pointer grab to be
+released, then the pointer does not freeze. SyncPointer has no effect if the
+pointer is not frozen by the client or if the pointer is not grabbed by the
+client. */
+
+    XCB_ALLOW_REPLAY_POINTER = 2,
+/**< For ReplayPointer, if the pointer is actively grabbed by the client and is
+frozen as the result of an event having been sent to the client (either from
+the activation of a GrabButton or from a previous AllowEvents with mode
+SyncPointer but not from a GrabPointer), then the pointer grab is released and
+that event is completely reprocessed, this time ignoring any passive grabs at
+or above (towards the root) the grab-window of the grab just released. The
+request has no effect if the pointer is not grabbed by the client or if the
+pointer is not frozen as the result of an event. */
+
+    XCB_ALLOW_ASYNC_KEYBOARD = 3,
+/**< For AsyncKeyboard, if the keyboard is frozen by the client, keyboard event
+processing continues normally. If the keyboard is frozen twice by the client on
+behalf of two separate grabs, AsyncKeyboard thaws for both. AsyncKeyboard has
+no effect if the keyboard is not frozen by the client, but the keyboard need
+not be grabbed by the client. */
+
+    XCB_ALLOW_SYNC_KEYBOARD = 4,
+/**< For SyncKeyboard, if the keyboard is frozen and actively grabbed by the client,
+keyboard event processing continues normally until the next KeyPress or
+KeyRelease event is reported to the client, at which time the keyboard again
+appears to freeze. However, if the reported event causes the keyboard grab to
+be released, then the keyboard does not freeze. SyncKeyboard has no effect if
+the keyboard is not frozen by the client or if the keyboard is not grabbed by
+the client. */
+
+    XCB_ALLOW_REPLAY_KEYBOARD = 5,
+/**< For ReplayKeyboard, if the keyboard is actively grabbed by the client and is
+frozen as the result of an event having been sent to the client (either from
+the activation of a GrabKey or from a previous AllowEvents with mode
+SyncKeyboard but not from a GrabKeyboard), then the keyboard grab is released
+and that event is completely reprocessed, this time ignoring any passive grabs
+at or above (towards the root) the grab-window of the grab just released. The
+request has no effect if the keyboard is not grabbed by the client or if the
+keyboard is not frozen as the result of an event. */
+
+    XCB_ALLOW_ASYNC_BOTH = 6,
+/**< For AsyncBoth, if the pointer and the keyboard are frozen by the client, event
+processing for both devices continues normally. If a device is frozen twice by
+the client on behalf of two separate grabs, AsyncBoth thaws for both. AsyncBoth
+has no effect unless both pointer and keyboard are frozen by the client. */
+
+    XCB_ALLOW_SYNC_BOTH = 7
+/**< For SyncBoth, if both pointer and keyboard are frozen by the client, event
+processing (for both devices) continues normally until the next ButtonPress,
+ButtonRelease, KeyPress, or KeyRelease event is reported to the client for a
+grabbed device (button event for the pointer, key event for the keyboard), at
+which time the devices again appear to freeze. However, if the reported event
+causes the grab to be released, then the devices do not freeze (but if the
+other device is still grabbed, then a subsequent event for it will still cause
+both devices to freeze). SyncBoth has no effect unless both pointer and
+keyboard are frozen by the client. If the pointer or keyboard is frozen twice
+by the client on behalf of two separate grabs, SyncBoth thaws for both (but a
+subsequent freeze for SyncBoth will only freeze each device once). */
+
+} xcb_allow_t;
+
+/** Opcode for xcb_allow_events. */
+#define XCB_ALLOW_EVENTS 35
+
+/**
+ * @brief xcb_allow_events_request_t
+ **/
+typedef struct xcb_allow_events_request_t {
+    uint8_t         major_opcode;
+    uint8_t         mode;
+    uint16_t        length;
+    xcb_timestamp_t time;
+} xcb_allow_events_request_t;
+
+/** Opcode for xcb_grab_server. */
+#define XCB_GRAB_SERVER 36
+
+/**
+ * @brief xcb_grab_server_request_t
+ **/
+typedef struct xcb_grab_server_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+} xcb_grab_server_request_t;
+
+/** Opcode for xcb_ungrab_server. */
+#define XCB_UNGRAB_SERVER 37
+
+/**
+ * @brief xcb_ungrab_server_request_t
+ **/
+typedef struct xcb_ungrab_server_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+} xcb_ungrab_server_request_t;
+
+/**
+ * @brief xcb_query_pointer_cookie_t
+ **/
+typedef struct xcb_query_pointer_cookie_t {
+    unsigned int sequence;
+} xcb_query_pointer_cookie_t;
+
+/** Opcode for xcb_query_pointer. */
+#define XCB_QUERY_POINTER 38
+
+/**
+ * @brief xcb_query_pointer_request_t
+ **/
+typedef struct xcb_query_pointer_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_query_pointer_request_t;
+
+/**
+ * @brief xcb_query_pointer_reply_t
+ **/
+typedef struct xcb_query_pointer_reply_t {
+    uint8_t      response_type;
+    uint8_t      same_screen;
+    uint16_t     sequence;
+    uint32_t     length;
+    xcb_window_t root;
+    xcb_window_t child;
+    int16_t      root_x;
+    int16_t      root_y;
+    int16_t      win_x;
+    int16_t      win_y;
+    uint16_t     mask;
+    uint8_t      pad0[2];
+} xcb_query_pointer_reply_t;
+
+/**
+ * @brief xcb_timecoord_t
+ **/
+typedef struct xcb_timecoord_t {
+    xcb_timestamp_t time;
+    int16_t         x;
+    int16_t         y;
+} xcb_timecoord_t;
+
+/**
+ * @brief xcb_timecoord_iterator_t
+ **/
+typedef struct xcb_timecoord_iterator_t {
+    xcb_timecoord_t *data;
+    int              rem;
+    int              index;
+} xcb_timecoord_iterator_t;
+
+/**
+ * @brief xcb_get_motion_events_cookie_t
+ **/
+typedef struct xcb_get_motion_events_cookie_t {
+    unsigned int sequence;
+} xcb_get_motion_events_cookie_t;
+
+/** Opcode for xcb_get_motion_events. */
+#define XCB_GET_MOTION_EVENTS 39
+
+/**
+ * @brief xcb_get_motion_events_request_t
+ **/
+typedef struct xcb_get_motion_events_request_t {
+    uint8_t         major_opcode;
+    uint8_t         pad0;
+    uint16_t        length;
+    xcb_window_t    window;
+    xcb_timestamp_t start;
+    xcb_timestamp_t stop;
+} xcb_get_motion_events_request_t;
+
+/**
+ * @brief xcb_get_motion_events_reply_t
+ **/
+typedef struct xcb_get_motion_events_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t events_len;
+    uint8_t  pad1[20];
+} xcb_get_motion_events_reply_t;
+
+/**
+ * @brief xcb_translate_coordinates_cookie_t
+ **/
+typedef struct xcb_translate_coordinates_cookie_t {
+    unsigned int sequence;
+} xcb_translate_coordinates_cookie_t;
+
+/** Opcode for xcb_translate_coordinates. */
+#define XCB_TRANSLATE_COORDINATES 40
+
+/**
+ * @brief xcb_translate_coordinates_request_t
+ **/
+typedef struct xcb_translate_coordinates_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_window_t src_window;
+    xcb_window_t dst_window;
+    int16_t      src_x;
+    int16_t      src_y;
+} xcb_translate_coordinates_request_t;
+
+/**
+ * @brief xcb_translate_coordinates_reply_t
+ **/
+typedef struct xcb_translate_coordinates_reply_t {
+    uint8_t      response_type;
+    uint8_t      same_screen;
+    uint16_t     sequence;
+    uint32_t     length;
+    xcb_window_t child;
+    int16_t      dst_x;
+    int16_t      dst_y;
+} xcb_translate_coordinates_reply_t;
+
+/** Opcode for xcb_warp_pointer. */
+#define XCB_WARP_POINTER 41
+
+/**
+ * @brief xcb_warp_pointer_request_t
+ **/
+typedef struct xcb_warp_pointer_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_window_t src_window;
+    xcb_window_t dst_window;
+    int16_t      src_x;
+    int16_t      src_y;
+    uint16_t     src_width;
+    uint16_t     src_height;
+    int16_t      dst_x;
+    int16_t      dst_y;
+} xcb_warp_pointer_request_t;
+
+typedef enum xcb_input_focus_t {
+    XCB_INPUT_FOCUS_NONE = 0,
+/**< The focus reverts to `XCB_NONE`, so no window will have the input focus. */
+
+    XCB_INPUT_FOCUS_POINTER_ROOT = 1,
+/**< The focus reverts to `XCB_POINTER_ROOT` respectively. When the focus reverts,
+FocusIn and FocusOut events are generated, but the last-focus-change time is
+not changed. */
+
+    XCB_INPUT_FOCUS_PARENT = 2,
+/**< The focus reverts to the parent (or closest viewable ancestor) and the new
+revert_to value is `XCB_INPUT_FOCUS_NONE`. */
+
+    XCB_INPUT_FOCUS_FOLLOW_KEYBOARD = 3
+/**< NOT YET DOCUMENTED. Only relevant for the xinput extension. */
+
+} xcb_input_focus_t;
+
+/** Opcode for xcb_set_input_focus. */
+#define XCB_SET_INPUT_FOCUS 42
+
+/**
+ * @brief xcb_set_input_focus_request_t
+ **/
+typedef struct xcb_set_input_focus_request_t {
+    uint8_t         major_opcode;
+    uint8_t         revert_to;
+    uint16_t        length;
+    xcb_window_t    focus;
+    xcb_timestamp_t time;
+} xcb_set_input_focus_request_t;
+
+/**
+ * @brief xcb_get_input_focus_cookie_t
+ **/
+typedef struct xcb_get_input_focus_cookie_t {
+    unsigned int sequence;
+} xcb_get_input_focus_cookie_t;
+
+/** Opcode for xcb_get_input_focus. */
+#define XCB_GET_INPUT_FOCUS 43
+
+/**
+ * @brief xcb_get_input_focus_request_t
+ **/
+typedef struct xcb_get_input_focus_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+} xcb_get_input_focus_request_t;
+
+/**
+ * @brief xcb_get_input_focus_reply_t
+ **/
+typedef struct xcb_get_input_focus_reply_t {
+    uint8_t      response_type;
+    uint8_t      revert_to;
+    uint16_t     sequence;
+    uint32_t     length;
+    xcb_window_t focus;
+} xcb_get_input_focus_reply_t;
+
+/**
+ * @brief xcb_query_keymap_cookie_t
+ **/
+typedef struct xcb_query_keymap_cookie_t {
+    unsigned int sequence;
+} xcb_query_keymap_cookie_t;
+
+/** Opcode for xcb_query_keymap. */
+#define XCB_QUERY_KEYMAP 44
+
+/**
+ * @brief xcb_query_keymap_request_t
+ **/
+typedef struct xcb_query_keymap_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+} xcb_query_keymap_request_t;
+
+/**
+ * @brief xcb_query_keymap_reply_t
+ **/
+typedef struct xcb_query_keymap_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  keys[32];
+} xcb_query_keymap_reply_t;
+
+/** Opcode for xcb_open_font. */
+#define XCB_OPEN_FONT 45
+
+/**
+ * @brief xcb_open_font_request_t
+ **/
+typedef struct xcb_open_font_request_t {
+    uint8_t    major_opcode;
+    uint8_t    pad0;
+    uint16_t   length;
+    xcb_font_t fid;
+    uint16_t   name_len;
+    uint8_t    pad1[2];
+} xcb_open_font_request_t;
+
+/** Opcode for xcb_close_font. */
+#define XCB_CLOSE_FONT 46
+
+/**
+ * @brief xcb_close_font_request_t
+ **/
+typedef struct xcb_close_font_request_t {
+    uint8_t    major_opcode;
+    uint8_t    pad0;
+    uint16_t   length;
+    xcb_font_t font;
+} xcb_close_font_request_t;
+
+typedef enum xcb_font_draw_t {
+    XCB_FONT_DRAW_LEFT_TO_RIGHT = 0,
+    XCB_FONT_DRAW_RIGHT_TO_LEFT = 1
+} xcb_font_draw_t;
+
+/**
+ * @brief xcb_fontprop_t
+ **/
+typedef struct xcb_fontprop_t {
+    xcb_atom_t name;
+    uint32_t   value;
+} xcb_fontprop_t;
+
+/**
+ * @brief xcb_fontprop_iterator_t
+ **/
+typedef struct xcb_fontprop_iterator_t {
+    xcb_fontprop_t *data;
+    int             rem;
+    int             index;
+} xcb_fontprop_iterator_t;
+
+/**
+ * @brief xcb_charinfo_t
+ **/
+typedef struct xcb_charinfo_t {
+    int16_t  left_side_bearing;
+    int16_t  right_side_bearing;
+    int16_t  character_width;
+    int16_t  ascent;
+    int16_t  descent;
+    uint16_t attributes;
+} xcb_charinfo_t;
+
+/**
+ * @brief xcb_charinfo_iterator_t
+ **/
+typedef struct xcb_charinfo_iterator_t {
+    xcb_charinfo_t *data;
+    int             rem;
+    int             index;
+} xcb_charinfo_iterator_t;
+
+/**
+ * @brief xcb_query_font_cookie_t
+ **/
+typedef struct xcb_query_font_cookie_t {
+    unsigned int sequence;
+} xcb_query_font_cookie_t;
+
+/** Opcode for xcb_query_font. */
+#define XCB_QUERY_FONT 47
+
+/**
+ * @brief xcb_query_font_request_t
+ **/
+typedef struct xcb_query_font_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_fontable_t font;
+} xcb_query_font_request_t;
+
+/**
+ * @brief xcb_query_font_reply_t
+ **/
+typedef struct xcb_query_font_reply_t {
+    uint8_t        response_type;
+    uint8_t        pad0;
+    uint16_t       sequence;
+    uint32_t       length;
+    xcb_charinfo_t min_bounds;
+    uint8_t        pad1[4];
+    xcb_charinfo_t max_bounds;
+    uint8_t        pad2[4];
+    uint16_t       min_char_or_byte2;
+    uint16_t       max_char_or_byte2;
+    uint16_t       default_char;
+    uint16_t       properties_len;
+    uint8_t        draw_direction;
+    uint8_t        min_byte1;
+    uint8_t        max_byte1;
+    uint8_t        all_chars_exist;
+    int16_t        font_ascent;
+    int16_t        font_descent;
+    uint32_t       char_infos_len;
+} xcb_query_font_reply_t;
+
+/**
+ * @brief xcb_query_text_extents_cookie_t
+ **/
+typedef struct xcb_query_text_extents_cookie_t {
+    unsigned int sequence;
+} xcb_query_text_extents_cookie_t;
+
+/** Opcode for xcb_query_text_extents. */
+#define XCB_QUERY_TEXT_EXTENTS 48
+
+/**
+ * @brief xcb_query_text_extents_request_t
+ **/
+typedef struct xcb_query_text_extents_request_t {
+    uint8_t        major_opcode;
+    uint8_t        odd_length;
+    uint16_t       length;
+    xcb_fontable_t font;
+} xcb_query_text_extents_request_t;
+
+/**
+ * @brief xcb_query_text_extents_reply_t
+ **/
+typedef struct xcb_query_text_extents_reply_t {
+    uint8_t  response_type;
+    uint8_t  draw_direction;
+    uint16_t sequence;
+    uint32_t length;
+    int16_t  font_ascent;
+    int16_t  font_descent;
+    int16_t  overall_ascent;
+    int16_t  overall_descent;
+    int32_t  overall_width;
+    int32_t  overall_left;
+    int32_t  overall_right;
+} xcb_query_text_extents_reply_t;
+
+/**
+ * @brief xcb_str_t
+ **/
+typedef struct xcb_str_t {
+    uint8_t name_len;
+} xcb_str_t;
+
+/**
+ * @brief xcb_str_iterator_t
+ **/
+typedef struct xcb_str_iterator_t {
+    xcb_str_t *data;
+    int        rem;
+    int        index;
+} xcb_str_iterator_t;
+
+/**
+ * @brief xcb_list_fonts_cookie_t
+ **/
+typedef struct xcb_list_fonts_cookie_t {
+    unsigned int sequence;
+} xcb_list_fonts_cookie_t;
+
+/** Opcode for xcb_list_fonts. */
+#define XCB_LIST_FONTS 49
+
+/**
+ * @brief xcb_list_fonts_request_t
+ **/
+typedef struct xcb_list_fonts_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+    uint16_t max_names;
+    uint16_t pattern_len;
+} xcb_list_fonts_request_t;
+
+/**
+ * @brief xcb_list_fonts_reply_t
+ **/
+typedef struct xcb_list_fonts_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t names_len;
+    uint8_t  pad1[22];
+} xcb_list_fonts_reply_t;
+
+/**
+ * @brief xcb_list_fonts_with_info_cookie_t
+ **/
+typedef struct xcb_list_fonts_with_info_cookie_t {
+    unsigned int sequence;
+} xcb_list_fonts_with_info_cookie_t;
+
+/** Opcode for xcb_list_fonts_with_info. */
+#define XCB_LIST_FONTS_WITH_INFO 50
+
+/**
+ * @brief xcb_list_fonts_with_info_request_t
+ **/
+typedef struct xcb_list_fonts_with_info_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+    uint16_t max_names;
+    uint16_t pattern_len;
+} xcb_list_fonts_with_info_request_t;
+
+/**
+ * @brief xcb_list_fonts_with_info_reply_t
+ **/
+typedef struct xcb_list_fonts_with_info_reply_t {
+    uint8_t        response_type;
+    uint8_t        name_len;
+    uint16_t       sequence;
+    uint32_t       length;
+    xcb_charinfo_t min_bounds;
+    uint8_t        pad0[4];
+    xcb_charinfo_t max_bounds;
+    uint8_t        pad1[4];
+    uint16_t       min_char_or_byte2;
+    uint16_t       max_char_or_byte2;
+    uint16_t       default_char;
+    uint16_t       properties_len;
+    uint8_t        draw_direction;
+    uint8_t        min_byte1;
+    uint8_t        max_byte1;
+    uint8_t        all_chars_exist;
+    int16_t        font_ascent;
+    int16_t        font_descent;
+    uint32_t       replies_hint;
+} xcb_list_fonts_with_info_reply_t;
+
+/** Opcode for xcb_set_font_path. */
+#define XCB_SET_FONT_PATH 51
+
+/**
+ * @brief xcb_set_font_path_request_t
+ **/
+typedef struct xcb_set_font_path_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+    uint16_t font_qty;
+    uint8_t  pad1[2];
+} xcb_set_font_path_request_t;
+
+/**
+ * @brief xcb_get_font_path_cookie_t
+ **/
+typedef struct xcb_get_font_path_cookie_t {
+    unsigned int sequence;
+} xcb_get_font_path_cookie_t;
+
+/** Opcode for xcb_get_font_path. */
+#define XCB_GET_FONT_PATH 52
+
+/**
+ * @brief xcb_get_font_path_request_t
+ **/
+typedef struct xcb_get_font_path_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+} xcb_get_font_path_request_t;
+
+/**
+ * @brief xcb_get_font_path_reply_t
+ **/
+typedef struct xcb_get_font_path_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t path_len;
+    uint8_t  pad1[22];
+} xcb_get_font_path_reply_t;
+
+/** Opcode for xcb_create_pixmap. */
+#define XCB_CREATE_PIXMAP 53
+
+/**
+ * @brief xcb_create_pixmap_request_t
+ **/
+typedef struct xcb_create_pixmap_request_t {
+    uint8_t        major_opcode;
+    uint8_t        depth;
+    uint16_t       length;
+    xcb_pixmap_t   pid;
+    xcb_drawable_t drawable;
+    uint16_t       width;
+    uint16_t       height;
+} xcb_create_pixmap_request_t;
+
+/** Opcode for xcb_free_pixmap. */
+#define XCB_FREE_PIXMAP 54
+
+/**
+ * @brief xcb_free_pixmap_request_t
+ **/
+typedef struct xcb_free_pixmap_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_pixmap_t pixmap;
+} xcb_free_pixmap_request_t;
+
+typedef enum xcb_gc_t {
+    XCB_GC_FUNCTION = 1,
+/**< TODO: Refer to GX */
+
+    XCB_GC_PLANE_MASK = 2,
+/**< In graphics operations, given a source and destination pixel, the result is
+computed bitwise on corresponding bits of the pixels; that is, a Boolean
+operation is performed in each bit plane. The plane-mask restricts the
+operation to a subset of planes, so the result is:
+
+        ((src FUNC dst) AND plane-mask) OR (dst AND (NOT plane-mask)) */
+
+    XCB_GC_FOREGROUND = 4,
+/**< Foreground colorpixel. */
+
+    XCB_GC_BACKGROUND = 8,
+/**< Background colorpixel. */
+
+    XCB_GC_LINE_WIDTH = 16,
+/**< The line-width is measured in pixels and can be greater than or equal to one, a wide line, or the
+special value zero, a thin line. */
+
+    XCB_GC_LINE_STYLE = 32,
+/**< The line-style defines which sections of a line are drawn:
+Solid                The full path of the line is drawn.
+DoubleDash           The full path of the line is drawn, but the even dashes are filled differently
+                     than the odd dashes (see fill-style), with Butt cap-style used where even and
+                     odd dashes meet.
+OnOffDash            Only the even dashes are drawn, and cap-style applies to all internal ends of
+                     the individual dashes (except NotLast is treated as Butt). */
+
+    XCB_GC_CAP_STYLE = 64,
+/**< The cap-style defines how the endpoints of a path are drawn:
+NotLast    The result is equivalent to Butt, except that for a line-width of zero the final
+           endpoint is not drawn.
+Butt       The result is square at the endpoint (perpendicular to the slope of the line)
+           with no projection beyond.
+Round      The result is a circular arc with its diameter equal to the line-width, centered
+           on the endpoint; it is equivalent to Butt for line-width zero.
+Projecting The result is square at the end, but the path continues beyond the endpoint for
+           a distance equal to half the line-width; it is equivalent to Butt for line-width
+           zero. */
+
+    XCB_GC_JOIN_STYLE = 128,
+/**< The join-style defines how corners are drawn for wide lines:
+Miter               The outer edges of the two lines extend to meet at an angle. However, if the
+                    angle is less than 11 degrees, a Bevel join-style is used instead.
+Round               The result is a circular arc with a diameter equal to the line-width, centered
+                    on the joinpoint.
+Bevel               The result is Butt endpoint styles, and then the triangular notch is filled. */
+
+    XCB_GC_FILL_STYLE = 256,
+/**< The fill-style defines the contents of the source for line, text, and fill requests. For all text and fill
+requests (for example, PolyText8, PolyText16, PolyFillRectangle, FillPoly, and PolyFillArc)
+as well as for line requests with line-style Solid, (for example, PolyLine, PolySegment,
+PolyRectangle, PolyArc) and for the even dashes for line requests with line-style OnOffDash
+or DoubleDash:
+Solid                     Foreground
+Tiled                     Tile
+OpaqueStippled            A tile with the same width and height as stipple but with background
+                          everywhere stipple has a zero and with foreground everywhere stipple
+                          has a one
+Stippled                  Foreground masked by stipple
+For the odd dashes for line requests with line-style DoubleDash:
+Solid                     Background
+Tiled                     Same as for even dashes
+OpaqueStippled            Same as for even dashes
+Stippled                  Background masked by stipple */
+
+    XCB_GC_FILL_RULE = 512,
+/**<  */
+
+    XCB_GC_TILE = 1024,
+/**< The tile/stipple represents an infinite two-dimensional plane with the tile/stipple replicated in all
+dimensions. When that plane is superimposed on the drawable for use in a graphics operation,
+the upper-left corner of some instance of the tile/stipple is at the coordinates within the drawable
+specified by the tile/stipple origin. The tile/stipple and clip origins are interpreted relative to the
+origin of whatever destination drawable is specified in a graphics request.
+The tile pixmap must have the same root and depth as the gcontext (or a Match error results).
+The stipple pixmap must have depth one and must have the same root as the gcontext (or a
+Match error results). For fill-style Stippled (but not fill-style
+OpaqueStippled), the stipple pattern is tiled in a single plane and acts as an
+additional clip mask to be ANDed with the clip-mask.
+Any size pixmap can be used for tiling or stippling, although some sizes may be faster to use than
+others. */
+
+    XCB_GC_STIPPLE = 2048,
+/**< The tile/stipple represents an infinite two-dimensional plane with the tile/stipple replicated in all
+dimensions. When that plane is superimposed on the drawable for use in a graphics operation,
+the upper-left corner of some instance of the tile/stipple is at the coordinates within the drawable
+specified by the tile/stipple origin. The tile/stipple and clip origins are interpreted relative to the
+origin of whatever destination drawable is specified in a graphics request.
+The tile pixmap must have the same root and depth as the gcontext (or a Match error results).
+The stipple pixmap must have depth one and must have the same root as the gcontext (or a
+Match error results). For fill-style Stippled (but not fill-style
+OpaqueStippled), the stipple pattern is tiled in a single plane and acts as an
+additional clip mask to be ANDed with the clip-mask.
+Any size pixmap can be used for tiling or stippling, although some sizes may be faster to use than
+others. */
+
+    XCB_GC_TILE_STIPPLE_ORIGIN_X = 4096,
+/**< TODO */
+
+    XCB_GC_TILE_STIPPLE_ORIGIN_Y = 8192,
+/**< TODO */
+
+    XCB_GC_FONT = 16384,
+/**< Which font to use for the `ImageText8` and `ImageText16` requests. */
+
+    XCB_GC_SUBWINDOW_MODE = 32768,
+/**< For ClipByChildren, both source and destination windows are additionally
+clipped by all viewable InputOutput children. For IncludeInferiors, neither
+source nor destination window is
+clipped by inferiors. This will result in including subwindow contents in the source and drawing
+through subwindow boundaries of the destination. The use of IncludeInferiors with a source or
+destination window of one depth with mapped inferiors of differing depth is not illegal, but the
+semantics is undefined by the core protocol. */
+
+    XCB_GC_GRAPHICS_EXPOSURES = 65536,
+/**< Whether ExposureEvents should be generated (1) or not (0).
+
+The default is 1. */
+
+    XCB_GC_CLIP_ORIGIN_X = 131072,
+/**< TODO */
+
+    XCB_GC_CLIP_ORIGIN_Y = 262144,
+/**< TODO */
+
+    XCB_GC_CLIP_MASK = 524288,
+/**< The clip-mask restricts writes to the destination drawable. Only pixels where the clip-mask has
+bits set to 1 are drawn. Pixels are not drawn outside the area covered by the clip-mask or where
+the clip-mask has bits set to 0. The clip-mask affects all graphics requests, but it does not clip
+sources. The clip-mask origin is interpreted relative to the origin of whatever destination drawable is specified in a graphics request. If a pixmap is specified as the clip-mask, it must have
+depth 1 and have the same root as the gcontext (or a Match error results). If clip-mask is None,
+then pixels are always drawn, regardless of the clip origin. The clip-mask can also be set with the
+SetClipRectangles request. */
+
+    XCB_GC_DASH_OFFSET = 1048576,
+/**< TODO */
+
+    XCB_GC_DASH_LIST = 2097152,
+/**< TODO */
+
+    XCB_GC_ARC_MODE = 4194304
+/**< TODO */
+
+} xcb_gc_t;
+
+typedef enum xcb_gx_t {
+    XCB_GX_CLEAR = 0,
+    XCB_GX_AND = 1,
+    XCB_GX_AND_REVERSE = 2,
+    XCB_GX_COPY = 3,
+    XCB_GX_AND_INVERTED = 4,
+    XCB_GX_NOOP = 5,
+    XCB_GX_XOR = 6,
+    XCB_GX_OR = 7,
+    XCB_GX_NOR = 8,
+    XCB_GX_EQUIV = 9,
+    XCB_GX_INVERT = 10,
+    XCB_GX_OR_REVERSE = 11,
+    XCB_GX_COPY_INVERTED = 12,
+    XCB_GX_OR_INVERTED = 13,
+    XCB_GX_NAND = 14,
+    XCB_GX_SET = 15
+} xcb_gx_t;
+
+typedef enum xcb_line_style_t {
+    XCB_LINE_STYLE_SOLID = 0,
+    XCB_LINE_STYLE_ON_OFF_DASH = 1,
+    XCB_LINE_STYLE_DOUBLE_DASH = 2
+} xcb_line_style_t;
+
+typedef enum xcb_cap_style_t {
+    XCB_CAP_STYLE_NOT_LAST = 0,
+    XCB_CAP_STYLE_BUTT = 1,
+    XCB_CAP_STYLE_ROUND = 2,
+    XCB_CAP_STYLE_PROJECTING = 3
+} xcb_cap_style_t;
+
+typedef enum xcb_join_style_t {
+    XCB_JOIN_STYLE_MITER = 0,
+    XCB_JOIN_STYLE_ROUND = 1,
+    XCB_JOIN_STYLE_BEVEL = 2
+} xcb_join_style_t;
+
+typedef enum xcb_fill_style_t {
+    XCB_FILL_STYLE_SOLID = 0,
+    XCB_FILL_STYLE_TILED = 1,
+    XCB_FILL_STYLE_STIPPLED = 2,
+    XCB_FILL_STYLE_OPAQUE_STIPPLED = 3
+} xcb_fill_style_t;
+
+typedef enum xcb_fill_rule_t {
+    XCB_FILL_RULE_EVEN_ODD = 0,
+    XCB_FILL_RULE_WINDING = 1
+} xcb_fill_rule_t;
+
+typedef enum xcb_subwindow_mode_t {
+    XCB_SUBWINDOW_MODE_CLIP_BY_CHILDREN = 0,
+    XCB_SUBWINDOW_MODE_INCLUDE_INFERIORS = 1
+} xcb_subwindow_mode_t;
+
+typedef enum xcb_arc_mode_t {
+    XCB_ARC_MODE_CHORD = 0,
+    XCB_ARC_MODE_PIE_SLICE = 1
+} xcb_arc_mode_t;
+
+/**
+ * @brief xcb_create_gc_value_list_t
+ **/
+typedef struct xcb_create_gc_value_list_t {
+    uint32_t     function;
+    uint32_t     plane_mask;
+    uint32_t     foreground;
+    uint32_t     background;
+    uint32_t     line_width;
+    uint32_t     line_style;
+    uint32_t     cap_style;
+    uint32_t     join_style;
+    uint32_t     fill_style;
+    uint32_t     fill_rule;
+    xcb_pixmap_t tile;
+    xcb_pixmap_t stipple;
+    int32_t      tile_stipple_x_origin;
+    int32_t      tile_stipple_y_origin;
+    xcb_font_t   font;
+    uint32_t     subwindow_mode;
+    xcb_bool32_t graphics_exposures;
+    int32_t      clip_x_origin;
+    int32_t      clip_y_origin;
+    xcb_pixmap_t clip_mask;
+    uint32_t     dash_offset;
+    uint32_t     dashes;
+    uint32_t     arc_mode;
+} xcb_create_gc_value_list_t;
+
+/** Opcode for xcb_create_gc. */
+#define XCB_CREATE_GC 55
+
+/**
+ * @brief xcb_create_gc_request_t
+ **/
+typedef struct xcb_create_gc_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_gcontext_t cid;
+    xcb_drawable_t drawable;
+    uint32_t       value_mask;
+} xcb_create_gc_request_t;
+
+/**
+ * @brief xcb_change_gc_value_list_t
+ **/
+typedef struct xcb_change_gc_value_list_t {
+    uint32_t     function;
+    uint32_t     plane_mask;
+    uint32_t     foreground;
+    uint32_t     background;
+    uint32_t     line_width;
+    uint32_t     line_style;
+    uint32_t     cap_style;
+    uint32_t     join_style;
+    uint32_t     fill_style;
+    uint32_t     fill_rule;
+    xcb_pixmap_t tile;
+    xcb_pixmap_t stipple;
+    int32_t      tile_stipple_x_origin;
+    int32_t      tile_stipple_y_origin;
+    xcb_font_t   font;
+    uint32_t     subwindow_mode;
+    xcb_bool32_t graphics_exposures;
+    int32_t      clip_x_origin;
+    int32_t      clip_y_origin;
+    xcb_pixmap_t clip_mask;
+    uint32_t     dash_offset;
+    uint32_t     dashes;
+    uint32_t     arc_mode;
+} xcb_change_gc_value_list_t;
+
+/** Opcode for xcb_change_gc. */
+#define XCB_CHANGE_GC 56
+
+/**
+ * @brief xcb_change_gc_request_t
+ **/
+typedef struct xcb_change_gc_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_gcontext_t gc;
+    uint32_t       value_mask;
+} xcb_change_gc_request_t;
+
+/** Opcode for xcb_copy_gc. */
+#define XCB_COPY_GC 57
+
+/**
+ * @brief xcb_copy_gc_request_t
+ **/
+typedef struct xcb_copy_gc_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_gcontext_t src_gc;
+    xcb_gcontext_t dst_gc;
+    uint32_t       value_mask;
+} xcb_copy_gc_request_t;
+
+/** Opcode for xcb_set_dashes. */
+#define XCB_SET_DASHES 58
+
+/**
+ * @brief xcb_set_dashes_request_t
+ **/
+typedef struct xcb_set_dashes_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_gcontext_t gc;
+    uint16_t       dash_offset;
+    uint16_t       dashes_len;
+} xcb_set_dashes_request_t;
+
+typedef enum xcb_clip_ordering_t {
+    XCB_CLIP_ORDERING_UNSORTED = 0,
+    XCB_CLIP_ORDERING_Y_SORTED = 1,
+    XCB_CLIP_ORDERING_YX_SORTED = 2,
+    XCB_CLIP_ORDERING_YX_BANDED = 3
+} xcb_clip_ordering_t;
+
+/** Opcode for xcb_set_clip_rectangles. */
+#define XCB_SET_CLIP_RECTANGLES 59
+
+/**
+ * @brief xcb_set_clip_rectangles_request_t
+ **/
+typedef struct xcb_set_clip_rectangles_request_t {
+    uint8_t        major_opcode;
+    uint8_t        ordering;
+    uint16_t       length;
+    xcb_gcontext_t gc;
+    int16_t        clip_x_origin;
+    int16_t        clip_y_origin;
+} xcb_set_clip_rectangles_request_t;
+
+/** Opcode for xcb_free_gc. */
+#define XCB_FREE_GC 60
+
+/**
+ * @brief xcb_free_gc_request_t
+ **/
+typedef struct xcb_free_gc_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_gcontext_t gc;
+} xcb_free_gc_request_t;
+
+/** Opcode for xcb_clear_area. */
+#define XCB_CLEAR_AREA 61
+
+/**
+ * @brief xcb_clear_area_request_t
+ **/
+typedef struct xcb_clear_area_request_t {
+    uint8_t      major_opcode;
+    uint8_t      exposures;
+    uint16_t     length;
+    xcb_window_t window;
+    int16_t      x;
+    int16_t      y;
+    uint16_t     width;
+    uint16_t     height;
+} xcb_clear_area_request_t;
+
+/** Opcode for xcb_copy_area. */
+#define XCB_COPY_AREA 62
+
+/**
+ * @brief xcb_copy_area_request_t
+ **/
+typedef struct xcb_copy_area_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_drawable_t src_drawable;
+    xcb_drawable_t dst_drawable;
+    xcb_gcontext_t gc;
+    int16_t        src_x;
+    int16_t        src_y;
+    int16_t        dst_x;
+    int16_t        dst_y;
+    uint16_t       width;
+    uint16_t       height;
+} xcb_copy_area_request_t;
+
+/** Opcode for xcb_copy_plane. */
+#define XCB_COPY_PLANE 63
+
+/**
+ * @brief xcb_copy_plane_request_t
+ **/
+typedef struct xcb_copy_plane_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_drawable_t src_drawable;
+    xcb_drawable_t dst_drawable;
+    xcb_gcontext_t gc;
+    int16_t        src_x;
+    int16_t        src_y;
+    int16_t        dst_x;
+    int16_t        dst_y;
+    uint16_t       width;
+    uint16_t       height;
+    uint32_t       bit_plane;
+} xcb_copy_plane_request_t;
+
+typedef enum xcb_coord_mode_t {
+    XCB_COORD_MODE_ORIGIN = 0,
+/**< Treats all coordinates as relative to the origin. */
+
+    XCB_COORD_MODE_PREVIOUS = 1
+/**< Treats all coordinates after the first as relative to the previous coordinate. */
+
+} xcb_coord_mode_t;
+
+/** Opcode for xcb_poly_point. */
+#define XCB_POLY_POINT 64
+
+/**
+ * @brief xcb_poly_point_request_t
+ **/
+typedef struct xcb_poly_point_request_t {
+    uint8_t        major_opcode;
+    uint8_t        coordinate_mode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    xcb_gcontext_t gc;
+} xcb_poly_point_request_t;
+
+/** Opcode for xcb_poly_line. */
+#define XCB_POLY_LINE 65
+
+/**
+ * @brief xcb_poly_line_request_t
+ **/
+typedef struct xcb_poly_line_request_t {
+    uint8_t        major_opcode;
+    uint8_t        coordinate_mode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    xcb_gcontext_t gc;
+} xcb_poly_line_request_t;
+
+/**
+ * @brief xcb_segment_t
+ **/
+typedef struct xcb_segment_t {
+    int16_t x1;
+    int16_t y1;
+    int16_t x2;
+    int16_t y2;
+} xcb_segment_t;
+
+/**
+ * @brief xcb_segment_iterator_t
+ **/
+typedef struct xcb_segment_iterator_t {
+    xcb_segment_t *data;
+    int            rem;
+    int            index;
+} xcb_segment_iterator_t;
+
+/** Opcode for xcb_poly_segment. */
+#define XCB_POLY_SEGMENT 66
+
+/**
+ * @brief xcb_poly_segment_request_t
+ **/
+typedef struct xcb_poly_segment_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    xcb_gcontext_t gc;
+} xcb_poly_segment_request_t;
+
+/** Opcode for xcb_poly_rectangle. */
+#define XCB_POLY_RECTANGLE 67
+
+/**
+ * @brief xcb_poly_rectangle_request_t
+ **/
+typedef struct xcb_poly_rectangle_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    xcb_gcontext_t gc;
+} xcb_poly_rectangle_request_t;
+
+/** Opcode for xcb_poly_arc. */
+#define XCB_POLY_ARC 68
+
+/**
+ * @brief xcb_poly_arc_request_t
+ **/
+typedef struct xcb_poly_arc_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    xcb_gcontext_t gc;
+} xcb_poly_arc_request_t;
+
+typedef enum xcb_poly_shape_t {
+    XCB_POLY_SHAPE_COMPLEX = 0,
+    XCB_POLY_SHAPE_NONCONVEX = 1,
+    XCB_POLY_SHAPE_CONVEX = 2
+} xcb_poly_shape_t;
+
+/** Opcode for xcb_fill_poly. */
+#define XCB_FILL_POLY 69
+
+/**
+ * @brief xcb_fill_poly_request_t
+ **/
+typedef struct xcb_fill_poly_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    xcb_gcontext_t gc;
+    uint8_t        shape;
+    uint8_t        coordinate_mode;
+    uint8_t        pad1[2];
+} xcb_fill_poly_request_t;
+
+/** Opcode for xcb_poly_fill_rectangle. */
+#define XCB_POLY_FILL_RECTANGLE 70
+
+/**
+ * @brief xcb_poly_fill_rectangle_request_t
+ **/
+typedef struct xcb_poly_fill_rectangle_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    xcb_gcontext_t gc;
+} xcb_poly_fill_rectangle_request_t;
+
+/** Opcode for xcb_poly_fill_arc. */
+#define XCB_POLY_FILL_ARC 71
+
+/**
+ * @brief xcb_poly_fill_arc_request_t
+ **/
+typedef struct xcb_poly_fill_arc_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    xcb_gcontext_t gc;
+} xcb_poly_fill_arc_request_t;
+
+typedef enum xcb_image_format_t {
+    XCB_IMAGE_FORMAT_XY_BITMAP = 0,
+    XCB_IMAGE_FORMAT_XY_PIXMAP = 1,
+    XCB_IMAGE_FORMAT_Z_PIXMAP = 2
+} xcb_image_format_t;
+
+/** Opcode for xcb_put_image. */
+#define XCB_PUT_IMAGE 72
+
+/**
+ * @brief xcb_put_image_request_t
+ **/
+typedef struct xcb_put_image_request_t {
+    uint8_t        major_opcode;
+    uint8_t        format;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    xcb_gcontext_t gc;
+    uint16_t       width;
+    uint16_t       height;
+    int16_t        dst_x;
+    int16_t        dst_y;
+    uint8_t        left_pad;
+    uint8_t        depth;
+    uint8_t        pad0[2];
+} xcb_put_image_request_t;
+
+/**
+ * @brief xcb_get_image_cookie_t
+ **/
+typedef struct xcb_get_image_cookie_t {
+    unsigned int sequence;
+} xcb_get_image_cookie_t;
+
+/** Opcode for xcb_get_image. */
+#define XCB_GET_IMAGE 73
+
+/**
+ * @brief xcb_get_image_request_t
+ **/
+typedef struct xcb_get_image_request_t {
+    uint8_t        major_opcode;
+    uint8_t        format;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    int16_t        x;
+    int16_t        y;
+    uint16_t       width;
+    uint16_t       height;
+    uint32_t       plane_mask;
+} xcb_get_image_request_t;
+
+/**
+ * @brief xcb_get_image_reply_t
+ **/
+typedef struct xcb_get_image_reply_t {
+    uint8_t        response_type;
+    uint8_t        depth;
+    uint16_t       sequence;
+    uint32_t       length;
+    xcb_visualid_t visual;
+    uint8_t        pad0[20];
+} xcb_get_image_reply_t;
+
+/** Opcode for xcb_poly_text_8. */
+#define XCB_POLY_TEXT_8 74
+
+/**
+ * @brief xcb_poly_text_8_request_t
+ **/
+typedef struct xcb_poly_text_8_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    xcb_gcontext_t gc;
+    int16_t        x;
+    int16_t        y;
+} xcb_poly_text_8_request_t;
+
+/** Opcode for xcb_poly_text_16. */
+#define XCB_POLY_TEXT_16 75
+
+/**
+ * @brief xcb_poly_text_16_request_t
+ **/
+typedef struct xcb_poly_text_16_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    xcb_gcontext_t gc;
+    int16_t        x;
+    int16_t        y;
+} xcb_poly_text_16_request_t;
+
+/** Opcode for xcb_image_text_8. */
+#define XCB_IMAGE_TEXT_8 76
+
+/**
+ * @brief xcb_image_text_8_request_t
+ **/
+typedef struct xcb_image_text_8_request_t {
+    uint8_t        major_opcode;
+    uint8_t        string_len;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    xcb_gcontext_t gc;
+    int16_t        x;
+    int16_t        y;
+} xcb_image_text_8_request_t;
+
+/** Opcode for xcb_image_text_16. */
+#define XCB_IMAGE_TEXT_16 77
+
+/**
+ * @brief xcb_image_text_16_request_t
+ **/
+typedef struct xcb_image_text_16_request_t {
+    uint8_t        major_opcode;
+    uint8_t        string_len;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    xcb_gcontext_t gc;
+    int16_t        x;
+    int16_t        y;
+} xcb_image_text_16_request_t;
+
+typedef enum xcb_colormap_alloc_t {
+    XCB_COLORMAP_ALLOC_NONE = 0,
+    XCB_COLORMAP_ALLOC_ALL = 1
+} xcb_colormap_alloc_t;
+
+/** Opcode for xcb_create_colormap. */
+#define XCB_CREATE_COLORMAP 78
+
+/**
+ * @brief xcb_create_colormap_request_t
+ **/
+typedef struct xcb_create_colormap_request_t {
+    uint8_t        major_opcode;
+    uint8_t        alloc;
+    uint16_t       length;
+    xcb_colormap_t mid;
+    xcb_window_t   window;
+    xcb_visualid_t visual;
+} xcb_create_colormap_request_t;
+
+/** Opcode for xcb_free_colormap. */
+#define XCB_FREE_COLORMAP 79
+
+/**
+ * @brief xcb_free_colormap_request_t
+ **/
+typedef struct xcb_free_colormap_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_colormap_t cmap;
+} xcb_free_colormap_request_t;
+
+/** Opcode for xcb_copy_colormap_and_free. */
+#define XCB_COPY_COLORMAP_AND_FREE 80
+
+/**
+ * @brief xcb_copy_colormap_and_free_request_t
+ **/
+typedef struct xcb_copy_colormap_and_free_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_colormap_t mid;
+    xcb_colormap_t src_cmap;
+} xcb_copy_colormap_and_free_request_t;
+
+/** Opcode for xcb_install_colormap. */
+#define XCB_INSTALL_COLORMAP 81
+
+/**
+ * @brief xcb_install_colormap_request_t
+ **/
+typedef struct xcb_install_colormap_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_colormap_t cmap;
+} xcb_install_colormap_request_t;
+
+/** Opcode for xcb_uninstall_colormap. */
+#define XCB_UNINSTALL_COLORMAP 82
+
+/**
+ * @brief xcb_uninstall_colormap_request_t
+ **/
+typedef struct xcb_uninstall_colormap_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_colormap_t cmap;
+} xcb_uninstall_colormap_request_t;
+
+/**
+ * @brief xcb_list_installed_colormaps_cookie_t
+ **/
+typedef struct xcb_list_installed_colormaps_cookie_t {
+    unsigned int sequence;
+} xcb_list_installed_colormaps_cookie_t;
+
+/** Opcode for xcb_list_installed_colormaps. */
+#define XCB_LIST_INSTALLED_COLORMAPS 83
+
+/**
+ * @brief xcb_list_installed_colormaps_request_t
+ **/
+typedef struct xcb_list_installed_colormaps_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_list_installed_colormaps_request_t;
+
+/**
+ * @brief xcb_list_installed_colormaps_reply_t
+ **/
+typedef struct xcb_list_installed_colormaps_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t cmaps_len;
+    uint8_t  pad1[22];
+} xcb_list_installed_colormaps_reply_t;
+
+/**
+ * @brief xcb_alloc_color_cookie_t
+ **/
+typedef struct xcb_alloc_color_cookie_t {
+    unsigned int sequence;
+} xcb_alloc_color_cookie_t;
+
+/** Opcode for xcb_alloc_color. */
+#define XCB_ALLOC_COLOR 84
+
+/**
+ * @brief xcb_alloc_color_request_t
+ **/
+typedef struct xcb_alloc_color_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_colormap_t cmap;
+    uint16_t       red;
+    uint16_t       green;
+    uint16_t       blue;
+    uint8_t        pad1[2];
+} xcb_alloc_color_request_t;
+
+/**
+ * @brief xcb_alloc_color_reply_t
+ **/
+typedef struct xcb_alloc_color_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t red;
+    uint16_t green;
+    uint16_t blue;
+    uint8_t  pad1[2];
+    uint32_t pixel;
+} xcb_alloc_color_reply_t;
+
+/**
+ * @brief xcb_alloc_named_color_cookie_t
+ **/
+typedef struct xcb_alloc_named_color_cookie_t {
+    unsigned int sequence;
+} xcb_alloc_named_color_cookie_t;
+
+/** Opcode for xcb_alloc_named_color. */
+#define XCB_ALLOC_NAMED_COLOR 85
+
+/**
+ * @brief xcb_alloc_named_color_request_t
+ **/
+typedef struct xcb_alloc_named_color_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_colormap_t cmap;
+    uint16_t       name_len;
+    uint8_t        pad1[2];
+} xcb_alloc_named_color_request_t;
+
+/**
+ * @brief xcb_alloc_named_color_reply_t
+ **/
+typedef struct xcb_alloc_named_color_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t pixel;
+    uint16_t exact_red;
+    uint16_t exact_green;
+    uint16_t exact_blue;
+    uint16_t visual_red;
+    uint16_t visual_green;
+    uint16_t visual_blue;
+} xcb_alloc_named_color_reply_t;
+
+/**
+ * @brief xcb_alloc_color_cells_cookie_t
+ **/
+typedef struct xcb_alloc_color_cells_cookie_t {
+    unsigned int sequence;
+} xcb_alloc_color_cells_cookie_t;
+
+/** Opcode for xcb_alloc_color_cells. */
+#define XCB_ALLOC_COLOR_CELLS 86
+
+/**
+ * @brief xcb_alloc_color_cells_request_t
+ **/
+typedef struct xcb_alloc_color_cells_request_t {
+    uint8_t        major_opcode;
+    uint8_t        contiguous;
+    uint16_t       length;
+    xcb_colormap_t cmap;
+    uint16_t       colors;
+    uint16_t       planes;
+} xcb_alloc_color_cells_request_t;
+
+/**
+ * @brief xcb_alloc_color_cells_reply_t
+ **/
+typedef struct xcb_alloc_color_cells_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t pixels_len;
+    uint16_t masks_len;
+    uint8_t  pad1[20];
+} xcb_alloc_color_cells_reply_t;
+
+/**
+ * @brief xcb_alloc_color_planes_cookie_t
+ **/
+typedef struct xcb_alloc_color_planes_cookie_t {
+    unsigned int sequence;
+} xcb_alloc_color_planes_cookie_t;
+
+/** Opcode for xcb_alloc_color_planes. */
+#define XCB_ALLOC_COLOR_PLANES 87
+
+/**
+ * @brief xcb_alloc_color_planes_request_t
+ **/
+typedef struct xcb_alloc_color_planes_request_t {
+    uint8_t        major_opcode;
+    uint8_t        contiguous;
+    uint16_t       length;
+    xcb_colormap_t cmap;
+    uint16_t       colors;
+    uint16_t       reds;
+    uint16_t       greens;
+    uint16_t       blues;
+} xcb_alloc_color_planes_request_t;
+
+/**
+ * @brief xcb_alloc_color_planes_reply_t
+ **/
+typedef struct xcb_alloc_color_planes_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t pixels_len;
+    uint8_t  pad1[2];
+    uint32_t red_mask;
+    uint32_t green_mask;
+    uint32_t blue_mask;
+    uint8_t  pad2[8];
+} xcb_alloc_color_planes_reply_t;
+
+/** Opcode for xcb_free_colors. */
+#define XCB_FREE_COLORS 88
+
+/**
+ * @brief xcb_free_colors_request_t
+ **/
+typedef struct xcb_free_colors_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_colormap_t cmap;
+    uint32_t       plane_mask;
+} xcb_free_colors_request_t;
+
+typedef enum xcb_color_flag_t {
+    XCB_COLOR_FLAG_RED = 1,
+    XCB_COLOR_FLAG_GREEN = 2,
+    XCB_COLOR_FLAG_BLUE = 4
+} xcb_color_flag_t;
+
+/**
+ * @brief xcb_coloritem_t
+ **/
+typedef struct xcb_coloritem_t {
+    uint32_t pixel;
+    uint16_t red;
+    uint16_t green;
+    uint16_t blue;
+    uint8_t  flags;
+    uint8_t  pad0;
+} xcb_coloritem_t;
+
+/**
+ * @brief xcb_coloritem_iterator_t
+ **/
+typedef struct xcb_coloritem_iterator_t {
+    xcb_coloritem_t *data;
+    int              rem;
+    int              index;
+} xcb_coloritem_iterator_t;
+
+/** Opcode for xcb_store_colors. */
+#define XCB_STORE_COLORS 89
+
+/**
+ * @brief xcb_store_colors_request_t
+ **/
+typedef struct xcb_store_colors_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_colormap_t cmap;
+} xcb_store_colors_request_t;
+
+/** Opcode for xcb_store_named_color. */
+#define XCB_STORE_NAMED_COLOR 90
+
+/**
+ * @brief xcb_store_named_color_request_t
+ **/
+typedef struct xcb_store_named_color_request_t {
+    uint8_t        major_opcode;
+    uint8_t        flags;
+    uint16_t       length;
+    xcb_colormap_t cmap;
+    uint32_t       pixel;
+    uint16_t       name_len;
+    uint8_t        pad0[2];
+} xcb_store_named_color_request_t;
+
+/**
+ * @brief xcb_rgb_t
+ **/
+typedef struct xcb_rgb_t {
+    uint16_t red;
+    uint16_t green;
+    uint16_t blue;
+    uint8_t  pad0[2];
+} xcb_rgb_t;
+
+/**
+ * @brief xcb_rgb_iterator_t
+ **/
+typedef struct xcb_rgb_iterator_t {
+    xcb_rgb_t *data;
+    int        rem;
+    int        index;
+} xcb_rgb_iterator_t;
+
+/**
+ * @brief xcb_query_colors_cookie_t
+ **/
+typedef struct xcb_query_colors_cookie_t {
+    unsigned int sequence;
+} xcb_query_colors_cookie_t;
+
+/** Opcode for xcb_query_colors. */
+#define XCB_QUERY_COLORS 91
+
+/**
+ * @brief xcb_query_colors_request_t
+ **/
+typedef struct xcb_query_colors_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_colormap_t cmap;
+} xcb_query_colors_request_t;
+
+/**
+ * @brief xcb_query_colors_reply_t
+ **/
+typedef struct xcb_query_colors_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t colors_len;
+    uint8_t  pad1[22];
+} xcb_query_colors_reply_t;
+
+/**
+ * @brief xcb_lookup_color_cookie_t
+ **/
+typedef struct xcb_lookup_color_cookie_t {
+    unsigned int sequence;
+} xcb_lookup_color_cookie_t;
+
+/** Opcode for xcb_lookup_color. */
+#define XCB_LOOKUP_COLOR 92
+
+/**
+ * @brief xcb_lookup_color_request_t
+ **/
+typedef struct xcb_lookup_color_request_t {
+    uint8_t        major_opcode;
+    uint8_t        pad0;
+    uint16_t       length;
+    xcb_colormap_t cmap;
+    uint16_t       name_len;
+    uint8_t        pad1[2];
+} xcb_lookup_color_request_t;
+
+/**
+ * @brief xcb_lookup_color_reply_t
+ **/
+typedef struct xcb_lookup_color_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t exact_red;
+    uint16_t exact_green;
+    uint16_t exact_blue;
+    uint16_t visual_red;
+    uint16_t visual_green;
+    uint16_t visual_blue;
+} xcb_lookup_color_reply_t;
+
+typedef enum xcb_pixmap_enum_t {
+    XCB_PIXMAP_NONE = 0
+} xcb_pixmap_enum_t;
+
+/** Opcode for xcb_create_cursor. */
+#define XCB_CREATE_CURSOR 93
+
+/**
+ * @brief xcb_create_cursor_request_t
+ **/
+typedef struct xcb_create_cursor_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_cursor_t cid;
+    xcb_pixmap_t source;
+    xcb_pixmap_t mask;
+    uint16_t     fore_red;
+    uint16_t     fore_green;
+    uint16_t     fore_blue;
+    uint16_t     back_red;
+    uint16_t     back_green;
+    uint16_t     back_blue;
+    uint16_t     x;
+    uint16_t     y;
+} xcb_create_cursor_request_t;
+
+typedef enum xcb_font_enum_t {
+    XCB_FONT_NONE = 0
+} xcb_font_enum_t;
+
+/** Opcode for xcb_create_glyph_cursor. */
+#define XCB_CREATE_GLYPH_CURSOR 94
+
+/**
+ * @brief xcb_create_glyph_cursor_request_t
+ **/
+typedef struct xcb_create_glyph_cursor_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_cursor_t cid;
+    xcb_font_t   source_font;
+    xcb_font_t   mask_font;
+    uint16_t     source_char;
+    uint16_t     mask_char;
+    uint16_t     fore_red;
+    uint16_t     fore_green;
+    uint16_t     fore_blue;
+    uint16_t     back_red;
+    uint16_t     back_green;
+    uint16_t     back_blue;
+} xcb_create_glyph_cursor_request_t;
+
+/** Opcode for xcb_free_cursor. */
+#define XCB_FREE_CURSOR 95
+
+/**
+ * @brief xcb_free_cursor_request_t
+ **/
+typedef struct xcb_free_cursor_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_cursor_t cursor;
+} xcb_free_cursor_request_t;
+
+/** Opcode for xcb_recolor_cursor. */
+#define XCB_RECOLOR_CURSOR 96
+
+/**
+ * @brief xcb_recolor_cursor_request_t
+ **/
+typedef struct xcb_recolor_cursor_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_cursor_t cursor;
+    uint16_t     fore_red;
+    uint16_t     fore_green;
+    uint16_t     fore_blue;
+    uint16_t     back_red;
+    uint16_t     back_green;
+    uint16_t     back_blue;
+} xcb_recolor_cursor_request_t;
+
+typedef enum xcb_query_shape_of_t {
+    XCB_QUERY_SHAPE_OF_LARGEST_CURSOR = 0,
+    XCB_QUERY_SHAPE_OF_FASTEST_TILE = 1,
+    XCB_QUERY_SHAPE_OF_FASTEST_STIPPLE = 2
+} xcb_query_shape_of_t;
+
+/**
+ * @brief xcb_query_best_size_cookie_t
+ **/
+typedef struct xcb_query_best_size_cookie_t {
+    unsigned int sequence;
+} xcb_query_best_size_cookie_t;
+
+/** Opcode for xcb_query_best_size. */
+#define XCB_QUERY_BEST_SIZE 97
+
+/**
+ * @brief xcb_query_best_size_request_t
+ **/
+typedef struct xcb_query_best_size_request_t {
+    uint8_t        major_opcode;
+    uint8_t        _class;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    uint16_t       width;
+    uint16_t       height;
+} xcb_query_best_size_request_t;
+
+/**
+ * @brief xcb_query_best_size_reply_t
+ **/
+typedef struct xcb_query_best_size_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t width;
+    uint16_t height;
+} xcb_query_best_size_reply_t;
+
+/**
+ * @brief xcb_query_extension_cookie_t
+ **/
+typedef struct xcb_query_extension_cookie_t {
+    unsigned int sequence;
+} xcb_query_extension_cookie_t;
+
+/** Opcode for xcb_query_extension. */
+#define XCB_QUERY_EXTENSION 98
+
+/**
+ * @brief xcb_query_extension_request_t
+ **/
+typedef struct xcb_query_extension_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+    uint16_t name_len;
+    uint8_t  pad1[2];
+} xcb_query_extension_request_t;
+
+/**
+ * @brief xcb_query_extension_reply_t
+ **/
+typedef struct xcb_query_extension_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  present;
+    uint8_t  major_opcode;
+    uint8_t  first_event;
+    uint8_t  first_error;
+} xcb_query_extension_reply_t;
+
+/**
+ * @brief xcb_list_extensions_cookie_t
+ **/
+typedef struct xcb_list_extensions_cookie_t {
+    unsigned int sequence;
+} xcb_list_extensions_cookie_t;
+
+/** Opcode for xcb_list_extensions. */
+#define XCB_LIST_EXTENSIONS 99
+
+/**
+ * @brief xcb_list_extensions_request_t
+ **/
+typedef struct xcb_list_extensions_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+} xcb_list_extensions_request_t;
+
+/**
+ * @brief xcb_list_extensions_reply_t
+ **/
+typedef struct xcb_list_extensions_reply_t {
+    uint8_t  response_type;
+    uint8_t  names_len;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad0[24];
+} xcb_list_extensions_reply_t;
+
+/** Opcode for xcb_change_keyboard_mapping. */
+#define XCB_CHANGE_KEYBOARD_MAPPING 100
+
+/**
+ * @brief xcb_change_keyboard_mapping_request_t
+ **/
+typedef struct xcb_change_keyboard_mapping_request_t {
+    uint8_t       major_opcode;
+    uint8_t       keycode_count;
+    uint16_t      length;
+    xcb_keycode_t first_keycode;
+    uint8_t       keysyms_per_keycode;
+    uint8_t       pad0[2];
+} xcb_change_keyboard_mapping_request_t;
+
+/**
+ * @brief xcb_get_keyboard_mapping_cookie_t
+ **/
+typedef struct xcb_get_keyboard_mapping_cookie_t {
+    unsigned int sequence;
+} xcb_get_keyboard_mapping_cookie_t;
+
+/** Opcode for xcb_get_keyboard_mapping. */
+#define XCB_GET_KEYBOARD_MAPPING 101
+
+/**
+ * @brief xcb_get_keyboard_mapping_request_t
+ **/
+typedef struct xcb_get_keyboard_mapping_request_t {
+    uint8_t       major_opcode;
+    uint8_t       pad0;
+    uint16_t      length;
+    xcb_keycode_t first_keycode;
+    uint8_t       count;
+} xcb_get_keyboard_mapping_request_t;
+
+/**
+ * @brief xcb_get_keyboard_mapping_reply_t
+ **/
+typedef struct xcb_get_keyboard_mapping_reply_t {
+    uint8_t  response_type;
+    uint8_t  keysyms_per_keycode;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad0[24];
+} xcb_get_keyboard_mapping_reply_t;
+
+typedef enum xcb_kb_t {
+    XCB_KB_KEY_CLICK_PERCENT = 1,
+    XCB_KB_BELL_PERCENT = 2,
+    XCB_KB_BELL_PITCH = 4,
+    XCB_KB_BELL_DURATION = 8,
+    XCB_KB_LED = 16,
+    XCB_KB_LED_MODE = 32,
+    XCB_KB_KEY = 64,
+    XCB_KB_AUTO_REPEAT_MODE = 128
+} xcb_kb_t;
+
+typedef enum xcb_led_mode_t {
+    XCB_LED_MODE_OFF = 0,
+    XCB_LED_MODE_ON = 1
+} xcb_led_mode_t;
+
+typedef enum xcb_auto_repeat_mode_t {
+    XCB_AUTO_REPEAT_MODE_OFF = 0,
+    XCB_AUTO_REPEAT_MODE_ON = 1,
+    XCB_AUTO_REPEAT_MODE_DEFAULT = 2
+} xcb_auto_repeat_mode_t;
+
+/**
+ * @brief xcb_change_keyboard_control_value_list_t
+ **/
+typedef struct xcb_change_keyboard_control_value_list_t {
+    int32_t         key_click_percent;
+    int32_t         bell_percent;
+    int32_t         bell_pitch;
+    int32_t         bell_duration;
+    uint32_t        led;
+    uint32_t        led_mode;
+    xcb_keycode32_t key;
+    uint32_t        auto_repeat_mode;
+} xcb_change_keyboard_control_value_list_t;
+
+/** Opcode for xcb_change_keyboard_control. */
+#define XCB_CHANGE_KEYBOARD_CONTROL 102
+
+/**
+ * @brief xcb_change_keyboard_control_request_t
+ **/
+typedef struct xcb_change_keyboard_control_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+    uint32_t value_mask;
+} xcb_change_keyboard_control_request_t;
+
+/**
+ * @brief xcb_get_keyboard_control_cookie_t
+ **/
+typedef struct xcb_get_keyboard_control_cookie_t {
+    unsigned int sequence;
+} xcb_get_keyboard_control_cookie_t;
+
+/** Opcode for xcb_get_keyboard_control. */
+#define XCB_GET_KEYBOARD_CONTROL 103
+
+/**
+ * @brief xcb_get_keyboard_control_request_t
+ **/
+typedef struct xcb_get_keyboard_control_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+} xcb_get_keyboard_control_request_t;
+
+/**
+ * @brief xcb_get_keyboard_control_reply_t
+ **/
+typedef struct xcb_get_keyboard_control_reply_t {
+    uint8_t  response_type;
+    uint8_t  global_auto_repeat;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t led_mask;
+    uint8_t  key_click_percent;
+    uint8_t  bell_percent;
+    uint16_t bell_pitch;
+    uint16_t bell_duration;
+    uint8_t  pad0[2];
+    uint8_t  auto_repeats[32];
+} xcb_get_keyboard_control_reply_t;
+
+/** Opcode for xcb_bell. */
+#define XCB_BELL 104
+
+/**
+ * @brief xcb_bell_request_t
+ **/
+typedef struct xcb_bell_request_t {
+    uint8_t  major_opcode;
+    int8_t   percent;
+    uint16_t length;
+} xcb_bell_request_t;
+
+/** Opcode for xcb_change_pointer_control. */
+#define XCB_CHANGE_POINTER_CONTROL 105
+
+/**
+ * @brief xcb_change_pointer_control_request_t
+ **/
+typedef struct xcb_change_pointer_control_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+    int16_t  acceleration_numerator;
+    int16_t  acceleration_denominator;
+    int16_t  threshold;
+    uint8_t  do_acceleration;
+    uint8_t  do_threshold;
+} xcb_change_pointer_control_request_t;
+
+/**
+ * @brief xcb_get_pointer_control_cookie_t
+ **/
+typedef struct xcb_get_pointer_control_cookie_t {
+    unsigned int sequence;
+} xcb_get_pointer_control_cookie_t;
+
+/** Opcode for xcb_get_pointer_control. */
+#define XCB_GET_POINTER_CONTROL 106
+
+/**
+ * @brief xcb_get_pointer_control_request_t
+ **/
+typedef struct xcb_get_pointer_control_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+} xcb_get_pointer_control_request_t;
+
+/**
+ * @brief xcb_get_pointer_control_reply_t
+ **/
+typedef struct xcb_get_pointer_control_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t acceleration_numerator;
+    uint16_t acceleration_denominator;
+    uint16_t threshold;
+    uint8_t  pad1[18];
+} xcb_get_pointer_control_reply_t;
+
+typedef enum xcb_blanking_t {
+    XCB_BLANKING_NOT_PREFERRED = 0,
+    XCB_BLANKING_PREFERRED = 1,
+    XCB_BLANKING_DEFAULT = 2
+} xcb_blanking_t;
+
+typedef enum xcb_exposures_t {
+    XCB_EXPOSURES_NOT_ALLOWED = 0,
+    XCB_EXPOSURES_ALLOWED = 1,
+    XCB_EXPOSURES_DEFAULT = 2
+} xcb_exposures_t;
+
+/** Opcode for xcb_set_screen_saver. */
+#define XCB_SET_SCREEN_SAVER 107
+
+/**
+ * @brief xcb_set_screen_saver_request_t
+ **/
+typedef struct xcb_set_screen_saver_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+    int16_t  timeout;
+    int16_t  interval;
+    uint8_t  prefer_blanking;
+    uint8_t  allow_exposures;
+} xcb_set_screen_saver_request_t;
+
+/**
+ * @brief xcb_get_screen_saver_cookie_t
+ **/
+typedef struct xcb_get_screen_saver_cookie_t {
+    unsigned int sequence;
+} xcb_get_screen_saver_cookie_t;
+
+/** Opcode for xcb_get_screen_saver. */
+#define XCB_GET_SCREEN_SAVER 108
+
+/**
+ * @brief xcb_get_screen_saver_request_t
+ **/
+typedef struct xcb_get_screen_saver_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+} xcb_get_screen_saver_request_t;
+
+/**
+ * @brief xcb_get_screen_saver_reply_t
+ **/
+typedef struct xcb_get_screen_saver_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t timeout;
+    uint16_t interval;
+    uint8_t  prefer_blanking;
+    uint8_t  allow_exposures;
+    uint8_t  pad1[18];
+} xcb_get_screen_saver_reply_t;
+
+typedef enum xcb_host_mode_t {
+    XCB_HOST_MODE_INSERT = 0,
+    XCB_HOST_MODE_DELETE = 1
+} xcb_host_mode_t;
+
+typedef enum xcb_family_t {
+    XCB_FAMILY_INTERNET = 0,
+    XCB_FAMILY_DECNET = 1,
+    XCB_FAMILY_CHAOS = 2,
+    XCB_FAMILY_SERVER_INTERPRETED = 5,
+    XCB_FAMILY_INTERNET_6 = 6
+} xcb_family_t;
+
+/** Opcode for xcb_change_hosts. */
+#define XCB_CHANGE_HOSTS 109
+
+/**
+ * @brief xcb_change_hosts_request_t
+ **/
+typedef struct xcb_change_hosts_request_t {
+    uint8_t  major_opcode;
+    uint8_t  mode;
+    uint16_t length;
+    uint8_t  family;
+    uint8_t  pad0;
+    uint16_t address_len;
+} xcb_change_hosts_request_t;
+
+/**
+ * @brief xcb_host_t
+ **/
+typedef struct xcb_host_t {
+    uint8_t  family;
+    uint8_t  pad0;
+    uint16_t address_len;
+} xcb_host_t;
+
+/**
+ * @brief xcb_host_iterator_t
+ **/
+typedef struct xcb_host_iterator_t {
+    xcb_host_t *data;
+    int         rem;
+    int         index;
+} xcb_host_iterator_t;
+
+/**
+ * @brief xcb_list_hosts_cookie_t
+ **/
+typedef struct xcb_list_hosts_cookie_t {
+    unsigned int sequence;
+} xcb_list_hosts_cookie_t;
+
+/** Opcode for xcb_list_hosts. */
+#define XCB_LIST_HOSTS 110
+
+/**
+ * @brief xcb_list_hosts_request_t
+ **/
+typedef struct xcb_list_hosts_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+} xcb_list_hosts_request_t;
+
+/**
+ * @brief xcb_list_hosts_reply_t
+ **/
+typedef struct xcb_list_hosts_reply_t {
+    uint8_t  response_type;
+    uint8_t  mode;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t hosts_len;
+    uint8_t  pad0[22];
+} xcb_list_hosts_reply_t;
+
+typedef enum xcb_access_control_t {
+    XCB_ACCESS_CONTROL_DISABLE = 0,
+    XCB_ACCESS_CONTROL_ENABLE = 1
+} xcb_access_control_t;
+
+/** Opcode for xcb_set_access_control. */
+#define XCB_SET_ACCESS_CONTROL 111
+
+/**
+ * @brief xcb_set_access_control_request_t
+ **/
+typedef struct xcb_set_access_control_request_t {
+    uint8_t  major_opcode;
+    uint8_t  mode;
+    uint16_t length;
+} xcb_set_access_control_request_t;
+
+typedef enum xcb_close_down_t {
+    XCB_CLOSE_DOWN_DESTROY_ALL = 0,
+    XCB_CLOSE_DOWN_RETAIN_PERMANENT = 1,
+    XCB_CLOSE_DOWN_RETAIN_TEMPORARY = 2
+} xcb_close_down_t;
+
+/** Opcode for xcb_set_close_down_mode. */
+#define XCB_SET_CLOSE_DOWN_MODE 112
+
+/**
+ * @brief xcb_set_close_down_mode_request_t
+ **/
+typedef struct xcb_set_close_down_mode_request_t {
+    uint8_t  major_opcode;
+    uint8_t  mode;
+    uint16_t length;
+} xcb_set_close_down_mode_request_t;
+
+typedef enum xcb_kill_t {
+    XCB_KILL_ALL_TEMPORARY = 0
+} xcb_kill_t;
+
+/** Opcode for xcb_kill_client. */
+#define XCB_KILL_CLIENT 113
+
+/**
+ * @brief xcb_kill_client_request_t
+ **/
+typedef struct xcb_kill_client_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+    uint32_t resource;
+} xcb_kill_client_request_t;
+
+/** Opcode for xcb_rotate_properties. */
+#define XCB_ROTATE_PROPERTIES 114
+
+/**
+ * @brief xcb_rotate_properties_request_t
+ **/
+typedef struct xcb_rotate_properties_request_t {
+    uint8_t      major_opcode;
+    uint8_t      pad0;
+    uint16_t     length;
+    xcb_window_t window;
+    uint16_t     atoms_len;
+    int16_t      delta;
+} xcb_rotate_properties_request_t;
+
+typedef enum xcb_screen_saver_t {
+    XCB_SCREEN_SAVER_RESET = 0,
+    XCB_SCREEN_SAVER_ACTIVE = 1
+} xcb_screen_saver_t;
+
+/** Opcode for xcb_force_screen_saver. */
+#define XCB_FORCE_SCREEN_SAVER 115
+
+/**
+ * @brief xcb_force_screen_saver_request_t
+ **/
+typedef struct xcb_force_screen_saver_request_t {
+    uint8_t  major_opcode;
+    uint8_t  mode;
+    uint16_t length;
+} xcb_force_screen_saver_request_t;
+
+typedef enum xcb_mapping_status_t {
+    XCB_MAPPING_STATUS_SUCCESS = 0,
+    XCB_MAPPING_STATUS_BUSY = 1,
+    XCB_MAPPING_STATUS_FAILURE = 2
+} xcb_mapping_status_t;
+
+/**
+ * @brief xcb_set_pointer_mapping_cookie_t
+ **/
+typedef struct xcb_set_pointer_mapping_cookie_t {
+    unsigned int sequence;
+} xcb_set_pointer_mapping_cookie_t;
+
+/** Opcode for xcb_set_pointer_mapping. */
+#define XCB_SET_POINTER_MAPPING 116
+
+/**
+ * @brief xcb_set_pointer_mapping_request_t
+ **/
+typedef struct xcb_set_pointer_mapping_request_t {
+    uint8_t  major_opcode;
+    uint8_t  map_len;
+    uint16_t length;
+} xcb_set_pointer_mapping_request_t;
+
+/**
+ * @brief xcb_set_pointer_mapping_reply_t
+ **/
+typedef struct xcb_set_pointer_mapping_reply_t {
+    uint8_t  response_type;
+    uint8_t  status;
+    uint16_t sequence;
+    uint32_t length;
+} xcb_set_pointer_mapping_reply_t;
+
+/**
+ * @brief xcb_get_pointer_mapping_cookie_t
+ **/
+typedef struct xcb_get_pointer_mapping_cookie_t {
+    unsigned int sequence;
+} xcb_get_pointer_mapping_cookie_t;
+
+/** Opcode for xcb_get_pointer_mapping. */
+#define XCB_GET_POINTER_MAPPING 117
+
+/**
+ * @brief xcb_get_pointer_mapping_request_t
+ **/
+typedef struct xcb_get_pointer_mapping_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+} xcb_get_pointer_mapping_request_t;
+
+/**
+ * @brief xcb_get_pointer_mapping_reply_t
+ **/
+typedef struct xcb_get_pointer_mapping_reply_t {
+    uint8_t  response_type;
+    uint8_t  map_len;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad0[24];
+} xcb_get_pointer_mapping_reply_t;
+
+typedef enum xcb_map_index_t {
+    XCB_MAP_INDEX_SHIFT = 0,
+    XCB_MAP_INDEX_LOCK = 1,
+    XCB_MAP_INDEX_CONTROL = 2,
+    XCB_MAP_INDEX_1 = 3,
+    XCB_MAP_INDEX_2 = 4,
+    XCB_MAP_INDEX_3 = 5,
+    XCB_MAP_INDEX_4 = 6,
+    XCB_MAP_INDEX_5 = 7
+} xcb_map_index_t;
+
+/**
+ * @brief xcb_set_modifier_mapping_cookie_t
+ **/
+typedef struct xcb_set_modifier_mapping_cookie_t {
+    unsigned int sequence;
+} xcb_set_modifier_mapping_cookie_t;
+
+/** Opcode for xcb_set_modifier_mapping. */
+#define XCB_SET_MODIFIER_MAPPING 118
+
+/**
+ * @brief xcb_set_modifier_mapping_request_t
+ **/
+typedef struct xcb_set_modifier_mapping_request_t {
+    uint8_t  major_opcode;
+    uint8_t  keycodes_per_modifier;
+    uint16_t length;
+} xcb_set_modifier_mapping_request_t;
+
+/**
+ * @brief xcb_set_modifier_mapping_reply_t
+ **/
+typedef struct xcb_set_modifier_mapping_reply_t {
+    uint8_t  response_type;
+    uint8_t  status;
+    uint16_t sequence;
+    uint32_t length;
+} xcb_set_modifier_mapping_reply_t;
+
+/**
+ * @brief xcb_get_modifier_mapping_cookie_t
+ **/
+typedef struct xcb_get_modifier_mapping_cookie_t {
+    unsigned int sequence;
+} xcb_get_modifier_mapping_cookie_t;
+
+/** Opcode for xcb_get_modifier_mapping. */
+#define XCB_GET_MODIFIER_MAPPING 119
+
+/**
+ * @brief xcb_get_modifier_mapping_request_t
+ **/
+typedef struct xcb_get_modifier_mapping_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+} xcb_get_modifier_mapping_request_t;
+
+/**
+ * @brief xcb_get_modifier_mapping_reply_t
+ **/
+typedef struct xcb_get_modifier_mapping_reply_t {
+    uint8_t  response_type;
+    uint8_t  keycodes_per_modifier;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad0[24];
+} xcb_get_modifier_mapping_reply_t;
+
+/** Opcode for xcb_no_operation. */
+#define XCB_NO_OPERATION 127
+
+/**
+ * @brief xcb_no_operation_request_t
+ **/
+typedef struct xcb_no_operation_request_t {
+    uint8_t  major_opcode;
+    uint8_t  pad0;
+    uint16_t length;
+} xcb_no_operation_request_t;
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_char2b_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_char2b_t)
+ */
+void
+xcb_char2b_next (xcb_char2b_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_char2b_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_char2b_end (xcb_char2b_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_window_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_window_t)
+ */
+void
+xcb_window_next (xcb_window_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_window_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_window_end (xcb_window_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_pixmap_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_pixmap_t)
+ */
+void
+xcb_pixmap_next (xcb_pixmap_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_pixmap_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_pixmap_end (xcb_pixmap_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_cursor_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_cursor_t)
+ */
+void
+xcb_cursor_next (xcb_cursor_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_cursor_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_cursor_end (xcb_cursor_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_font_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_font_t)
+ */
+void
+xcb_font_next (xcb_font_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_font_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_font_end (xcb_font_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_gcontext_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_gcontext_t)
+ */
+void
+xcb_gcontext_next (xcb_gcontext_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_gcontext_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_gcontext_end (xcb_gcontext_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_colormap_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_colormap_t)
+ */
+void
+xcb_colormap_next (xcb_colormap_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_colormap_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_colormap_end (xcb_colormap_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_atom_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_atom_t)
+ */
+void
+xcb_atom_next (xcb_atom_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_atom_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_atom_end (xcb_atom_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_drawable_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_drawable_t)
+ */
+void
+xcb_drawable_next (xcb_drawable_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_drawable_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_drawable_end (xcb_drawable_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_fontable_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_fontable_t)
+ */
+void
+xcb_fontable_next (xcb_fontable_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_fontable_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_fontable_end (xcb_fontable_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_bool32_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_bool32_t)
+ */
+void
+xcb_bool32_next (xcb_bool32_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_bool32_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_bool32_end (xcb_bool32_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_visualid_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_visualid_t)
+ */
+void
+xcb_visualid_next (xcb_visualid_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_visualid_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_visualid_end (xcb_visualid_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_timestamp_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_timestamp_t)
+ */
+void
+xcb_timestamp_next (xcb_timestamp_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_timestamp_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_timestamp_end (xcb_timestamp_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_keysym_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_keysym_t)
+ */
+void
+xcb_keysym_next (xcb_keysym_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_keysym_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_keysym_end (xcb_keysym_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_keycode_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_keycode_t)
+ */
+void
+xcb_keycode_next (xcb_keycode_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_keycode_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_keycode_end (xcb_keycode_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_keycode32_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_keycode32_t)
+ */
+void
+xcb_keycode32_next (xcb_keycode32_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_keycode32_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_keycode32_end (xcb_keycode32_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_button_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_button_t)
+ */
+void
+xcb_button_next (xcb_button_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_button_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_button_end (xcb_button_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_point_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_point_t)
+ */
+void
+xcb_point_next (xcb_point_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_point_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_point_end (xcb_point_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_rectangle_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_rectangle_t)
+ */
+void
+xcb_rectangle_next (xcb_rectangle_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_rectangle_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_rectangle_end (xcb_rectangle_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_arc_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_arc_t)
+ */
+void
+xcb_arc_next (xcb_arc_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_arc_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_arc_end (xcb_arc_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_format_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_format_t)
+ */
+void
+xcb_format_next (xcb_format_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_format_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_format_end (xcb_format_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_visualtype_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_visualtype_t)
+ */
+void
+xcb_visualtype_next (xcb_visualtype_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_visualtype_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_visualtype_end (xcb_visualtype_iterator_t i);
+
+int
+xcb_depth_sizeof (const void  *_buffer);
+
+xcb_visualtype_t *
+xcb_depth_visuals (const xcb_depth_t *R);
+
+int
+xcb_depth_visuals_length (const xcb_depth_t *R);
+
+xcb_visualtype_iterator_t
+xcb_depth_visuals_iterator (const xcb_depth_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_depth_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_depth_t)
+ */
+void
+xcb_depth_next (xcb_depth_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_depth_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_depth_end (xcb_depth_iterator_t i);
+
+int
+xcb_screen_sizeof (const void  *_buffer);
+
+int
+xcb_screen_allowed_depths_length (const xcb_screen_t *R);
+
+xcb_depth_iterator_t
+xcb_screen_allowed_depths_iterator (const xcb_screen_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_screen_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_screen_t)
+ */
+void
+xcb_screen_next (xcb_screen_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_screen_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_screen_end (xcb_screen_iterator_t i);
+
+int
+xcb_setup_request_sizeof (const void  *_buffer);
+
+char *
+xcb_setup_request_authorization_protocol_name (const xcb_setup_request_t *R);
+
+int
+xcb_setup_request_authorization_protocol_name_length (const xcb_setup_request_t *R);
+
+xcb_generic_iterator_t
+xcb_setup_request_authorization_protocol_name_end (const xcb_setup_request_t *R);
+
+char *
+xcb_setup_request_authorization_protocol_data (const xcb_setup_request_t *R);
+
+int
+xcb_setup_request_authorization_protocol_data_length (const xcb_setup_request_t *R);
+
+xcb_generic_iterator_t
+xcb_setup_request_authorization_protocol_data_end (const xcb_setup_request_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_setup_request_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_setup_request_t)
+ */
+void
+xcb_setup_request_next (xcb_setup_request_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_setup_request_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_setup_request_end (xcb_setup_request_iterator_t i);
+
+int
+xcb_setup_failed_sizeof (const void  *_buffer);
+
+char *
+xcb_setup_failed_reason (const xcb_setup_failed_t *R);
+
+int
+xcb_setup_failed_reason_length (const xcb_setup_failed_t *R);
+
+xcb_generic_iterator_t
+xcb_setup_failed_reason_end (const xcb_setup_failed_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_setup_failed_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_setup_failed_t)
+ */
+void
+xcb_setup_failed_next (xcb_setup_failed_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_setup_failed_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_setup_failed_end (xcb_setup_failed_iterator_t i);
+
+int
+xcb_setup_authenticate_sizeof (const void  *_buffer);
+
+char *
+xcb_setup_authenticate_reason (const xcb_setup_authenticate_t *R);
+
+int
+xcb_setup_authenticate_reason_length (const xcb_setup_authenticate_t *R);
+
+xcb_generic_iterator_t
+xcb_setup_authenticate_reason_end (const xcb_setup_authenticate_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_setup_authenticate_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_setup_authenticate_t)
+ */
+void
+xcb_setup_authenticate_next (xcb_setup_authenticate_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_setup_authenticate_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_setup_authenticate_end (xcb_setup_authenticate_iterator_t i);
+
+int
+xcb_setup_sizeof (const void  *_buffer);
+
+char *
+xcb_setup_vendor (const xcb_setup_t *R);
+
+int
+xcb_setup_vendor_length (const xcb_setup_t *R);
+
+xcb_generic_iterator_t
+xcb_setup_vendor_end (const xcb_setup_t *R);
+
+xcb_format_t *
+xcb_setup_pixmap_formats (const xcb_setup_t *R);
+
+int
+xcb_setup_pixmap_formats_length (const xcb_setup_t *R);
+
+xcb_format_iterator_t
+xcb_setup_pixmap_formats_iterator (const xcb_setup_t *R);
+
+int
+xcb_setup_roots_length (const xcb_setup_t *R);
+
+xcb_screen_iterator_t
+xcb_setup_roots_iterator (const xcb_setup_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_setup_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_setup_t)
+ */
+void
+xcb_setup_next (xcb_setup_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_setup_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_setup_end (xcb_setup_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_client_message_data_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_client_message_data_t)
+ */
+void
+xcb_client_message_data_next (xcb_client_message_data_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_client_message_data_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_client_message_data_end (xcb_client_message_data_iterator_t i);
+
+int
+xcb_create_window_value_list_serialize (void                                 **_buffer,
+                                        uint32_t                               value_mask,
+                                        const xcb_create_window_value_list_t  *_aux);
+
+int
+xcb_create_window_value_list_unpack (const void                      *_buffer,
+                                     uint32_t                         value_mask,
+                                     xcb_create_window_value_list_t  *_aux);
+
+int
+xcb_create_window_value_list_sizeof (const void  *_buffer,
+                                     uint32_t     value_mask);
+
+int
+xcb_create_window_sizeof (const void  *_buffer);
+
+/**
+ * @brief Creates a window
+ *
+ * @param c The connection
+ * @param depth Specifies the new window's depth (TODO: what unit?).
+ * \n
+ * The special value `XCB_COPY_FROM_PARENT` means the depth is taken from the
+ * \a parent window.
+ * @param wid The ID with which you will refer to the new window, created by
+ * `xcb_generate_id`.
+ * @param parent The parent window of the new window.
+ * @param x The X coordinate of the new window.
+ * @param y The Y coordinate of the new window.
+ * @param width The width of the new window.
+ * @param height The height of the new window.
+ * @param border_width TODO:
+ * \n
+ * Must be zero if the `class` is `InputOnly` or a `xcb_match_error_t` occurs.
+ * @param _class A bitmask of #xcb_window_class_t values.
+ * @param _class \n
+ * @param visual Specifies the id for the new window's visual.
+ * \n
+ * The special value `XCB_COPY_FROM_PARENT` means the visual is taken from the
+ * \a parent window.
+ * @param value_mask A bitmask of #xcb_cw_t values.
+ * @return A cookie
+ *
+ * Creates an unmapped window as child of the specified \a parent window. A
+ * CreateNotify event will be generated. The new window is placed on top in the
+ * stacking order with respect to siblings.
+ * 
+ * The coordinate system has the X axis horizontal and the Y axis vertical with
+ * the origin [0, 0] at the upper-left corner. Coordinates are integral, in terms
+ * of pixels, and coincide with pixel centers. Each window and pixmap has its own
+ * coordinate system. For a window, the origin is inside the border at the inside,
+ * upper-left corner.
+ * 
+ * The created window is not yet displayed (mapped), call `xcb_map_window` to
+ * display it.
+ * 
+ * The created window will initially use the same cursor as its parent.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_create_window_checked (xcb_connection_t *c,
+                           uint8_t           depth,
+                           xcb_window_t      wid,
+                           xcb_window_t      parent,
+                           int16_t           x,
+                           int16_t           y,
+                           uint16_t          width,
+                           uint16_t          height,
+                           uint16_t          border_width,
+                           uint16_t          _class,
+                           xcb_visualid_t    visual,
+                           uint32_t          value_mask,
+                           const void       *value_list);
+
+/**
+ * @brief Creates a window
+ *
+ * @param c The connection
+ * @param depth Specifies the new window's depth (TODO: what unit?).
+ * \n
+ * The special value `XCB_COPY_FROM_PARENT` means the depth is taken from the
+ * \a parent window.
+ * @param wid The ID with which you will refer to the new window, created by
+ * `xcb_generate_id`.
+ * @param parent The parent window of the new window.
+ * @param x The X coordinate of the new window.
+ * @param y The Y coordinate of the new window.
+ * @param width The width of the new window.
+ * @param height The height of the new window.
+ * @param border_width TODO:
+ * \n
+ * Must be zero if the `class` is `InputOnly` or a `xcb_match_error_t` occurs.
+ * @param _class A bitmask of #xcb_window_class_t values.
+ * @param _class \n
+ * @param visual Specifies the id for the new window's visual.
+ * \n
+ * The special value `XCB_COPY_FROM_PARENT` means the visual is taken from the
+ * \a parent window.
+ * @param value_mask A bitmask of #xcb_cw_t values.
+ * @return A cookie
+ *
+ * Creates an unmapped window as child of the specified \a parent window. A
+ * CreateNotify event will be generated. The new window is placed on top in the
+ * stacking order with respect to siblings.
+ * 
+ * The coordinate system has the X axis horizontal and the Y axis vertical with
+ * the origin [0, 0] at the upper-left corner. Coordinates are integral, in terms
+ * of pixels, and coincide with pixel centers. Each window and pixmap has its own
+ * coordinate system. For a window, the origin is inside the border at the inside,
+ * upper-left corner.
+ * 
+ * The created window is not yet displayed (mapped), call `xcb_map_window` to
+ * display it.
+ * 
+ * The created window will initially use the same cursor as its parent.
+ *
+ */
+xcb_void_cookie_t
+xcb_create_window (xcb_connection_t *c,
+                   uint8_t           depth,
+                   xcb_window_t      wid,
+                   xcb_window_t      parent,
+                   int16_t           x,
+                   int16_t           y,
+                   uint16_t          width,
+                   uint16_t          height,
+                   uint16_t          border_width,
+                   uint16_t          _class,
+                   xcb_visualid_t    visual,
+                   uint32_t          value_mask,
+                   const void       *value_list);
+
+/**
+ * @brief Creates a window
+ *
+ * @param c The connection
+ * @param depth Specifies the new window's depth (TODO: what unit?).
+ * \n
+ * The special value `XCB_COPY_FROM_PARENT` means the depth is taken from the
+ * \a parent window.
+ * @param wid The ID with which you will refer to the new window, created by
+ * `xcb_generate_id`.
+ * @param parent The parent window of the new window.
+ * @param x The X coordinate of the new window.
+ * @param y The Y coordinate of the new window.
+ * @param width The width of the new window.
+ * @param height The height of the new window.
+ * @param border_width TODO:
+ * \n
+ * Must be zero if the `class` is `InputOnly` or a `xcb_match_error_t` occurs.
+ * @param _class A bitmask of #xcb_window_class_t values.
+ * @param _class \n
+ * @param visual Specifies the id for the new window's visual.
+ * \n
+ * The special value `XCB_COPY_FROM_PARENT` means the visual is taken from the
+ * \a parent window.
+ * @param value_mask A bitmask of #xcb_cw_t values.
+ * @return A cookie
+ *
+ * Creates an unmapped window as child of the specified \a parent window. A
+ * CreateNotify event will be generated. The new window is placed on top in the
+ * stacking order with respect to siblings.
+ * 
+ * The coordinate system has the X axis horizontal and the Y axis vertical with
+ * the origin [0, 0] at the upper-left corner. Coordinates are integral, in terms
+ * of pixels, and coincide with pixel centers. Each window and pixmap has its own
+ * coordinate system. For a window, the origin is inside the border at the inside,
+ * upper-left corner.
+ * 
+ * The created window is not yet displayed (mapped), call `xcb_map_window` to
+ * display it.
+ * 
+ * The created window will initially use the same cursor as its parent.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_create_window_aux_checked (xcb_connection_t                     *c,
+                               uint8_t                               depth,
+                               xcb_window_t                          wid,
+                               xcb_window_t                          parent,
+                               int16_t                               x,
+                               int16_t                               y,
+                               uint16_t                              width,
+                               uint16_t                              height,
+                               uint16_t                              border_width,
+                               uint16_t                              _class,
+                               xcb_visualid_t                        visual,
+                               uint32_t                              value_mask,
+                               const xcb_create_window_value_list_t *value_list);
+
+/**
+ * @brief Creates a window
+ *
+ * @param c The connection
+ * @param depth Specifies the new window's depth (TODO: what unit?).
+ * \n
+ * The special value `XCB_COPY_FROM_PARENT` means the depth is taken from the
+ * \a parent window.
+ * @param wid The ID with which you will refer to the new window, created by
+ * `xcb_generate_id`.
+ * @param parent The parent window of the new window.
+ * @param x The X coordinate of the new window.
+ * @param y The Y coordinate of the new window.
+ * @param width The width of the new window.
+ * @param height The height of the new window.
+ * @param border_width TODO:
+ * \n
+ * Must be zero if the `class` is `InputOnly` or a `xcb_match_error_t` occurs.
+ * @param _class A bitmask of #xcb_window_class_t values.
+ * @param _class \n
+ * @param visual Specifies the id for the new window's visual.
+ * \n
+ * The special value `XCB_COPY_FROM_PARENT` means the visual is taken from the
+ * \a parent window.
+ * @param value_mask A bitmask of #xcb_cw_t values.
+ * @return A cookie
+ *
+ * Creates an unmapped window as child of the specified \a parent window. A
+ * CreateNotify event will be generated. The new window is placed on top in the
+ * stacking order with respect to siblings.
+ * 
+ * The coordinate system has the X axis horizontal and the Y axis vertical with
+ * the origin [0, 0] at the upper-left corner. Coordinates are integral, in terms
+ * of pixels, and coincide with pixel centers. Each window and pixmap has its own
+ * coordinate system. For a window, the origin is inside the border at the inside,
+ * upper-left corner.
+ * 
+ * The created window is not yet displayed (mapped), call `xcb_map_window` to
+ * display it.
+ * 
+ * The created window will initially use the same cursor as its parent.
+ *
+ */
+xcb_void_cookie_t
+xcb_create_window_aux (xcb_connection_t                     *c,
+                       uint8_t                               depth,
+                       xcb_window_t                          wid,
+                       xcb_window_t                          parent,
+                       int16_t                               x,
+                       int16_t                               y,
+                       uint16_t                              width,
+                       uint16_t                              height,
+                       uint16_t                              border_width,
+                       uint16_t                              _class,
+                       xcb_visualid_t                        visual,
+                       uint32_t                              value_mask,
+                       const xcb_create_window_value_list_t *value_list);
+
+void *
+xcb_create_window_value_list (const xcb_create_window_request_t *R);
+
+int
+xcb_change_window_attributes_value_list_serialize (void                                            **_buffer,
+                                                   uint32_t                                          value_mask,
+                                                   const xcb_change_window_attributes_value_list_t  *_aux);
+
+int
+xcb_change_window_attributes_value_list_unpack (const void                                 *_buffer,
+                                                uint32_t                                    value_mask,
+                                                xcb_change_window_attributes_value_list_t  *_aux);
+
+int
+xcb_change_window_attributes_value_list_sizeof (const void  *_buffer,
+                                                uint32_t     value_mask);
+
+int
+xcb_change_window_attributes_sizeof (const void  *_buffer);
+
+/**
+ * @brief change window attributes
+ *
+ * @param c The connection
+ * @param window The window to change.
+ * @param value_mask A bitmask of #xcb_cw_t values.
+ * @param value_mask \n
+ * @param value_list Values for each of the attributes specified in the bitmask \a value_mask. The
+ * order has to correspond to the order of possible \a value_mask bits. See the
+ * example.
+ * @return A cookie
+ *
+ * Changes the attributes specified by \a value_mask for the specified \a window.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_change_window_attributes_checked (xcb_connection_t *c,
+                                      xcb_window_t      window,
+                                      uint32_t          value_mask,
+                                      const void       *value_list);
+
+/**
+ * @brief change window attributes
+ *
+ * @param c The connection
+ * @param window The window to change.
+ * @param value_mask A bitmask of #xcb_cw_t values.
+ * @param value_mask \n
+ * @param value_list Values for each of the attributes specified in the bitmask \a value_mask. The
+ * order has to correspond to the order of possible \a value_mask bits. See the
+ * example.
+ * @return A cookie
+ *
+ * Changes the attributes specified by \a value_mask for the specified \a window.
+ *
+ */
+xcb_void_cookie_t
+xcb_change_window_attributes (xcb_connection_t *c,
+                              xcb_window_t      window,
+                              uint32_t          value_mask,
+                              const void       *value_list);
+
+/**
+ * @brief change window attributes
+ *
+ * @param c The connection
+ * @param window The window to change.
+ * @param value_mask A bitmask of #xcb_cw_t values.
+ * @param value_mask \n
+ * @param value_list Values for each of the attributes specified in the bitmask \a value_mask. The
+ * order has to correspond to the order of possible \a value_mask bits. See the
+ * example.
+ * @return A cookie
+ *
+ * Changes the attributes specified by \a value_mask for the specified \a window.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_change_window_attributes_aux_checked (xcb_connection_t                                *c,
+                                          xcb_window_t                                     window,
+                                          uint32_t                                         value_mask,
+                                          const xcb_change_window_attributes_value_list_t *value_list);
+
+/**
+ * @brief change window attributes
+ *
+ * @param c The connection
+ * @param window The window to change.
+ * @param value_mask A bitmask of #xcb_cw_t values.
+ * @param value_mask \n
+ * @param value_list Values for each of the attributes specified in the bitmask \a value_mask. The
+ * order has to correspond to the order of possible \a value_mask bits. See the
+ * example.
+ * @return A cookie
+ *
+ * Changes the attributes specified by \a value_mask for the specified \a window.
+ *
+ */
+xcb_void_cookie_t
+xcb_change_window_attributes_aux (xcb_connection_t                                *c,
+                                  xcb_window_t                                     window,
+                                  uint32_t                                         value_mask,
+                                  const xcb_change_window_attributes_value_list_t *value_list);
+
+void *
+xcb_change_window_attributes_value_list (const xcb_change_window_attributes_request_t *R);
+
+/**
+ * @brief Gets window attributes
+ *
+ * @param c The connection
+ * @param window The window to get the attributes from.
+ * @return A cookie
+ *
+ * Gets the current attributes for the specified \a window.
+ *
+ */
+xcb_get_window_attributes_cookie_t
+xcb_get_window_attributes (xcb_connection_t *c,
+                           xcb_window_t      window);
+
+/**
+ * @brief Gets window attributes
+ *
+ * @param c The connection
+ * @param window The window to get the attributes from.
+ * @return A cookie
+ *
+ * Gets the current attributes for the specified \a window.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_get_window_attributes_cookie_t
+xcb_get_window_attributes_unchecked (xcb_connection_t *c,
+                                     xcb_window_t      window);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_get_window_attributes_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_get_window_attributes_reply_t *
+xcb_get_window_attributes_reply (xcb_connection_t                    *c,
+                                 xcb_get_window_attributes_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e);
+
+/**
+ * @brief Destroys a window
+ *
+ * @param c The connection
+ * @param window The window to destroy.
+ * @return A cookie
+ *
+ * Destroys the specified window and all of its subwindows. A DestroyNotify event
+ * is generated for each destroyed window (a DestroyNotify event is first generated
+ * for any given window's inferiors). If the window was mapped, it will be
+ * automatically unmapped before destroying.
+ * 
+ * Calling DestroyWindow on the root window will do nothing.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_destroy_window_checked (xcb_connection_t *c,
+                            xcb_window_t      window);
+
+/**
+ * @brief Destroys a window
+ *
+ * @param c The connection
+ * @param window The window to destroy.
+ * @return A cookie
+ *
+ * Destroys the specified window and all of its subwindows. A DestroyNotify event
+ * is generated for each destroyed window (a DestroyNotify event is first generated
+ * for any given window's inferiors). If the window was mapped, it will be
+ * automatically unmapped before destroying.
+ * 
+ * Calling DestroyWindow on the root window will do nothing.
+ *
+ */
+xcb_void_cookie_t
+xcb_destroy_window (xcb_connection_t *c,
+                    xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_destroy_subwindows_checked (xcb_connection_t *c,
+                                xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_destroy_subwindows (xcb_connection_t *c,
+                        xcb_window_t      window);
+
+/**
+ * @brief Changes a client's save set
+ *
+ * @param c The connection
+ * @param mode A bitmask of #xcb_set_mode_t values.
+ * @param mode Insert to add the specified window to the save set or Delete to delete it from the save set.
+ * @param window The window to add or delete to/from your save set.
+ * @return A cookie
+ *
+ * TODO: explain what the save set is for.
+ * 
+ * This function either adds or removes the specified window to the client's (your
+ * application's) save set.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_change_save_set_checked (xcb_connection_t *c,
+                             uint8_t           mode,
+                             xcb_window_t      window);
+
+/**
+ * @brief Changes a client's save set
+ *
+ * @param c The connection
+ * @param mode A bitmask of #xcb_set_mode_t values.
+ * @param mode Insert to add the specified window to the save set or Delete to delete it from the save set.
+ * @param window The window to add or delete to/from your save set.
+ * @return A cookie
+ *
+ * TODO: explain what the save set is for.
+ * 
+ * This function either adds or removes the specified window to the client's (your
+ * application's) save set.
+ *
+ */
+xcb_void_cookie_t
+xcb_change_save_set (xcb_connection_t *c,
+                     uint8_t           mode,
+                     xcb_window_t      window);
+
+/**
+ * @brief Reparents a window
+ *
+ * @param c The connection
+ * @param window The window to reparent.
+ * @param parent The new parent of the window.
+ * @param x The X position of the window within its new parent.
+ * @param y The Y position of the window within its new parent.
+ * @return A cookie
+ *
+ * Makes the specified window a child of the specified parent window. If the
+ * window is mapped, it will automatically be unmapped before reparenting and
+ * re-mapped after reparenting. The window is placed in the stacking order on top
+ * with respect to sibling windows.
+ * 
+ * After reparenting, a ReparentNotify event is generated.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_reparent_window_checked (xcb_connection_t *c,
+                             xcb_window_t      window,
+                             xcb_window_t      parent,
+                             int16_t           x,
+                             int16_t           y);
+
+/**
+ * @brief Reparents a window
+ *
+ * @param c The connection
+ * @param window The window to reparent.
+ * @param parent The new parent of the window.
+ * @param x The X position of the window within its new parent.
+ * @param y The Y position of the window within its new parent.
+ * @return A cookie
+ *
+ * Makes the specified window a child of the specified parent window. If the
+ * window is mapped, it will automatically be unmapped before reparenting and
+ * re-mapped after reparenting. The window is placed in the stacking order on top
+ * with respect to sibling windows.
+ * 
+ * After reparenting, a ReparentNotify event is generated.
+ *
+ */
+xcb_void_cookie_t
+xcb_reparent_window (xcb_connection_t *c,
+                     xcb_window_t      window,
+                     xcb_window_t      parent,
+                     int16_t           x,
+                     int16_t           y);
+
+/**
+ * @brief Makes a window visible
+ *
+ * @param c The connection
+ * @param window The window to make visible.
+ * @return A cookie
+ *
+ * Maps the specified window. This means making the window visible (as long as its
+ * parent is visible).
+ * 
+ * This MapWindow request will be translated to a MapRequest request if a window
+ * manager is running. The window manager then decides to either map the window or
+ * not. Set the override-redirect window attribute to true if you want to bypass
+ * this mechanism.
+ * 
+ * If the window manager decides to map the window (or if no window manager is
+ * running), a MapNotify event is generated.
+ * 
+ * If the window becomes viewable and no earlier contents for it are remembered,
+ * the X server tiles the window with its background. If the window's background
+ * is undefined, the existing screen contents are not altered, and the X server
+ * generates zero or more Expose events.
+ * 
+ * If the window type is InputOutput, an Expose event will be generated when the
+ * window becomes visible. The normal response to an Expose event should be to
+ * repaint the window.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_map_window_checked (xcb_connection_t *c,
+                        xcb_window_t      window);
+
+/**
+ * @brief Makes a window visible
+ *
+ * @param c The connection
+ * @param window The window to make visible.
+ * @return A cookie
+ *
+ * Maps the specified window. This means making the window visible (as long as its
+ * parent is visible).
+ * 
+ * This MapWindow request will be translated to a MapRequest request if a window
+ * manager is running. The window manager then decides to either map the window or
+ * not. Set the override-redirect window attribute to true if you want to bypass
+ * this mechanism.
+ * 
+ * If the window manager decides to map the window (or if no window manager is
+ * running), a MapNotify event is generated.
+ * 
+ * If the window becomes viewable and no earlier contents for it are remembered,
+ * the X server tiles the window with its background. If the window's background
+ * is undefined, the existing screen contents are not altered, and the X server
+ * generates zero or more Expose events.
+ * 
+ * If the window type is InputOutput, an Expose event will be generated when the
+ * window becomes visible. The normal response to an Expose event should be to
+ * repaint the window.
+ *
+ */
+xcb_void_cookie_t
+xcb_map_window (xcb_connection_t *c,
+                xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_map_subwindows_checked (xcb_connection_t *c,
+                            xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_map_subwindows (xcb_connection_t *c,
+                    xcb_window_t      window);
+
+/**
+ * @brief Makes a window invisible
+ *
+ * @param c The connection
+ * @param window The window to make invisible.
+ * @return A cookie
+ *
+ * Unmaps the specified window. This means making the window invisible (and all
+ * its child windows).
+ * 
+ * Unmapping a window leads to the `UnmapNotify` event being generated. Also,
+ * `Expose` events are generated for formerly obscured windows.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_unmap_window_checked (xcb_connection_t *c,
+                          xcb_window_t      window);
+
+/**
+ * @brief Makes a window invisible
+ *
+ * @param c The connection
+ * @param window The window to make invisible.
+ * @return A cookie
+ *
+ * Unmaps the specified window. This means making the window invisible (and all
+ * its child windows).
+ * 
+ * Unmapping a window leads to the `UnmapNotify` event being generated. Also,
+ * `Expose` events are generated for formerly obscured windows.
+ *
+ */
+xcb_void_cookie_t
+xcb_unmap_window (xcb_connection_t *c,
+                  xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_unmap_subwindows_checked (xcb_connection_t *c,
+                              xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_unmap_subwindows (xcb_connection_t *c,
+                      xcb_window_t      window);
+
+int
+xcb_configure_window_value_list_serialize (void                                    **_buffer,
+                                           uint16_t                                  value_mask,
+                                           const xcb_configure_window_value_list_t  *_aux);
+
+int
+xcb_configure_window_value_list_unpack (const void                         *_buffer,
+                                        uint16_t                            value_mask,
+                                        xcb_configure_window_value_list_t  *_aux);
+
+int
+xcb_configure_window_value_list_sizeof (const void  *_buffer,
+                                        uint16_t     value_mask);
+
+int
+xcb_configure_window_sizeof (const void  *_buffer);
+
+/**
+ * @brief Configures window attributes
+ *
+ * @param c The connection
+ * @param window The window to configure.
+ * @param value_mask Bitmask of attributes to change.
+ * @param value_list New values, corresponding to the attributes in value_mask. The order has to
+ * correspond to the order of possible \a value_mask bits. See the example.
+ * @return A cookie
+ *
+ * Configures a window's size, position, border width and stacking order.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_configure_window_checked (xcb_connection_t *c,
+                              xcb_window_t      window,
+                              uint16_t          value_mask,
+                              const void       *value_list);
+
+/**
+ * @brief Configures window attributes
+ *
+ * @param c The connection
+ * @param window The window to configure.
+ * @param value_mask Bitmask of attributes to change.
+ * @param value_list New values, corresponding to the attributes in value_mask. The order has to
+ * correspond to the order of possible \a value_mask bits. See the example.
+ * @return A cookie
+ *
+ * Configures a window's size, position, border width and stacking order.
+ *
+ */
+xcb_void_cookie_t
+xcb_configure_window (xcb_connection_t *c,
+                      xcb_window_t      window,
+                      uint16_t          value_mask,
+                      const void       *value_list);
+
+/**
+ * @brief Configures window attributes
+ *
+ * @param c The connection
+ * @param window The window to configure.
+ * @param value_mask Bitmask of attributes to change.
+ * @param value_list New values, corresponding to the attributes in value_mask. The order has to
+ * correspond to the order of possible \a value_mask bits. See the example.
+ * @return A cookie
+ *
+ * Configures a window's size, position, border width and stacking order.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_configure_window_aux_checked (xcb_connection_t                        *c,
+                                  xcb_window_t                             window,
+                                  uint16_t                                 value_mask,
+                                  const xcb_configure_window_value_list_t *value_list);
+
+/**
+ * @brief Configures window attributes
+ *
+ * @param c The connection
+ * @param window The window to configure.
+ * @param value_mask Bitmask of attributes to change.
+ * @param value_list New values, corresponding to the attributes in value_mask. The order has to
+ * correspond to the order of possible \a value_mask bits. See the example.
+ * @return A cookie
+ *
+ * Configures a window's size, position, border width and stacking order.
+ *
+ */
+xcb_void_cookie_t
+xcb_configure_window_aux (xcb_connection_t                        *c,
+                          xcb_window_t                             window,
+                          uint16_t                                 value_mask,
+                          const xcb_configure_window_value_list_t *value_list);
+
+void *
+xcb_configure_window_value_list (const xcb_configure_window_request_t *R);
+
+/**
+ * @brief Change window stacking order
+ *
+ * @param c The connection
+ * @param direction A bitmask of #xcb_circulate_t values.
+ * @param direction \n
+ * @param window The window to raise/lower (depending on \a direction).
+ * @return A cookie
+ *
+ * If \a direction is `XCB_CIRCULATE_RAISE_LOWEST`, the lowest mapped child (if
+ * any) will be raised to the top of the stack.
+ * 
+ * If \a direction is `XCB_CIRCULATE_LOWER_HIGHEST`, the highest mapped child will
+ * be lowered to the bottom of the stack.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_circulate_window_checked (xcb_connection_t *c,
+                              uint8_t           direction,
+                              xcb_window_t      window);
+
+/**
+ * @brief Change window stacking order
+ *
+ * @param c The connection
+ * @param direction A bitmask of #xcb_circulate_t values.
+ * @param direction \n
+ * @param window The window to raise/lower (depending on \a direction).
+ * @return A cookie
+ *
+ * If \a direction is `XCB_CIRCULATE_RAISE_LOWEST`, the lowest mapped child (if
+ * any) will be raised to the top of the stack.
+ * 
+ * If \a direction is `XCB_CIRCULATE_LOWER_HIGHEST`, the highest mapped child will
+ * be lowered to the bottom of the stack.
+ *
+ */
+xcb_void_cookie_t
+xcb_circulate_window (xcb_connection_t *c,
+                      uint8_t           direction,
+                      xcb_window_t      window);
+
+/**
+ * @brief Get current window geometry
+ *
+ * @param c The connection
+ * @param drawable The drawable (`Window` or `Pixmap`) of which the geometry will be received.
+ * @return A cookie
+ *
+ * Gets the current geometry of the specified drawable (either `Window` or `Pixmap`).
+ *
+ */
+xcb_get_geometry_cookie_t
+xcb_get_geometry (xcb_connection_t *c,
+                  xcb_drawable_t    drawable);
+
+/**
+ * @brief Get current window geometry
+ *
+ * @param c The connection
+ * @param drawable The drawable (`Window` or `Pixmap`) of which the geometry will be received.
+ * @return A cookie
+ *
+ * Gets the current geometry of the specified drawable (either `Window` or `Pixmap`).
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_get_geometry_cookie_t
+xcb_get_geometry_unchecked (xcb_connection_t *c,
+                            xcb_drawable_t    drawable);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_get_geometry_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_get_geometry_reply_t *
+xcb_get_geometry_reply (xcb_connection_t           *c,
+                        xcb_get_geometry_cookie_t   cookie  /**< */,
+                        xcb_generic_error_t       **e);
+
+int
+xcb_query_tree_sizeof (const void  *_buffer);
+
+/**
+ * @brief query the window tree
+ *
+ * @param c The connection
+ * @param window The \a window to query.
+ * @return A cookie
+ *
+ * Gets the root window ID, parent window ID and list of children windows for the
+ * specified \a window. The children are listed in bottom-to-top stacking order.
+ *
+ */
+xcb_query_tree_cookie_t
+xcb_query_tree (xcb_connection_t *c,
+                xcb_window_t      window);
+
+/**
+ * @brief query the window tree
+ *
+ * @param c The connection
+ * @param window The \a window to query.
+ * @return A cookie
+ *
+ * Gets the root window ID, parent window ID and list of children windows for the
+ * specified \a window. The children are listed in bottom-to-top stacking order.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_query_tree_cookie_t
+xcb_query_tree_unchecked (xcb_connection_t *c,
+                          xcb_window_t      window);
+
+xcb_window_t *
+xcb_query_tree_children (const xcb_query_tree_reply_t *R);
+
+int
+xcb_query_tree_children_length (const xcb_query_tree_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_query_tree_children_end (const xcb_query_tree_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_query_tree_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_query_tree_reply_t *
+xcb_query_tree_reply (xcb_connection_t         *c,
+                      xcb_query_tree_cookie_t   cookie  /**< */,
+                      xcb_generic_error_t     **e);
+
+int
+xcb_intern_atom_sizeof (const void  *_buffer);
+
+/**
+ * @brief Get atom identifier by name
+ *
+ * @param c The connection
+ * @param only_if_exists Return a valid atom id only if the atom already exists.
+ * @param name_len The length of the following \a name.
+ * @param name The name of the atom.
+ * @return A cookie
+ *
+ * Retrieves the identifier (xcb_atom_t TODO) for the atom with the specified
+ * name. Atoms are used in protocols like EWMH, for example to store window titles
+ * (`_NET_WM_NAME` atom) as property of a window.
+ * 
+ * If \a only_if_exists is 0, the atom will be created if it does not already exist.
+ * If \a only_if_exists is 1, `XCB_ATOM_NONE` will be returned if the atom does
+ * not yet exist.
+ *
+ */
+xcb_intern_atom_cookie_t
+xcb_intern_atom (xcb_connection_t *c,
+                 uint8_t           only_if_exists,
+                 uint16_t          name_len,
+                 const char       *name);
+
+/**
+ * @brief Get atom identifier by name
+ *
+ * @param c The connection
+ * @param only_if_exists Return a valid atom id only if the atom already exists.
+ * @param name_len The length of the following \a name.
+ * @param name The name of the atom.
+ * @return A cookie
+ *
+ * Retrieves the identifier (xcb_atom_t TODO) for the atom with the specified
+ * name. Atoms are used in protocols like EWMH, for example to store window titles
+ * (`_NET_WM_NAME` atom) as property of a window.
+ * 
+ * If \a only_if_exists is 0, the atom will be created if it does not already exist.
+ * If \a only_if_exists is 1, `XCB_ATOM_NONE` will be returned if the atom does
+ * not yet exist.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_intern_atom_cookie_t
+xcb_intern_atom_unchecked (xcb_connection_t *c,
+                           uint8_t           only_if_exists,
+                           uint16_t          name_len,
+                           const char       *name);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_intern_atom_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_intern_atom_reply_t *
+xcb_intern_atom_reply (xcb_connection_t          *c,
+                       xcb_intern_atom_cookie_t   cookie  /**< */,
+                       xcb_generic_error_t      **e);
+
+int
+xcb_get_atom_name_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_get_atom_name_cookie_t
+xcb_get_atom_name (xcb_connection_t *c,
+                   xcb_atom_t        atom);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_get_atom_name_cookie_t
+xcb_get_atom_name_unchecked (xcb_connection_t *c,
+                             xcb_atom_t        atom);
+
+char *
+xcb_get_atom_name_name (const xcb_get_atom_name_reply_t *R);
+
+int
+xcb_get_atom_name_name_length (const xcb_get_atom_name_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_get_atom_name_name_end (const xcb_get_atom_name_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_get_atom_name_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_get_atom_name_reply_t *
+xcb_get_atom_name_reply (xcb_connection_t            *c,
+                         xcb_get_atom_name_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e);
+
+int
+xcb_change_property_sizeof (const void  *_buffer);
+
+/**
+ * @brief Changes a window property
+ *
+ * @param c The connection
+ * @param mode A bitmask of #xcb_prop_mode_t values.
+ * @param mode \n
+ * @param window The window whose property you want to change.
+ * @param property The property you want to change (an atom).
+ * @param type The type of the property you want to change (an atom).
+ * @param format Specifies whether the data should be viewed as a list of 8-bit, 16-bit or
+ * 32-bit quantities. Possible values are 8, 16 and 32. This information allows
+ * the X server to correctly perform byte-swap operations as necessary.
+ * @param data_len Specifies the number of elements (see \a format).
+ * @param data The property data.
+ * @return A cookie
+ *
+ * Sets or updates a property on the specified \a window. Properties are for
+ * example the window title (`WM_NAME`) or its minimum size (`WM_NORMAL_HINTS`).
+ * Protocols such as EWMH also use properties - for example EWMH defines the
+ * window title, encoded as UTF-8 string, in the `_NET_WM_NAME` property.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_change_property_checked (xcb_connection_t *c,
+                             uint8_t           mode,
+                             xcb_window_t      window,
+                             xcb_atom_t        property,
+                             xcb_atom_t        type,
+                             uint8_t           format,
+                             uint32_t          data_len,
+                             const void       *data);
+
+/**
+ * @brief Changes a window property
+ *
+ * @param c The connection
+ * @param mode A bitmask of #xcb_prop_mode_t values.
+ * @param mode \n
+ * @param window The window whose property you want to change.
+ * @param property The property you want to change (an atom).
+ * @param type The type of the property you want to change (an atom).
+ * @param format Specifies whether the data should be viewed as a list of 8-bit, 16-bit or
+ * 32-bit quantities. Possible values are 8, 16 and 32. This information allows
+ * the X server to correctly perform byte-swap operations as necessary.
+ * @param data_len Specifies the number of elements (see \a format).
+ * @param data The property data.
+ * @return A cookie
+ *
+ * Sets or updates a property on the specified \a window. Properties are for
+ * example the window title (`WM_NAME`) or its minimum size (`WM_NORMAL_HINTS`).
+ * Protocols such as EWMH also use properties - for example EWMH defines the
+ * window title, encoded as UTF-8 string, in the `_NET_WM_NAME` property.
+ *
+ */
+xcb_void_cookie_t
+xcb_change_property (xcb_connection_t *c,
+                     uint8_t           mode,
+                     xcb_window_t      window,
+                     xcb_atom_t        property,
+                     xcb_atom_t        type,
+                     uint8_t           format,
+                     uint32_t          data_len,
+                     const void       *data);
+
+void *
+xcb_change_property_data (const xcb_change_property_request_t *R);
+
+int
+xcb_change_property_data_length (const xcb_change_property_request_t *R);
+
+xcb_generic_iterator_t
+xcb_change_property_data_end (const xcb_change_property_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_delete_property_checked (xcb_connection_t *c,
+                             xcb_window_t      window,
+                             xcb_atom_t        property);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_delete_property (xcb_connection_t *c,
+                     xcb_window_t      window,
+                     xcb_atom_t        property);
+
+int
+xcb_get_property_sizeof (const void  *_buffer);
+
+/**
+ * @brief Gets a window property
+ *
+ * @param c The connection
+ * @param _delete Whether the property should actually be deleted. For deleting a property, the
+ * specified \a type has to match the actual property type.
+ * @param window The window whose property you want to get.
+ * @param property The property you want to get (an atom).
+ * @param type The type of the property you want to get (an atom).
+ * @param long_offset Specifies the offset (in 32-bit multiples) in the specified property where the
+ * data is to be retrieved.
+ * @param long_length Specifies how many 32-bit multiples of data should be retrieved (e.g. if you
+ * set \a long_length to 4, you will receive 16 bytes of data).
+ * @return A cookie
+ *
+ * Gets the specified \a property from the specified \a window. Properties are for
+ * example the window title (`WM_NAME`) or its minimum size (`WM_NORMAL_HINTS`).
+ * Protocols such as EWMH also use properties - for example EWMH defines the
+ * window title, encoded as UTF-8 string, in the `_NET_WM_NAME` property.
+ * 
+ * TODO: talk about \a type
+ * 
+ * TODO: talk about `delete`
+ * 
+ * TODO: talk about the offset/length thing. what's a valid use case?
+ *
+ */
+xcb_get_property_cookie_t
+xcb_get_property (xcb_connection_t *c,
+                  uint8_t           _delete,
+                  xcb_window_t      window,
+                  xcb_atom_t        property,
+                  xcb_atom_t        type,
+                  uint32_t          long_offset,
+                  uint32_t          long_length);
+
+/**
+ * @brief Gets a window property
+ *
+ * @param c The connection
+ * @param _delete Whether the property should actually be deleted. For deleting a property, the
+ * specified \a type has to match the actual property type.
+ * @param window The window whose property you want to get.
+ * @param property The property you want to get (an atom).
+ * @param type The type of the property you want to get (an atom).
+ * @param long_offset Specifies the offset (in 32-bit multiples) in the specified property where the
+ * data is to be retrieved.
+ * @param long_length Specifies how many 32-bit multiples of data should be retrieved (e.g. if you
+ * set \a long_length to 4, you will receive 16 bytes of data).
+ * @return A cookie
+ *
+ * Gets the specified \a property from the specified \a window. Properties are for
+ * example the window title (`WM_NAME`) or its minimum size (`WM_NORMAL_HINTS`).
+ * Protocols such as EWMH also use properties - for example EWMH defines the
+ * window title, encoded as UTF-8 string, in the `_NET_WM_NAME` property.
+ * 
+ * TODO: talk about \a type
+ * 
+ * TODO: talk about `delete`
+ * 
+ * TODO: talk about the offset/length thing. what's a valid use case?
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_get_property_cookie_t
+xcb_get_property_unchecked (xcb_connection_t *c,
+                            uint8_t           _delete,
+                            xcb_window_t      window,
+                            xcb_atom_t        property,
+                            xcb_atom_t        type,
+                            uint32_t          long_offset,
+                            uint32_t          long_length);
+
+void *
+xcb_get_property_value (const xcb_get_property_reply_t *R);
+
+int
+xcb_get_property_value_length (const xcb_get_property_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_get_property_value_end (const xcb_get_property_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_get_property_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_get_property_reply_t *
+xcb_get_property_reply (xcb_connection_t           *c,
+                        xcb_get_property_cookie_t   cookie  /**< */,
+                        xcb_generic_error_t       **e);
+
+int
+xcb_list_properties_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_list_properties_cookie_t
+xcb_list_properties (xcb_connection_t *c,
+                     xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_list_properties_cookie_t
+xcb_list_properties_unchecked (xcb_connection_t *c,
+                               xcb_window_t      window);
+
+xcb_atom_t *
+xcb_list_properties_atoms (const xcb_list_properties_reply_t *R);
+
+int
+xcb_list_properties_atoms_length (const xcb_list_properties_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_list_properties_atoms_end (const xcb_list_properties_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_list_properties_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_list_properties_reply_t *
+xcb_list_properties_reply (xcb_connection_t              *c,
+                           xcb_list_properties_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e);
+
+/**
+ * @brief Sets the owner of a selection
+ *
+ * @param c The connection
+ * @param owner The new owner of the selection.
+ * \n
+ * The special value `XCB_NONE` means that the selection will have no owner.
+ * @param selection The selection.
+ * @param time Timestamp to avoid race conditions when running X over the network.
+ * \n
+ * The selection will not be changed if \a time is earlier than the current
+ * last-change time of the \a selection or is later than the current X server time.
+ * Otherwise, the last-change time is set to the specified time.
+ * \n
+ * The special value `XCB_CURRENT_TIME` will be replaced with the current server
+ * time.
+ * @return A cookie
+ *
+ * Makes `window` the owner of the selection \a selection and updates the
+ * last-change time of the specified selection.
+ * 
+ * TODO: briefly explain what a selection is.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_set_selection_owner_checked (xcb_connection_t *c,
+                                 xcb_window_t      owner,
+                                 xcb_atom_t        selection,
+                                 xcb_timestamp_t   time);
+
+/**
+ * @brief Sets the owner of a selection
+ *
+ * @param c The connection
+ * @param owner The new owner of the selection.
+ * \n
+ * The special value `XCB_NONE` means that the selection will have no owner.
+ * @param selection The selection.
+ * @param time Timestamp to avoid race conditions when running X over the network.
+ * \n
+ * The selection will not be changed if \a time is earlier than the current
+ * last-change time of the \a selection or is later than the current X server time.
+ * Otherwise, the last-change time is set to the specified time.
+ * \n
+ * The special value `XCB_CURRENT_TIME` will be replaced with the current server
+ * time.
+ * @return A cookie
+ *
+ * Makes `window` the owner of the selection \a selection and updates the
+ * last-change time of the specified selection.
+ * 
+ * TODO: briefly explain what a selection is.
+ *
+ */
+xcb_void_cookie_t
+xcb_set_selection_owner (xcb_connection_t *c,
+                         xcb_window_t      owner,
+                         xcb_atom_t        selection,
+                         xcb_timestamp_t   time);
+
+/**
+ * @brief Gets the owner of a selection
+ *
+ * @param c The connection
+ * @param selection The selection.
+ * @return A cookie
+ *
+ * Gets the owner of the specified selection.
+ * 
+ * TODO: briefly explain what a selection is.
+ *
+ */
+xcb_get_selection_owner_cookie_t
+xcb_get_selection_owner (xcb_connection_t *c,
+                         xcb_atom_t        selection);
+
+/**
+ * @brief Gets the owner of a selection
+ *
+ * @param c The connection
+ * @param selection The selection.
+ * @return A cookie
+ *
+ * Gets the owner of the specified selection.
+ * 
+ * TODO: briefly explain what a selection is.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_get_selection_owner_cookie_t
+xcb_get_selection_owner_unchecked (xcb_connection_t *c,
+                                   xcb_atom_t        selection);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_get_selection_owner_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_get_selection_owner_reply_t *
+xcb_get_selection_owner_reply (xcb_connection_t                  *c,
+                               xcb_get_selection_owner_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_convert_selection_checked (xcb_connection_t *c,
+                               xcb_window_t      requestor,
+                               xcb_atom_t        selection,
+                               xcb_atom_t        target,
+                               xcb_atom_t        property,
+                               xcb_timestamp_t   time);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_convert_selection (xcb_connection_t *c,
+                       xcb_window_t      requestor,
+                       xcb_atom_t        selection,
+                       xcb_atom_t        target,
+                       xcb_atom_t        property,
+                       xcb_timestamp_t   time);
+
+/**
+ * @brief send an event
+ *
+ * @param c The connection
+ * @param propagate If \a propagate is true and no clients have selected any event on \a destination,
+ * the destination is replaced with the closest ancestor of \a destination for
+ * which some client has selected a type in \a event_mask and for which no
+ * intervening window has that type in its do-not-propagate-mask. If no such
+ * window exists or if the window is an ancestor of the focus window and
+ * `InputFocus` was originally specified as the destination, the event is not sent
+ * to any clients. Otherwise, the event is reported to every client selecting on
+ * the final destination any of the types specified in \a event_mask.
+ * @param destination The window to send this event to. Every client which selects any event within
+ * \a event_mask on \a destination will get the event.
+ * \n
+ * The special value `XCB_SEND_EVENT_DEST_POINTER_WINDOW` refers to the window
+ * that contains the mouse pointer.
+ * \n
+ * The special value `XCB_SEND_EVENT_DEST_ITEM_FOCUS` refers to the window which
+ * has the keyboard focus.
+ * @param event_mask Event_mask for determining which clients should receive the specified event.
+ * See \a destination and \a propagate.
+ * @param event The event to send to the specified \a destination.
+ * @return A cookie
+ *
+ * Identifies the \a destination window, determines which clients should receive
+ * the specified event and ignores any active grabs.
+ * 
+ * The \a event must be one of the core events or an event defined by an extension,
+ * so that the X server can correctly byte-swap the contents as necessary. The
+ * contents of \a event are otherwise unaltered and unchecked except for the
+ * `send_event` field which is forced to 'true'.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_send_event_checked (xcb_connection_t *c,
+                        uint8_t           propagate,
+                        xcb_window_t      destination,
+                        uint32_t          event_mask,
+                        const char       *event);
+
+/**
+ * @brief send an event
+ *
+ * @param c The connection
+ * @param propagate If \a propagate is true and no clients have selected any event on \a destination,
+ * the destination is replaced with the closest ancestor of \a destination for
+ * which some client has selected a type in \a event_mask and for which no
+ * intervening window has that type in its do-not-propagate-mask. If no such
+ * window exists or if the window is an ancestor of the focus window and
+ * `InputFocus` was originally specified as the destination, the event is not sent
+ * to any clients. Otherwise, the event is reported to every client selecting on
+ * the final destination any of the types specified in \a event_mask.
+ * @param destination The window to send this event to. Every client which selects any event within
+ * \a event_mask on \a destination will get the event.
+ * \n
+ * The special value `XCB_SEND_EVENT_DEST_POINTER_WINDOW` refers to the window
+ * that contains the mouse pointer.
+ * \n
+ * The special value `XCB_SEND_EVENT_DEST_ITEM_FOCUS` refers to the window which
+ * has the keyboard focus.
+ * @param event_mask Event_mask for determining which clients should receive the specified event.
+ * See \a destination and \a propagate.
+ * @param event The event to send to the specified \a destination.
+ * @return A cookie
+ *
+ * Identifies the \a destination window, determines which clients should receive
+ * the specified event and ignores any active grabs.
+ * 
+ * The \a event must be one of the core events or an event defined by an extension,
+ * so that the X server can correctly byte-swap the contents as necessary. The
+ * contents of \a event are otherwise unaltered and unchecked except for the
+ * `send_event` field which is forced to 'true'.
+ *
+ */
+xcb_void_cookie_t
+xcb_send_event (xcb_connection_t *c,
+                uint8_t           propagate,
+                xcb_window_t      destination,
+                uint32_t          event_mask,
+                const char       *event);
+
+/**
+ * @brief Grab the pointer
+ *
+ * @param c The connection
+ * @param owner_events If 1, the \a grab_window will still get the pointer events. If 0, events are not
+ * reported to the \a grab_window.
+ * @param grab_window Specifies the window on which the pointer should be grabbed.
+ * @param event_mask Specifies which pointer events are reported to the client.
+ * \n
+ * TODO: which values?
+ * @param pointer_mode A bitmask of #xcb_grab_mode_t values.
+ * @param pointer_mode \n
+ * @param keyboard_mode A bitmask of #xcb_grab_mode_t values.
+ * @param keyboard_mode \n
+ * @param confine_to Specifies the window to confine the pointer in (the user will not be able to
+ * move the pointer out of that window).
+ * \n
+ * The special value `XCB_NONE` means don't confine the pointer.
+ * @param cursor Specifies the cursor that should be displayed or `XCB_NONE` to not change the
+ * cursor.
+ * @param time The time argument allows you to avoid certain circumstances that come up if
+ * applications take a long time to respond or if there are long network delays.
+ * Consider a situation where you have two applications, both of which normally
+ * grab the pointer when clicked on. If both applications specify the timestamp
+ * from the event, the second application may wake up faster and successfully grab
+ * the pointer before the first application. The first application then will get
+ * an indication that the other application grabbed the pointer before its request
+ * was processed.
+ * \n
+ * The special value `XCB_CURRENT_TIME` will be replaced with the current server
+ * time.
+ * @return A cookie
+ *
+ * Actively grabs control of the pointer. Further pointer events are reported only to the grabbing client. Overrides any active pointer grab by this client.
+ *
+ */
+xcb_grab_pointer_cookie_t
+xcb_grab_pointer (xcb_connection_t *c,
+                  uint8_t           owner_events,
+                  xcb_window_t      grab_window,
+                  uint16_t          event_mask,
+                  uint8_t           pointer_mode,
+                  uint8_t           keyboard_mode,
+                  xcb_window_t      confine_to,
+                  xcb_cursor_t      cursor,
+                  xcb_timestamp_t   time);
+
+/**
+ * @brief Grab the pointer
+ *
+ * @param c The connection
+ * @param owner_events If 1, the \a grab_window will still get the pointer events. If 0, events are not
+ * reported to the \a grab_window.
+ * @param grab_window Specifies the window on which the pointer should be grabbed.
+ * @param event_mask Specifies which pointer events are reported to the client.
+ * \n
+ * TODO: which values?
+ * @param pointer_mode A bitmask of #xcb_grab_mode_t values.
+ * @param pointer_mode \n
+ * @param keyboard_mode A bitmask of #xcb_grab_mode_t values.
+ * @param keyboard_mode \n
+ * @param confine_to Specifies the window to confine the pointer in (the user will not be able to
+ * move the pointer out of that window).
+ * \n
+ * The special value `XCB_NONE` means don't confine the pointer.
+ * @param cursor Specifies the cursor that should be displayed or `XCB_NONE` to not change the
+ * cursor.
+ * @param time The time argument allows you to avoid certain circumstances that come up if
+ * applications take a long time to respond or if there are long network delays.
+ * Consider a situation where you have two applications, both of which normally
+ * grab the pointer when clicked on. If both applications specify the timestamp
+ * from the event, the second application may wake up faster and successfully grab
+ * the pointer before the first application. The first application then will get
+ * an indication that the other application grabbed the pointer before its request
+ * was processed.
+ * \n
+ * The special value `XCB_CURRENT_TIME` will be replaced with the current server
+ * time.
+ * @return A cookie
+ *
+ * Actively grabs control of the pointer. Further pointer events are reported only to the grabbing client. Overrides any active pointer grab by this client.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_grab_pointer_cookie_t
+xcb_grab_pointer_unchecked (xcb_connection_t *c,
+                            uint8_t           owner_events,
+                            xcb_window_t      grab_window,
+                            uint16_t          event_mask,
+                            uint8_t           pointer_mode,
+                            uint8_t           keyboard_mode,
+                            xcb_window_t      confine_to,
+                            xcb_cursor_t      cursor,
+                            xcb_timestamp_t   time);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_grab_pointer_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_grab_pointer_reply_t *
+xcb_grab_pointer_reply (xcb_connection_t           *c,
+                        xcb_grab_pointer_cookie_t   cookie  /**< */,
+                        xcb_generic_error_t       **e);
+
+/**
+ * @brief release the pointer
+ *
+ * @param c The connection
+ * @param time Timestamp to avoid race conditions when running X over the network.
+ * \n
+ * The pointer will not be released if \a time is earlier than the
+ * last-pointer-grab time or later than the current X server time.
+ * @return A cookie
+ *
+ * Releases the pointer and any queued events if you actively grabbed the pointer
+ * before using `xcb_grab_pointer`, `xcb_grab_button` or within a normal button
+ * press.
+ * 
+ * EnterNotify and LeaveNotify events are generated.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_ungrab_pointer_checked (xcb_connection_t *c,
+                            xcb_timestamp_t   time);
+
+/**
+ * @brief release the pointer
+ *
+ * @param c The connection
+ * @param time Timestamp to avoid race conditions when running X over the network.
+ * \n
+ * The pointer will not be released if \a time is earlier than the
+ * last-pointer-grab time or later than the current X server time.
+ * @return A cookie
+ *
+ * Releases the pointer and any queued events if you actively grabbed the pointer
+ * before using `xcb_grab_pointer`, `xcb_grab_button` or within a normal button
+ * press.
+ * 
+ * EnterNotify and LeaveNotify events are generated.
+ *
+ */
+xcb_void_cookie_t
+xcb_ungrab_pointer (xcb_connection_t *c,
+                    xcb_timestamp_t   time);
+
+/**
+ * @brief Grab pointer button(s)
+ *
+ * @param c The connection
+ * @param owner_events If 1, the \a grab_window will still get the pointer events. If 0, events are not
+ * reported to the \a grab_window.
+ * @param grab_window Specifies the window on which the pointer should be grabbed.
+ * @param event_mask Specifies which pointer events are reported to the client.
+ * \n
+ * TODO: which values?
+ * @param pointer_mode A bitmask of #xcb_grab_mode_t values.
+ * @param pointer_mode \n
+ * @param keyboard_mode A bitmask of #xcb_grab_mode_t values.
+ * @param keyboard_mode \n
+ * @param confine_to Specifies the window to confine the pointer in (the user will not be able to
+ * move the pointer out of that window).
+ * \n
+ * The special value `XCB_NONE` means don't confine the pointer.
+ * @param cursor Specifies the cursor that should be displayed or `XCB_NONE` to not change the
+ * cursor.
+ * @param button A bitmask of #xcb_button_index_t values.
+ * @param button \n
+ * @param modifiers The modifiers to grab.
+ * \n
+ * Using the special value `XCB_MOD_MASK_ANY` means grab the pointer with all
+ * possible modifier combinations.
+ * @return A cookie
+ *
+ * This request establishes a passive grab. The pointer is actively grabbed as
+ * described in GrabPointer, the last-pointer-grab time is set to the time at
+ * which the button was pressed (as transmitted in the ButtonPress event), and the
+ * ButtonPress event is reported if all of the following conditions are true:
+ * 
+ * The pointer is not grabbed and the specified button is logically pressed when
+ * the specified modifier keys are logically down, and no other buttons or
+ * modifier keys are logically down.
+ * 
+ * The grab-window contains the pointer.
+ * 
+ * The confine-to window (if any) is viewable.
+ * 
+ * A passive grab on the same button/key combination does not exist on any
+ * ancestor of grab-window.
+ * 
+ * The interpretation of the remaining arguments is the same as for GrabPointer.
+ * The active grab is terminated automatically when the logical state of the
+ * pointer has all buttons released, independent of the logical state of modifier
+ * keys. Note that the logical state of a device (as seen by means of the
+ * protocol) may lag the physical state if device event processing is frozen. This
+ * request overrides all previous passive grabs by the same client on the same
+ * button/key combinations on the same window. A modifier of AnyModifier is
+ * equivalent to issuing the request for all possible modifier combinations
+ * (including the combination of no modifiers). It is not required that all
+ * specified modifiers have currently assigned keycodes. A button of AnyButton is
+ * equivalent to issuing the request for all possible buttons. Otherwise, it is
+ * not required that the button specified currently be assigned to a physical
+ * button.
+ * 
+ * An Access error is generated if some other client has already issued a
+ * GrabButton request with the same button/key combination on the same window.
+ * When using AnyModifier or AnyButton, the request fails completely (no grabs are
+ * established), and an Access error is generated if there is a conflicting grab
+ * for any combination. The request has no effect on an active grab.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_grab_button_checked (xcb_connection_t *c,
+                         uint8_t           owner_events,
+                         xcb_window_t      grab_window,
+                         uint16_t          event_mask,
+                         uint8_t           pointer_mode,
+                         uint8_t           keyboard_mode,
+                         xcb_window_t      confine_to,
+                         xcb_cursor_t      cursor,
+                         uint8_t           button,
+                         uint16_t          modifiers);
+
+/**
+ * @brief Grab pointer button(s)
+ *
+ * @param c The connection
+ * @param owner_events If 1, the \a grab_window will still get the pointer events. If 0, events are not
+ * reported to the \a grab_window.
+ * @param grab_window Specifies the window on which the pointer should be grabbed.
+ * @param event_mask Specifies which pointer events are reported to the client.
+ * \n
+ * TODO: which values?
+ * @param pointer_mode A bitmask of #xcb_grab_mode_t values.
+ * @param pointer_mode \n
+ * @param keyboard_mode A bitmask of #xcb_grab_mode_t values.
+ * @param keyboard_mode \n
+ * @param confine_to Specifies the window to confine the pointer in (the user will not be able to
+ * move the pointer out of that window).
+ * \n
+ * The special value `XCB_NONE` means don't confine the pointer.
+ * @param cursor Specifies the cursor that should be displayed or `XCB_NONE` to not change the
+ * cursor.
+ * @param button A bitmask of #xcb_button_index_t values.
+ * @param button \n
+ * @param modifiers The modifiers to grab.
+ * \n
+ * Using the special value `XCB_MOD_MASK_ANY` means grab the pointer with all
+ * possible modifier combinations.
+ * @return A cookie
+ *
+ * This request establishes a passive grab. The pointer is actively grabbed as
+ * described in GrabPointer, the last-pointer-grab time is set to the time at
+ * which the button was pressed (as transmitted in the ButtonPress event), and the
+ * ButtonPress event is reported if all of the following conditions are true:
+ * 
+ * The pointer is not grabbed and the specified button is logically pressed when
+ * the specified modifier keys are logically down, and no other buttons or
+ * modifier keys are logically down.
+ * 
+ * The grab-window contains the pointer.
+ * 
+ * The confine-to window (if any) is viewable.
+ * 
+ * A passive grab on the same button/key combination does not exist on any
+ * ancestor of grab-window.
+ * 
+ * The interpretation of the remaining arguments is the same as for GrabPointer.
+ * The active grab is terminated automatically when the logical state of the
+ * pointer has all buttons released, independent of the logical state of modifier
+ * keys. Note that the logical state of a device (as seen by means of the
+ * protocol) may lag the physical state if device event processing is frozen. This
+ * request overrides all previous passive grabs by the same client on the same
+ * button/key combinations on the same window. A modifier of AnyModifier is
+ * equivalent to issuing the request for all possible modifier combinations
+ * (including the combination of no modifiers). It is not required that all
+ * specified modifiers have currently assigned keycodes. A button of AnyButton is
+ * equivalent to issuing the request for all possible buttons. Otherwise, it is
+ * not required that the button specified currently be assigned to a physical
+ * button.
+ * 
+ * An Access error is generated if some other client has already issued a
+ * GrabButton request with the same button/key combination on the same window.
+ * When using AnyModifier or AnyButton, the request fails completely (no grabs are
+ * established), and an Access error is generated if there is a conflicting grab
+ * for any combination. The request has no effect on an active grab.
+ *
+ */
+xcb_void_cookie_t
+xcb_grab_button (xcb_connection_t *c,
+                 uint8_t           owner_events,
+                 xcb_window_t      grab_window,
+                 uint16_t          event_mask,
+                 uint8_t           pointer_mode,
+                 uint8_t           keyboard_mode,
+                 xcb_window_t      confine_to,
+                 xcb_cursor_t      cursor,
+                 uint8_t           button,
+                 uint16_t          modifiers);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_ungrab_button_checked (xcb_connection_t *c,
+                           uint8_t           button,
+                           xcb_window_t      grab_window,
+                           uint16_t          modifiers);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_ungrab_button (xcb_connection_t *c,
+                   uint8_t           button,
+                   xcb_window_t      grab_window,
+                   uint16_t          modifiers);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_change_active_pointer_grab_checked (xcb_connection_t *c,
+                                        xcb_cursor_t      cursor,
+                                        xcb_timestamp_t   time,
+                                        uint16_t          event_mask);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_change_active_pointer_grab (xcb_connection_t *c,
+                                xcb_cursor_t      cursor,
+                                xcb_timestamp_t   time,
+                                uint16_t          event_mask);
+
+/**
+ * @brief Grab the keyboard
+ *
+ * @param c The connection
+ * @param owner_events If 1, the \a grab_window will still get the pointer events. If 0, events are not
+ * reported to the \a grab_window.
+ * @param grab_window Specifies the window on which the pointer should be grabbed.
+ * @param time Timestamp to avoid race conditions when running X over the network.
+ * \n
+ * The special value `XCB_CURRENT_TIME` will be replaced with the current server
+ * time.
+ * @param pointer_mode A bitmask of #xcb_grab_mode_t values.
+ * @param pointer_mode \n
+ * @param keyboard_mode A bitmask of #xcb_grab_mode_t values.
+ * @param keyboard_mode \n
+ * @return A cookie
+ *
+ * Actively grabs control of the keyboard and generates FocusIn and FocusOut
+ * events. Further key events are reported only to the grabbing client.
+ * 
+ * Any active keyboard grab by this client is overridden. If the keyboard is
+ * actively grabbed by some other client, `AlreadyGrabbed` is returned. If
+ * \a grab_window is not viewable, `GrabNotViewable` is returned. If the keyboard
+ * is frozen by an active grab of another client, `GrabFrozen` is returned. If the
+ * specified \a time is earlier than the last-keyboard-grab time or later than the
+ * current X server time, `GrabInvalidTime` is returned. Otherwise, the
+ * last-keyboard-grab time is set to the specified time.
+ *
+ */
+xcb_grab_keyboard_cookie_t
+xcb_grab_keyboard (xcb_connection_t *c,
+                   uint8_t           owner_events,
+                   xcb_window_t      grab_window,
+                   xcb_timestamp_t   time,
+                   uint8_t           pointer_mode,
+                   uint8_t           keyboard_mode);
+
+/**
+ * @brief Grab the keyboard
+ *
+ * @param c The connection
+ * @param owner_events If 1, the \a grab_window will still get the pointer events. If 0, events are not
+ * reported to the \a grab_window.
+ * @param grab_window Specifies the window on which the pointer should be grabbed.
+ * @param time Timestamp to avoid race conditions when running X over the network.
+ * \n
+ * The special value `XCB_CURRENT_TIME` will be replaced with the current server
+ * time.
+ * @param pointer_mode A bitmask of #xcb_grab_mode_t values.
+ * @param pointer_mode \n
+ * @param keyboard_mode A bitmask of #xcb_grab_mode_t values.
+ * @param keyboard_mode \n
+ * @return A cookie
+ *
+ * Actively grabs control of the keyboard and generates FocusIn and FocusOut
+ * events. Further key events are reported only to the grabbing client.
+ * 
+ * Any active keyboard grab by this client is overridden. If the keyboard is
+ * actively grabbed by some other client, `AlreadyGrabbed` is returned. If
+ * \a grab_window is not viewable, `GrabNotViewable` is returned. If the keyboard
+ * is frozen by an active grab of another client, `GrabFrozen` is returned. If the
+ * specified \a time is earlier than the last-keyboard-grab time or later than the
+ * current X server time, `GrabInvalidTime` is returned. Otherwise, the
+ * last-keyboard-grab time is set to the specified time.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_grab_keyboard_cookie_t
+xcb_grab_keyboard_unchecked (xcb_connection_t *c,
+                             uint8_t           owner_events,
+                             xcb_window_t      grab_window,
+                             xcb_timestamp_t   time,
+                             uint8_t           pointer_mode,
+                             uint8_t           keyboard_mode);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_grab_keyboard_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_grab_keyboard_reply_t *
+xcb_grab_keyboard_reply (xcb_connection_t            *c,
+                         xcb_grab_keyboard_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_ungrab_keyboard_checked (xcb_connection_t *c,
+                             xcb_timestamp_t   time);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_ungrab_keyboard (xcb_connection_t *c,
+                     xcb_timestamp_t   time);
+
+/**
+ * @brief Grab keyboard key(s)
+ *
+ * @param c The connection
+ * @param owner_events If 1, the \a grab_window will still get the key events. If 0, events are not
+ * reported to the \a grab_window.
+ * @param grab_window Specifies the window on which the key should be grabbed.
+ * @param modifiers The modifiers to grab.
+ * \n
+ * Using the special value `XCB_MOD_MASK_ANY` means grab the key with all
+ * possible modifier combinations.
+ * @param key The keycode of the key to grab.
+ * \n
+ * The special value `XCB_GRAB_ANY` means grab any key.
+ * @param pointer_mode A bitmask of #xcb_grab_mode_t values.
+ * @param pointer_mode \n
+ * @param keyboard_mode A bitmask of #xcb_grab_mode_t values.
+ * @param keyboard_mode \n
+ * @return A cookie
+ *
+ * Establishes a passive grab on the keyboard. In the future, the keyboard is
+ * actively grabbed (as for `GrabKeyboard`), the last-keyboard-grab time is set to
+ * the time at which the key was pressed (as transmitted in the KeyPress event),
+ * and the KeyPress event is reported if all of the following conditions are true:
+ * 
+ * The keyboard is not grabbed and the specified key (which can itself be a
+ * modifier key) is logically pressed when the specified modifier keys are
+ * logically down, and no other modifier keys are logically down.
+ * 
+ * Either the grab_window is an ancestor of (or is) the focus window, or the
+ * grab_window is a descendant of the focus window and contains the pointer.
+ * 
+ * A passive grab on the same key combination does not exist on any ancestor of
+ * grab_window.
+ * 
+ * The interpretation of the remaining arguments is as for XGrabKeyboard.  The active grab is terminated
+ * automatically when the logical state of the keyboard has the specified key released (independent of the
+ * logical state of the modifier keys), at which point a KeyRelease event is reported to the grabbing window.
+ * 
+ * Note that the logical state of a device (as seen by client applications) may lag the physical state if
+ * device event processing is frozen.
+ * 
+ * A modifiers argument of AnyModifier is equivalent to issuing the request for all possible modifier combinations (including the combination of no modifiers).  It is not required that all modifiers specified
+ * have currently assigned KeyCodes.  A keycode argument of AnyKey is equivalent to issuing the request for
+ * all possible KeyCodes.  Otherwise, the specified keycode must be in the range specified by min_keycode
+ * and max_keycode in the connection setup, or a BadValue error results.
+ * 
+ * If some other client has issued a XGrabKey with the same key combination on the same window, a BadAccess
+ * error results.  When using AnyModifier or AnyKey, the request fails completely, and a BadAccess error
+ * results (no grabs are established) if there is a conflicting grab for any combination.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_grab_key_checked (xcb_connection_t *c,
+                      uint8_t           owner_events,
+                      xcb_window_t      grab_window,
+                      uint16_t          modifiers,
+                      xcb_keycode_t     key,
+                      uint8_t           pointer_mode,
+                      uint8_t           keyboard_mode);
+
+/**
+ * @brief Grab keyboard key(s)
+ *
+ * @param c The connection
+ * @param owner_events If 1, the \a grab_window will still get the key events. If 0, events are not
+ * reported to the \a grab_window.
+ * @param grab_window Specifies the window on which the key should be grabbed.
+ * @param modifiers The modifiers to grab.
+ * \n
+ * Using the special value `XCB_MOD_MASK_ANY` means grab the key with all
+ * possible modifier combinations.
+ * @param key The keycode of the key to grab.
+ * \n
+ * The special value `XCB_GRAB_ANY` means grab any key.
+ * @param pointer_mode A bitmask of #xcb_grab_mode_t values.
+ * @param pointer_mode \n
+ * @param keyboard_mode A bitmask of #xcb_grab_mode_t values.
+ * @param keyboard_mode \n
+ * @return A cookie
+ *
+ * Establishes a passive grab on the keyboard. In the future, the keyboard is
+ * actively grabbed (as for `GrabKeyboard`), the last-keyboard-grab time is set to
+ * the time at which the key was pressed (as transmitted in the KeyPress event),
+ * and the KeyPress event is reported if all of the following conditions are true:
+ * 
+ * The keyboard is not grabbed and the specified key (which can itself be a
+ * modifier key) is logically pressed when the specified modifier keys are
+ * logically down, and no other modifier keys are logically down.
+ * 
+ * Either the grab_window is an ancestor of (or is) the focus window, or the
+ * grab_window is a descendant of the focus window and contains the pointer.
+ * 
+ * A passive grab on the same key combination does not exist on any ancestor of
+ * grab_window.
+ * 
+ * The interpretation of the remaining arguments is as for XGrabKeyboard.  The active grab is terminated
+ * automatically when the logical state of the keyboard has the specified key released (independent of the
+ * logical state of the modifier keys), at which point a KeyRelease event is reported to the grabbing window.
+ * 
+ * Note that the logical state of a device (as seen by client applications) may lag the physical state if
+ * device event processing is frozen.
+ * 
+ * A modifiers argument of AnyModifier is equivalent to issuing the request for all possible modifier combinations (including the combination of no modifiers).  It is not required that all modifiers specified
+ * have currently assigned KeyCodes.  A keycode argument of AnyKey is equivalent to issuing the request for
+ * all possible KeyCodes.  Otherwise, the specified keycode must be in the range specified by min_keycode
+ * and max_keycode in the connection setup, or a BadValue error results.
+ * 
+ * If some other client has issued a XGrabKey with the same key combination on the same window, a BadAccess
+ * error results.  When using AnyModifier or AnyKey, the request fails completely, and a BadAccess error
+ * results (no grabs are established) if there is a conflicting grab for any combination.
+ *
+ */
+xcb_void_cookie_t
+xcb_grab_key (xcb_connection_t *c,
+              uint8_t           owner_events,
+              xcb_window_t      grab_window,
+              uint16_t          modifiers,
+              xcb_keycode_t     key,
+              uint8_t           pointer_mode,
+              uint8_t           keyboard_mode);
+
+/**
+ * @brief release a key combination
+ *
+ * @param c The connection
+ * @param key The keycode of the specified key combination.
+ * \n
+ * Using the special value `XCB_GRAB_ANY` means releasing all possible key codes.
+ * @param grab_window The window on which the grabbed key combination will be released.
+ * @param modifiers The modifiers of the specified key combination.
+ * \n
+ * Using the special value `XCB_MOD_MASK_ANY` means releasing the key combination
+ * with every possible modifier combination.
+ * @return A cookie
+ *
+ * Releases the key combination on \a grab_window if you grabbed it using
+ * `xcb_grab_key` before.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_ungrab_key_checked (xcb_connection_t *c,
+                        xcb_keycode_t     key,
+                        xcb_window_t      grab_window,
+                        uint16_t          modifiers);
+
+/**
+ * @brief release a key combination
+ *
+ * @param c The connection
+ * @param key The keycode of the specified key combination.
+ * \n
+ * Using the special value `XCB_GRAB_ANY` means releasing all possible key codes.
+ * @param grab_window The window on which the grabbed key combination will be released.
+ * @param modifiers The modifiers of the specified key combination.
+ * \n
+ * Using the special value `XCB_MOD_MASK_ANY` means releasing the key combination
+ * with every possible modifier combination.
+ * @return A cookie
+ *
+ * Releases the key combination on \a grab_window if you grabbed it using
+ * `xcb_grab_key` before.
+ *
+ */
+xcb_void_cookie_t
+xcb_ungrab_key (xcb_connection_t *c,
+                xcb_keycode_t     key,
+                xcb_window_t      grab_window,
+                uint16_t          modifiers);
+
+/**
+ * @brief release queued events
+ *
+ * @param c The connection
+ * @param mode A bitmask of #xcb_allow_t values.
+ * @param mode \n
+ * @param time Timestamp to avoid race conditions when running X over the network.
+ * \n
+ * The special value `XCB_CURRENT_TIME` will be replaced with the current server
+ * time.
+ * @return A cookie
+ *
+ * Releases queued events if the client has caused a device (pointer/keyboard) to
+ * freeze due to grabbing it actively. This request has no effect if \a time is
+ * earlier than the last-grab time of the most recent active grab for this client
+ * or if \a time is later than the current X server time.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_allow_events_checked (xcb_connection_t *c,
+                          uint8_t           mode,
+                          xcb_timestamp_t   time);
+
+/**
+ * @brief release queued events
+ *
+ * @param c The connection
+ * @param mode A bitmask of #xcb_allow_t values.
+ * @param mode \n
+ * @param time Timestamp to avoid race conditions when running X over the network.
+ * \n
+ * The special value `XCB_CURRENT_TIME` will be replaced with the current server
+ * time.
+ * @return A cookie
+ *
+ * Releases queued events if the client has caused a device (pointer/keyboard) to
+ * freeze due to grabbing it actively. This request has no effect if \a time is
+ * earlier than the last-grab time of the most recent active grab for this client
+ * or if \a time is later than the current X server time.
+ *
+ */
+xcb_void_cookie_t
+xcb_allow_events (xcb_connection_t *c,
+                  uint8_t           mode,
+                  xcb_timestamp_t   time);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_grab_server_checked (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_grab_server (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_ungrab_server_checked (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_ungrab_server (xcb_connection_t *c);
+
+/**
+ * @brief get pointer coordinates
+ *
+ * @param c The connection
+ * @param window A window to check if the pointer is on the same screen as \a window (see the
+ * `same_screen` field in the reply).
+ * @return A cookie
+ *
+ * Gets the root window the pointer is logically on and the pointer coordinates
+ * relative to the root window's origin.
+ *
+ */
+xcb_query_pointer_cookie_t
+xcb_query_pointer (xcb_connection_t *c,
+                   xcb_window_t      window);
+
+/**
+ * @brief get pointer coordinates
+ *
+ * @param c The connection
+ * @param window A window to check if the pointer is on the same screen as \a window (see the
+ * `same_screen` field in the reply).
+ * @return A cookie
+ *
+ * Gets the root window the pointer is logically on and the pointer coordinates
+ * relative to the root window's origin.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_query_pointer_cookie_t
+xcb_query_pointer_unchecked (xcb_connection_t *c,
+                             xcb_window_t      window);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_query_pointer_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_query_pointer_reply_t *
+xcb_query_pointer_reply (xcb_connection_t            *c,
+                         xcb_query_pointer_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_timecoord_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_timecoord_t)
+ */
+void
+xcb_timecoord_next (xcb_timecoord_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_timecoord_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_timecoord_end (xcb_timecoord_iterator_t i);
+
+int
+xcb_get_motion_events_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_get_motion_events_cookie_t
+xcb_get_motion_events (xcb_connection_t *c,
+                       xcb_window_t      window,
+                       xcb_timestamp_t   start,
+                       xcb_timestamp_t   stop);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_get_motion_events_cookie_t
+xcb_get_motion_events_unchecked (xcb_connection_t *c,
+                                 xcb_window_t      window,
+                                 xcb_timestamp_t   start,
+                                 xcb_timestamp_t   stop);
+
+xcb_timecoord_t *
+xcb_get_motion_events_events (const xcb_get_motion_events_reply_t *R);
+
+int
+xcb_get_motion_events_events_length (const xcb_get_motion_events_reply_t *R);
+
+xcb_timecoord_iterator_t
+xcb_get_motion_events_events_iterator (const xcb_get_motion_events_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_get_motion_events_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_get_motion_events_reply_t *
+xcb_get_motion_events_reply (xcb_connection_t                *c,
+                             xcb_get_motion_events_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_translate_coordinates_cookie_t
+xcb_translate_coordinates (xcb_connection_t *c,
+                           xcb_window_t      src_window,
+                           xcb_window_t      dst_window,
+                           int16_t           src_x,
+                           int16_t           src_y);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_translate_coordinates_cookie_t
+xcb_translate_coordinates_unchecked (xcb_connection_t *c,
+                                     xcb_window_t      src_window,
+                                     xcb_window_t      dst_window,
+                                     int16_t           src_x,
+                                     int16_t           src_y);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_translate_coordinates_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_translate_coordinates_reply_t *
+xcb_translate_coordinates_reply (xcb_connection_t                    *c,
+                                 xcb_translate_coordinates_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e);
+
+/**
+ * @brief move mouse pointer
+ *
+ * @param c The connection
+ * @param src_window If \a src_window is not `XCB_NONE` (TODO), the move will only take place if the
+ * pointer is inside \a src_window and within the rectangle specified by (\a src_x,
+ * \a src_y, \a src_width, \a src_height). The rectangle coordinates are relative to
+ * \a src_window.
+ * @param dst_window If \a dst_window is not `XCB_NONE` (TODO), the pointer will be moved to the
+ * offsets (\a dst_x, \a dst_y) relative to \a dst_window. If \a dst_window is
+ * `XCB_NONE` (TODO), the pointer will be moved by the offsets (\a dst_x, \a dst_y)
+ * relative to the current position of the pointer.
+ * @return A cookie
+ *
+ * Moves the mouse pointer to the specified position.
+ * 
+ * If \a src_window is not `XCB_NONE` (TODO), the move will only take place if the
+ * pointer is inside \a src_window and within the rectangle specified by (\a src_x,
+ * \a src_y, \a src_width, \a src_height). The rectangle coordinates are relative to
+ * \a src_window.
+ * 
+ * If \a dst_window is not `XCB_NONE` (TODO), the pointer will be moved to the
+ * offsets (\a dst_x, \a dst_y) relative to \a dst_window. If \a dst_window is
+ * `XCB_NONE` (TODO), the pointer will be moved by the offsets (\a dst_x, \a dst_y)
+ * relative to the current position of the pointer.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_warp_pointer_checked (xcb_connection_t *c,
+                          xcb_window_t      src_window,
+                          xcb_window_t      dst_window,
+                          int16_t           src_x,
+                          int16_t           src_y,
+                          uint16_t          src_width,
+                          uint16_t          src_height,
+                          int16_t           dst_x,
+                          int16_t           dst_y);
+
+/**
+ * @brief move mouse pointer
+ *
+ * @param c The connection
+ * @param src_window If \a src_window is not `XCB_NONE` (TODO), the move will only take place if the
+ * pointer is inside \a src_window and within the rectangle specified by (\a src_x,
+ * \a src_y, \a src_width, \a src_height). The rectangle coordinates are relative to
+ * \a src_window.
+ * @param dst_window If \a dst_window is not `XCB_NONE` (TODO), the pointer will be moved to the
+ * offsets (\a dst_x, \a dst_y) relative to \a dst_window. If \a dst_window is
+ * `XCB_NONE` (TODO), the pointer will be moved by the offsets (\a dst_x, \a dst_y)
+ * relative to the current position of the pointer.
+ * @return A cookie
+ *
+ * Moves the mouse pointer to the specified position.
+ * 
+ * If \a src_window is not `XCB_NONE` (TODO), the move will only take place if the
+ * pointer is inside \a src_window and within the rectangle specified by (\a src_x,
+ * \a src_y, \a src_width, \a src_height). The rectangle coordinates are relative to
+ * \a src_window.
+ * 
+ * If \a dst_window is not `XCB_NONE` (TODO), the pointer will be moved to the
+ * offsets (\a dst_x, \a dst_y) relative to \a dst_window. If \a dst_window is
+ * `XCB_NONE` (TODO), the pointer will be moved by the offsets (\a dst_x, \a dst_y)
+ * relative to the current position of the pointer.
+ *
+ */
+xcb_void_cookie_t
+xcb_warp_pointer (xcb_connection_t *c,
+                  xcb_window_t      src_window,
+                  xcb_window_t      dst_window,
+                  int16_t           src_x,
+                  int16_t           src_y,
+                  uint16_t          src_width,
+                  uint16_t          src_height,
+                  int16_t           dst_x,
+                  int16_t           dst_y);
+
+/**
+ * @brief Sets input focus
+ *
+ * @param c The connection
+ * @param revert_to A bitmask of #xcb_input_focus_t values.
+ * @param revert_to Specifies what happens when the \a focus window becomes unviewable (if \a focus
+ * is neither `XCB_NONE` nor `XCB_POINTER_ROOT`).
+ * @param focus The window to focus. All keyboard events will be reported to this window. The
+ * window must be viewable (TODO), or a `xcb_match_error_t` occurs (TODO).
+ * \n
+ * If \a focus is `XCB_NONE` (TODO), all keyboard events are
+ * discarded until a new focus window is set.
+ * \n
+ * If \a focus is `XCB_POINTER_ROOT` (TODO), focus is on the root window of the
+ * screen on which the pointer is on currently.
+ * @param time Timestamp to avoid race conditions when running X over the network.
+ * \n
+ * The special value `XCB_CURRENT_TIME` will be replaced with the current server
+ * time.
+ * @return A cookie
+ *
+ * Changes the input focus and the last-focus-change time. If the specified \a time
+ * is earlier than the current last-focus-change time, the request is ignored (to
+ * avoid race conditions when running X over the network).
+ * 
+ * A FocusIn and FocusOut event is generated when focus is changed.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_set_input_focus_checked (xcb_connection_t *c,
+                             uint8_t           revert_to,
+                             xcb_window_t      focus,
+                             xcb_timestamp_t   time);
+
+/**
+ * @brief Sets input focus
+ *
+ * @param c The connection
+ * @param revert_to A bitmask of #xcb_input_focus_t values.
+ * @param revert_to Specifies what happens when the \a focus window becomes unviewable (if \a focus
+ * is neither `XCB_NONE` nor `XCB_POINTER_ROOT`).
+ * @param focus The window to focus. All keyboard events will be reported to this window. The
+ * window must be viewable (TODO), or a `xcb_match_error_t` occurs (TODO).
+ * \n
+ * If \a focus is `XCB_NONE` (TODO), all keyboard events are
+ * discarded until a new focus window is set.
+ * \n
+ * If \a focus is `XCB_POINTER_ROOT` (TODO), focus is on the root window of the
+ * screen on which the pointer is on currently.
+ * @param time Timestamp to avoid race conditions when running X over the network.
+ * \n
+ * The special value `XCB_CURRENT_TIME` will be replaced with the current server
+ * time.
+ * @return A cookie
+ *
+ * Changes the input focus and the last-focus-change time. If the specified \a time
+ * is earlier than the current last-focus-change time, the request is ignored (to
+ * avoid race conditions when running X over the network).
+ * 
+ * A FocusIn and FocusOut event is generated when focus is changed.
+ *
+ */
+xcb_void_cookie_t
+xcb_set_input_focus (xcb_connection_t *c,
+                     uint8_t           revert_to,
+                     xcb_window_t      focus,
+                     xcb_timestamp_t   time);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_get_input_focus_cookie_t
+xcb_get_input_focus (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_get_input_focus_cookie_t
+xcb_get_input_focus_unchecked (xcb_connection_t *c);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_get_input_focus_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_get_input_focus_reply_t *
+xcb_get_input_focus_reply (xcb_connection_t              *c,
+                           xcb_get_input_focus_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_query_keymap_cookie_t
+xcb_query_keymap (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_query_keymap_cookie_t
+xcb_query_keymap_unchecked (xcb_connection_t *c);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_query_keymap_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_query_keymap_reply_t *
+xcb_query_keymap_reply (xcb_connection_t           *c,
+                        xcb_query_keymap_cookie_t   cookie  /**< */,
+                        xcb_generic_error_t       **e);
+
+int
+xcb_open_font_sizeof (const void  *_buffer);
+
+/**
+ * @brief opens a font
+ *
+ * @param c The connection
+ * @param fid The ID with which you will refer to the font, created by `xcb_generate_id`.
+ * @param name_len Length (in bytes) of \a name.
+ * @param name A pattern describing an X core font.
+ * @return A cookie
+ *
+ * Opens any X core font matching the given \a name (for example "-misc-fixed-*").
+ * 
+ * Note that X core fonts are deprecated (but still supported) in favor of
+ * client-side rendering using Xft.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_open_font_checked (xcb_connection_t *c,
+                       xcb_font_t        fid,
+                       uint16_t          name_len,
+                       const char       *name);
+
+/**
+ * @brief opens a font
+ *
+ * @param c The connection
+ * @param fid The ID with which you will refer to the font, created by `xcb_generate_id`.
+ * @param name_len Length (in bytes) of \a name.
+ * @param name A pattern describing an X core font.
+ * @return A cookie
+ *
+ * Opens any X core font matching the given \a name (for example "-misc-fixed-*").
+ * 
+ * Note that X core fonts are deprecated (but still supported) in favor of
+ * client-side rendering using Xft.
+ *
+ */
+xcb_void_cookie_t
+xcb_open_font (xcb_connection_t *c,
+               xcb_font_t        fid,
+               uint16_t          name_len,
+               const char       *name);
+
+char *
+xcb_open_font_name (const xcb_open_font_request_t *R);
+
+int
+xcb_open_font_name_length (const xcb_open_font_request_t *R);
+
+xcb_generic_iterator_t
+xcb_open_font_name_end (const xcb_open_font_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_close_font_checked (xcb_connection_t *c,
+                        xcb_font_t        font);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_close_font (xcb_connection_t *c,
+                xcb_font_t        font);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_fontprop_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_fontprop_t)
+ */
+void
+xcb_fontprop_next (xcb_fontprop_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_fontprop_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_fontprop_end (xcb_fontprop_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_charinfo_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_charinfo_t)
+ */
+void
+xcb_charinfo_next (xcb_charinfo_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_charinfo_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_charinfo_end (xcb_charinfo_iterator_t i);
+
+int
+xcb_query_font_sizeof (const void  *_buffer);
+
+/**
+ * @brief query font metrics
+ *
+ * @param c The connection
+ * @param font The fontable (Font or Graphics Context) to query.
+ * @return A cookie
+ *
+ * Queries information associated with the font.
+ *
+ */
+xcb_query_font_cookie_t
+xcb_query_font (xcb_connection_t *c,
+                xcb_fontable_t    font);
+
+/**
+ * @brief query font metrics
+ *
+ * @param c The connection
+ * @param font The fontable (Font or Graphics Context) to query.
+ * @return A cookie
+ *
+ * Queries information associated with the font.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_query_font_cookie_t
+xcb_query_font_unchecked (xcb_connection_t *c,
+                          xcb_fontable_t    font);
+
+xcb_fontprop_t *
+xcb_query_font_properties (const xcb_query_font_reply_t *R);
+
+int
+xcb_query_font_properties_length (const xcb_query_font_reply_t *R);
+
+xcb_fontprop_iterator_t
+xcb_query_font_properties_iterator (const xcb_query_font_reply_t *R);
+
+xcb_charinfo_t *
+xcb_query_font_char_infos (const xcb_query_font_reply_t *R);
+
+int
+xcb_query_font_char_infos_length (const xcb_query_font_reply_t *R);
+
+xcb_charinfo_iterator_t
+xcb_query_font_char_infos_iterator (const xcb_query_font_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_query_font_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_query_font_reply_t *
+xcb_query_font_reply (xcb_connection_t         *c,
+                      xcb_query_font_cookie_t   cookie  /**< */,
+                      xcb_generic_error_t     **e);
+
+int
+xcb_query_text_extents_sizeof (const void  *_buffer,
+                               uint32_t     string_len);
+
+/**
+ * @brief get text extents
+ *
+ * @param c The connection
+ * @param font The \a font to calculate text extents in. You can also pass a graphics context.
+ * @param string_len The number of characters in \a string.
+ * @param string The text to get text extents for.
+ * @return A cookie
+ *
+ * Query text extents from the X11 server. This request returns the bounding box
+ * of the specified 16-bit character string in the specified \a font or the font
+ * contained in the specified graphics context.
+ * 
+ * `font_ascent` is set to the maximum of the ascent metrics of all characters in
+ * the string. `font_descent` is set to the maximum of the descent metrics.
+ * `overall_width` is set to the sum of the character-width metrics of all
+ * characters in the string. For each character in the string, let W be the sum of
+ * the character-width metrics of all characters preceding it in the string. Let L
+ * be the left-side-bearing metric of the character plus W. Let R be the
+ * right-side-bearing metric of the character plus W. The lbearing member is set
+ * to the minimum L of all characters in the string. The rbearing member is set to
+ * the maximum R.
+ * 
+ * For fonts defined with linear indexing rather than 2-byte matrix indexing, each
+ * `xcb_char2b_t` structure is interpreted as a 16-bit number with byte1 as the
+ * most significant byte. If the font has no defined default character, undefined
+ * characters in the string are taken to have all zero metrics.
+ * 
+ * Characters with all zero metrics are ignored. If the font has no defined
+ * default_char, the undefined characters in the string are also ignored.
+ *
+ */
+xcb_query_text_extents_cookie_t
+xcb_query_text_extents (xcb_connection_t   *c,
+                        xcb_fontable_t      font,
+                        uint32_t            string_len,
+                        const xcb_char2b_t *string);
+
+/**
+ * @brief get text extents
+ *
+ * @param c The connection
+ * @param font The \a font to calculate text extents in. You can also pass a graphics context.
+ * @param string_len The number of characters in \a string.
+ * @param string The text to get text extents for.
+ * @return A cookie
+ *
+ * Query text extents from the X11 server. This request returns the bounding box
+ * of the specified 16-bit character string in the specified \a font or the font
+ * contained in the specified graphics context.
+ * 
+ * `font_ascent` is set to the maximum of the ascent metrics of all characters in
+ * the string. `font_descent` is set to the maximum of the descent metrics.
+ * `overall_width` is set to the sum of the character-width metrics of all
+ * characters in the string. For each character in the string, let W be the sum of
+ * the character-width metrics of all characters preceding it in the string. Let L
+ * be the left-side-bearing metric of the character plus W. Let R be the
+ * right-side-bearing metric of the character plus W. The lbearing member is set
+ * to the minimum L of all characters in the string. The rbearing member is set to
+ * the maximum R.
+ * 
+ * For fonts defined with linear indexing rather than 2-byte matrix indexing, each
+ * `xcb_char2b_t` structure is interpreted as a 16-bit number with byte1 as the
+ * most significant byte. If the font has no defined default character, undefined
+ * characters in the string are taken to have all zero metrics.
+ * 
+ * Characters with all zero metrics are ignored. If the font has no defined
+ * default_char, the undefined characters in the string are also ignored.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_query_text_extents_cookie_t
+xcb_query_text_extents_unchecked (xcb_connection_t   *c,
+                                  xcb_fontable_t      font,
+                                  uint32_t            string_len,
+                                  const xcb_char2b_t *string);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_query_text_extents_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_query_text_extents_reply_t *
+xcb_query_text_extents_reply (xcb_connection_t                 *c,
+                              xcb_query_text_extents_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+int
+xcb_str_sizeof (const void  *_buffer);
+
+char *
+xcb_str_name (const xcb_str_t *R);
+
+int
+xcb_str_name_length (const xcb_str_t *R);
+
+xcb_generic_iterator_t
+xcb_str_name_end (const xcb_str_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_str_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_str_t)
+ */
+void
+xcb_str_next (xcb_str_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_str_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_str_end (xcb_str_iterator_t i);
+
+int
+xcb_list_fonts_sizeof (const void  *_buffer);
+
+/**
+ * @brief get matching font names
+ *
+ * @param c The connection
+ * @param max_names The maximum number of fonts to be returned.
+ * @param pattern_len The length (in bytes) of \a pattern.
+ * @param pattern A font pattern, for example "-misc-fixed-*".
+ * \n
+ * The asterisk (*) is a wildcard for any number of characters. The question mark
+ * (?) is a wildcard for a single character. Use of uppercase or lowercase does
+ * not matter.
+ * @return A cookie
+ *
+ * Gets a list of available font names which match the given \a pattern.
+ *
+ */
+xcb_list_fonts_cookie_t
+xcb_list_fonts (xcb_connection_t *c,
+                uint16_t          max_names,
+                uint16_t          pattern_len,
+                const char       *pattern);
+
+/**
+ * @brief get matching font names
+ *
+ * @param c The connection
+ * @param max_names The maximum number of fonts to be returned.
+ * @param pattern_len The length (in bytes) of \a pattern.
+ * @param pattern A font pattern, for example "-misc-fixed-*".
+ * \n
+ * The asterisk (*) is a wildcard for any number of characters. The question mark
+ * (?) is a wildcard for a single character. Use of uppercase or lowercase does
+ * not matter.
+ * @return A cookie
+ *
+ * Gets a list of available font names which match the given \a pattern.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_list_fonts_cookie_t
+xcb_list_fonts_unchecked (xcb_connection_t *c,
+                          uint16_t          max_names,
+                          uint16_t          pattern_len,
+                          const char       *pattern);
+
+int
+xcb_list_fonts_names_length (const xcb_list_fonts_reply_t *R);
+
+xcb_str_iterator_t
+xcb_list_fonts_names_iterator (const xcb_list_fonts_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_list_fonts_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_list_fonts_reply_t *
+xcb_list_fonts_reply (xcb_connection_t         *c,
+                      xcb_list_fonts_cookie_t   cookie  /**< */,
+                      xcb_generic_error_t     **e);
+
+int
+xcb_list_fonts_with_info_sizeof (const void  *_buffer);
+
+/**
+ * @brief get matching font names and information
+ *
+ * @param c The connection
+ * @param max_names The maximum number of fonts to be returned.
+ * @param pattern_len The length (in bytes) of \a pattern.
+ * @param pattern A font pattern, for example "-misc-fixed-*".
+ * \n
+ * The asterisk (*) is a wildcard for any number of characters. The question mark
+ * (?) is a wildcard for a single character. Use of uppercase or lowercase does
+ * not matter.
+ * @return A cookie
+ *
+ * Gets a list of available font names which match the given \a pattern.
+ *
+ */
+xcb_list_fonts_with_info_cookie_t
+xcb_list_fonts_with_info (xcb_connection_t *c,
+                          uint16_t          max_names,
+                          uint16_t          pattern_len,
+                          const char       *pattern);
+
+/**
+ * @brief get matching font names and information
+ *
+ * @param c The connection
+ * @param max_names The maximum number of fonts to be returned.
+ * @param pattern_len The length (in bytes) of \a pattern.
+ * @param pattern A font pattern, for example "-misc-fixed-*".
+ * \n
+ * The asterisk (*) is a wildcard for any number of characters. The question mark
+ * (?) is a wildcard for a single character. Use of uppercase or lowercase does
+ * not matter.
+ * @return A cookie
+ *
+ * Gets a list of available font names which match the given \a pattern.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_list_fonts_with_info_cookie_t
+xcb_list_fonts_with_info_unchecked (xcb_connection_t *c,
+                                    uint16_t          max_names,
+                                    uint16_t          pattern_len,
+                                    const char       *pattern);
+
+xcb_fontprop_t *
+xcb_list_fonts_with_info_properties (const xcb_list_fonts_with_info_reply_t *R);
+
+int
+xcb_list_fonts_with_info_properties_length (const xcb_list_fonts_with_info_reply_t *R);
+
+xcb_fontprop_iterator_t
+xcb_list_fonts_with_info_properties_iterator (const xcb_list_fonts_with_info_reply_t *R);
+
+char *
+xcb_list_fonts_with_info_name (const xcb_list_fonts_with_info_reply_t *R);
+
+int
+xcb_list_fonts_with_info_name_length (const xcb_list_fonts_with_info_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_list_fonts_with_info_name_end (const xcb_list_fonts_with_info_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_list_fonts_with_info_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_list_fonts_with_info_reply_t *
+xcb_list_fonts_with_info_reply (xcb_connection_t                   *c,
+                                xcb_list_fonts_with_info_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e);
+
+int
+xcb_set_font_path_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_set_font_path_checked (xcb_connection_t *c,
+                           uint16_t          font_qty,
+                           const xcb_str_t  *font);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_set_font_path (xcb_connection_t *c,
+                   uint16_t          font_qty,
+                   const xcb_str_t  *font);
+
+int
+xcb_set_font_path_font_length (const xcb_set_font_path_request_t *R);
+
+xcb_str_iterator_t
+xcb_set_font_path_font_iterator (const xcb_set_font_path_request_t *R);
+
+int
+xcb_get_font_path_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_get_font_path_cookie_t
+xcb_get_font_path (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_get_font_path_cookie_t
+xcb_get_font_path_unchecked (xcb_connection_t *c);
+
+int
+xcb_get_font_path_path_length (const xcb_get_font_path_reply_t *R);
+
+xcb_str_iterator_t
+xcb_get_font_path_path_iterator (const xcb_get_font_path_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_get_font_path_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_get_font_path_reply_t *
+xcb_get_font_path_reply (xcb_connection_t            *c,
+                         xcb_get_font_path_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e);
+
+/**
+ * @brief Creates a pixmap
+ *
+ * @param c The connection
+ * @param depth TODO
+ * @param pid The ID with which you will refer to the new pixmap, created by
+ * `xcb_generate_id`.
+ * @param drawable Drawable to get the screen from.
+ * @param width The width of the new pixmap.
+ * @param height The height of the new pixmap.
+ * @return A cookie
+ *
+ * Creates a pixmap. The pixmap can only be used on the same screen as \a drawable
+ * is on and only with drawables of the same \a depth.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_create_pixmap_checked (xcb_connection_t *c,
+                           uint8_t           depth,
+                           xcb_pixmap_t      pid,
+                           xcb_drawable_t    drawable,
+                           uint16_t          width,
+                           uint16_t          height);
+
+/**
+ * @brief Creates a pixmap
+ *
+ * @param c The connection
+ * @param depth TODO
+ * @param pid The ID with which you will refer to the new pixmap, created by
+ * `xcb_generate_id`.
+ * @param drawable Drawable to get the screen from.
+ * @param width The width of the new pixmap.
+ * @param height The height of the new pixmap.
+ * @return A cookie
+ *
+ * Creates a pixmap. The pixmap can only be used on the same screen as \a drawable
+ * is on and only with drawables of the same \a depth.
+ *
+ */
+xcb_void_cookie_t
+xcb_create_pixmap (xcb_connection_t *c,
+                   uint8_t           depth,
+                   xcb_pixmap_t      pid,
+                   xcb_drawable_t    drawable,
+                   uint16_t          width,
+                   uint16_t          height);
+
+/**
+ * @brief Destroys a pixmap
+ *
+ * @param c The connection
+ * @param pixmap The pixmap to destroy.
+ * @return A cookie
+ *
+ * Deletes the association between the pixmap ID and the pixmap. The pixmap
+ * storage will be freed when there are no more references to it.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_free_pixmap_checked (xcb_connection_t *c,
+                         xcb_pixmap_t      pixmap);
+
+/**
+ * @brief Destroys a pixmap
+ *
+ * @param c The connection
+ * @param pixmap The pixmap to destroy.
+ * @return A cookie
+ *
+ * Deletes the association between the pixmap ID and the pixmap. The pixmap
+ * storage will be freed when there are no more references to it.
+ *
+ */
+xcb_void_cookie_t
+xcb_free_pixmap (xcb_connection_t *c,
+                 xcb_pixmap_t      pixmap);
+
+int
+xcb_create_gc_value_list_serialize (void                             **_buffer,
+                                    uint32_t                           value_mask,
+                                    const xcb_create_gc_value_list_t  *_aux);
+
+int
+xcb_create_gc_value_list_unpack (const void                  *_buffer,
+                                 uint32_t                     value_mask,
+                                 xcb_create_gc_value_list_t  *_aux);
+
+int
+xcb_create_gc_value_list_sizeof (const void  *_buffer,
+                                 uint32_t     value_mask);
+
+int
+xcb_create_gc_sizeof (const void  *_buffer);
+
+/**
+ * @brief Creates a graphics context
+ *
+ * @param c The connection
+ * @param cid The ID with which you will refer to the graphics context, created by
+ * `xcb_generate_id`.
+ * @param drawable Drawable to get the root/depth from.
+ * @return A cookie
+ *
+ * Creates a graphics context. The graphics context can be used with any drawable
+ * that has the same root and depth as the specified drawable.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_create_gc_checked (xcb_connection_t *c,
+                       xcb_gcontext_t    cid,
+                       xcb_drawable_t    drawable,
+                       uint32_t          value_mask,
+                       const void       *value_list);
+
+/**
+ * @brief Creates a graphics context
+ *
+ * @param c The connection
+ * @param cid The ID with which you will refer to the graphics context, created by
+ * `xcb_generate_id`.
+ * @param drawable Drawable to get the root/depth from.
+ * @return A cookie
+ *
+ * Creates a graphics context. The graphics context can be used with any drawable
+ * that has the same root and depth as the specified drawable.
+ *
+ */
+xcb_void_cookie_t
+xcb_create_gc (xcb_connection_t *c,
+               xcb_gcontext_t    cid,
+               xcb_drawable_t    drawable,
+               uint32_t          value_mask,
+               const void       *value_list);
+
+/**
+ * @brief Creates a graphics context
+ *
+ * @param c The connection
+ * @param cid The ID with which you will refer to the graphics context, created by
+ * `xcb_generate_id`.
+ * @param drawable Drawable to get the root/depth from.
+ * @return A cookie
+ *
+ * Creates a graphics context. The graphics context can be used with any drawable
+ * that has the same root and depth as the specified drawable.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_create_gc_aux_checked (xcb_connection_t                 *c,
+                           xcb_gcontext_t                    cid,
+                           xcb_drawable_t                    drawable,
+                           uint32_t                          value_mask,
+                           const xcb_create_gc_value_list_t *value_list);
+
+/**
+ * @brief Creates a graphics context
+ *
+ * @param c The connection
+ * @param cid The ID with which you will refer to the graphics context, created by
+ * `xcb_generate_id`.
+ * @param drawable Drawable to get the root/depth from.
+ * @return A cookie
+ *
+ * Creates a graphics context. The graphics context can be used with any drawable
+ * that has the same root and depth as the specified drawable.
+ *
+ */
+xcb_void_cookie_t
+xcb_create_gc_aux (xcb_connection_t                 *c,
+                   xcb_gcontext_t                    cid,
+                   xcb_drawable_t                    drawable,
+                   uint32_t                          value_mask,
+                   const xcb_create_gc_value_list_t *value_list);
+
+void *
+xcb_create_gc_value_list (const xcb_create_gc_request_t *R);
+
+int
+xcb_change_gc_value_list_serialize (void                             **_buffer,
+                                    uint32_t                           value_mask,
+                                    const xcb_change_gc_value_list_t  *_aux);
+
+int
+xcb_change_gc_value_list_unpack (const void                  *_buffer,
+                                 uint32_t                     value_mask,
+                                 xcb_change_gc_value_list_t  *_aux);
+
+int
+xcb_change_gc_value_list_sizeof (const void  *_buffer,
+                                 uint32_t     value_mask);
+
+int
+xcb_change_gc_sizeof (const void  *_buffer);
+
+/**
+ * @brief change graphics context components
+ *
+ * @param c The connection
+ * @param gc The graphics context to change.
+ * @param value_mask A bitmask of #xcb_gc_t values.
+ * @param value_mask \n
+ * @param value_list Values for each of the components specified in the bitmask \a value_mask. The
+ * order has to correspond to the order of possible \a value_mask bits. See the
+ * example.
+ * @return A cookie
+ *
+ * Changes the components specified by \a value_mask for the specified graphics context.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_change_gc_checked (xcb_connection_t *c,
+                       xcb_gcontext_t    gc,
+                       uint32_t          value_mask,
+                       const void       *value_list);
+
+/**
+ * @brief change graphics context components
+ *
+ * @param c The connection
+ * @param gc The graphics context to change.
+ * @param value_mask A bitmask of #xcb_gc_t values.
+ * @param value_mask \n
+ * @param value_list Values for each of the components specified in the bitmask \a value_mask. The
+ * order has to correspond to the order of possible \a value_mask bits. See the
+ * example.
+ * @return A cookie
+ *
+ * Changes the components specified by \a value_mask for the specified graphics context.
+ *
+ */
+xcb_void_cookie_t
+xcb_change_gc (xcb_connection_t *c,
+               xcb_gcontext_t    gc,
+               uint32_t          value_mask,
+               const void       *value_list);
+
+/**
+ * @brief change graphics context components
+ *
+ * @param c The connection
+ * @param gc The graphics context to change.
+ * @param value_mask A bitmask of #xcb_gc_t values.
+ * @param value_mask \n
+ * @param value_list Values for each of the components specified in the bitmask \a value_mask. The
+ * order has to correspond to the order of possible \a value_mask bits. See the
+ * example.
+ * @return A cookie
+ *
+ * Changes the components specified by \a value_mask for the specified graphics context.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_change_gc_aux_checked (xcb_connection_t                 *c,
+                           xcb_gcontext_t                    gc,
+                           uint32_t                          value_mask,
+                           const xcb_change_gc_value_list_t *value_list);
+
+/**
+ * @brief change graphics context components
+ *
+ * @param c The connection
+ * @param gc The graphics context to change.
+ * @param value_mask A bitmask of #xcb_gc_t values.
+ * @param value_mask \n
+ * @param value_list Values for each of the components specified in the bitmask \a value_mask. The
+ * order has to correspond to the order of possible \a value_mask bits. See the
+ * example.
+ * @return A cookie
+ *
+ * Changes the components specified by \a value_mask for the specified graphics context.
+ *
+ */
+xcb_void_cookie_t
+xcb_change_gc_aux (xcb_connection_t                 *c,
+                   xcb_gcontext_t                    gc,
+                   uint32_t                          value_mask,
+                   const xcb_change_gc_value_list_t *value_list);
+
+void *
+xcb_change_gc_value_list (const xcb_change_gc_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_copy_gc_checked (xcb_connection_t *c,
+                     xcb_gcontext_t    src_gc,
+                     xcb_gcontext_t    dst_gc,
+                     uint32_t          value_mask);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_copy_gc (xcb_connection_t *c,
+             xcb_gcontext_t    src_gc,
+             xcb_gcontext_t    dst_gc,
+             uint32_t          value_mask);
+
+int
+xcb_set_dashes_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_set_dashes_checked (xcb_connection_t *c,
+                        xcb_gcontext_t    gc,
+                        uint16_t          dash_offset,
+                        uint16_t          dashes_len,
+                        const uint8_t    *dashes);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_set_dashes (xcb_connection_t *c,
+                xcb_gcontext_t    gc,
+                uint16_t          dash_offset,
+                uint16_t          dashes_len,
+                const uint8_t    *dashes);
+
+uint8_t *
+xcb_set_dashes_dashes (const xcb_set_dashes_request_t *R);
+
+int
+xcb_set_dashes_dashes_length (const xcb_set_dashes_request_t *R);
+
+xcb_generic_iterator_t
+xcb_set_dashes_dashes_end (const xcb_set_dashes_request_t *R);
+
+int
+xcb_set_clip_rectangles_sizeof (const void  *_buffer,
+                                uint32_t     rectangles_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_set_clip_rectangles_checked (xcb_connection_t      *c,
+                                 uint8_t                ordering,
+                                 xcb_gcontext_t         gc,
+                                 int16_t                clip_x_origin,
+                                 int16_t                clip_y_origin,
+                                 uint32_t               rectangles_len,
+                                 const xcb_rectangle_t *rectangles);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_set_clip_rectangles (xcb_connection_t      *c,
+                         uint8_t                ordering,
+                         xcb_gcontext_t         gc,
+                         int16_t                clip_x_origin,
+                         int16_t                clip_y_origin,
+                         uint32_t               rectangles_len,
+                         const xcb_rectangle_t *rectangles);
+
+xcb_rectangle_t *
+xcb_set_clip_rectangles_rectangles (const xcb_set_clip_rectangles_request_t *R);
+
+int
+xcb_set_clip_rectangles_rectangles_length (const xcb_set_clip_rectangles_request_t *R);
+
+xcb_rectangle_iterator_t
+xcb_set_clip_rectangles_rectangles_iterator (const xcb_set_clip_rectangles_request_t *R);
+
+/**
+ * @brief Destroys a graphics context
+ *
+ * @param c The connection
+ * @param gc The graphics context to destroy.
+ * @return A cookie
+ *
+ * Destroys the specified \a gc and all associated storage.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_free_gc_checked (xcb_connection_t *c,
+                     xcb_gcontext_t    gc);
+
+/**
+ * @brief Destroys a graphics context
+ *
+ * @param c The connection
+ * @param gc The graphics context to destroy.
+ * @return A cookie
+ *
+ * Destroys the specified \a gc and all associated storage.
+ *
+ */
+xcb_void_cookie_t
+xcb_free_gc (xcb_connection_t *c,
+             xcb_gcontext_t    gc);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_clear_area_checked (xcb_connection_t *c,
+                        uint8_t           exposures,
+                        xcb_window_t      window,
+                        int16_t           x,
+                        int16_t           y,
+                        uint16_t          width,
+                        uint16_t          height);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_clear_area (xcb_connection_t *c,
+                uint8_t           exposures,
+                xcb_window_t      window,
+                int16_t           x,
+                int16_t           y,
+                uint16_t          width,
+                uint16_t          height);
+
+/**
+ * @brief copy areas
+ *
+ * @param c The connection
+ * @param src_drawable The source drawable (Window or Pixmap).
+ * @param dst_drawable The destination drawable (Window or Pixmap).
+ * @param gc The graphics context to use.
+ * @param src_x The source X coordinate.
+ * @param src_y The source Y coordinate.
+ * @param dst_x The destination X coordinate.
+ * @param dst_y The destination Y coordinate.
+ * @param width The width of the area to copy (in pixels).
+ * @param height The height of the area to copy (in pixels).
+ * @return A cookie
+ *
+ * Copies the specified rectangle from \a src_drawable to \a dst_drawable.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_copy_area_checked (xcb_connection_t *c,
+                       xcb_drawable_t    src_drawable,
+                       xcb_drawable_t    dst_drawable,
+                       xcb_gcontext_t    gc,
+                       int16_t           src_x,
+                       int16_t           src_y,
+                       int16_t           dst_x,
+                       int16_t           dst_y,
+                       uint16_t          width,
+                       uint16_t          height);
+
+/**
+ * @brief copy areas
+ *
+ * @param c The connection
+ * @param src_drawable The source drawable (Window or Pixmap).
+ * @param dst_drawable The destination drawable (Window or Pixmap).
+ * @param gc The graphics context to use.
+ * @param src_x The source X coordinate.
+ * @param src_y The source Y coordinate.
+ * @param dst_x The destination X coordinate.
+ * @param dst_y The destination Y coordinate.
+ * @param width The width of the area to copy (in pixels).
+ * @param height The height of the area to copy (in pixels).
+ * @return A cookie
+ *
+ * Copies the specified rectangle from \a src_drawable to \a dst_drawable.
+ *
+ */
+xcb_void_cookie_t
+xcb_copy_area (xcb_connection_t *c,
+               xcb_drawable_t    src_drawable,
+               xcb_drawable_t    dst_drawable,
+               xcb_gcontext_t    gc,
+               int16_t           src_x,
+               int16_t           src_y,
+               int16_t           dst_x,
+               int16_t           dst_y,
+               uint16_t          width,
+               uint16_t          height);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_copy_plane_checked (xcb_connection_t *c,
+                        xcb_drawable_t    src_drawable,
+                        xcb_drawable_t    dst_drawable,
+                        xcb_gcontext_t    gc,
+                        int16_t           src_x,
+                        int16_t           src_y,
+                        int16_t           dst_x,
+                        int16_t           dst_y,
+                        uint16_t          width,
+                        uint16_t          height,
+                        uint32_t          bit_plane);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_copy_plane (xcb_connection_t *c,
+                xcb_drawable_t    src_drawable,
+                xcb_drawable_t    dst_drawable,
+                xcb_gcontext_t    gc,
+                int16_t           src_x,
+                int16_t           src_y,
+                int16_t           dst_x,
+                int16_t           dst_y,
+                uint16_t          width,
+                uint16_t          height,
+                uint32_t          bit_plane);
+
+int
+xcb_poly_point_sizeof (const void  *_buffer,
+                       uint32_t     points_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_poly_point_checked (xcb_connection_t  *c,
+                        uint8_t            coordinate_mode,
+                        xcb_drawable_t     drawable,
+                        xcb_gcontext_t     gc,
+                        uint32_t           points_len,
+                        const xcb_point_t *points);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_poly_point (xcb_connection_t  *c,
+                uint8_t            coordinate_mode,
+                xcb_drawable_t     drawable,
+                xcb_gcontext_t     gc,
+                uint32_t           points_len,
+                const xcb_point_t *points);
+
+xcb_point_t *
+xcb_poly_point_points (const xcb_poly_point_request_t *R);
+
+int
+xcb_poly_point_points_length (const xcb_poly_point_request_t *R);
+
+xcb_point_iterator_t
+xcb_poly_point_points_iterator (const xcb_poly_point_request_t *R);
+
+int
+xcb_poly_line_sizeof (const void  *_buffer,
+                      uint32_t     points_len);
+
+/**
+ * @brief draw lines
+ *
+ * @param c The connection
+ * @param coordinate_mode A bitmask of #xcb_coord_mode_t values.
+ * @param coordinate_mode \n
+ * @param drawable The drawable to draw the line(s) on.
+ * @param gc The graphics context to use.
+ * @param points_len The number of `xcb_point_t` structures in \a points.
+ * @param points An array of points.
+ * @return A cookie
+ *
+ * Draws \a points_len-1 lines between each pair of points (point[i], point[i+1])
+ * in the \a points array. The lines are drawn in the order listed in the array.
+ * They join correctly at all intermediate points, and if the first and last
+ * points coincide, the first and last lines also join correctly. For any given
+ * line, a pixel is not drawn more than once. If thin (zero line-width) lines
+ * intersect, the intersecting pixels are drawn multiple times. If wide lines
+ * intersect, the intersecting pixels are drawn only once, as though the entire
+ * request were a single, filled shape.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_poly_line_checked (xcb_connection_t  *c,
+                       uint8_t            coordinate_mode,
+                       xcb_drawable_t     drawable,
+                       xcb_gcontext_t     gc,
+                       uint32_t           points_len,
+                       const xcb_point_t *points);
+
+/**
+ * @brief draw lines
+ *
+ * @param c The connection
+ * @param coordinate_mode A bitmask of #xcb_coord_mode_t values.
+ * @param coordinate_mode \n
+ * @param drawable The drawable to draw the line(s) on.
+ * @param gc The graphics context to use.
+ * @param points_len The number of `xcb_point_t` structures in \a points.
+ * @param points An array of points.
+ * @return A cookie
+ *
+ * Draws \a points_len-1 lines between each pair of points (point[i], point[i+1])
+ * in the \a points array. The lines are drawn in the order listed in the array.
+ * They join correctly at all intermediate points, and if the first and last
+ * points coincide, the first and last lines also join correctly. For any given
+ * line, a pixel is not drawn more than once. If thin (zero line-width) lines
+ * intersect, the intersecting pixels are drawn multiple times. If wide lines
+ * intersect, the intersecting pixels are drawn only once, as though the entire
+ * request were a single, filled shape.
+ *
+ */
+xcb_void_cookie_t
+xcb_poly_line (xcb_connection_t  *c,
+               uint8_t            coordinate_mode,
+               xcb_drawable_t     drawable,
+               xcb_gcontext_t     gc,
+               uint32_t           points_len,
+               const xcb_point_t *points);
+
+xcb_point_t *
+xcb_poly_line_points (const xcb_poly_line_request_t *R);
+
+int
+xcb_poly_line_points_length (const xcb_poly_line_request_t *R);
+
+xcb_point_iterator_t
+xcb_poly_line_points_iterator (const xcb_poly_line_request_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_segment_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_segment_t)
+ */
+void
+xcb_segment_next (xcb_segment_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_segment_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_segment_end (xcb_segment_iterator_t i);
+
+int
+xcb_poly_segment_sizeof (const void  *_buffer,
+                         uint32_t     segments_len);
+
+/**
+ * @brief draw lines
+ *
+ * @param c The connection
+ * @param drawable A drawable (Window or Pixmap) to draw on.
+ * @param gc The graphics context to use.
+ * \n
+ * TODO: document which attributes of a gc are used
+ * @param segments_len The number of `xcb_segment_t` structures in \a segments.
+ * @param segments An array of `xcb_segment_t` structures.
+ * @return A cookie
+ *
+ * Draws multiple, unconnected lines. For each segment, a line is drawn between
+ * (x1, y1) and (x2, y2). The lines are drawn in the order listed in the array of
+ * `xcb_segment_t` structures and does not perform joining at coincident
+ * endpoints. For any given line, a pixel is not drawn more than once. If lines
+ * intersect, the intersecting pixels are drawn multiple times.
+ * 
+ * TODO: include the xcb_segment_t data structure
+ * 
+ * TODO: an example
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_poly_segment_checked (xcb_connection_t    *c,
+                          xcb_drawable_t       drawable,
+                          xcb_gcontext_t       gc,
+                          uint32_t             segments_len,
+                          const xcb_segment_t *segments);
+
+/**
+ * @brief draw lines
+ *
+ * @param c The connection
+ * @param drawable A drawable (Window or Pixmap) to draw on.
+ * @param gc The graphics context to use.
+ * \n
+ * TODO: document which attributes of a gc are used
+ * @param segments_len The number of `xcb_segment_t` structures in \a segments.
+ * @param segments An array of `xcb_segment_t` structures.
+ * @return A cookie
+ *
+ * Draws multiple, unconnected lines. For each segment, a line is drawn between
+ * (x1, y1) and (x2, y2). The lines are drawn in the order listed in the array of
+ * `xcb_segment_t` structures and does not perform joining at coincident
+ * endpoints. For any given line, a pixel is not drawn more than once. If lines
+ * intersect, the intersecting pixels are drawn multiple times.
+ * 
+ * TODO: include the xcb_segment_t data structure
+ * 
+ * TODO: an example
+ *
+ */
+xcb_void_cookie_t
+xcb_poly_segment (xcb_connection_t    *c,
+                  xcb_drawable_t       drawable,
+                  xcb_gcontext_t       gc,
+                  uint32_t             segments_len,
+                  const xcb_segment_t *segments);
+
+xcb_segment_t *
+xcb_poly_segment_segments (const xcb_poly_segment_request_t *R);
+
+int
+xcb_poly_segment_segments_length (const xcb_poly_segment_request_t *R);
+
+xcb_segment_iterator_t
+xcb_poly_segment_segments_iterator (const xcb_poly_segment_request_t *R);
+
+int
+xcb_poly_rectangle_sizeof (const void  *_buffer,
+                           uint32_t     rectangles_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_poly_rectangle_checked (xcb_connection_t      *c,
+                            xcb_drawable_t         drawable,
+                            xcb_gcontext_t         gc,
+                            uint32_t               rectangles_len,
+                            const xcb_rectangle_t *rectangles);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_poly_rectangle (xcb_connection_t      *c,
+                    xcb_drawable_t         drawable,
+                    xcb_gcontext_t         gc,
+                    uint32_t               rectangles_len,
+                    const xcb_rectangle_t *rectangles);
+
+xcb_rectangle_t *
+xcb_poly_rectangle_rectangles (const xcb_poly_rectangle_request_t *R);
+
+int
+xcb_poly_rectangle_rectangles_length (const xcb_poly_rectangle_request_t *R);
+
+xcb_rectangle_iterator_t
+xcb_poly_rectangle_rectangles_iterator (const xcb_poly_rectangle_request_t *R);
+
+int
+xcb_poly_arc_sizeof (const void  *_buffer,
+                     uint32_t     arcs_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_poly_arc_checked (xcb_connection_t *c,
+                      xcb_drawable_t    drawable,
+                      xcb_gcontext_t    gc,
+                      uint32_t          arcs_len,
+                      const xcb_arc_t  *arcs);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_poly_arc (xcb_connection_t *c,
+              xcb_drawable_t    drawable,
+              xcb_gcontext_t    gc,
+              uint32_t          arcs_len,
+              const xcb_arc_t  *arcs);
+
+xcb_arc_t *
+xcb_poly_arc_arcs (const xcb_poly_arc_request_t *R);
+
+int
+xcb_poly_arc_arcs_length (const xcb_poly_arc_request_t *R);
+
+xcb_arc_iterator_t
+xcb_poly_arc_arcs_iterator (const xcb_poly_arc_request_t *R);
+
+int
+xcb_fill_poly_sizeof (const void  *_buffer,
+                      uint32_t     points_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_fill_poly_checked (xcb_connection_t  *c,
+                       xcb_drawable_t     drawable,
+                       xcb_gcontext_t     gc,
+                       uint8_t            shape,
+                       uint8_t            coordinate_mode,
+                       uint32_t           points_len,
+                       const xcb_point_t *points);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_fill_poly (xcb_connection_t  *c,
+               xcb_drawable_t     drawable,
+               xcb_gcontext_t     gc,
+               uint8_t            shape,
+               uint8_t            coordinate_mode,
+               uint32_t           points_len,
+               const xcb_point_t *points);
+
+xcb_point_t *
+xcb_fill_poly_points (const xcb_fill_poly_request_t *R);
+
+int
+xcb_fill_poly_points_length (const xcb_fill_poly_request_t *R);
+
+xcb_point_iterator_t
+xcb_fill_poly_points_iterator (const xcb_fill_poly_request_t *R);
+
+int
+xcb_poly_fill_rectangle_sizeof (const void  *_buffer,
+                                uint32_t     rectangles_len);
+
+/**
+ * @brief Fills rectangles
+ *
+ * @param c The connection
+ * @param drawable The drawable (Window or Pixmap) to draw on.
+ * @param gc The graphics context to use.
+ * \n
+ * The following graphics context components are used: function, plane-mask,
+ * fill-style, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.
+ * \n
+ * The following graphics context mode-dependent components are used:
+ * foreground, background, tile, stipple, tile-stipple-x-origin, and
+ * tile-stipple-y-origin.
+ * @param rectangles_len The number of `xcb_rectangle_t` structures in \a rectangles.
+ * @param rectangles The rectangles to fill.
+ * @return A cookie
+ *
+ * Fills the specified rectangle(s) in the order listed in the array. For any
+ * given rectangle, each pixel is not drawn more than once. If rectangles
+ * intersect, the intersecting pixels are drawn multiple times.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_poly_fill_rectangle_checked (xcb_connection_t      *c,
+                                 xcb_drawable_t         drawable,
+                                 xcb_gcontext_t         gc,
+                                 uint32_t               rectangles_len,
+                                 const xcb_rectangle_t *rectangles);
+
+/**
+ * @brief Fills rectangles
+ *
+ * @param c The connection
+ * @param drawable The drawable (Window or Pixmap) to draw on.
+ * @param gc The graphics context to use.
+ * \n
+ * The following graphics context components are used: function, plane-mask,
+ * fill-style, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.
+ * \n
+ * The following graphics context mode-dependent components are used:
+ * foreground, background, tile, stipple, tile-stipple-x-origin, and
+ * tile-stipple-y-origin.
+ * @param rectangles_len The number of `xcb_rectangle_t` structures in \a rectangles.
+ * @param rectangles The rectangles to fill.
+ * @return A cookie
+ *
+ * Fills the specified rectangle(s) in the order listed in the array. For any
+ * given rectangle, each pixel is not drawn more than once. If rectangles
+ * intersect, the intersecting pixels are drawn multiple times.
+ *
+ */
+xcb_void_cookie_t
+xcb_poly_fill_rectangle (xcb_connection_t      *c,
+                         xcb_drawable_t         drawable,
+                         xcb_gcontext_t         gc,
+                         uint32_t               rectangles_len,
+                         const xcb_rectangle_t *rectangles);
+
+xcb_rectangle_t *
+xcb_poly_fill_rectangle_rectangles (const xcb_poly_fill_rectangle_request_t *R);
+
+int
+xcb_poly_fill_rectangle_rectangles_length (const xcb_poly_fill_rectangle_request_t *R);
+
+xcb_rectangle_iterator_t
+xcb_poly_fill_rectangle_rectangles_iterator (const xcb_poly_fill_rectangle_request_t *R);
+
+int
+xcb_poly_fill_arc_sizeof (const void  *_buffer,
+                          uint32_t     arcs_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_poly_fill_arc_checked (xcb_connection_t *c,
+                           xcb_drawable_t    drawable,
+                           xcb_gcontext_t    gc,
+                           uint32_t          arcs_len,
+                           const xcb_arc_t  *arcs);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_poly_fill_arc (xcb_connection_t *c,
+                   xcb_drawable_t    drawable,
+                   xcb_gcontext_t    gc,
+                   uint32_t          arcs_len,
+                   const xcb_arc_t  *arcs);
+
+xcb_arc_t *
+xcb_poly_fill_arc_arcs (const xcb_poly_fill_arc_request_t *R);
+
+int
+xcb_poly_fill_arc_arcs_length (const xcb_poly_fill_arc_request_t *R);
+
+xcb_arc_iterator_t
+xcb_poly_fill_arc_arcs_iterator (const xcb_poly_fill_arc_request_t *R);
+
+int
+xcb_put_image_sizeof (const void  *_buffer,
+                      uint32_t     data_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_put_image_checked (xcb_connection_t *c,
+                       uint8_t           format,
+                       xcb_drawable_t    drawable,
+                       xcb_gcontext_t    gc,
+                       uint16_t          width,
+                       uint16_t          height,
+                       int16_t           dst_x,
+                       int16_t           dst_y,
+                       uint8_t           left_pad,
+                       uint8_t           depth,
+                       uint32_t          data_len,
+                       const uint8_t    *data);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_put_image (xcb_connection_t *c,
+               uint8_t           format,
+               xcb_drawable_t    drawable,
+               xcb_gcontext_t    gc,
+               uint16_t          width,
+               uint16_t          height,
+               int16_t           dst_x,
+               int16_t           dst_y,
+               uint8_t           left_pad,
+               uint8_t           depth,
+               uint32_t          data_len,
+               const uint8_t    *data);
+
+uint8_t *
+xcb_put_image_data (const xcb_put_image_request_t *R);
+
+int
+xcb_put_image_data_length (const xcb_put_image_request_t *R);
+
+xcb_generic_iterator_t
+xcb_put_image_data_end (const xcb_put_image_request_t *R);
+
+int
+xcb_get_image_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_get_image_cookie_t
+xcb_get_image (xcb_connection_t *c,
+               uint8_t           format,
+               xcb_drawable_t    drawable,
+               int16_t           x,
+               int16_t           y,
+               uint16_t          width,
+               uint16_t          height,
+               uint32_t          plane_mask);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_get_image_cookie_t
+xcb_get_image_unchecked (xcb_connection_t *c,
+                         uint8_t           format,
+                         xcb_drawable_t    drawable,
+                         int16_t           x,
+                         int16_t           y,
+                         uint16_t          width,
+                         uint16_t          height,
+                         uint32_t          plane_mask);
+
+uint8_t *
+xcb_get_image_data (const xcb_get_image_reply_t *R);
+
+int
+xcb_get_image_data_length (const xcb_get_image_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_get_image_data_end (const xcb_get_image_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_get_image_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_get_image_reply_t *
+xcb_get_image_reply (xcb_connection_t        *c,
+                     xcb_get_image_cookie_t   cookie  /**< */,
+                     xcb_generic_error_t    **e);
+
+int
+xcb_poly_text_8_sizeof (const void  *_buffer,
+                        uint32_t     items_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_poly_text_8_checked (xcb_connection_t *c,
+                         xcb_drawable_t    drawable,
+                         xcb_gcontext_t    gc,
+                         int16_t           x,
+                         int16_t           y,
+                         uint32_t          items_len,
+                         const uint8_t    *items);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_poly_text_8 (xcb_connection_t *c,
+                 xcb_drawable_t    drawable,
+                 xcb_gcontext_t    gc,
+                 int16_t           x,
+                 int16_t           y,
+                 uint32_t          items_len,
+                 const uint8_t    *items);
+
+uint8_t *
+xcb_poly_text_8_items (const xcb_poly_text_8_request_t *R);
+
+int
+xcb_poly_text_8_items_length (const xcb_poly_text_8_request_t *R);
+
+xcb_generic_iterator_t
+xcb_poly_text_8_items_end (const xcb_poly_text_8_request_t *R);
+
+int
+xcb_poly_text_16_sizeof (const void  *_buffer,
+                         uint32_t     items_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_poly_text_16_checked (xcb_connection_t *c,
+                          xcb_drawable_t    drawable,
+                          xcb_gcontext_t    gc,
+                          int16_t           x,
+                          int16_t           y,
+                          uint32_t          items_len,
+                          const uint8_t    *items);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_poly_text_16 (xcb_connection_t *c,
+                  xcb_drawable_t    drawable,
+                  xcb_gcontext_t    gc,
+                  int16_t           x,
+                  int16_t           y,
+                  uint32_t          items_len,
+                  const uint8_t    *items);
+
+uint8_t *
+xcb_poly_text_16_items (const xcb_poly_text_16_request_t *R);
+
+int
+xcb_poly_text_16_items_length (const xcb_poly_text_16_request_t *R);
+
+xcb_generic_iterator_t
+xcb_poly_text_16_items_end (const xcb_poly_text_16_request_t *R);
+
+int
+xcb_image_text_8_sizeof (const void  *_buffer);
+
+/**
+ * @brief Draws text
+ *
+ * @param c The connection
+ * @param string_len The length of the \a string. Note that this parameter limited by 255 due to
+ * using 8 bits!
+ * @param drawable The drawable (Window or Pixmap) to draw text on.
+ * @param gc The graphics context to use.
+ * \n
+ * The following graphics context components are used: plane-mask, foreground,
+ * background, font, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.
+ * @param x The x coordinate of the first character, relative to the origin of \a drawable.
+ * @param y The y coordinate of the first character, relative to the origin of \a drawable.
+ * @param string The string to draw. Only the first 255 characters are relevant due to the data
+ * type of \a string_len.
+ * @return A cookie
+ *
+ * Fills the destination rectangle with the background pixel from \a gc, then
+ * paints the text with the foreground pixel from \a gc. The upper-left corner of
+ * the filled rectangle is at [x, y - font-ascent]. The width is overall-width,
+ * the height is font-ascent + font-descent. The overall-width, font-ascent and
+ * font-descent are as returned by `xcb_query_text_extents` (TODO).
+ * 
+ * Note that using X core fonts is deprecated (but still supported) in favor of
+ * client-side rendering using Xft.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_image_text_8_checked (xcb_connection_t *c,
+                          uint8_t           string_len,
+                          xcb_drawable_t    drawable,
+                          xcb_gcontext_t    gc,
+                          int16_t           x,
+                          int16_t           y,
+                          const char       *string);
+
+/**
+ * @brief Draws text
+ *
+ * @param c The connection
+ * @param string_len The length of the \a string. Note that this parameter limited by 255 due to
+ * using 8 bits!
+ * @param drawable The drawable (Window or Pixmap) to draw text on.
+ * @param gc The graphics context to use.
+ * \n
+ * The following graphics context components are used: plane-mask, foreground,
+ * background, font, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.
+ * @param x The x coordinate of the first character, relative to the origin of \a drawable.
+ * @param y The y coordinate of the first character, relative to the origin of \a drawable.
+ * @param string The string to draw. Only the first 255 characters are relevant due to the data
+ * type of \a string_len.
+ * @return A cookie
+ *
+ * Fills the destination rectangle with the background pixel from \a gc, then
+ * paints the text with the foreground pixel from \a gc. The upper-left corner of
+ * the filled rectangle is at [x, y - font-ascent]. The width is overall-width,
+ * the height is font-ascent + font-descent. The overall-width, font-ascent and
+ * font-descent are as returned by `xcb_query_text_extents` (TODO).
+ * 
+ * Note that using X core fonts is deprecated (but still supported) in favor of
+ * client-side rendering using Xft.
+ *
+ */
+xcb_void_cookie_t
+xcb_image_text_8 (xcb_connection_t *c,
+                  uint8_t           string_len,
+                  xcb_drawable_t    drawable,
+                  xcb_gcontext_t    gc,
+                  int16_t           x,
+                  int16_t           y,
+                  const char       *string);
+
+char *
+xcb_image_text_8_string (const xcb_image_text_8_request_t *R);
+
+int
+xcb_image_text_8_string_length (const xcb_image_text_8_request_t *R);
+
+xcb_generic_iterator_t
+xcb_image_text_8_string_end (const xcb_image_text_8_request_t *R);
+
+int
+xcb_image_text_16_sizeof (const void  *_buffer);
+
+/**
+ * @brief Draws text
+ *
+ * @param c The connection
+ * @param string_len The length of the \a string in characters. Note that this parameter limited by
+ * 255 due to using 8 bits!
+ * @param drawable The drawable (Window or Pixmap) to draw text on.
+ * @param gc The graphics context to use.
+ * \n
+ * The following graphics context components are used: plane-mask, foreground,
+ * background, font, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.
+ * @param x The x coordinate of the first character, relative to the origin of \a drawable.
+ * @param y The y coordinate of the first character, relative to the origin of \a drawable.
+ * @param string The string to draw. Only the first 255 characters are relevant due to the data
+ * type of \a string_len. Every character uses 2 bytes (hence the 16 in this
+ * request's name).
+ * @return A cookie
+ *
+ * Fills the destination rectangle with the background pixel from \a gc, then
+ * paints the text with the foreground pixel from \a gc. The upper-left corner of
+ * the filled rectangle is at [x, y - font-ascent]. The width is overall-width,
+ * the height is font-ascent + font-descent. The overall-width, font-ascent and
+ * font-descent are as returned by `xcb_query_text_extents` (TODO).
+ * 
+ * Note that using X core fonts is deprecated (but still supported) in favor of
+ * client-side rendering using Xft.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_image_text_16_checked (xcb_connection_t   *c,
+                           uint8_t             string_len,
+                           xcb_drawable_t      drawable,
+                           xcb_gcontext_t      gc,
+                           int16_t             x,
+                           int16_t             y,
+                           const xcb_char2b_t *string);
+
+/**
+ * @brief Draws text
+ *
+ * @param c The connection
+ * @param string_len The length of the \a string in characters. Note that this parameter limited by
+ * 255 due to using 8 bits!
+ * @param drawable The drawable (Window or Pixmap) to draw text on.
+ * @param gc The graphics context to use.
+ * \n
+ * The following graphics context components are used: plane-mask, foreground,
+ * background, font, subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.
+ * @param x The x coordinate of the first character, relative to the origin of \a drawable.
+ * @param y The y coordinate of the first character, relative to the origin of \a drawable.
+ * @param string The string to draw. Only the first 255 characters are relevant due to the data
+ * type of \a string_len. Every character uses 2 bytes (hence the 16 in this
+ * request's name).
+ * @return A cookie
+ *
+ * Fills the destination rectangle with the background pixel from \a gc, then
+ * paints the text with the foreground pixel from \a gc. The upper-left corner of
+ * the filled rectangle is at [x, y - font-ascent]. The width is overall-width,
+ * the height is font-ascent + font-descent. The overall-width, font-ascent and
+ * font-descent are as returned by `xcb_query_text_extents` (TODO).
+ * 
+ * Note that using X core fonts is deprecated (but still supported) in favor of
+ * client-side rendering using Xft.
+ *
+ */
+xcb_void_cookie_t
+xcb_image_text_16 (xcb_connection_t   *c,
+                   uint8_t             string_len,
+                   xcb_drawable_t      drawable,
+                   xcb_gcontext_t      gc,
+                   int16_t             x,
+                   int16_t             y,
+                   const xcb_char2b_t *string);
+
+xcb_char2b_t *
+xcb_image_text_16_string (const xcb_image_text_16_request_t *R);
+
+int
+xcb_image_text_16_string_length (const xcb_image_text_16_request_t *R);
+
+xcb_char2b_iterator_t
+xcb_image_text_16_string_iterator (const xcb_image_text_16_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_create_colormap_checked (xcb_connection_t *c,
+                             uint8_t           alloc,
+                             xcb_colormap_t    mid,
+                             xcb_window_t      window,
+                             xcb_visualid_t    visual);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_create_colormap (xcb_connection_t *c,
+                     uint8_t           alloc,
+                     xcb_colormap_t    mid,
+                     xcb_window_t      window,
+                     xcb_visualid_t    visual);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_free_colormap_checked (xcb_connection_t *c,
+                           xcb_colormap_t    cmap);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_free_colormap (xcb_connection_t *c,
+                   xcb_colormap_t    cmap);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_copy_colormap_and_free_checked (xcb_connection_t *c,
+                                    xcb_colormap_t    mid,
+                                    xcb_colormap_t    src_cmap);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_copy_colormap_and_free (xcb_connection_t *c,
+                            xcb_colormap_t    mid,
+                            xcb_colormap_t    src_cmap);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_install_colormap_checked (xcb_connection_t *c,
+                              xcb_colormap_t    cmap);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_install_colormap (xcb_connection_t *c,
+                      xcb_colormap_t    cmap);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_uninstall_colormap_checked (xcb_connection_t *c,
+                                xcb_colormap_t    cmap);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_uninstall_colormap (xcb_connection_t *c,
+                        xcb_colormap_t    cmap);
+
+int
+xcb_list_installed_colormaps_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_list_installed_colormaps_cookie_t
+xcb_list_installed_colormaps (xcb_connection_t *c,
+                              xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_list_installed_colormaps_cookie_t
+xcb_list_installed_colormaps_unchecked (xcb_connection_t *c,
+                                        xcb_window_t      window);
+
+xcb_colormap_t *
+xcb_list_installed_colormaps_cmaps (const xcb_list_installed_colormaps_reply_t *R);
+
+int
+xcb_list_installed_colormaps_cmaps_length (const xcb_list_installed_colormaps_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_list_installed_colormaps_cmaps_end (const xcb_list_installed_colormaps_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_list_installed_colormaps_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_list_installed_colormaps_reply_t *
+xcb_list_installed_colormaps_reply (xcb_connection_t                       *c,
+                                    xcb_list_installed_colormaps_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e);
+
+/**
+ * @brief Allocate a color
+ *
+ * @param c The connection
+ * @param cmap TODO
+ * @param red The red value of your color.
+ * @param green The green value of your color.
+ * @param blue The blue value of your color.
+ * @return A cookie
+ *
+ * Allocates a read-only colormap entry corresponding to the closest RGB value
+ * supported by the hardware. If you are using TrueColor, you can take a shortcut
+ * and directly calculate the color pixel value to avoid the round trip. But, for
+ * example, on 16-bit color setups (VNC), you can easily get the closest supported
+ * RGB value to the RGB value you are specifying.
+ *
+ */
+xcb_alloc_color_cookie_t
+xcb_alloc_color (xcb_connection_t *c,
+                 xcb_colormap_t    cmap,
+                 uint16_t          red,
+                 uint16_t          green,
+                 uint16_t          blue);
+
+/**
+ * @brief Allocate a color
+ *
+ * @param c The connection
+ * @param cmap TODO
+ * @param red The red value of your color.
+ * @param green The green value of your color.
+ * @param blue The blue value of your color.
+ * @return A cookie
+ *
+ * Allocates a read-only colormap entry corresponding to the closest RGB value
+ * supported by the hardware. If you are using TrueColor, you can take a shortcut
+ * and directly calculate the color pixel value to avoid the round trip. But, for
+ * example, on 16-bit color setups (VNC), you can easily get the closest supported
+ * RGB value to the RGB value you are specifying.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_alloc_color_cookie_t
+xcb_alloc_color_unchecked (xcb_connection_t *c,
+                           xcb_colormap_t    cmap,
+                           uint16_t          red,
+                           uint16_t          green,
+                           uint16_t          blue);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_alloc_color_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_alloc_color_reply_t *
+xcb_alloc_color_reply (xcb_connection_t          *c,
+                       xcb_alloc_color_cookie_t   cookie  /**< */,
+                       xcb_generic_error_t      **e);
+
+int
+xcb_alloc_named_color_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_alloc_named_color_cookie_t
+xcb_alloc_named_color (xcb_connection_t *c,
+                       xcb_colormap_t    cmap,
+                       uint16_t          name_len,
+                       const char       *name);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_alloc_named_color_cookie_t
+xcb_alloc_named_color_unchecked (xcb_connection_t *c,
+                                 xcb_colormap_t    cmap,
+                                 uint16_t          name_len,
+                                 const char       *name);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_alloc_named_color_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_alloc_named_color_reply_t *
+xcb_alloc_named_color_reply (xcb_connection_t                *c,
+                             xcb_alloc_named_color_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+int
+xcb_alloc_color_cells_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_alloc_color_cells_cookie_t
+xcb_alloc_color_cells (xcb_connection_t *c,
+                       uint8_t           contiguous,
+                       xcb_colormap_t    cmap,
+                       uint16_t          colors,
+                       uint16_t          planes);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_alloc_color_cells_cookie_t
+xcb_alloc_color_cells_unchecked (xcb_connection_t *c,
+                                 uint8_t           contiguous,
+                                 xcb_colormap_t    cmap,
+                                 uint16_t          colors,
+                                 uint16_t          planes);
+
+uint32_t *
+xcb_alloc_color_cells_pixels (const xcb_alloc_color_cells_reply_t *R);
+
+int
+xcb_alloc_color_cells_pixels_length (const xcb_alloc_color_cells_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_alloc_color_cells_pixels_end (const xcb_alloc_color_cells_reply_t *R);
+
+uint32_t *
+xcb_alloc_color_cells_masks (const xcb_alloc_color_cells_reply_t *R);
+
+int
+xcb_alloc_color_cells_masks_length (const xcb_alloc_color_cells_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_alloc_color_cells_masks_end (const xcb_alloc_color_cells_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_alloc_color_cells_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_alloc_color_cells_reply_t *
+xcb_alloc_color_cells_reply (xcb_connection_t                *c,
+                             xcb_alloc_color_cells_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+int
+xcb_alloc_color_planes_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_alloc_color_planes_cookie_t
+xcb_alloc_color_planes (xcb_connection_t *c,
+                        uint8_t           contiguous,
+                        xcb_colormap_t    cmap,
+                        uint16_t          colors,
+                        uint16_t          reds,
+                        uint16_t          greens,
+                        uint16_t          blues);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_alloc_color_planes_cookie_t
+xcb_alloc_color_planes_unchecked (xcb_connection_t *c,
+                                  uint8_t           contiguous,
+                                  xcb_colormap_t    cmap,
+                                  uint16_t          colors,
+                                  uint16_t          reds,
+                                  uint16_t          greens,
+                                  uint16_t          blues);
+
+uint32_t *
+xcb_alloc_color_planes_pixels (const xcb_alloc_color_planes_reply_t *R);
+
+int
+xcb_alloc_color_planes_pixels_length (const xcb_alloc_color_planes_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_alloc_color_planes_pixels_end (const xcb_alloc_color_planes_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_alloc_color_planes_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_alloc_color_planes_reply_t *
+xcb_alloc_color_planes_reply (xcb_connection_t                 *c,
+                              xcb_alloc_color_planes_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+int
+xcb_free_colors_sizeof (const void  *_buffer,
+                        uint32_t     pixels_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_free_colors_checked (xcb_connection_t *c,
+                         xcb_colormap_t    cmap,
+                         uint32_t          plane_mask,
+                         uint32_t          pixels_len,
+                         const uint32_t   *pixels);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_free_colors (xcb_connection_t *c,
+                 xcb_colormap_t    cmap,
+                 uint32_t          plane_mask,
+                 uint32_t          pixels_len,
+                 const uint32_t   *pixels);
+
+uint32_t *
+xcb_free_colors_pixels (const xcb_free_colors_request_t *R);
+
+int
+xcb_free_colors_pixels_length (const xcb_free_colors_request_t *R);
+
+xcb_generic_iterator_t
+xcb_free_colors_pixels_end (const xcb_free_colors_request_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_coloritem_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_coloritem_t)
+ */
+void
+xcb_coloritem_next (xcb_coloritem_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_coloritem_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_coloritem_end (xcb_coloritem_iterator_t i);
+
+int
+xcb_store_colors_sizeof (const void  *_buffer,
+                         uint32_t     items_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_store_colors_checked (xcb_connection_t      *c,
+                          xcb_colormap_t         cmap,
+                          uint32_t               items_len,
+                          const xcb_coloritem_t *items);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_store_colors (xcb_connection_t      *c,
+                  xcb_colormap_t         cmap,
+                  uint32_t               items_len,
+                  const xcb_coloritem_t *items);
+
+xcb_coloritem_t *
+xcb_store_colors_items (const xcb_store_colors_request_t *R);
+
+int
+xcb_store_colors_items_length (const xcb_store_colors_request_t *R);
+
+xcb_coloritem_iterator_t
+xcb_store_colors_items_iterator (const xcb_store_colors_request_t *R);
+
+int
+xcb_store_named_color_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_store_named_color_checked (xcb_connection_t *c,
+                               uint8_t           flags,
+                               xcb_colormap_t    cmap,
+                               uint32_t          pixel,
+                               uint16_t          name_len,
+                               const char       *name);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_store_named_color (xcb_connection_t *c,
+                       uint8_t           flags,
+                       xcb_colormap_t    cmap,
+                       uint32_t          pixel,
+                       uint16_t          name_len,
+                       const char       *name);
+
+char *
+xcb_store_named_color_name (const xcb_store_named_color_request_t *R);
+
+int
+xcb_store_named_color_name_length (const xcb_store_named_color_request_t *R);
+
+xcb_generic_iterator_t
+xcb_store_named_color_name_end (const xcb_store_named_color_request_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_rgb_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_rgb_t)
+ */
+void
+xcb_rgb_next (xcb_rgb_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_rgb_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_rgb_end (xcb_rgb_iterator_t i);
+
+int
+xcb_query_colors_sizeof (const void  *_buffer,
+                         uint32_t     pixels_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_query_colors_cookie_t
+xcb_query_colors (xcb_connection_t *c,
+                  xcb_colormap_t    cmap,
+                  uint32_t          pixels_len,
+                  const uint32_t   *pixels);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_query_colors_cookie_t
+xcb_query_colors_unchecked (xcb_connection_t *c,
+                            xcb_colormap_t    cmap,
+                            uint32_t          pixels_len,
+                            const uint32_t   *pixels);
+
+xcb_rgb_t *
+xcb_query_colors_colors (const xcb_query_colors_reply_t *R);
+
+int
+xcb_query_colors_colors_length (const xcb_query_colors_reply_t *R);
+
+xcb_rgb_iterator_t
+xcb_query_colors_colors_iterator (const xcb_query_colors_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_query_colors_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_query_colors_reply_t *
+xcb_query_colors_reply (xcb_connection_t           *c,
+                        xcb_query_colors_cookie_t   cookie  /**< */,
+                        xcb_generic_error_t       **e);
+
+int
+xcb_lookup_color_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_lookup_color_cookie_t
+xcb_lookup_color (xcb_connection_t *c,
+                  xcb_colormap_t    cmap,
+                  uint16_t          name_len,
+                  const char       *name);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_lookup_color_cookie_t
+xcb_lookup_color_unchecked (xcb_connection_t *c,
+                            xcb_colormap_t    cmap,
+                            uint16_t          name_len,
+                            const char       *name);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_lookup_color_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_lookup_color_reply_t *
+xcb_lookup_color_reply (xcb_connection_t           *c,
+                        xcb_lookup_color_cookie_t   cookie  /**< */,
+                        xcb_generic_error_t       **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_create_cursor_checked (xcb_connection_t *c,
+                           xcb_cursor_t      cid,
+                           xcb_pixmap_t      source,
+                           xcb_pixmap_t      mask,
+                           uint16_t          fore_red,
+                           uint16_t          fore_green,
+                           uint16_t          fore_blue,
+                           uint16_t          back_red,
+                           uint16_t          back_green,
+                           uint16_t          back_blue,
+                           uint16_t          x,
+                           uint16_t          y);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_create_cursor (xcb_connection_t *c,
+                   xcb_cursor_t      cid,
+                   xcb_pixmap_t      source,
+                   xcb_pixmap_t      mask,
+                   uint16_t          fore_red,
+                   uint16_t          fore_green,
+                   uint16_t          fore_blue,
+                   uint16_t          back_red,
+                   uint16_t          back_green,
+                   uint16_t          back_blue,
+                   uint16_t          x,
+                   uint16_t          y);
+
+/**
+ * @brief create cursor
+ *
+ * @param c The connection
+ * @param cid The ID with which you will refer to the cursor, created by `xcb_generate_id`.
+ * @param source_font In which font to look for the cursor glyph.
+ * @param mask_font In which font to look for the mask glyph.
+ * @param source_char The glyph of \a source_font to use.
+ * @param mask_char The glyph of \a mask_font to use as a mask: Pixels which are set to 1 define
+ * which source pixels are displayed. All pixels which are set to 0 are not
+ * displayed.
+ * @param fore_red The red value of the foreground color.
+ * @param fore_green The green value of the foreground color.
+ * @param fore_blue The blue value of the foreground color.
+ * @param back_red The red value of the background color.
+ * @param back_green The green value of the background color.
+ * @param back_blue The blue value of the background color.
+ * @return A cookie
+ *
+ * Creates a cursor from a font glyph. X provides a set of standard cursor shapes
+ * in a special font named cursor. Applications are encouraged to use this
+ * interface for their cursors because the font can be customized for the
+ * individual display type.
+ * 
+ * All pixels which are set to 1 in the source will use the foreground color (as
+ * specified by \a fore_red, \a fore_green and \a fore_blue). All pixels set to 0
+ * will use the background color (as specified by \a back_red, \a back_green and
+ * \a back_blue).
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_create_glyph_cursor_checked (xcb_connection_t *c,
+                                 xcb_cursor_t      cid,
+                                 xcb_font_t        source_font,
+                                 xcb_font_t        mask_font,
+                                 uint16_t          source_char,
+                                 uint16_t          mask_char,
+                                 uint16_t          fore_red,
+                                 uint16_t          fore_green,
+                                 uint16_t          fore_blue,
+                                 uint16_t          back_red,
+                                 uint16_t          back_green,
+                                 uint16_t          back_blue);
+
+/**
+ * @brief create cursor
+ *
+ * @param c The connection
+ * @param cid The ID with which you will refer to the cursor, created by `xcb_generate_id`.
+ * @param source_font In which font to look for the cursor glyph.
+ * @param mask_font In which font to look for the mask glyph.
+ * @param source_char The glyph of \a source_font to use.
+ * @param mask_char The glyph of \a mask_font to use as a mask: Pixels which are set to 1 define
+ * which source pixels are displayed. All pixels which are set to 0 are not
+ * displayed.
+ * @param fore_red The red value of the foreground color.
+ * @param fore_green The green value of the foreground color.
+ * @param fore_blue The blue value of the foreground color.
+ * @param back_red The red value of the background color.
+ * @param back_green The green value of the background color.
+ * @param back_blue The blue value of the background color.
+ * @return A cookie
+ *
+ * Creates a cursor from a font glyph. X provides a set of standard cursor shapes
+ * in a special font named cursor. Applications are encouraged to use this
+ * interface for their cursors because the font can be customized for the
+ * individual display type.
+ * 
+ * All pixels which are set to 1 in the source will use the foreground color (as
+ * specified by \a fore_red, \a fore_green and \a fore_blue). All pixels set to 0
+ * will use the background color (as specified by \a back_red, \a back_green and
+ * \a back_blue).
+ *
+ */
+xcb_void_cookie_t
+xcb_create_glyph_cursor (xcb_connection_t *c,
+                         xcb_cursor_t      cid,
+                         xcb_font_t        source_font,
+                         xcb_font_t        mask_font,
+                         uint16_t          source_char,
+                         uint16_t          mask_char,
+                         uint16_t          fore_red,
+                         uint16_t          fore_green,
+                         uint16_t          fore_blue,
+                         uint16_t          back_red,
+                         uint16_t          back_green,
+                         uint16_t          back_blue);
+
+/**
+ * @brief Deletes a cursor
+ *
+ * @param c The connection
+ * @param cursor The cursor to destroy.
+ * @return A cookie
+ *
+ * Deletes the association between the cursor resource ID and the specified
+ * cursor. The cursor is freed when no other resource references it.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_free_cursor_checked (xcb_connection_t *c,
+                         xcb_cursor_t      cursor);
+
+/**
+ * @brief Deletes a cursor
+ *
+ * @param c The connection
+ * @param cursor The cursor to destroy.
+ * @return A cookie
+ *
+ * Deletes the association between the cursor resource ID and the specified
+ * cursor. The cursor is freed when no other resource references it.
+ *
+ */
+xcb_void_cookie_t
+xcb_free_cursor (xcb_connection_t *c,
+                 xcb_cursor_t      cursor);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_recolor_cursor_checked (xcb_connection_t *c,
+                            xcb_cursor_t      cursor,
+                            uint16_t          fore_red,
+                            uint16_t          fore_green,
+                            uint16_t          fore_blue,
+                            uint16_t          back_red,
+                            uint16_t          back_green,
+                            uint16_t          back_blue);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_recolor_cursor (xcb_connection_t *c,
+                    xcb_cursor_t      cursor,
+                    uint16_t          fore_red,
+                    uint16_t          fore_green,
+                    uint16_t          fore_blue,
+                    uint16_t          back_red,
+                    uint16_t          back_green,
+                    uint16_t          back_blue);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_query_best_size_cookie_t
+xcb_query_best_size (xcb_connection_t *c,
+                     uint8_t           _class,
+                     xcb_drawable_t    drawable,
+                     uint16_t          width,
+                     uint16_t          height);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_query_best_size_cookie_t
+xcb_query_best_size_unchecked (xcb_connection_t *c,
+                               uint8_t           _class,
+                               xcb_drawable_t    drawable,
+                               uint16_t          width,
+                               uint16_t          height);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_query_best_size_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_query_best_size_reply_t *
+xcb_query_best_size_reply (xcb_connection_t              *c,
+                           xcb_query_best_size_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e);
+
+int
+xcb_query_extension_sizeof (const void  *_buffer);
+
+/**
+ * @brief check if extension is present
+ *
+ * @param c The connection
+ * @param name_len The length of \a name in bytes.
+ * @param name The name of the extension to query, for example "RANDR". This is case
+ * sensitive!
+ * @return A cookie
+ *
+ * Determines if the specified extension is present on this X11 server.
+ * 
+ * Every extension has a unique `major_opcode` to identify requests, the minor
+ * opcodes and request formats are extension-specific. If the extension provides
+ * events and errors, the `first_event` and `first_error` fields in the reply are
+ * set accordingly.
+ * 
+ * There should rarely be a need to use this request directly, XCB provides the
+ * `xcb_get_extension_data` function instead.
+ *
+ */
+xcb_query_extension_cookie_t
+xcb_query_extension (xcb_connection_t *c,
+                     uint16_t          name_len,
+                     const char       *name);
+
+/**
+ * @brief check if extension is present
+ *
+ * @param c The connection
+ * @param name_len The length of \a name in bytes.
+ * @param name The name of the extension to query, for example "RANDR". This is case
+ * sensitive!
+ * @return A cookie
+ *
+ * Determines if the specified extension is present on this X11 server.
+ * 
+ * Every extension has a unique `major_opcode` to identify requests, the minor
+ * opcodes and request formats are extension-specific. If the extension provides
+ * events and errors, the `first_event` and `first_error` fields in the reply are
+ * set accordingly.
+ * 
+ * There should rarely be a need to use this request directly, XCB provides the
+ * `xcb_get_extension_data` function instead.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_query_extension_cookie_t
+xcb_query_extension_unchecked (xcb_connection_t *c,
+                               uint16_t          name_len,
+                               const char       *name);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_query_extension_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_query_extension_reply_t *
+xcb_query_extension_reply (xcb_connection_t              *c,
+                           xcb_query_extension_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e);
+
+int
+xcb_list_extensions_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_list_extensions_cookie_t
+xcb_list_extensions (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_list_extensions_cookie_t
+xcb_list_extensions_unchecked (xcb_connection_t *c);
+
+int
+xcb_list_extensions_names_length (const xcb_list_extensions_reply_t *R);
+
+xcb_str_iterator_t
+xcb_list_extensions_names_iterator (const xcb_list_extensions_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_list_extensions_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_list_extensions_reply_t *
+xcb_list_extensions_reply (xcb_connection_t              *c,
+                           xcb_list_extensions_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e);
+
+int
+xcb_change_keyboard_mapping_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_change_keyboard_mapping_checked (xcb_connection_t   *c,
+                                     uint8_t             keycode_count,
+                                     xcb_keycode_t       first_keycode,
+                                     uint8_t             keysyms_per_keycode,
+                                     const xcb_keysym_t *keysyms);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_change_keyboard_mapping (xcb_connection_t   *c,
+                             uint8_t             keycode_count,
+                             xcb_keycode_t       first_keycode,
+                             uint8_t             keysyms_per_keycode,
+                             const xcb_keysym_t *keysyms);
+
+xcb_keysym_t *
+xcb_change_keyboard_mapping_keysyms (const xcb_change_keyboard_mapping_request_t *R);
+
+int
+xcb_change_keyboard_mapping_keysyms_length (const xcb_change_keyboard_mapping_request_t *R);
+
+xcb_generic_iterator_t
+xcb_change_keyboard_mapping_keysyms_end (const xcb_change_keyboard_mapping_request_t *R);
+
+int
+xcb_get_keyboard_mapping_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_get_keyboard_mapping_cookie_t
+xcb_get_keyboard_mapping (xcb_connection_t *c,
+                          xcb_keycode_t     first_keycode,
+                          uint8_t           count);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_get_keyboard_mapping_cookie_t
+xcb_get_keyboard_mapping_unchecked (xcb_connection_t *c,
+                                    xcb_keycode_t     first_keycode,
+                                    uint8_t           count);
+
+xcb_keysym_t *
+xcb_get_keyboard_mapping_keysyms (const xcb_get_keyboard_mapping_reply_t *R);
+
+int
+xcb_get_keyboard_mapping_keysyms_length (const xcb_get_keyboard_mapping_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_get_keyboard_mapping_keysyms_end (const xcb_get_keyboard_mapping_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_get_keyboard_mapping_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_get_keyboard_mapping_reply_t *
+xcb_get_keyboard_mapping_reply (xcb_connection_t                   *c,
+                                xcb_get_keyboard_mapping_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e);
+
+int
+xcb_change_keyboard_control_value_list_serialize (void                                           **_buffer,
+                                                  uint32_t                                         value_mask,
+                                                  const xcb_change_keyboard_control_value_list_t  *_aux);
+
+int
+xcb_change_keyboard_control_value_list_unpack (const void                                *_buffer,
+                                               uint32_t                                   value_mask,
+                                               xcb_change_keyboard_control_value_list_t  *_aux);
+
+int
+xcb_change_keyboard_control_value_list_sizeof (const void  *_buffer,
+                                               uint32_t     value_mask);
+
+int
+xcb_change_keyboard_control_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_change_keyboard_control_checked (xcb_connection_t *c,
+                                     uint32_t          value_mask,
+                                     const void       *value_list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_change_keyboard_control (xcb_connection_t *c,
+                             uint32_t          value_mask,
+                             const void       *value_list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_change_keyboard_control_aux_checked (xcb_connection_t                               *c,
+                                         uint32_t                                        value_mask,
+                                         const xcb_change_keyboard_control_value_list_t *value_list);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_change_keyboard_control_aux (xcb_connection_t                               *c,
+                                 uint32_t                                        value_mask,
+                                 const xcb_change_keyboard_control_value_list_t *value_list);
+
+void *
+xcb_change_keyboard_control_value_list (const xcb_change_keyboard_control_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_get_keyboard_control_cookie_t
+xcb_get_keyboard_control (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_get_keyboard_control_cookie_t
+xcb_get_keyboard_control_unchecked (xcb_connection_t *c);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_get_keyboard_control_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_get_keyboard_control_reply_t *
+xcb_get_keyboard_control_reply (xcb_connection_t                   *c,
+                                xcb_get_keyboard_control_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_bell_checked (xcb_connection_t *c,
+                  int8_t            percent);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_bell (xcb_connection_t *c,
+          int8_t            percent);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_change_pointer_control_checked (xcb_connection_t *c,
+                                    int16_t           acceleration_numerator,
+                                    int16_t           acceleration_denominator,
+                                    int16_t           threshold,
+                                    uint8_t           do_acceleration,
+                                    uint8_t           do_threshold);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_change_pointer_control (xcb_connection_t *c,
+                            int16_t           acceleration_numerator,
+                            int16_t           acceleration_denominator,
+                            int16_t           threshold,
+                            uint8_t           do_acceleration,
+                            uint8_t           do_threshold);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_get_pointer_control_cookie_t
+xcb_get_pointer_control (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_get_pointer_control_cookie_t
+xcb_get_pointer_control_unchecked (xcb_connection_t *c);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_get_pointer_control_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_get_pointer_control_reply_t *
+xcb_get_pointer_control_reply (xcb_connection_t                  *c,
+                               xcb_get_pointer_control_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_set_screen_saver_checked (xcb_connection_t *c,
+                              int16_t           timeout,
+                              int16_t           interval,
+                              uint8_t           prefer_blanking,
+                              uint8_t           allow_exposures);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_set_screen_saver (xcb_connection_t *c,
+                      int16_t           timeout,
+                      int16_t           interval,
+                      uint8_t           prefer_blanking,
+                      uint8_t           allow_exposures);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_get_screen_saver_cookie_t
+xcb_get_screen_saver (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_get_screen_saver_cookie_t
+xcb_get_screen_saver_unchecked (xcb_connection_t *c);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_get_screen_saver_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_get_screen_saver_reply_t *
+xcb_get_screen_saver_reply (xcb_connection_t               *c,
+                            xcb_get_screen_saver_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e);
+
+int
+xcb_change_hosts_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_change_hosts_checked (xcb_connection_t *c,
+                          uint8_t           mode,
+                          uint8_t           family,
+                          uint16_t          address_len,
+                          const uint8_t    *address);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_change_hosts (xcb_connection_t *c,
+                  uint8_t           mode,
+                  uint8_t           family,
+                  uint16_t          address_len,
+                  const uint8_t    *address);
+
+uint8_t *
+xcb_change_hosts_address (const xcb_change_hosts_request_t *R);
+
+int
+xcb_change_hosts_address_length (const xcb_change_hosts_request_t *R);
+
+xcb_generic_iterator_t
+xcb_change_hosts_address_end (const xcb_change_hosts_request_t *R);
+
+int
+xcb_host_sizeof (const void  *_buffer);
+
+uint8_t *
+xcb_host_address (const xcb_host_t *R);
+
+int
+xcb_host_address_length (const xcb_host_t *R);
+
+xcb_generic_iterator_t
+xcb_host_address_end (const xcb_host_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_host_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_host_t)
+ */
+void
+xcb_host_next (xcb_host_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_host_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_host_end (xcb_host_iterator_t i);
+
+int
+xcb_list_hosts_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_list_hosts_cookie_t
+xcb_list_hosts (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_list_hosts_cookie_t
+xcb_list_hosts_unchecked (xcb_connection_t *c);
+
+int
+xcb_list_hosts_hosts_length (const xcb_list_hosts_reply_t *R);
+
+xcb_host_iterator_t
+xcb_list_hosts_hosts_iterator (const xcb_list_hosts_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_list_hosts_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_list_hosts_reply_t *
+xcb_list_hosts_reply (xcb_connection_t         *c,
+                      xcb_list_hosts_cookie_t   cookie  /**< */,
+                      xcb_generic_error_t     **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_set_access_control_checked (xcb_connection_t *c,
+                                uint8_t           mode);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_set_access_control (xcb_connection_t *c,
+                        uint8_t           mode);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_set_close_down_mode_checked (xcb_connection_t *c,
+                                 uint8_t           mode);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_set_close_down_mode (xcb_connection_t *c,
+                         uint8_t           mode);
+
+/**
+ * @brief kills a client
+ *
+ * @param c The connection
+ * @param resource Any resource belonging to the client (for example a Window), used to identify
+ * the client connection.
+ * \n
+ * The special value of `XCB_KILL_ALL_TEMPORARY`, the resources of all clients
+ * that have terminated in `RetainTemporary` (TODO) are destroyed.
+ * @return A cookie
+ *
+ * Forces a close down of the client that created the specified \a resource.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_kill_client_checked (xcb_connection_t *c,
+                         uint32_t          resource);
+
+/**
+ * @brief kills a client
+ *
+ * @param c The connection
+ * @param resource Any resource belonging to the client (for example a Window), used to identify
+ * the client connection.
+ * \n
+ * The special value of `XCB_KILL_ALL_TEMPORARY`, the resources of all clients
+ * that have terminated in `RetainTemporary` (TODO) are destroyed.
+ * @return A cookie
+ *
+ * Forces a close down of the client that created the specified \a resource.
+ *
+ */
+xcb_void_cookie_t
+xcb_kill_client (xcb_connection_t *c,
+                 uint32_t          resource);
+
+int
+xcb_rotate_properties_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_rotate_properties_checked (xcb_connection_t *c,
+                               xcb_window_t      window,
+                               uint16_t          atoms_len,
+                               int16_t           delta,
+                               const xcb_atom_t *atoms);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_rotate_properties (xcb_connection_t *c,
+                       xcb_window_t      window,
+                       uint16_t          atoms_len,
+                       int16_t           delta,
+                       const xcb_atom_t *atoms);
+
+xcb_atom_t *
+xcb_rotate_properties_atoms (const xcb_rotate_properties_request_t *R);
+
+int
+xcb_rotate_properties_atoms_length (const xcb_rotate_properties_request_t *R);
+
+xcb_generic_iterator_t
+xcb_rotate_properties_atoms_end (const xcb_rotate_properties_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_force_screen_saver_checked (xcb_connection_t *c,
+                                uint8_t           mode);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_force_screen_saver (xcb_connection_t *c,
+                        uint8_t           mode);
+
+int
+xcb_set_pointer_mapping_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_set_pointer_mapping_cookie_t
+xcb_set_pointer_mapping (xcb_connection_t *c,
+                         uint8_t           map_len,
+                         const uint8_t    *map);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_set_pointer_mapping_cookie_t
+xcb_set_pointer_mapping_unchecked (xcb_connection_t *c,
+                                   uint8_t           map_len,
+                                   const uint8_t    *map);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_set_pointer_mapping_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_set_pointer_mapping_reply_t *
+xcb_set_pointer_mapping_reply (xcb_connection_t                  *c,
+                               xcb_set_pointer_mapping_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+int
+xcb_get_pointer_mapping_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_get_pointer_mapping_cookie_t
+xcb_get_pointer_mapping (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_get_pointer_mapping_cookie_t
+xcb_get_pointer_mapping_unchecked (xcb_connection_t *c);
+
+uint8_t *
+xcb_get_pointer_mapping_map (const xcb_get_pointer_mapping_reply_t *R);
+
+int
+xcb_get_pointer_mapping_map_length (const xcb_get_pointer_mapping_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_get_pointer_mapping_map_end (const xcb_get_pointer_mapping_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_get_pointer_mapping_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_get_pointer_mapping_reply_t *
+xcb_get_pointer_mapping_reply (xcb_connection_t                  *c,
+                               xcb_get_pointer_mapping_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+int
+xcb_set_modifier_mapping_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_set_modifier_mapping_cookie_t
+xcb_set_modifier_mapping (xcb_connection_t    *c,
+                          uint8_t              keycodes_per_modifier,
+                          const xcb_keycode_t *keycodes);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_set_modifier_mapping_cookie_t
+xcb_set_modifier_mapping_unchecked (xcb_connection_t    *c,
+                                    uint8_t              keycodes_per_modifier,
+                                    const xcb_keycode_t *keycodes);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_set_modifier_mapping_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_set_modifier_mapping_reply_t *
+xcb_set_modifier_mapping_reply (xcb_connection_t                   *c,
+                                xcb_set_modifier_mapping_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e);
+
+int
+xcb_get_modifier_mapping_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_get_modifier_mapping_cookie_t
+xcb_get_modifier_mapping (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_get_modifier_mapping_cookie_t
+xcb_get_modifier_mapping_unchecked (xcb_connection_t *c);
+
+xcb_keycode_t *
+xcb_get_modifier_mapping_keycodes (const xcb_get_modifier_mapping_reply_t *R);
+
+int
+xcb_get_modifier_mapping_keycodes_length (const xcb_get_modifier_mapping_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_get_modifier_mapping_keycodes_end (const xcb_get_modifier_mapping_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_get_modifier_mapping_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_get_modifier_mapping_reply_t *
+xcb_get_modifier_mapping_reply (xcb_connection_t                   *c,
+                                xcb_get_modifier_mapping_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_no_operation_checked (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_no_operation (xcb_connection_t *c);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/xselinux.h b/depends/libxcb/include/xcb/xselinux.h
new file mode 100644
index 0000000..abcb28d
--- /dev/null
+++ b/depends/libxcb/include/xcb/xselinux.h
@@ -0,0 +1,1889 @@
+/*
+ * This file generated automatically from xselinux.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_SELinux_API XCB SELinux API
+ * @brief SELinux XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __XSELINUX_H
+#define __XSELINUX_H
+
+#include "xcb.h"
+#include "xproto.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_SELINUX_MAJOR_VERSION 1
+#define XCB_SELINUX_MINOR_VERSION 0
+
+extern xcb_extension_t xcb_selinux_id;
+
+/**
+ * @brief xcb_selinux_query_version_cookie_t
+ **/
+typedef struct xcb_selinux_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_selinux_query_version_cookie_t;
+
+/** Opcode for xcb_selinux_query_version. */
+#define XCB_SELINUX_QUERY_VERSION 0
+
+/**
+ * @brief xcb_selinux_query_version_request_t
+ **/
+typedef struct xcb_selinux_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  client_major;
+    uint8_t  client_minor;
+} xcb_selinux_query_version_request_t;
+
+/**
+ * @brief xcb_selinux_query_version_reply_t
+ **/
+typedef struct xcb_selinux_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t server_major;
+    uint16_t server_minor;
+} xcb_selinux_query_version_reply_t;
+
+/** Opcode for xcb_selinux_set_device_create_context. */
+#define XCB_SELINUX_SET_DEVICE_CREATE_CONTEXT 1
+
+/**
+ * @brief xcb_selinux_set_device_create_context_request_t
+ **/
+typedef struct xcb_selinux_set_device_create_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t context_len;
+} xcb_selinux_set_device_create_context_request_t;
+
+/**
+ * @brief xcb_selinux_get_device_create_context_cookie_t
+ **/
+typedef struct xcb_selinux_get_device_create_context_cookie_t {
+    unsigned int sequence;
+} xcb_selinux_get_device_create_context_cookie_t;
+
+/** Opcode for xcb_selinux_get_device_create_context. */
+#define XCB_SELINUX_GET_DEVICE_CREATE_CONTEXT 2
+
+/**
+ * @brief xcb_selinux_get_device_create_context_request_t
+ **/
+typedef struct xcb_selinux_get_device_create_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_selinux_get_device_create_context_request_t;
+
+/**
+ * @brief xcb_selinux_get_device_create_context_reply_t
+ **/
+typedef struct xcb_selinux_get_device_create_context_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t context_len;
+    uint8_t  pad1[20];
+} xcb_selinux_get_device_create_context_reply_t;
+
+/** Opcode for xcb_selinux_set_device_context. */
+#define XCB_SELINUX_SET_DEVICE_CONTEXT 3
+
+/**
+ * @brief xcb_selinux_set_device_context_request_t
+ **/
+typedef struct xcb_selinux_set_device_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t device;
+    uint32_t context_len;
+} xcb_selinux_set_device_context_request_t;
+
+/**
+ * @brief xcb_selinux_get_device_context_cookie_t
+ **/
+typedef struct xcb_selinux_get_device_context_cookie_t {
+    unsigned int sequence;
+} xcb_selinux_get_device_context_cookie_t;
+
+/** Opcode for xcb_selinux_get_device_context. */
+#define XCB_SELINUX_GET_DEVICE_CONTEXT 4
+
+/**
+ * @brief xcb_selinux_get_device_context_request_t
+ **/
+typedef struct xcb_selinux_get_device_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t device;
+} xcb_selinux_get_device_context_request_t;
+
+/**
+ * @brief xcb_selinux_get_device_context_reply_t
+ **/
+typedef struct xcb_selinux_get_device_context_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t context_len;
+    uint8_t  pad1[20];
+} xcb_selinux_get_device_context_reply_t;
+
+/** Opcode for xcb_selinux_set_window_create_context. */
+#define XCB_SELINUX_SET_WINDOW_CREATE_CONTEXT 5
+
+/**
+ * @brief xcb_selinux_set_window_create_context_request_t
+ **/
+typedef struct xcb_selinux_set_window_create_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t context_len;
+} xcb_selinux_set_window_create_context_request_t;
+
+/**
+ * @brief xcb_selinux_get_window_create_context_cookie_t
+ **/
+typedef struct xcb_selinux_get_window_create_context_cookie_t {
+    unsigned int sequence;
+} xcb_selinux_get_window_create_context_cookie_t;
+
+/** Opcode for xcb_selinux_get_window_create_context. */
+#define XCB_SELINUX_GET_WINDOW_CREATE_CONTEXT 6
+
+/**
+ * @brief xcb_selinux_get_window_create_context_request_t
+ **/
+typedef struct xcb_selinux_get_window_create_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_selinux_get_window_create_context_request_t;
+
+/**
+ * @brief xcb_selinux_get_window_create_context_reply_t
+ **/
+typedef struct xcb_selinux_get_window_create_context_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t context_len;
+    uint8_t  pad1[20];
+} xcb_selinux_get_window_create_context_reply_t;
+
+/**
+ * @brief xcb_selinux_get_window_context_cookie_t
+ **/
+typedef struct xcb_selinux_get_window_context_cookie_t {
+    unsigned int sequence;
+} xcb_selinux_get_window_context_cookie_t;
+
+/** Opcode for xcb_selinux_get_window_context. */
+#define XCB_SELINUX_GET_WINDOW_CONTEXT 7
+
+/**
+ * @brief xcb_selinux_get_window_context_request_t
+ **/
+typedef struct xcb_selinux_get_window_context_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_selinux_get_window_context_request_t;
+
+/**
+ * @brief xcb_selinux_get_window_context_reply_t
+ **/
+typedef struct xcb_selinux_get_window_context_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t context_len;
+    uint8_t  pad1[20];
+} xcb_selinux_get_window_context_reply_t;
+
+/**
+ * @brief xcb_selinux_list_item_t
+ **/
+typedef struct xcb_selinux_list_item_t {
+    xcb_atom_t name;
+    uint32_t   object_context_len;
+    uint32_t   data_context_len;
+} xcb_selinux_list_item_t;
+
+/**
+ * @brief xcb_selinux_list_item_iterator_t
+ **/
+typedef struct xcb_selinux_list_item_iterator_t {
+    xcb_selinux_list_item_t *data;
+    int                      rem;
+    int                      index;
+} xcb_selinux_list_item_iterator_t;
+
+/** Opcode for xcb_selinux_set_property_create_context. */
+#define XCB_SELINUX_SET_PROPERTY_CREATE_CONTEXT 8
+
+/**
+ * @brief xcb_selinux_set_property_create_context_request_t
+ **/
+typedef struct xcb_selinux_set_property_create_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t context_len;
+} xcb_selinux_set_property_create_context_request_t;
+
+/**
+ * @brief xcb_selinux_get_property_create_context_cookie_t
+ **/
+typedef struct xcb_selinux_get_property_create_context_cookie_t {
+    unsigned int sequence;
+} xcb_selinux_get_property_create_context_cookie_t;
+
+/** Opcode for xcb_selinux_get_property_create_context. */
+#define XCB_SELINUX_GET_PROPERTY_CREATE_CONTEXT 9
+
+/**
+ * @brief xcb_selinux_get_property_create_context_request_t
+ **/
+typedef struct xcb_selinux_get_property_create_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_selinux_get_property_create_context_request_t;
+
+/**
+ * @brief xcb_selinux_get_property_create_context_reply_t
+ **/
+typedef struct xcb_selinux_get_property_create_context_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t context_len;
+    uint8_t  pad1[20];
+} xcb_selinux_get_property_create_context_reply_t;
+
+/** Opcode for xcb_selinux_set_property_use_context. */
+#define XCB_SELINUX_SET_PROPERTY_USE_CONTEXT 10
+
+/**
+ * @brief xcb_selinux_set_property_use_context_request_t
+ **/
+typedef struct xcb_selinux_set_property_use_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t context_len;
+} xcb_selinux_set_property_use_context_request_t;
+
+/**
+ * @brief xcb_selinux_get_property_use_context_cookie_t
+ **/
+typedef struct xcb_selinux_get_property_use_context_cookie_t {
+    unsigned int sequence;
+} xcb_selinux_get_property_use_context_cookie_t;
+
+/** Opcode for xcb_selinux_get_property_use_context. */
+#define XCB_SELINUX_GET_PROPERTY_USE_CONTEXT 11
+
+/**
+ * @brief xcb_selinux_get_property_use_context_request_t
+ **/
+typedef struct xcb_selinux_get_property_use_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_selinux_get_property_use_context_request_t;
+
+/**
+ * @brief xcb_selinux_get_property_use_context_reply_t
+ **/
+typedef struct xcb_selinux_get_property_use_context_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t context_len;
+    uint8_t  pad1[20];
+} xcb_selinux_get_property_use_context_reply_t;
+
+/**
+ * @brief xcb_selinux_get_property_context_cookie_t
+ **/
+typedef struct xcb_selinux_get_property_context_cookie_t {
+    unsigned int sequence;
+} xcb_selinux_get_property_context_cookie_t;
+
+/** Opcode for xcb_selinux_get_property_context. */
+#define XCB_SELINUX_GET_PROPERTY_CONTEXT 12
+
+/**
+ * @brief xcb_selinux_get_property_context_request_t
+ **/
+typedef struct xcb_selinux_get_property_context_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    xcb_atom_t   property;
+} xcb_selinux_get_property_context_request_t;
+
+/**
+ * @brief xcb_selinux_get_property_context_reply_t
+ **/
+typedef struct xcb_selinux_get_property_context_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t context_len;
+    uint8_t  pad1[20];
+} xcb_selinux_get_property_context_reply_t;
+
+/**
+ * @brief xcb_selinux_get_property_data_context_cookie_t
+ **/
+typedef struct xcb_selinux_get_property_data_context_cookie_t {
+    unsigned int sequence;
+} xcb_selinux_get_property_data_context_cookie_t;
+
+/** Opcode for xcb_selinux_get_property_data_context. */
+#define XCB_SELINUX_GET_PROPERTY_DATA_CONTEXT 13
+
+/**
+ * @brief xcb_selinux_get_property_data_context_request_t
+ **/
+typedef struct xcb_selinux_get_property_data_context_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    xcb_atom_t   property;
+} xcb_selinux_get_property_data_context_request_t;
+
+/**
+ * @brief xcb_selinux_get_property_data_context_reply_t
+ **/
+typedef struct xcb_selinux_get_property_data_context_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t context_len;
+    uint8_t  pad1[20];
+} xcb_selinux_get_property_data_context_reply_t;
+
+/**
+ * @brief xcb_selinux_list_properties_cookie_t
+ **/
+typedef struct xcb_selinux_list_properties_cookie_t {
+    unsigned int sequence;
+} xcb_selinux_list_properties_cookie_t;
+
+/** Opcode for xcb_selinux_list_properties. */
+#define XCB_SELINUX_LIST_PROPERTIES 14
+
+/**
+ * @brief xcb_selinux_list_properties_request_t
+ **/
+typedef struct xcb_selinux_list_properties_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_selinux_list_properties_request_t;
+
+/**
+ * @brief xcb_selinux_list_properties_reply_t
+ **/
+typedef struct xcb_selinux_list_properties_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t properties_len;
+    uint8_t  pad1[20];
+} xcb_selinux_list_properties_reply_t;
+
+/** Opcode for xcb_selinux_set_selection_create_context. */
+#define XCB_SELINUX_SET_SELECTION_CREATE_CONTEXT 15
+
+/**
+ * @brief xcb_selinux_set_selection_create_context_request_t
+ **/
+typedef struct xcb_selinux_set_selection_create_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t context_len;
+} xcb_selinux_set_selection_create_context_request_t;
+
+/**
+ * @brief xcb_selinux_get_selection_create_context_cookie_t
+ **/
+typedef struct xcb_selinux_get_selection_create_context_cookie_t {
+    unsigned int sequence;
+} xcb_selinux_get_selection_create_context_cookie_t;
+
+/** Opcode for xcb_selinux_get_selection_create_context. */
+#define XCB_SELINUX_GET_SELECTION_CREATE_CONTEXT 16
+
+/**
+ * @brief xcb_selinux_get_selection_create_context_request_t
+ **/
+typedef struct xcb_selinux_get_selection_create_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_selinux_get_selection_create_context_request_t;
+
+/**
+ * @brief xcb_selinux_get_selection_create_context_reply_t
+ **/
+typedef struct xcb_selinux_get_selection_create_context_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t context_len;
+    uint8_t  pad1[20];
+} xcb_selinux_get_selection_create_context_reply_t;
+
+/** Opcode for xcb_selinux_set_selection_use_context. */
+#define XCB_SELINUX_SET_SELECTION_USE_CONTEXT 17
+
+/**
+ * @brief xcb_selinux_set_selection_use_context_request_t
+ **/
+typedef struct xcb_selinux_set_selection_use_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t context_len;
+} xcb_selinux_set_selection_use_context_request_t;
+
+/**
+ * @brief xcb_selinux_get_selection_use_context_cookie_t
+ **/
+typedef struct xcb_selinux_get_selection_use_context_cookie_t {
+    unsigned int sequence;
+} xcb_selinux_get_selection_use_context_cookie_t;
+
+/** Opcode for xcb_selinux_get_selection_use_context. */
+#define XCB_SELINUX_GET_SELECTION_USE_CONTEXT 18
+
+/**
+ * @brief xcb_selinux_get_selection_use_context_request_t
+ **/
+typedef struct xcb_selinux_get_selection_use_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_selinux_get_selection_use_context_request_t;
+
+/**
+ * @brief xcb_selinux_get_selection_use_context_reply_t
+ **/
+typedef struct xcb_selinux_get_selection_use_context_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t context_len;
+    uint8_t  pad1[20];
+} xcb_selinux_get_selection_use_context_reply_t;
+
+/**
+ * @brief xcb_selinux_get_selection_context_cookie_t
+ **/
+typedef struct xcb_selinux_get_selection_context_cookie_t {
+    unsigned int sequence;
+} xcb_selinux_get_selection_context_cookie_t;
+
+/** Opcode for xcb_selinux_get_selection_context. */
+#define XCB_SELINUX_GET_SELECTION_CONTEXT 19
+
+/**
+ * @brief xcb_selinux_get_selection_context_request_t
+ **/
+typedef struct xcb_selinux_get_selection_context_request_t {
+    uint8_t    major_opcode;
+    uint8_t    minor_opcode;
+    uint16_t   length;
+    xcb_atom_t selection;
+} xcb_selinux_get_selection_context_request_t;
+
+/**
+ * @brief xcb_selinux_get_selection_context_reply_t
+ **/
+typedef struct xcb_selinux_get_selection_context_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t context_len;
+    uint8_t  pad1[20];
+} xcb_selinux_get_selection_context_reply_t;
+
+/**
+ * @brief xcb_selinux_get_selection_data_context_cookie_t
+ **/
+typedef struct xcb_selinux_get_selection_data_context_cookie_t {
+    unsigned int sequence;
+} xcb_selinux_get_selection_data_context_cookie_t;
+
+/** Opcode for xcb_selinux_get_selection_data_context. */
+#define XCB_SELINUX_GET_SELECTION_DATA_CONTEXT 20
+
+/**
+ * @brief xcb_selinux_get_selection_data_context_request_t
+ **/
+typedef struct xcb_selinux_get_selection_data_context_request_t {
+    uint8_t    major_opcode;
+    uint8_t    minor_opcode;
+    uint16_t   length;
+    xcb_atom_t selection;
+} xcb_selinux_get_selection_data_context_request_t;
+
+/**
+ * @brief xcb_selinux_get_selection_data_context_reply_t
+ **/
+typedef struct xcb_selinux_get_selection_data_context_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t context_len;
+    uint8_t  pad1[20];
+} xcb_selinux_get_selection_data_context_reply_t;
+
+/**
+ * @brief xcb_selinux_list_selections_cookie_t
+ **/
+typedef struct xcb_selinux_list_selections_cookie_t {
+    unsigned int sequence;
+} xcb_selinux_list_selections_cookie_t;
+
+/** Opcode for xcb_selinux_list_selections. */
+#define XCB_SELINUX_LIST_SELECTIONS 21
+
+/**
+ * @brief xcb_selinux_list_selections_request_t
+ **/
+typedef struct xcb_selinux_list_selections_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_selinux_list_selections_request_t;
+
+/**
+ * @brief xcb_selinux_list_selections_reply_t
+ **/
+typedef struct xcb_selinux_list_selections_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t selections_len;
+    uint8_t  pad1[20];
+} xcb_selinux_list_selections_reply_t;
+
+/**
+ * @brief xcb_selinux_get_client_context_cookie_t
+ **/
+typedef struct xcb_selinux_get_client_context_cookie_t {
+    unsigned int sequence;
+} xcb_selinux_get_client_context_cookie_t;
+
+/** Opcode for xcb_selinux_get_client_context. */
+#define XCB_SELINUX_GET_CLIENT_CONTEXT 22
+
+/**
+ * @brief xcb_selinux_get_client_context_request_t
+ **/
+typedef struct xcb_selinux_get_client_context_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint32_t resource;
+} xcb_selinux_get_client_context_request_t;
+
+/**
+ * @brief xcb_selinux_get_client_context_reply_t
+ **/
+typedef struct xcb_selinux_get_client_context_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t context_len;
+    uint8_t  pad1[20];
+} xcb_selinux_get_client_context_reply_t;
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_selinux_query_version_cookie_t
+xcb_selinux_query_version (xcb_connection_t *c,
+                           uint8_t           client_major,
+                           uint8_t           client_minor);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_selinux_query_version_cookie_t
+xcb_selinux_query_version_unchecked (xcb_connection_t *c,
+                                     uint8_t           client_major,
+                                     uint8_t           client_minor);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_selinux_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_selinux_query_version_reply_t *
+xcb_selinux_query_version_reply (xcb_connection_t                    *c,
+                                 xcb_selinux_query_version_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e);
+
+int
+xcb_selinux_set_device_create_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_selinux_set_device_create_context_checked (xcb_connection_t *c,
+                                               uint32_t          context_len,
+                                               const char       *context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_selinux_set_device_create_context (xcb_connection_t *c,
+                                       uint32_t          context_len,
+                                       const char       *context);
+
+char *
+xcb_selinux_set_device_create_context_context (const xcb_selinux_set_device_create_context_request_t *R);
+
+int
+xcb_selinux_set_device_create_context_context_length (const xcb_selinux_set_device_create_context_request_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_set_device_create_context_context_end (const xcb_selinux_set_device_create_context_request_t *R);
+
+int
+xcb_selinux_get_device_create_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_selinux_get_device_create_context_cookie_t
+xcb_selinux_get_device_create_context (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_selinux_get_device_create_context_cookie_t
+xcb_selinux_get_device_create_context_unchecked (xcb_connection_t *c);
+
+char *
+xcb_selinux_get_device_create_context_context (const xcb_selinux_get_device_create_context_reply_t *R);
+
+int
+xcb_selinux_get_device_create_context_context_length (const xcb_selinux_get_device_create_context_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_get_device_create_context_context_end (const xcb_selinux_get_device_create_context_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_selinux_get_device_create_context_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_selinux_get_device_create_context_reply_t *
+xcb_selinux_get_device_create_context_reply (xcb_connection_t                                *c,
+                                             xcb_selinux_get_device_create_context_cookie_t   cookie  /**< */,
+                                             xcb_generic_error_t                            **e);
+
+int
+xcb_selinux_set_device_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_selinux_set_device_context_checked (xcb_connection_t *c,
+                                        uint32_t          device,
+                                        uint32_t          context_len,
+                                        const char       *context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_selinux_set_device_context (xcb_connection_t *c,
+                                uint32_t          device,
+                                uint32_t          context_len,
+                                const char       *context);
+
+char *
+xcb_selinux_set_device_context_context (const xcb_selinux_set_device_context_request_t *R);
+
+int
+xcb_selinux_set_device_context_context_length (const xcb_selinux_set_device_context_request_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_set_device_context_context_end (const xcb_selinux_set_device_context_request_t *R);
+
+int
+xcb_selinux_get_device_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_selinux_get_device_context_cookie_t
+xcb_selinux_get_device_context (xcb_connection_t *c,
+                                uint32_t          device);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_selinux_get_device_context_cookie_t
+xcb_selinux_get_device_context_unchecked (xcb_connection_t *c,
+                                          uint32_t          device);
+
+char *
+xcb_selinux_get_device_context_context (const xcb_selinux_get_device_context_reply_t *R);
+
+int
+xcb_selinux_get_device_context_context_length (const xcb_selinux_get_device_context_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_get_device_context_context_end (const xcb_selinux_get_device_context_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_selinux_get_device_context_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_selinux_get_device_context_reply_t *
+xcb_selinux_get_device_context_reply (xcb_connection_t                         *c,
+                                      xcb_selinux_get_device_context_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e);
+
+int
+xcb_selinux_set_window_create_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_selinux_set_window_create_context_checked (xcb_connection_t *c,
+                                               uint32_t          context_len,
+                                               const char       *context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_selinux_set_window_create_context (xcb_connection_t *c,
+                                       uint32_t          context_len,
+                                       const char       *context);
+
+char *
+xcb_selinux_set_window_create_context_context (const xcb_selinux_set_window_create_context_request_t *R);
+
+int
+xcb_selinux_set_window_create_context_context_length (const xcb_selinux_set_window_create_context_request_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_set_window_create_context_context_end (const xcb_selinux_set_window_create_context_request_t *R);
+
+int
+xcb_selinux_get_window_create_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_selinux_get_window_create_context_cookie_t
+xcb_selinux_get_window_create_context (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_selinux_get_window_create_context_cookie_t
+xcb_selinux_get_window_create_context_unchecked (xcb_connection_t *c);
+
+char *
+xcb_selinux_get_window_create_context_context (const xcb_selinux_get_window_create_context_reply_t *R);
+
+int
+xcb_selinux_get_window_create_context_context_length (const xcb_selinux_get_window_create_context_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_get_window_create_context_context_end (const xcb_selinux_get_window_create_context_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_selinux_get_window_create_context_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_selinux_get_window_create_context_reply_t *
+xcb_selinux_get_window_create_context_reply (xcb_connection_t                                *c,
+                                             xcb_selinux_get_window_create_context_cookie_t   cookie  /**< */,
+                                             xcb_generic_error_t                            **e);
+
+int
+xcb_selinux_get_window_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_selinux_get_window_context_cookie_t
+xcb_selinux_get_window_context (xcb_connection_t *c,
+                                xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_selinux_get_window_context_cookie_t
+xcb_selinux_get_window_context_unchecked (xcb_connection_t *c,
+                                          xcb_window_t      window);
+
+char *
+xcb_selinux_get_window_context_context (const xcb_selinux_get_window_context_reply_t *R);
+
+int
+xcb_selinux_get_window_context_context_length (const xcb_selinux_get_window_context_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_get_window_context_context_end (const xcb_selinux_get_window_context_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_selinux_get_window_context_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_selinux_get_window_context_reply_t *
+xcb_selinux_get_window_context_reply (xcb_connection_t                         *c,
+                                      xcb_selinux_get_window_context_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e);
+
+int
+xcb_selinux_list_item_sizeof (const void  *_buffer);
+
+char *
+xcb_selinux_list_item_object_context (const xcb_selinux_list_item_t *R);
+
+int
+xcb_selinux_list_item_object_context_length (const xcb_selinux_list_item_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_list_item_object_context_end (const xcb_selinux_list_item_t *R);
+
+char *
+xcb_selinux_list_item_data_context (const xcb_selinux_list_item_t *R);
+
+int
+xcb_selinux_list_item_data_context_length (const xcb_selinux_list_item_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_list_item_data_context_end (const xcb_selinux_list_item_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_selinux_list_item_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_selinux_list_item_t)
+ */
+void
+xcb_selinux_list_item_next (xcb_selinux_list_item_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_selinux_list_item_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_selinux_list_item_end (xcb_selinux_list_item_iterator_t i);
+
+int
+xcb_selinux_set_property_create_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_selinux_set_property_create_context_checked (xcb_connection_t *c,
+                                                 uint32_t          context_len,
+                                                 const char       *context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_selinux_set_property_create_context (xcb_connection_t *c,
+                                         uint32_t          context_len,
+                                         const char       *context);
+
+char *
+xcb_selinux_set_property_create_context_context (const xcb_selinux_set_property_create_context_request_t *R);
+
+int
+xcb_selinux_set_property_create_context_context_length (const xcb_selinux_set_property_create_context_request_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_set_property_create_context_context_end (const xcb_selinux_set_property_create_context_request_t *R);
+
+int
+xcb_selinux_get_property_create_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_selinux_get_property_create_context_cookie_t
+xcb_selinux_get_property_create_context (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_selinux_get_property_create_context_cookie_t
+xcb_selinux_get_property_create_context_unchecked (xcb_connection_t *c);
+
+char *
+xcb_selinux_get_property_create_context_context (const xcb_selinux_get_property_create_context_reply_t *R);
+
+int
+xcb_selinux_get_property_create_context_context_length (const xcb_selinux_get_property_create_context_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_get_property_create_context_context_end (const xcb_selinux_get_property_create_context_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_selinux_get_property_create_context_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_selinux_get_property_create_context_reply_t *
+xcb_selinux_get_property_create_context_reply (xcb_connection_t                                  *c,
+                                               xcb_selinux_get_property_create_context_cookie_t   cookie  /**< */,
+                                               xcb_generic_error_t                              **e);
+
+int
+xcb_selinux_set_property_use_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_selinux_set_property_use_context_checked (xcb_connection_t *c,
+                                              uint32_t          context_len,
+                                              const char       *context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_selinux_set_property_use_context (xcb_connection_t *c,
+                                      uint32_t          context_len,
+                                      const char       *context);
+
+char *
+xcb_selinux_set_property_use_context_context (const xcb_selinux_set_property_use_context_request_t *R);
+
+int
+xcb_selinux_set_property_use_context_context_length (const xcb_selinux_set_property_use_context_request_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_set_property_use_context_context_end (const xcb_selinux_set_property_use_context_request_t *R);
+
+int
+xcb_selinux_get_property_use_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_selinux_get_property_use_context_cookie_t
+xcb_selinux_get_property_use_context (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_selinux_get_property_use_context_cookie_t
+xcb_selinux_get_property_use_context_unchecked (xcb_connection_t *c);
+
+char *
+xcb_selinux_get_property_use_context_context (const xcb_selinux_get_property_use_context_reply_t *R);
+
+int
+xcb_selinux_get_property_use_context_context_length (const xcb_selinux_get_property_use_context_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_get_property_use_context_context_end (const xcb_selinux_get_property_use_context_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_selinux_get_property_use_context_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_selinux_get_property_use_context_reply_t *
+xcb_selinux_get_property_use_context_reply (xcb_connection_t                               *c,
+                                            xcb_selinux_get_property_use_context_cookie_t   cookie  /**< */,
+                                            xcb_generic_error_t                           **e);
+
+int
+xcb_selinux_get_property_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_selinux_get_property_context_cookie_t
+xcb_selinux_get_property_context (xcb_connection_t *c,
+                                  xcb_window_t      window,
+                                  xcb_atom_t        property);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_selinux_get_property_context_cookie_t
+xcb_selinux_get_property_context_unchecked (xcb_connection_t *c,
+                                            xcb_window_t      window,
+                                            xcb_atom_t        property);
+
+char *
+xcb_selinux_get_property_context_context (const xcb_selinux_get_property_context_reply_t *R);
+
+int
+xcb_selinux_get_property_context_context_length (const xcb_selinux_get_property_context_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_get_property_context_context_end (const xcb_selinux_get_property_context_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_selinux_get_property_context_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_selinux_get_property_context_reply_t *
+xcb_selinux_get_property_context_reply (xcb_connection_t                           *c,
+                                        xcb_selinux_get_property_context_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e);
+
+int
+xcb_selinux_get_property_data_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_selinux_get_property_data_context_cookie_t
+xcb_selinux_get_property_data_context (xcb_connection_t *c,
+                                       xcb_window_t      window,
+                                       xcb_atom_t        property);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_selinux_get_property_data_context_cookie_t
+xcb_selinux_get_property_data_context_unchecked (xcb_connection_t *c,
+                                                 xcb_window_t      window,
+                                                 xcb_atom_t        property);
+
+char *
+xcb_selinux_get_property_data_context_context (const xcb_selinux_get_property_data_context_reply_t *R);
+
+int
+xcb_selinux_get_property_data_context_context_length (const xcb_selinux_get_property_data_context_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_get_property_data_context_context_end (const xcb_selinux_get_property_data_context_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_selinux_get_property_data_context_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_selinux_get_property_data_context_reply_t *
+xcb_selinux_get_property_data_context_reply (xcb_connection_t                                *c,
+                                             xcb_selinux_get_property_data_context_cookie_t   cookie  /**< */,
+                                             xcb_generic_error_t                            **e);
+
+int
+xcb_selinux_list_properties_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_selinux_list_properties_cookie_t
+xcb_selinux_list_properties (xcb_connection_t *c,
+                             xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_selinux_list_properties_cookie_t
+xcb_selinux_list_properties_unchecked (xcb_connection_t *c,
+                                       xcb_window_t      window);
+
+int
+xcb_selinux_list_properties_properties_length (const xcb_selinux_list_properties_reply_t *R);
+
+xcb_selinux_list_item_iterator_t
+xcb_selinux_list_properties_properties_iterator (const xcb_selinux_list_properties_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_selinux_list_properties_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_selinux_list_properties_reply_t *
+xcb_selinux_list_properties_reply (xcb_connection_t                      *c,
+                                   xcb_selinux_list_properties_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e);
+
+int
+xcb_selinux_set_selection_create_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_selinux_set_selection_create_context_checked (xcb_connection_t *c,
+                                                  uint32_t          context_len,
+                                                  const char       *context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_selinux_set_selection_create_context (xcb_connection_t *c,
+                                          uint32_t          context_len,
+                                          const char       *context);
+
+char *
+xcb_selinux_set_selection_create_context_context (const xcb_selinux_set_selection_create_context_request_t *R);
+
+int
+xcb_selinux_set_selection_create_context_context_length (const xcb_selinux_set_selection_create_context_request_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_set_selection_create_context_context_end (const xcb_selinux_set_selection_create_context_request_t *R);
+
+int
+xcb_selinux_get_selection_create_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_selinux_get_selection_create_context_cookie_t
+xcb_selinux_get_selection_create_context (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_selinux_get_selection_create_context_cookie_t
+xcb_selinux_get_selection_create_context_unchecked (xcb_connection_t *c);
+
+char *
+xcb_selinux_get_selection_create_context_context (const xcb_selinux_get_selection_create_context_reply_t *R);
+
+int
+xcb_selinux_get_selection_create_context_context_length (const xcb_selinux_get_selection_create_context_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_get_selection_create_context_context_end (const xcb_selinux_get_selection_create_context_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_selinux_get_selection_create_context_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_selinux_get_selection_create_context_reply_t *
+xcb_selinux_get_selection_create_context_reply (xcb_connection_t                                   *c,
+                                                xcb_selinux_get_selection_create_context_cookie_t   cookie  /**< */,
+                                                xcb_generic_error_t                               **e);
+
+int
+xcb_selinux_set_selection_use_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_selinux_set_selection_use_context_checked (xcb_connection_t *c,
+                                               uint32_t          context_len,
+                                               const char       *context);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_selinux_set_selection_use_context (xcb_connection_t *c,
+                                       uint32_t          context_len,
+                                       const char       *context);
+
+char *
+xcb_selinux_set_selection_use_context_context (const xcb_selinux_set_selection_use_context_request_t *R);
+
+int
+xcb_selinux_set_selection_use_context_context_length (const xcb_selinux_set_selection_use_context_request_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_set_selection_use_context_context_end (const xcb_selinux_set_selection_use_context_request_t *R);
+
+int
+xcb_selinux_get_selection_use_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_selinux_get_selection_use_context_cookie_t
+xcb_selinux_get_selection_use_context (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_selinux_get_selection_use_context_cookie_t
+xcb_selinux_get_selection_use_context_unchecked (xcb_connection_t *c);
+
+char *
+xcb_selinux_get_selection_use_context_context (const xcb_selinux_get_selection_use_context_reply_t *R);
+
+int
+xcb_selinux_get_selection_use_context_context_length (const xcb_selinux_get_selection_use_context_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_get_selection_use_context_context_end (const xcb_selinux_get_selection_use_context_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_selinux_get_selection_use_context_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_selinux_get_selection_use_context_reply_t *
+xcb_selinux_get_selection_use_context_reply (xcb_connection_t                                *c,
+                                             xcb_selinux_get_selection_use_context_cookie_t   cookie  /**< */,
+                                             xcb_generic_error_t                            **e);
+
+int
+xcb_selinux_get_selection_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_selinux_get_selection_context_cookie_t
+xcb_selinux_get_selection_context (xcb_connection_t *c,
+                                   xcb_atom_t        selection);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_selinux_get_selection_context_cookie_t
+xcb_selinux_get_selection_context_unchecked (xcb_connection_t *c,
+                                             xcb_atom_t        selection);
+
+char *
+xcb_selinux_get_selection_context_context (const xcb_selinux_get_selection_context_reply_t *R);
+
+int
+xcb_selinux_get_selection_context_context_length (const xcb_selinux_get_selection_context_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_get_selection_context_context_end (const xcb_selinux_get_selection_context_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_selinux_get_selection_context_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_selinux_get_selection_context_reply_t *
+xcb_selinux_get_selection_context_reply (xcb_connection_t                            *c,
+                                         xcb_selinux_get_selection_context_cookie_t   cookie  /**< */,
+                                         xcb_generic_error_t                        **e);
+
+int
+xcb_selinux_get_selection_data_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_selinux_get_selection_data_context_cookie_t
+xcb_selinux_get_selection_data_context (xcb_connection_t *c,
+                                        xcb_atom_t        selection);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_selinux_get_selection_data_context_cookie_t
+xcb_selinux_get_selection_data_context_unchecked (xcb_connection_t *c,
+                                                  xcb_atom_t        selection);
+
+char *
+xcb_selinux_get_selection_data_context_context (const xcb_selinux_get_selection_data_context_reply_t *R);
+
+int
+xcb_selinux_get_selection_data_context_context_length (const xcb_selinux_get_selection_data_context_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_get_selection_data_context_context_end (const xcb_selinux_get_selection_data_context_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_selinux_get_selection_data_context_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_selinux_get_selection_data_context_reply_t *
+xcb_selinux_get_selection_data_context_reply (xcb_connection_t                                 *c,
+                                              xcb_selinux_get_selection_data_context_cookie_t   cookie  /**< */,
+                                              xcb_generic_error_t                             **e);
+
+int
+xcb_selinux_list_selections_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_selinux_list_selections_cookie_t
+xcb_selinux_list_selections (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_selinux_list_selections_cookie_t
+xcb_selinux_list_selections_unchecked (xcb_connection_t *c);
+
+int
+xcb_selinux_list_selections_selections_length (const xcb_selinux_list_selections_reply_t *R);
+
+xcb_selinux_list_item_iterator_t
+xcb_selinux_list_selections_selections_iterator (const xcb_selinux_list_selections_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_selinux_list_selections_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_selinux_list_selections_reply_t *
+xcb_selinux_list_selections_reply (xcb_connection_t                      *c,
+                                   xcb_selinux_list_selections_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e);
+
+int
+xcb_selinux_get_client_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_selinux_get_client_context_cookie_t
+xcb_selinux_get_client_context (xcb_connection_t *c,
+                                uint32_t          resource);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_selinux_get_client_context_cookie_t
+xcb_selinux_get_client_context_unchecked (xcb_connection_t *c,
+                                          uint32_t          resource);
+
+char *
+xcb_selinux_get_client_context_context (const xcb_selinux_get_client_context_reply_t *R);
+
+int
+xcb_selinux_get_client_context_context_length (const xcb_selinux_get_client_context_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_selinux_get_client_context_context_end (const xcb_selinux_get_client_context_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_selinux_get_client_context_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_selinux_get_client_context_reply_t *
+xcb_selinux_get_client_context_reply (xcb_connection_t                         *c,
+                                      xcb_selinux_get_client_context_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/xtest.h b/depends/libxcb/include/xcb/xtest.h
new file mode 100644
index 0000000..e97733e
--- /dev/null
+++ b/depends/libxcb/include/xcb/xtest.h
@@ -0,0 +1,303 @@
+/*
+ * This file generated automatically from xtest.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_Test_API XCB Test API
+ * @brief Test XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __XTEST_H
+#define __XTEST_H
+
+#include "xcb.h"
+#include "xproto.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_TEST_MAJOR_VERSION 2
+#define XCB_TEST_MINOR_VERSION 2
+
+extern xcb_extension_t xcb_test_id;
+
+/**
+ * @brief xcb_test_get_version_cookie_t
+ **/
+typedef struct xcb_test_get_version_cookie_t {
+    unsigned int sequence;
+} xcb_test_get_version_cookie_t;
+
+/** Opcode for xcb_test_get_version. */
+#define XCB_TEST_GET_VERSION 0
+
+/**
+ * @brief xcb_test_get_version_request_t
+ **/
+typedef struct xcb_test_get_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  major_version;
+    uint8_t  pad0;
+    uint16_t minor_version;
+} xcb_test_get_version_request_t;
+
+/**
+ * @brief xcb_test_get_version_reply_t
+ **/
+typedef struct xcb_test_get_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  major_version;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t minor_version;
+} xcb_test_get_version_reply_t;
+
+typedef enum xcb_test_cursor_t {
+    XCB_TEST_CURSOR_NONE = 0,
+    XCB_TEST_CURSOR_CURRENT = 1
+} xcb_test_cursor_t;
+
+/**
+ * @brief xcb_test_compare_cursor_cookie_t
+ **/
+typedef struct xcb_test_compare_cursor_cookie_t {
+    unsigned int sequence;
+} xcb_test_compare_cursor_cookie_t;
+
+/** Opcode for xcb_test_compare_cursor. */
+#define XCB_TEST_COMPARE_CURSOR 1
+
+/**
+ * @brief xcb_test_compare_cursor_request_t
+ **/
+typedef struct xcb_test_compare_cursor_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+    xcb_cursor_t cursor;
+} xcb_test_compare_cursor_request_t;
+
+/**
+ * @brief xcb_test_compare_cursor_reply_t
+ **/
+typedef struct xcb_test_compare_cursor_reply_t {
+    uint8_t  response_type;
+    uint8_t  same;
+    uint16_t sequence;
+    uint32_t length;
+} xcb_test_compare_cursor_reply_t;
+
+/** Opcode for xcb_test_fake_input. */
+#define XCB_TEST_FAKE_INPUT 2
+
+/**
+ * @brief xcb_test_fake_input_request_t
+ **/
+typedef struct xcb_test_fake_input_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    uint8_t      type;
+    uint8_t      detail;
+    uint8_t      pad0[2];
+    uint32_t     time;
+    xcb_window_t root;
+    uint8_t      pad1[8];
+    int16_t      rootX;
+    int16_t      rootY;
+    uint8_t      pad2[7];
+    uint8_t      deviceid;
+} xcb_test_fake_input_request_t;
+
+/** Opcode for xcb_test_grab_control. */
+#define XCB_TEST_GRAB_CONTROL 3
+
+/**
+ * @brief xcb_test_grab_control_request_t
+ **/
+typedef struct xcb_test_grab_control_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+    uint8_t  impervious;
+    uint8_t  pad0[3];
+} xcb_test_grab_control_request_t;
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_test_get_version_cookie_t
+xcb_test_get_version (xcb_connection_t *c,
+                      uint8_t           major_version,
+                      uint16_t          minor_version);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_test_get_version_cookie_t
+xcb_test_get_version_unchecked (xcb_connection_t *c,
+                                uint8_t           major_version,
+                                uint16_t          minor_version);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_test_get_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_test_get_version_reply_t *
+xcb_test_get_version_reply (xcb_connection_t               *c,
+                            xcb_test_get_version_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_test_compare_cursor_cookie_t
+xcb_test_compare_cursor (xcb_connection_t *c,
+                         xcb_window_t      window,
+                         xcb_cursor_t      cursor);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_test_compare_cursor_cookie_t
+xcb_test_compare_cursor_unchecked (xcb_connection_t *c,
+                                   xcb_window_t      window,
+                                   xcb_cursor_t      cursor);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_test_compare_cursor_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_test_compare_cursor_reply_t *
+xcb_test_compare_cursor_reply (xcb_connection_t                  *c,
+                               xcb_test_compare_cursor_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_test_fake_input_checked (xcb_connection_t *c,
+                             uint8_t           type,
+                             uint8_t           detail,
+                             uint32_t          time,
+                             xcb_window_t      root,
+                             int16_t           rootX,
+                             int16_t           rootY,
+                             uint8_t           deviceid);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_test_fake_input (xcb_connection_t *c,
+                     uint8_t           type,
+                     uint8_t           detail,
+                     uint32_t          time,
+                     xcb_window_t      root,
+                     int16_t           rootX,
+                     int16_t           rootY,
+                     uint8_t           deviceid);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_test_grab_control_checked (xcb_connection_t *c,
+                               uint8_t           impervious);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_test_grab_control (xcb_connection_t *c,
+                       uint8_t           impervious);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/xv.h b/depends/libxcb/include/xcb/xv.h
new file mode 100644
index 0000000..9e50008
--- /dev/null
+++ b/depends/libxcb/include/xcb/xv.h
@@ -0,0 +1,2096 @@
+/*
+ * This file generated automatically from xv.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_Xv_API XCB Xv API
+ * @brief Xv XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __XV_H
+#define __XV_H
+
+#include "xcb.h"
+#include "xproto.h"
+#include "shm.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_XV_MAJOR_VERSION 2
+#define XCB_XV_MINOR_VERSION 2
+
+extern xcb_extension_t xcb_xv_id;
+
+typedef uint32_t xcb_xv_port_t;
+
+/**
+ * @brief xcb_xv_port_iterator_t
+ **/
+typedef struct xcb_xv_port_iterator_t {
+    xcb_xv_port_t *data;
+    int            rem;
+    int            index;
+} xcb_xv_port_iterator_t;
+
+typedef uint32_t xcb_xv_encoding_t;
+
+/**
+ * @brief xcb_xv_encoding_iterator_t
+ **/
+typedef struct xcb_xv_encoding_iterator_t {
+    xcb_xv_encoding_t *data;
+    int                rem;
+    int                index;
+} xcb_xv_encoding_iterator_t;
+
+typedef enum xcb_xv_type_t {
+    XCB_XV_TYPE_INPUT_MASK = 1,
+    XCB_XV_TYPE_OUTPUT_MASK = 2,
+    XCB_XV_TYPE_VIDEO_MASK = 4,
+    XCB_XV_TYPE_STILL_MASK = 8,
+    XCB_XV_TYPE_IMAGE_MASK = 16
+} xcb_xv_type_t;
+
+typedef enum xcb_xv_image_format_info_type_t {
+    XCB_XV_IMAGE_FORMAT_INFO_TYPE_RGB = 0,
+    XCB_XV_IMAGE_FORMAT_INFO_TYPE_YUV = 1
+} xcb_xv_image_format_info_type_t;
+
+typedef enum xcb_xv_image_format_info_format_t {
+    XCB_XV_IMAGE_FORMAT_INFO_FORMAT_PACKED = 0,
+    XCB_XV_IMAGE_FORMAT_INFO_FORMAT_PLANAR = 1
+} xcb_xv_image_format_info_format_t;
+
+typedef enum xcb_xv_attribute_flag_t {
+    XCB_XV_ATTRIBUTE_FLAG_GETTABLE = 1,
+    XCB_XV_ATTRIBUTE_FLAG_SETTABLE = 2
+} xcb_xv_attribute_flag_t;
+
+typedef enum xcb_xv_video_notify_reason_t {
+    XCB_XV_VIDEO_NOTIFY_REASON_STARTED = 0,
+    XCB_XV_VIDEO_NOTIFY_REASON_STOPPED = 1,
+    XCB_XV_VIDEO_NOTIFY_REASON_BUSY = 2,
+    XCB_XV_VIDEO_NOTIFY_REASON_PREEMPTED = 3,
+    XCB_XV_VIDEO_NOTIFY_REASON_HARD_ERROR = 4
+} xcb_xv_video_notify_reason_t;
+
+typedef enum xcb_xv_scanline_order_t {
+    XCB_XV_SCANLINE_ORDER_TOP_TO_BOTTOM = 0,
+    XCB_XV_SCANLINE_ORDER_BOTTOM_TO_TOP = 1
+} xcb_xv_scanline_order_t;
+
+typedef enum xcb_xv_grab_port_status_t {
+    XCB_XV_GRAB_PORT_STATUS_SUCCESS = 0,
+    XCB_XV_GRAB_PORT_STATUS_BAD_EXTENSION = 1,
+    XCB_XV_GRAB_PORT_STATUS_ALREADY_GRABBED = 2,
+    XCB_XV_GRAB_PORT_STATUS_INVALID_TIME = 3,
+    XCB_XV_GRAB_PORT_STATUS_BAD_REPLY = 4,
+    XCB_XV_GRAB_PORT_STATUS_BAD_ALLOC = 5
+} xcb_xv_grab_port_status_t;
+
+/**
+ * @brief xcb_xv_rational_t
+ **/
+typedef struct xcb_xv_rational_t {
+    int32_t numerator;
+    int32_t denominator;
+} xcb_xv_rational_t;
+
+/**
+ * @brief xcb_xv_rational_iterator_t
+ **/
+typedef struct xcb_xv_rational_iterator_t {
+    xcb_xv_rational_t *data;
+    int                rem;
+    int                index;
+} xcb_xv_rational_iterator_t;
+
+/**
+ * @brief xcb_xv_format_t
+ **/
+typedef struct xcb_xv_format_t {
+    xcb_visualid_t visual;
+    uint8_t        depth;
+    uint8_t        pad0[3];
+} xcb_xv_format_t;
+
+/**
+ * @brief xcb_xv_format_iterator_t
+ **/
+typedef struct xcb_xv_format_iterator_t {
+    xcb_xv_format_t *data;
+    int              rem;
+    int              index;
+} xcb_xv_format_iterator_t;
+
+/**
+ * @brief xcb_xv_adaptor_info_t
+ **/
+typedef struct xcb_xv_adaptor_info_t {
+    xcb_xv_port_t base_id;
+    uint16_t      name_size;
+    uint16_t      num_ports;
+    uint16_t      num_formats;
+    uint8_t       type;
+    uint8_t       pad0;
+} xcb_xv_adaptor_info_t;
+
+/**
+ * @brief xcb_xv_adaptor_info_iterator_t
+ **/
+typedef struct xcb_xv_adaptor_info_iterator_t {
+    xcb_xv_adaptor_info_t *data;
+    int                    rem;
+    int                    index;
+} xcb_xv_adaptor_info_iterator_t;
+
+/**
+ * @brief xcb_xv_encoding_info_t
+ **/
+typedef struct xcb_xv_encoding_info_t {
+    xcb_xv_encoding_t encoding;
+    uint16_t          name_size;
+    uint16_t          width;
+    uint16_t          height;
+    uint8_t           pad0[2];
+    xcb_xv_rational_t rate;
+} xcb_xv_encoding_info_t;
+
+/**
+ * @brief xcb_xv_encoding_info_iterator_t
+ **/
+typedef struct xcb_xv_encoding_info_iterator_t {
+    xcb_xv_encoding_info_t *data;
+    int                     rem;
+    int                     index;
+} xcb_xv_encoding_info_iterator_t;
+
+/**
+ * @brief xcb_xv_image_t
+ **/
+typedef struct xcb_xv_image_t {
+    uint32_t id;
+    uint16_t width;
+    uint16_t height;
+    uint32_t data_size;
+    uint32_t num_planes;
+} xcb_xv_image_t;
+
+/**
+ * @brief xcb_xv_image_iterator_t
+ **/
+typedef struct xcb_xv_image_iterator_t {
+    xcb_xv_image_t *data;
+    int             rem;
+    int             index;
+} xcb_xv_image_iterator_t;
+
+/**
+ * @brief xcb_xv_attribute_info_t
+ **/
+typedef struct xcb_xv_attribute_info_t {
+    uint32_t flags;
+    int32_t  min;
+    int32_t  max;
+    uint32_t size;
+} xcb_xv_attribute_info_t;
+
+/**
+ * @brief xcb_xv_attribute_info_iterator_t
+ **/
+typedef struct xcb_xv_attribute_info_iterator_t {
+    xcb_xv_attribute_info_t *data;
+    int                      rem;
+    int                      index;
+} xcb_xv_attribute_info_iterator_t;
+
+/**
+ * @brief xcb_xv_image_format_info_t
+ **/
+typedef struct xcb_xv_image_format_info_t {
+    uint32_t id;
+    uint8_t  type;
+    uint8_t  byte_order;
+    uint8_t  pad0[2];
+    uint8_t  guid[16];
+    uint8_t  bpp;
+    uint8_t  num_planes;
+    uint8_t  pad1[2];
+    uint8_t  depth;
+    uint8_t  pad2[3];
+    uint32_t red_mask;
+    uint32_t green_mask;
+    uint32_t blue_mask;
+    uint8_t  format;
+    uint8_t  pad3[3];
+    uint32_t y_sample_bits;
+    uint32_t u_sample_bits;
+    uint32_t v_sample_bits;
+    uint32_t vhorz_y_period;
+    uint32_t vhorz_u_period;
+    uint32_t vhorz_v_period;
+    uint32_t vvert_y_period;
+    uint32_t vvert_u_period;
+    uint32_t vvert_v_period;
+    uint8_t  vcomp_order[32];
+    uint8_t  vscanline_order;
+    uint8_t  pad4[11];
+} xcb_xv_image_format_info_t;
+
+/**
+ * @brief xcb_xv_image_format_info_iterator_t
+ **/
+typedef struct xcb_xv_image_format_info_iterator_t {
+    xcb_xv_image_format_info_t *data;
+    int                         rem;
+    int                         index;
+} xcb_xv_image_format_info_iterator_t;
+
+/** Opcode for xcb_xv_bad_port. */
+#define XCB_XV_BAD_PORT 0
+
+/**
+ * @brief xcb_xv_bad_port_error_t
+ **/
+typedef struct xcb_xv_bad_port_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_xv_bad_port_error_t;
+
+/** Opcode for xcb_xv_bad_encoding. */
+#define XCB_XV_BAD_ENCODING 1
+
+/**
+ * @brief xcb_xv_bad_encoding_error_t
+ **/
+typedef struct xcb_xv_bad_encoding_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_xv_bad_encoding_error_t;
+
+/** Opcode for xcb_xv_bad_control. */
+#define XCB_XV_BAD_CONTROL 2
+
+/**
+ * @brief xcb_xv_bad_control_error_t
+ **/
+typedef struct xcb_xv_bad_control_error_t {
+    uint8_t  response_type;
+    uint8_t  error_code;
+    uint16_t sequence;
+    uint32_t bad_value;
+    uint16_t minor_opcode;
+    uint8_t  major_opcode;
+} xcb_xv_bad_control_error_t;
+
+/** Opcode for xcb_xv_video_notify. */
+#define XCB_XV_VIDEO_NOTIFY 0
+
+/**
+ * @brief xcb_xv_video_notify_event_t
+ **/
+typedef struct xcb_xv_video_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         reason;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    xcb_drawable_t  drawable;
+    xcb_xv_port_t   port;
+} xcb_xv_video_notify_event_t;
+
+/** Opcode for xcb_xv_port_notify. */
+#define XCB_XV_PORT_NOTIFY 1
+
+/**
+ * @brief xcb_xv_port_notify_event_t
+ **/
+typedef struct xcb_xv_port_notify_event_t {
+    uint8_t         response_type;
+    uint8_t         pad0;
+    uint16_t        sequence;
+    xcb_timestamp_t time;
+    xcb_xv_port_t   port;
+    xcb_atom_t      attribute;
+    int32_t         value;
+} xcb_xv_port_notify_event_t;
+
+/**
+ * @brief xcb_xv_query_extension_cookie_t
+ **/
+typedef struct xcb_xv_query_extension_cookie_t {
+    unsigned int sequence;
+} xcb_xv_query_extension_cookie_t;
+
+/** Opcode for xcb_xv_query_extension. */
+#define XCB_XV_QUERY_EXTENSION 0
+
+/**
+ * @brief xcb_xv_query_extension_request_t
+ **/
+typedef struct xcb_xv_query_extension_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_xv_query_extension_request_t;
+
+/**
+ * @brief xcb_xv_query_extension_reply_t
+ **/
+typedef struct xcb_xv_query_extension_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t major;
+    uint16_t minor;
+} xcb_xv_query_extension_reply_t;
+
+/**
+ * @brief xcb_xv_query_adaptors_cookie_t
+ **/
+typedef struct xcb_xv_query_adaptors_cookie_t {
+    unsigned int sequence;
+} xcb_xv_query_adaptors_cookie_t;
+
+/** Opcode for xcb_xv_query_adaptors. */
+#define XCB_XV_QUERY_ADAPTORS 1
+
+/**
+ * @brief xcb_xv_query_adaptors_request_t
+ **/
+typedef struct xcb_xv_query_adaptors_request_t {
+    uint8_t      major_opcode;
+    uint8_t      minor_opcode;
+    uint16_t     length;
+    xcb_window_t window;
+} xcb_xv_query_adaptors_request_t;
+
+/**
+ * @brief xcb_xv_query_adaptors_reply_t
+ **/
+typedef struct xcb_xv_query_adaptors_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t num_adaptors;
+    uint8_t  pad1[22];
+} xcb_xv_query_adaptors_reply_t;
+
+/**
+ * @brief xcb_xv_query_encodings_cookie_t
+ **/
+typedef struct xcb_xv_query_encodings_cookie_t {
+    unsigned int sequence;
+} xcb_xv_query_encodings_cookie_t;
+
+/** Opcode for xcb_xv_query_encodings. */
+#define XCB_XV_QUERY_ENCODINGS 2
+
+/**
+ * @brief xcb_xv_query_encodings_request_t
+ **/
+typedef struct xcb_xv_query_encodings_request_t {
+    uint8_t       major_opcode;
+    uint8_t       minor_opcode;
+    uint16_t      length;
+    xcb_xv_port_t port;
+} xcb_xv_query_encodings_request_t;
+
+/**
+ * @brief xcb_xv_query_encodings_reply_t
+ **/
+typedef struct xcb_xv_query_encodings_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t num_encodings;
+    uint8_t  pad1[22];
+} xcb_xv_query_encodings_reply_t;
+
+/**
+ * @brief xcb_xv_grab_port_cookie_t
+ **/
+typedef struct xcb_xv_grab_port_cookie_t {
+    unsigned int sequence;
+} xcb_xv_grab_port_cookie_t;
+
+/** Opcode for xcb_xv_grab_port. */
+#define XCB_XV_GRAB_PORT 3
+
+/**
+ * @brief xcb_xv_grab_port_request_t
+ **/
+typedef struct xcb_xv_grab_port_request_t {
+    uint8_t         major_opcode;
+    uint8_t         minor_opcode;
+    uint16_t        length;
+    xcb_xv_port_t   port;
+    xcb_timestamp_t time;
+} xcb_xv_grab_port_request_t;
+
+/**
+ * @brief xcb_xv_grab_port_reply_t
+ **/
+typedef struct xcb_xv_grab_port_reply_t {
+    uint8_t  response_type;
+    uint8_t  result;
+    uint16_t sequence;
+    uint32_t length;
+} xcb_xv_grab_port_reply_t;
+
+/** Opcode for xcb_xv_ungrab_port. */
+#define XCB_XV_UNGRAB_PORT 4
+
+/**
+ * @brief xcb_xv_ungrab_port_request_t
+ **/
+typedef struct xcb_xv_ungrab_port_request_t {
+    uint8_t         major_opcode;
+    uint8_t         minor_opcode;
+    uint16_t        length;
+    xcb_xv_port_t   port;
+    xcb_timestamp_t time;
+} xcb_xv_ungrab_port_request_t;
+
+/** Opcode for xcb_xv_put_video. */
+#define XCB_XV_PUT_VIDEO 5
+
+/**
+ * @brief xcb_xv_put_video_request_t
+ **/
+typedef struct xcb_xv_put_video_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_xv_port_t  port;
+    xcb_drawable_t drawable;
+    xcb_gcontext_t gc;
+    int16_t        vid_x;
+    int16_t        vid_y;
+    uint16_t       vid_w;
+    uint16_t       vid_h;
+    int16_t        drw_x;
+    int16_t        drw_y;
+    uint16_t       drw_w;
+    uint16_t       drw_h;
+} xcb_xv_put_video_request_t;
+
+/** Opcode for xcb_xv_put_still. */
+#define XCB_XV_PUT_STILL 6
+
+/**
+ * @brief xcb_xv_put_still_request_t
+ **/
+typedef struct xcb_xv_put_still_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_xv_port_t  port;
+    xcb_drawable_t drawable;
+    xcb_gcontext_t gc;
+    int16_t        vid_x;
+    int16_t        vid_y;
+    uint16_t       vid_w;
+    uint16_t       vid_h;
+    int16_t        drw_x;
+    int16_t        drw_y;
+    uint16_t       drw_w;
+    uint16_t       drw_h;
+} xcb_xv_put_still_request_t;
+
+/** Opcode for xcb_xv_get_video. */
+#define XCB_XV_GET_VIDEO 7
+
+/**
+ * @brief xcb_xv_get_video_request_t
+ **/
+typedef struct xcb_xv_get_video_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_xv_port_t  port;
+    xcb_drawable_t drawable;
+    xcb_gcontext_t gc;
+    int16_t        vid_x;
+    int16_t        vid_y;
+    uint16_t       vid_w;
+    uint16_t       vid_h;
+    int16_t        drw_x;
+    int16_t        drw_y;
+    uint16_t       drw_w;
+    uint16_t       drw_h;
+} xcb_xv_get_video_request_t;
+
+/** Opcode for xcb_xv_get_still. */
+#define XCB_XV_GET_STILL 8
+
+/**
+ * @brief xcb_xv_get_still_request_t
+ **/
+typedef struct xcb_xv_get_still_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_xv_port_t  port;
+    xcb_drawable_t drawable;
+    xcb_gcontext_t gc;
+    int16_t        vid_x;
+    int16_t        vid_y;
+    uint16_t       vid_w;
+    uint16_t       vid_h;
+    int16_t        drw_x;
+    int16_t        drw_y;
+    uint16_t       drw_w;
+    uint16_t       drw_h;
+} xcb_xv_get_still_request_t;
+
+/** Opcode for xcb_xv_stop_video. */
+#define XCB_XV_STOP_VIDEO 9
+
+/**
+ * @brief xcb_xv_stop_video_request_t
+ **/
+typedef struct xcb_xv_stop_video_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_xv_port_t  port;
+    xcb_drawable_t drawable;
+} xcb_xv_stop_video_request_t;
+
+/** Opcode for xcb_xv_select_video_notify. */
+#define XCB_XV_SELECT_VIDEO_NOTIFY 10
+
+/**
+ * @brief xcb_xv_select_video_notify_request_t
+ **/
+typedef struct xcb_xv_select_video_notify_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_drawable_t drawable;
+    uint8_t        onoff;
+    uint8_t        pad0[3];
+} xcb_xv_select_video_notify_request_t;
+
+/** Opcode for xcb_xv_select_port_notify. */
+#define XCB_XV_SELECT_PORT_NOTIFY 11
+
+/**
+ * @brief xcb_xv_select_port_notify_request_t
+ **/
+typedef struct xcb_xv_select_port_notify_request_t {
+    uint8_t       major_opcode;
+    uint8_t       minor_opcode;
+    uint16_t      length;
+    xcb_xv_port_t port;
+    uint8_t       onoff;
+    uint8_t       pad0[3];
+} xcb_xv_select_port_notify_request_t;
+
+/**
+ * @brief xcb_xv_query_best_size_cookie_t
+ **/
+typedef struct xcb_xv_query_best_size_cookie_t {
+    unsigned int sequence;
+} xcb_xv_query_best_size_cookie_t;
+
+/** Opcode for xcb_xv_query_best_size. */
+#define XCB_XV_QUERY_BEST_SIZE 12
+
+/**
+ * @brief xcb_xv_query_best_size_request_t
+ **/
+typedef struct xcb_xv_query_best_size_request_t {
+    uint8_t       major_opcode;
+    uint8_t       minor_opcode;
+    uint16_t      length;
+    xcb_xv_port_t port;
+    uint16_t      vid_w;
+    uint16_t      vid_h;
+    uint16_t      drw_w;
+    uint16_t      drw_h;
+    uint8_t       motion;
+    uint8_t       pad0[3];
+} xcb_xv_query_best_size_request_t;
+
+/**
+ * @brief xcb_xv_query_best_size_reply_t
+ **/
+typedef struct xcb_xv_query_best_size_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t actual_width;
+    uint16_t actual_height;
+} xcb_xv_query_best_size_reply_t;
+
+/** Opcode for xcb_xv_set_port_attribute. */
+#define XCB_XV_SET_PORT_ATTRIBUTE 13
+
+/**
+ * @brief xcb_xv_set_port_attribute_request_t
+ **/
+typedef struct xcb_xv_set_port_attribute_request_t {
+    uint8_t       major_opcode;
+    uint8_t       minor_opcode;
+    uint16_t      length;
+    xcb_xv_port_t port;
+    xcb_atom_t    attribute;
+    int32_t       value;
+} xcb_xv_set_port_attribute_request_t;
+
+/**
+ * @brief xcb_xv_get_port_attribute_cookie_t
+ **/
+typedef struct xcb_xv_get_port_attribute_cookie_t {
+    unsigned int sequence;
+} xcb_xv_get_port_attribute_cookie_t;
+
+/** Opcode for xcb_xv_get_port_attribute. */
+#define XCB_XV_GET_PORT_ATTRIBUTE 14
+
+/**
+ * @brief xcb_xv_get_port_attribute_request_t
+ **/
+typedef struct xcb_xv_get_port_attribute_request_t {
+    uint8_t       major_opcode;
+    uint8_t       minor_opcode;
+    uint16_t      length;
+    xcb_xv_port_t port;
+    xcb_atom_t    attribute;
+} xcb_xv_get_port_attribute_request_t;
+
+/**
+ * @brief xcb_xv_get_port_attribute_reply_t
+ **/
+typedef struct xcb_xv_get_port_attribute_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    int32_t  value;
+} xcb_xv_get_port_attribute_reply_t;
+
+/**
+ * @brief xcb_xv_query_port_attributes_cookie_t
+ **/
+typedef struct xcb_xv_query_port_attributes_cookie_t {
+    unsigned int sequence;
+} xcb_xv_query_port_attributes_cookie_t;
+
+/** Opcode for xcb_xv_query_port_attributes. */
+#define XCB_XV_QUERY_PORT_ATTRIBUTES 15
+
+/**
+ * @brief xcb_xv_query_port_attributes_request_t
+ **/
+typedef struct xcb_xv_query_port_attributes_request_t {
+    uint8_t       major_opcode;
+    uint8_t       minor_opcode;
+    uint16_t      length;
+    xcb_xv_port_t port;
+} xcb_xv_query_port_attributes_request_t;
+
+/**
+ * @brief xcb_xv_query_port_attributes_reply_t
+ **/
+typedef struct xcb_xv_query_port_attributes_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t num_attributes;
+    uint32_t text_size;
+    uint8_t  pad1[16];
+} xcb_xv_query_port_attributes_reply_t;
+
+/**
+ * @brief xcb_xv_list_image_formats_cookie_t
+ **/
+typedef struct xcb_xv_list_image_formats_cookie_t {
+    unsigned int sequence;
+} xcb_xv_list_image_formats_cookie_t;
+
+/** Opcode for xcb_xv_list_image_formats. */
+#define XCB_XV_LIST_IMAGE_FORMATS 16
+
+/**
+ * @brief xcb_xv_list_image_formats_request_t
+ **/
+typedef struct xcb_xv_list_image_formats_request_t {
+    uint8_t       major_opcode;
+    uint8_t       minor_opcode;
+    uint16_t      length;
+    xcb_xv_port_t port;
+} xcb_xv_list_image_formats_request_t;
+
+/**
+ * @brief xcb_xv_list_image_formats_reply_t
+ **/
+typedef struct xcb_xv_list_image_formats_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t num_formats;
+    uint8_t  pad1[20];
+} xcb_xv_list_image_formats_reply_t;
+
+/**
+ * @brief xcb_xv_query_image_attributes_cookie_t
+ **/
+typedef struct xcb_xv_query_image_attributes_cookie_t {
+    unsigned int sequence;
+} xcb_xv_query_image_attributes_cookie_t;
+
+/** Opcode for xcb_xv_query_image_attributes. */
+#define XCB_XV_QUERY_IMAGE_ATTRIBUTES 17
+
+/**
+ * @brief xcb_xv_query_image_attributes_request_t
+ **/
+typedef struct xcb_xv_query_image_attributes_request_t {
+    uint8_t       major_opcode;
+    uint8_t       minor_opcode;
+    uint16_t      length;
+    xcb_xv_port_t port;
+    uint32_t      id;
+    uint16_t      width;
+    uint16_t      height;
+} xcb_xv_query_image_attributes_request_t;
+
+/**
+ * @brief xcb_xv_query_image_attributes_reply_t
+ **/
+typedef struct xcb_xv_query_image_attributes_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t num_planes;
+    uint32_t data_size;
+    uint16_t width;
+    uint16_t height;
+    uint8_t  pad1[12];
+} xcb_xv_query_image_attributes_reply_t;
+
+/** Opcode for xcb_xv_put_image. */
+#define XCB_XV_PUT_IMAGE 18
+
+/**
+ * @brief xcb_xv_put_image_request_t
+ **/
+typedef struct xcb_xv_put_image_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_xv_port_t  port;
+    xcb_drawable_t drawable;
+    xcb_gcontext_t gc;
+    uint32_t       id;
+    int16_t        src_x;
+    int16_t        src_y;
+    uint16_t       src_w;
+    uint16_t       src_h;
+    int16_t        drw_x;
+    int16_t        drw_y;
+    uint16_t       drw_w;
+    uint16_t       drw_h;
+    uint16_t       width;
+    uint16_t       height;
+} xcb_xv_put_image_request_t;
+
+/** Opcode for xcb_xv_shm_put_image. */
+#define XCB_XV_SHM_PUT_IMAGE 19
+
+/**
+ * @brief xcb_xv_shm_put_image_request_t
+ **/
+typedef struct xcb_xv_shm_put_image_request_t {
+    uint8_t        major_opcode;
+    uint8_t        minor_opcode;
+    uint16_t       length;
+    xcb_xv_port_t  port;
+    xcb_drawable_t drawable;
+    xcb_gcontext_t gc;
+    xcb_shm_seg_t  shmseg;
+    uint32_t       id;
+    uint32_t       offset;
+    int16_t        src_x;
+    int16_t        src_y;
+    uint16_t       src_w;
+    uint16_t       src_h;
+    int16_t        drw_x;
+    int16_t        drw_y;
+    uint16_t       drw_w;
+    uint16_t       drw_h;
+    uint16_t       width;
+    uint16_t       height;
+    uint8_t        send_event;
+    uint8_t        pad0[3];
+} xcb_xv_shm_put_image_request_t;
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xv_port_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xv_port_t)
+ */
+void
+xcb_xv_port_next (xcb_xv_port_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xv_port_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xv_port_end (xcb_xv_port_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xv_encoding_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xv_encoding_t)
+ */
+void
+xcb_xv_encoding_next (xcb_xv_encoding_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xv_encoding_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xv_encoding_end (xcb_xv_encoding_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xv_rational_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xv_rational_t)
+ */
+void
+xcb_xv_rational_next (xcb_xv_rational_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xv_rational_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xv_rational_end (xcb_xv_rational_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xv_format_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xv_format_t)
+ */
+void
+xcb_xv_format_next (xcb_xv_format_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xv_format_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xv_format_end (xcb_xv_format_iterator_t i);
+
+int
+xcb_xv_adaptor_info_sizeof (const void  *_buffer);
+
+char *
+xcb_xv_adaptor_info_name (const xcb_xv_adaptor_info_t *R);
+
+int
+xcb_xv_adaptor_info_name_length (const xcb_xv_adaptor_info_t *R);
+
+xcb_generic_iterator_t
+xcb_xv_adaptor_info_name_end (const xcb_xv_adaptor_info_t *R);
+
+xcb_xv_format_t *
+xcb_xv_adaptor_info_formats (const xcb_xv_adaptor_info_t *R);
+
+int
+xcb_xv_adaptor_info_formats_length (const xcb_xv_adaptor_info_t *R);
+
+xcb_xv_format_iterator_t
+xcb_xv_adaptor_info_formats_iterator (const xcb_xv_adaptor_info_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xv_adaptor_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xv_adaptor_info_t)
+ */
+void
+xcb_xv_adaptor_info_next (xcb_xv_adaptor_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xv_adaptor_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xv_adaptor_info_end (xcb_xv_adaptor_info_iterator_t i);
+
+int
+xcb_xv_encoding_info_sizeof (const void  *_buffer);
+
+char *
+xcb_xv_encoding_info_name (const xcb_xv_encoding_info_t *R);
+
+int
+xcb_xv_encoding_info_name_length (const xcb_xv_encoding_info_t *R);
+
+xcb_generic_iterator_t
+xcb_xv_encoding_info_name_end (const xcb_xv_encoding_info_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xv_encoding_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xv_encoding_info_t)
+ */
+void
+xcb_xv_encoding_info_next (xcb_xv_encoding_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xv_encoding_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xv_encoding_info_end (xcb_xv_encoding_info_iterator_t i);
+
+int
+xcb_xv_image_sizeof (const void  *_buffer);
+
+uint32_t *
+xcb_xv_image_pitches (const xcb_xv_image_t *R);
+
+int
+xcb_xv_image_pitches_length (const xcb_xv_image_t *R);
+
+xcb_generic_iterator_t
+xcb_xv_image_pitches_end (const xcb_xv_image_t *R);
+
+uint32_t *
+xcb_xv_image_offsets (const xcb_xv_image_t *R);
+
+int
+xcb_xv_image_offsets_length (const xcb_xv_image_t *R);
+
+xcb_generic_iterator_t
+xcb_xv_image_offsets_end (const xcb_xv_image_t *R);
+
+uint8_t *
+xcb_xv_image_data (const xcb_xv_image_t *R);
+
+int
+xcb_xv_image_data_length (const xcb_xv_image_t *R);
+
+xcb_generic_iterator_t
+xcb_xv_image_data_end (const xcb_xv_image_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xv_image_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xv_image_t)
+ */
+void
+xcb_xv_image_next (xcb_xv_image_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xv_image_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xv_image_end (xcb_xv_image_iterator_t i);
+
+int
+xcb_xv_attribute_info_sizeof (const void  *_buffer);
+
+char *
+xcb_xv_attribute_info_name (const xcb_xv_attribute_info_t *R);
+
+int
+xcb_xv_attribute_info_name_length (const xcb_xv_attribute_info_t *R);
+
+xcb_generic_iterator_t
+xcb_xv_attribute_info_name_end (const xcb_xv_attribute_info_t *R);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xv_attribute_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xv_attribute_info_t)
+ */
+void
+xcb_xv_attribute_info_next (xcb_xv_attribute_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xv_attribute_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xv_attribute_info_end (xcb_xv_attribute_info_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xv_image_format_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xv_image_format_info_t)
+ */
+void
+xcb_xv_image_format_info_next (xcb_xv_image_format_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xv_image_format_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xv_image_format_info_end (xcb_xv_image_format_info_iterator_t i);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xv_query_extension_cookie_t
+xcb_xv_query_extension (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xv_query_extension_cookie_t
+xcb_xv_query_extension_unchecked (xcb_connection_t *c);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xv_query_extension_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xv_query_extension_reply_t *
+xcb_xv_query_extension_reply (xcb_connection_t                 *c,
+                              xcb_xv_query_extension_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+int
+xcb_xv_query_adaptors_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xv_query_adaptors_cookie_t
+xcb_xv_query_adaptors (xcb_connection_t *c,
+                       xcb_window_t      window);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xv_query_adaptors_cookie_t
+xcb_xv_query_adaptors_unchecked (xcb_connection_t *c,
+                                 xcb_window_t      window);
+
+int
+xcb_xv_query_adaptors_info_length (const xcb_xv_query_adaptors_reply_t *R);
+
+xcb_xv_adaptor_info_iterator_t
+xcb_xv_query_adaptors_info_iterator (const xcb_xv_query_adaptors_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xv_query_adaptors_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xv_query_adaptors_reply_t *
+xcb_xv_query_adaptors_reply (xcb_connection_t                *c,
+                             xcb_xv_query_adaptors_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e);
+
+int
+xcb_xv_query_encodings_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xv_query_encodings_cookie_t
+xcb_xv_query_encodings (xcb_connection_t *c,
+                        xcb_xv_port_t     port);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xv_query_encodings_cookie_t
+xcb_xv_query_encodings_unchecked (xcb_connection_t *c,
+                                  xcb_xv_port_t     port);
+
+int
+xcb_xv_query_encodings_info_length (const xcb_xv_query_encodings_reply_t *R);
+
+xcb_xv_encoding_info_iterator_t
+xcb_xv_query_encodings_info_iterator (const xcb_xv_query_encodings_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xv_query_encodings_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xv_query_encodings_reply_t *
+xcb_xv_query_encodings_reply (xcb_connection_t                 *c,
+                              xcb_xv_query_encodings_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xv_grab_port_cookie_t
+xcb_xv_grab_port (xcb_connection_t *c,
+                  xcb_xv_port_t     port,
+                  xcb_timestamp_t   time);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xv_grab_port_cookie_t
+xcb_xv_grab_port_unchecked (xcb_connection_t *c,
+                            xcb_xv_port_t     port,
+                            xcb_timestamp_t   time);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xv_grab_port_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xv_grab_port_reply_t *
+xcb_xv_grab_port_reply (xcb_connection_t           *c,
+                        xcb_xv_grab_port_cookie_t   cookie  /**< */,
+                        xcb_generic_error_t       **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xv_ungrab_port_checked (xcb_connection_t *c,
+                            xcb_xv_port_t     port,
+                            xcb_timestamp_t   time);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xv_ungrab_port (xcb_connection_t *c,
+                    xcb_xv_port_t     port,
+                    xcb_timestamp_t   time);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xv_put_video_checked (xcb_connection_t *c,
+                          xcb_xv_port_t     port,
+                          xcb_drawable_t    drawable,
+                          xcb_gcontext_t    gc,
+                          int16_t           vid_x,
+                          int16_t           vid_y,
+                          uint16_t          vid_w,
+                          uint16_t          vid_h,
+                          int16_t           drw_x,
+                          int16_t           drw_y,
+                          uint16_t          drw_w,
+                          uint16_t          drw_h);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xv_put_video (xcb_connection_t *c,
+                  xcb_xv_port_t     port,
+                  xcb_drawable_t    drawable,
+                  xcb_gcontext_t    gc,
+                  int16_t           vid_x,
+                  int16_t           vid_y,
+                  uint16_t          vid_w,
+                  uint16_t          vid_h,
+                  int16_t           drw_x,
+                  int16_t           drw_y,
+                  uint16_t          drw_w,
+                  uint16_t          drw_h);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xv_put_still_checked (xcb_connection_t *c,
+                          xcb_xv_port_t     port,
+                          xcb_drawable_t    drawable,
+                          xcb_gcontext_t    gc,
+                          int16_t           vid_x,
+                          int16_t           vid_y,
+                          uint16_t          vid_w,
+                          uint16_t          vid_h,
+                          int16_t           drw_x,
+                          int16_t           drw_y,
+                          uint16_t          drw_w,
+                          uint16_t          drw_h);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xv_put_still (xcb_connection_t *c,
+                  xcb_xv_port_t     port,
+                  xcb_drawable_t    drawable,
+                  xcb_gcontext_t    gc,
+                  int16_t           vid_x,
+                  int16_t           vid_y,
+                  uint16_t          vid_w,
+                  uint16_t          vid_h,
+                  int16_t           drw_x,
+                  int16_t           drw_y,
+                  uint16_t          drw_w,
+                  uint16_t          drw_h);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xv_get_video_checked (xcb_connection_t *c,
+                          xcb_xv_port_t     port,
+                          xcb_drawable_t    drawable,
+                          xcb_gcontext_t    gc,
+                          int16_t           vid_x,
+                          int16_t           vid_y,
+                          uint16_t          vid_w,
+                          uint16_t          vid_h,
+                          int16_t           drw_x,
+                          int16_t           drw_y,
+                          uint16_t          drw_w,
+                          uint16_t          drw_h);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xv_get_video (xcb_connection_t *c,
+                  xcb_xv_port_t     port,
+                  xcb_drawable_t    drawable,
+                  xcb_gcontext_t    gc,
+                  int16_t           vid_x,
+                  int16_t           vid_y,
+                  uint16_t          vid_w,
+                  uint16_t          vid_h,
+                  int16_t           drw_x,
+                  int16_t           drw_y,
+                  uint16_t          drw_w,
+                  uint16_t          drw_h);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xv_get_still_checked (xcb_connection_t *c,
+                          xcb_xv_port_t     port,
+                          xcb_drawable_t    drawable,
+                          xcb_gcontext_t    gc,
+                          int16_t           vid_x,
+                          int16_t           vid_y,
+                          uint16_t          vid_w,
+                          uint16_t          vid_h,
+                          int16_t           drw_x,
+                          int16_t           drw_y,
+                          uint16_t          drw_w,
+                          uint16_t          drw_h);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xv_get_still (xcb_connection_t *c,
+                  xcb_xv_port_t     port,
+                  xcb_drawable_t    drawable,
+                  xcb_gcontext_t    gc,
+                  int16_t           vid_x,
+                  int16_t           vid_y,
+                  uint16_t          vid_w,
+                  uint16_t          vid_h,
+                  int16_t           drw_x,
+                  int16_t           drw_y,
+                  uint16_t          drw_w,
+                  uint16_t          drw_h);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xv_stop_video_checked (xcb_connection_t *c,
+                           xcb_xv_port_t     port,
+                           xcb_drawable_t    drawable);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xv_stop_video (xcb_connection_t *c,
+                   xcb_xv_port_t     port,
+                   xcb_drawable_t    drawable);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xv_select_video_notify_checked (xcb_connection_t *c,
+                                    xcb_drawable_t    drawable,
+                                    uint8_t           onoff);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xv_select_video_notify (xcb_connection_t *c,
+                            xcb_drawable_t    drawable,
+                            uint8_t           onoff);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xv_select_port_notify_checked (xcb_connection_t *c,
+                                   xcb_xv_port_t     port,
+                                   uint8_t           onoff);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xv_select_port_notify (xcb_connection_t *c,
+                           xcb_xv_port_t     port,
+                           uint8_t           onoff);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xv_query_best_size_cookie_t
+xcb_xv_query_best_size (xcb_connection_t *c,
+                        xcb_xv_port_t     port,
+                        uint16_t          vid_w,
+                        uint16_t          vid_h,
+                        uint16_t          drw_w,
+                        uint16_t          drw_h,
+                        uint8_t           motion);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xv_query_best_size_cookie_t
+xcb_xv_query_best_size_unchecked (xcb_connection_t *c,
+                                  xcb_xv_port_t     port,
+                                  uint16_t          vid_w,
+                                  uint16_t          vid_h,
+                                  uint16_t          drw_w,
+                                  uint16_t          drw_h,
+                                  uint8_t           motion);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xv_query_best_size_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xv_query_best_size_reply_t *
+xcb_xv_query_best_size_reply (xcb_connection_t                 *c,
+                              xcb_xv_query_best_size_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xv_set_port_attribute_checked (xcb_connection_t *c,
+                                   xcb_xv_port_t     port,
+                                   xcb_atom_t        attribute,
+                                   int32_t           value);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xv_set_port_attribute (xcb_connection_t *c,
+                           xcb_xv_port_t     port,
+                           xcb_atom_t        attribute,
+                           int32_t           value);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xv_get_port_attribute_cookie_t
+xcb_xv_get_port_attribute (xcb_connection_t *c,
+                           xcb_xv_port_t     port,
+                           xcb_atom_t        attribute);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xv_get_port_attribute_cookie_t
+xcb_xv_get_port_attribute_unchecked (xcb_connection_t *c,
+                                     xcb_xv_port_t     port,
+                                     xcb_atom_t        attribute);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xv_get_port_attribute_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xv_get_port_attribute_reply_t *
+xcb_xv_get_port_attribute_reply (xcb_connection_t                    *c,
+                                 xcb_xv_get_port_attribute_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e);
+
+int
+xcb_xv_query_port_attributes_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xv_query_port_attributes_cookie_t
+xcb_xv_query_port_attributes (xcb_connection_t *c,
+                              xcb_xv_port_t     port);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xv_query_port_attributes_cookie_t
+xcb_xv_query_port_attributes_unchecked (xcb_connection_t *c,
+                                        xcb_xv_port_t     port);
+
+int
+xcb_xv_query_port_attributes_attributes_length (const xcb_xv_query_port_attributes_reply_t *R);
+
+xcb_xv_attribute_info_iterator_t
+xcb_xv_query_port_attributes_attributes_iterator (const xcb_xv_query_port_attributes_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xv_query_port_attributes_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xv_query_port_attributes_reply_t *
+xcb_xv_query_port_attributes_reply (xcb_connection_t                       *c,
+                                    xcb_xv_query_port_attributes_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e);
+
+int
+xcb_xv_list_image_formats_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xv_list_image_formats_cookie_t
+xcb_xv_list_image_formats (xcb_connection_t *c,
+                           xcb_xv_port_t     port);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xv_list_image_formats_cookie_t
+xcb_xv_list_image_formats_unchecked (xcb_connection_t *c,
+                                     xcb_xv_port_t     port);
+
+xcb_xv_image_format_info_t *
+xcb_xv_list_image_formats_format (const xcb_xv_list_image_formats_reply_t *R);
+
+int
+xcb_xv_list_image_formats_format_length (const xcb_xv_list_image_formats_reply_t *R);
+
+xcb_xv_image_format_info_iterator_t
+xcb_xv_list_image_formats_format_iterator (const xcb_xv_list_image_formats_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xv_list_image_formats_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xv_list_image_formats_reply_t *
+xcb_xv_list_image_formats_reply (xcb_connection_t                    *c,
+                                 xcb_xv_list_image_formats_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e);
+
+int
+xcb_xv_query_image_attributes_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xv_query_image_attributes_cookie_t
+xcb_xv_query_image_attributes (xcb_connection_t *c,
+                               xcb_xv_port_t     port,
+                               uint32_t          id,
+                               uint16_t          width,
+                               uint16_t          height);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xv_query_image_attributes_cookie_t
+xcb_xv_query_image_attributes_unchecked (xcb_connection_t *c,
+                                         xcb_xv_port_t     port,
+                                         uint32_t          id,
+                                         uint16_t          width,
+                                         uint16_t          height);
+
+uint32_t *
+xcb_xv_query_image_attributes_pitches (const xcb_xv_query_image_attributes_reply_t *R);
+
+int
+xcb_xv_query_image_attributes_pitches_length (const xcb_xv_query_image_attributes_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_xv_query_image_attributes_pitches_end (const xcb_xv_query_image_attributes_reply_t *R);
+
+uint32_t *
+xcb_xv_query_image_attributes_offsets (const xcb_xv_query_image_attributes_reply_t *R);
+
+int
+xcb_xv_query_image_attributes_offsets_length (const xcb_xv_query_image_attributes_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_xv_query_image_attributes_offsets_end (const xcb_xv_query_image_attributes_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xv_query_image_attributes_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xv_query_image_attributes_reply_t *
+xcb_xv_query_image_attributes_reply (xcb_connection_t                        *c,
+                                     xcb_xv_query_image_attributes_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e);
+
+int
+xcb_xv_put_image_sizeof (const void  *_buffer,
+                         uint32_t     data_len);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xv_put_image_checked (xcb_connection_t *c,
+                          xcb_xv_port_t     port,
+                          xcb_drawable_t    drawable,
+                          xcb_gcontext_t    gc,
+                          uint32_t          id,
+                          int16_t           src_x,
+                          int16_t           src_y,
+                          uint16_t          src_w,
+                          uint16_t          src_h,
+                          int16_t           drw_x,
+                          int16_t           drw_y,
+                          uint16_t          drw_w,
+                          uint16_t          drw_h,
+                          uint16_t          width,
+                          uint16_t          height,
+                          uint32_t          data_len,
+                          const uint8_t    *data);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xv_put_image (xcb_connection_t *c,
+                  xcb_xv_port_t     port,
+                  xcb_drawable_t    drawable,
+                  xcb_gcontext_t    gc,
+                  uint32_t          id,
+                  int16_t           src_x,
+                  int16_t           src_y,
+                  uint16_t          src_w,
+                  uint16_t          src_h,
+                  int16_t           drw_x,
+                  int16_t           drw_y,
+                  uint16_t          drw_w,
+                  uint16_t          drw_h,
+                  uint16_t          width,
+                  uint16_t          height,
+                  uint32_t          data_len,
+                  const uint8_t    *data);
+
+uint8_t *
+xcb_xv_put_image_data (const xcb_xv_put_image_request_t *R);
+
+int
+xcb_xv_put_image_data_length (const xcb_xv_put_image_request_t *R);
+
+xcb_generic_iterator_t
+xcb_xv_put_image_data_end (const xcb_xv_put_image_request_t *R);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xv_shm_put_image_checked (xcb_connection_t *c,
+                              xcb_xv_port_t     port,
+                              xcb_drawable_t    drawable,
+                              xcb_gcontext_t    gc,
+                              xcb_shm_seg_t     shmseg,
+                              uint32_t          id,
+                              uint32_t          offset,
+                              int16_t           src_x,
+                              int16_t           src_y,
+                              uint16_t          src_w,
+                              uint16_t          src_h,
+                              int16_t           drw_x,
+                              int16_t           drw_y,
+                              uint16_t          drw_w,
+                              uint16_t          drw_h,
+                              uint16_t          width,
+                              uint16_t          height,
+                              uint8_t           send_event);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xv_shm_put_image (xcb_connection_t *c,
+                      xcb_xv_port_t     port,
+                      xcb_drawable_t    drawable,
+                      xcb_gcontext_t    gc,
+                      xcb_shm_seg_t     shmseg,
+                      uint32_t          id,
+                      uint32_t          offset,
+                      int16_t           src_x,
+                      int16_t           src_y,
+                      uint16_t          src_w,
+                      uint16_t          src_h,
+                      int16_t           drw_x,
+                      int16_t           drw_y,
+                      uint16_t          drw_w,
+                      uint16_t          drw_h,
+                      uint16_t          width,
+                      uint16_t          height,
+                      uint8_t           send_event);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/include/xcb/xvmc.h b/depends/libxcb/include/xcb/xvmc.h
new file mode 100644
index 0000000..6305416
--- /dev/null
+++ b/depends/libxcb/include/xcb/xvmc.h
@@ -0,0 +1,868 @@
+/*
+ * This file generated automatically from xvmc.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+/**
+ * @defgroup XCB_XvMC_API XCB XvMC API
+ * @brief XvMC XCB Protocol Implementation.
+ * @{
+ **/
+
+#ifndef __XVMC_H
+#define __XVMC_H
+
+#include "xcb.h"
+#include "xv.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCB_XVMC_MAJOR_VERSION 1
+#define XCB_XVMC_MINOR_VERSION 1
+
+extern xcb_extension_t xcb_xvmc_id;
+
+typedef uint32_t xcb_xvmc_context_t;
+
+/**
+ * @brief xcb_xvmc_context_iterator_t
+ **/
+typedef struct xcb_xvmc_context_iterator_t {
+    xcb_xvmc_context_t *data;
+    int                 rem;
+    int                 index;
+} xcb_xvmc_context_iterator_t;
+
+typedef uint32_t xcb_xvmc_surface_t;
+
+/**
+ * @brief xcb_xvmc_surface_iterator_t
+ **/
+typedef struct xcb_xvmc_surface_iterator_t {
+    xcb_xvmc_surface_t *data;
+    int                 rem;
+    int                 index;
+} xcb_xvmc_surface_iterator_t;
+
+typedef uint32_t xcb_xvmc_subpicture_t;
+
+/**
+ * @brief xcb_xvmc_subpicture_iterator_t
+ **/
+typedef struct xcb_xvmc_subpicture_iterator_t {
+    xcb_xvmc_subpicture_t *data;
+    int                    rem;
+    int                    index;
+} xcb_xvmc_subpicture_iterator_t;
+
+/**
+ * @brief xcb_xvmc_surface_info_t
+ **/
+typedef struct xcb_xvmc_surface_info_t {
+    xcb_xvmc_surface_t id;
+    uint16_t           chroma_format;
+    uint16_t           pad0;
+    uint16_t           max_width;
+    uint16_t           max_height;
+    uint16_t           subpicture_max_width;
+    uint16_t           subpicture_max_height;
+    uint32_t           mc_type;
+    uint32_t           flags;
+} xcb_xvmc_surface_info_t;
+
+/**
+ * @brief xcb_xvmc_surface_info_iterator_t
+ **/
+typedef struct xcb_xvmc_surface_info_iterator_t {
+    xcb_xvmc_surface_info_t *data;
+    int                      rem;
+    int                      index;
+} xcb_xvmc_surface_info_iterator_t;
+
+/**
+ * @brief xcb_xvmc_query_version_cookie_t
+ **/
+typedef struct xcb_xvmc_query_version_cookie_t {
+    unsigned int sequence;
+} xcb_xvmc_query_version_cookie_t;
+
+/** Opcode for xcb_xvmc_query_version. */
+#define XCB_XVMC_QUERY_VERSION 0
+
+/**
+ * @brief xcb_xvmc_query_version_request_t
+ **/
+typedef struct xcb_xvmc_query_version_request_t {
+    uint8_t  major_opcode;
+    uint8_t  minor_opcode;
+    uint16_t length;
+} xcb_xvmc_query_version_request_t;
+
+/**
+ * @brief xcb_xvmc_query_version_reply_t
+ **/
+typedef struct xcb_xvmc_query_version_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t major;
+    uint32_t minor;
+} xcb_xvmc_query_version_reply_t;
+
+/**
+ * @brief xcb_xvmc_list_surface_types_cookie_t
+ **/
+typedef struct xcb_xvmc_list_surface_types_cookie_t {
+    unsigned int sequence;
+} xcb_xvmc_list_surface_types_cookie_t;
+
+/** Opcode for xcb_xvmc_list_surface_types. */
+#define XCB_XVMC_LIST_SURFACE_TYPES 1
+
+/**
+ * @brief xcb_xvmc_list_surface_types_request_t
+ **/
+typedef struct xcb_xvmc_list_surface_types_request_t {
+    uint8_t       major_opcode;
+    uint8_t       minor_opcode;
+    uint16_t      length;
+    xcb_xv_port_t port_id;
+} xcb_xvmc_list_surface_types_request_t;
+
+/**
+ * @brief xcb_xvmc_list_surface_types_reply_t
+ **/
+typedef struct xcb_xvmc_list_surface_types_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t num;
+    uint8_t  pad1[20];
+} xcb_xvmc_list_surface_types_reply_t;
+
+/**
+ * @brief xcb_xvmc_create_context_cookie_t
+ **/
+typedef struct xcb_xvmc_create_context_cookie_t {
+    unsigned int sequence;
+} xcb_xvmc_create_context_cookie_t;
+
+/** Opcode for xcb_xvmc_create_context. */
+#define XCB_XVMC_CREATE_CONTEXT 2
+
+/**
+ * @brief xcb_xvmc_create_context_request_t
+ **/
+typedef struct xcb_xvmc_create_context_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_xvmc_context_t context_id;
+    xcb_xv_port_t      port_id;
+    xcb_xvmc_surface_t surface_id;
+    uint16_t           width;
+    uint16_t           height;
+    uint32_t           flags;
+} xcb_xvmc_create_context_request_t;
+
+/**
+ * @brief xcb_xvmc_create_context_reply_t
+ **/
+typedef struct xcb_xvmc_create_context_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t width_actual;
+    uint16_t height_actual;
+    uint32_t flags_return;
+    uint8_t  pad1[20];
+} xcb_xvmc_create_context_reply_t;
+
+/** Opcode for xcb_xvmc_destroy_context. */
+#define XCB_XVMC_DESTROY_CONTEXT 3
+
+/**
+ * @brief xcb_xvmc_destroy_context_request_t
+ **/
+typedef struct xcb_xvmc_destroy_context_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_xvmc_context_t context_id;
+} xcb_xvmc_destroy_context_request_t;
+
+/**
+ * @brief xcb_xvmc_create_surface_cookie_t
+ **/
+typedef struct xcb_xvmc_create_surface_cookie_t {
+    unsigned int sequence;
+} xcb_xvmc_create_surface_cookie_t;
+
+/** Opcode for xcb_xvmc_create_surface. */
+#define XCB_XVMC_CREATE_SURFACE 4
+
+/**
+ * @brief xcb_xvmc_create_surface_request_t
+ **/
+typedef struct xcb_xvmc_create_surface_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_xvmc_surface_t surface_id;
+    xcb_xvmc_context_t context_id;
+} xcb_xvmc_create_surface_request_t;
+
+/**
+ * @brief xcb_xvmc_create_surface_reply_t
+ **/
+typedef struct xcb_xvmc_create_surface_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint8_t  pad1[24];
+} xcb_xvmc_create_surface_reply_t;
+
+/** Opcode for xcb_xvmc_destroy_surface. */
+#define XCB_XVMC_DESTROY_SURFACE 5
+
+/**
+ * @brief xcb_xvmc_destroy_surface_request_t
+ **/
+typedef struct xcb_xvmc_destroy_surface_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_xvmc_surface_t surface_id;
+} xcb_xvmc_destroy_surface_request_t;
+
+/**
+ * @brief xcb_xvmc_create_subpicture_cookie_t
+ **/
+typedef struct xcb_xvmc_create_subpicture_cookie_t {
+    unsigned int sequence;
+} xcb_xvmc_create_subpicture_cookie_t;
+
+/** Opcode for xcb_xvmc_create_subpicture. */
+#define XCB_XVMC_CREATE_SUBPICTURE 6
+
+/**
+ * @brief xcb_xvmc_create_subpicture_request_t
+ **/
+typedef struct xcb_xvmc_create_subpicture_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_xvmc_subpicture_t subpicture_id;
+    xcb_xvmc_context_t    context;
+    uint32_t              xvimage_id;
+    uint16_t              width;
+    uint16_t              height;
+} xcb_xvmc_create_subpicture_request_t;
+
+/**
+ * @brief xcb_xvmc_create_subpicture_reply_t
+ **/
+typedef struct xcb_xvmc_create_subpicture_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint16_t width_actual;
+    uint16_t height_actual;
+    uint16_t num_palette_entries;
+    uint16_t entry_bytes;
+    uint8_t  component_order[4];
+    uint8_t  pad1[12];
+} xcb_xvmc_create_subpicture_reply_t;
+
+/** Opcode for xcb_xvmc_destroy_subpicture. */
+#define XCB_XVMC_DESTROY_SUBPICTURE 7
+
+/**
+ * @brief xcb_xvmc_destroy_subpicture_request_t
+ **/
+typedef struct xcb_xvmc_destroy_subpicture_request_t {
+    uint8_t               major_opcode;
+    uint8_t               minor_opcode;
+    uint16_t              length;
+    xcb_xvmc_subpicture_t subpicture_id;
+} xcb_xvmc_destroy_subpicture_request_t;
+
+/**
+ * @brief xcb_xvmc_list_subpicture_types_cookie_t
+ **/
+typedef struct xcb_xvmc_list_subpicture_types_cookie_t {
+    unsigned int sequence;
+} xcb_xvmc_list_subpicture_types_cookie_t;
+
+/** Opcode for xcb_xvmc_list_subpicture_types. */
+#define XCB_XVMC_LIST_SUBPICTURE_TYPES 8
+
+/**
+ * @brief xcb_xvmc_list_subpicture_types_request_t
+ **/
+typedef struct xcb_xvmc_list_subpicture_types_request_t {
+    uint8_t            major_opcode;
+    uint8_t            minor_opcode;
+    uint16_t           length;
+    xcb_xv_port_t      port_id;
+    xcb_xvmc_surface_t surface_id;
+} xcb_xvmc_list_subpicture_types_request_t;
+
+/**
+ * @brief xcb_xvmc_list_subpicture_types_reply_t
+ **/
+typedef struct xcb_xvmc_list_subpicture_types_reply_t {
+    uint8_t  response_type;
+    uint8_t  pad0;
+    uint16_t sequence;
+    uint32_t length;
+    uint32_t num;
+    uint8_t  pad1[20];
+} xcb_xvmc_list_subpicture_types_reply_t;
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xvmc_context_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xvmc_context_t)
+ */
+void
+xcb_xvmc_context_next (xcb_xvmc_context_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xvmc_context_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xvmc_context_end (xcb_xvmc_context_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xvmc_surface_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xvmc_surface_t)
+ */
+void
+xcb_xvmc_surface_next (xcb_xvmc_surface_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xvmc_surface_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xvmc_surface_end (xcb_xvmc_surface_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xvmc_subpicture_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xvmc_subpicture_t)
+ */
+void
+xcb_xvmc_subpicture_next (xcb_xvmc_subpicture_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xvmc_subpicture_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xvmc_subpicture_end (xcb_xvmc_subpicture_iterator_t i);
+
+/**
+ * Get the next element of the iterator
+ * @param i Pointer to a xcb_xvmc_surface_info_iterator_t
+ *
+ * Get the next element in the iterator. The member rem is
+ * decreased by one. The member data points to the next
+ * element. The member index is increased by sizeof(xcb_xvmc_surface_info_t)
+ */
+void
+xcb_xvmc_surface_info_next (xcb_xvmc_surface_info_iterator_t *i);
+
+/**
+ * Return the iterator pointing to the last element
+ * @param i An xcb_xvmc_surface_info_iterator_t
+ * @return  The iterator pointing to the last element
+ *
+ * Set the current element in the iterator to the last element.
+ * The member rem is set to 0. The member data points to the
+ * last element.
+ */
+xcb_generic_iterator_t
+xcb_xvmc_surface_info_end (xcb_xvmc_surface_info_iterator_t i);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xvmc_query_version_cookie_t
+xcb_xvmc_query_version (xcb_connection_t *c);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xvmc_query_version_cookie_t
+xcb_xvmc_query_version_unchecked (xcb_connection_t *c);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xvmc_query_version_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xvmc_query_version_reply_t *
+xcb_xvmc_query_version_reply (xcb_connection_t                 *c,
+                              xcb_xvmc_query_version_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e);
+
+int
+xcb_xvmc_list_surface_types_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xvmc_list_surface_types_cookie_t
+xcb_xvmc_list_surface_types (xcb_connection_t *c,
+                             xcb_xv_port_t     port_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xvmc_list_surface_types_cookie_t
+xcb_xvmc_list_surface_types_unchecked (xcb_connection_t *c,
+                                       xcb_xv_port_t     port_id);
+
+xcb_xvmc_surface_info_t *
+xcb_xvmc_list_surface_types_surfaces (const xcb_xvmc_list_surface_types_reply_t *R);
+
+int
+xcb_xvmc_list_surface_types_surfaces_length (const xcb_xvmc_list_surface_types_reply_t *R);
+
+xcb_xvmc_surface_info_iterator_t
+xcb_xvmc_list_surface_types_surfaces_iterator (const xcb_xvmc_list_surface_types_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xvmc_list_surface_types_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xvmc_list_surface_types_reply_t *
+xcb_xvmc_list_surface_types_reply (xcb_connection_t                      *c,
+                                   xcb_xvmc_list_surface_types_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e);
+
+int
+xcb_xvmc_create_context_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xvmc_create_context_cookie_t
+xcb_xvmc_create_context (xcb_connection_t   *c,
+                         xcb_xvmc_context_t  context_id,
+                         xcb_xv_port_t       port_id,
+                         xcb_xvmc_surface_t  surface_id,
+                         uint16_t            width,
+                         uint16_t            height,
+                         uint32_t            flags);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xvmc_create_context_cookie_t
+xcb_xvmc_create_context_unchecked (xcb_connection_t   *c,
+                                   xcb_xvmc_context_t  context_id,
+                                   xcb_xv_port_t       port_id,
+                                   xcb_xvmc_surface_t  surface_id,
+                                   uint16_t            width,
+                                   uint16_t            height,
+                                   uint32_t            flags);
+
+uint32_t *
+xcb_xvmc_create_context_priv_data (const xcb_xvmc_create_context_reply_t *R);
+
+int
+xcb_xvmc_create_context_priv_data_length (const xcb_xvmc_create_context_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_xvmc_create_context_priv_data_end (const xcb_xvmc_create_context_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xvmc_create_context_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xvmc_create_context_reply_t *
+xcb_xvmc_create_context_reply (xcb_connection_t                  *c,
+                               xcb_xvmc_create_context_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xvmc_destroy_context_checked (xcb_connection_t   *c,
+                                  xcb_xvmc_context_t  context_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xvmc_destroy_context (xcb_connection_t   *c,
+                          xcb_xvmc_context_t  context_id);
+
+int
+xcb_xvmc_create_surface_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xvmc_create_surface_cookie_t
+xcb_xvmc_create_surface (xcb_connection_t   *c,
+                         xcb_xvmc_surface_t  surface_id,
+                         xcb_xvmc_context_t  context_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xvmc_create_surface_cookie_t
+xcb_xvmc_create_surface_unchecked (xcb_connection_t   *c,
+                                   xcb_xvmc_surface_t  surface_id,
+                                   xcb_xvmc_context_t  context_id);
+
+uint32_t *
+xcb_xvmc_create_surface_priv_data (const xcb_xvmc_create_surface_reply_t *R);
+
+int
+xcb_xvmc_create_surface_priv_data_length (const xcb_xvmc_create_surface_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_xvmc_create_surface_priv_data_end (const xcb_xvmc_create_surface_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xvmc_create_surface_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xvmc_create_surface_reply_t *
+xcb_xvmc_create_surface_reply (xcb_connection_t                  *c,
+                               xcb_xvmc_create_surface_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xvmc_destroy_surface_checked (xcb_connection_t   *c,
+                                  xcb_xvmc_surface_t  surface_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xvmc_destroy_surface (xcb_connection_t   *c,
+                          xcb_xvmc_surface_t  surface_id);
+
+int
+xcb_xvmc_create_subpicture_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xvmc_create_subpicture_cookie_t
+xcb_xvmc_create_subpicture (xcb_connection_t      *c,
+                            xcb_xvmc_subpicture_t  subpicture_id,
+                            xcb_xvmc_context_t     context,
+                            uint32_t               xvimage_id,
+                            uint16_t               width,
+                            uint16_t               height);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xvmc_create_subpicture_cookie_t
+xcb_xvmc_create_subpicture_unchecked (xcb_connection_t      *c,
+                                      xcb_xvmc_subpicture_t  subpicture_id,
+                                      xcb_xvmc_context_t     context,
+                                      uint32_t               xvimage_id,
+                                      uint16_t               width,
+                                      uint16_t               height);
+
+uint32_t *
+xcb_xvmc_create_subpicture_priv_data (const xcb_xvmc_create_subpicture_reply_t *R);
+
+int
+xcb_xvmc_create_subpicture_priv_data_length (const xcb_xvmc_create_subpicture_reply_t *R);
+
+xcb_generic_iterator_t
+xcb_xvmc_create_subpicture_priv_data_end (const xcb_xvmc_create_subpicture_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xvmc_create_subpicture_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xvmc_create_subpicture_reply_t *
+xcb_xvmc_create_subpicture_reply (xcb_connection_t                     *c,
+                                  xcb_xvmc_create_subpicture_cookie_t   cookie  /**< */,
+                                  xcb_generic_error_t                 **e);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will not cause
+ * a reply to be generated. Any returned error will be
+ * saved for handling by xcb_request_check().
+ */
+xcb_void_cookie_t
+xcb_xvmc_destroy_subpicture_checked (xcb_connection_t      *c,
+                                     xcb_xvmc_subpicture_t  subpicture_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_void_cookie_t
+xcb_xvmc_destroy_subpicture (xcb_connection_t      *c,
+                             xcb_xvmc_subpicture_t  subpicture_id);
+
+int
+xcb_xvmc_list_subpicture_types_sizeof (const void  *_buffer);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ */
+xcb_xvmc_list_subpicture_types_cookie_t
+xcb_xvmc_list_subpicture_types (xcb_connection_t   *c,
+                                xcb_xv_port_t       port_id,
+                                xcb_xvmc_surface_t  surface_id);
+
+/**
+ *
+ * @param c The connection
+ * @return A cookie
+ *
+ * Delivers a request to the X server.
+ *
+ * This form can be used only if the request will cause
+ * a reply to be generated. Any returned error will be
+ * placed in the event queue.
+ */
+xcb_xvmc_list_subpicture_types_cookie_t
+xcb_xvmc_list_subpicture_types_unchecked (xcb_connection_t   *c,
+                                          xcb_xv_port_t       port_id,
+                                          xcb_xvmc_surface_t  surface_id);
+
+xcb_xv_image_format_info_t *
+xcb_xvmc_list_subpicture_types_types (const xcb_xvmc_list_subpicture_types_reply_t *R);
+
+int
+xcb_xvmc_list_subpicture_types_types_length (const xcb_xvmc_list_subpicture_types_reply_t *R);
+
+xcb_xv_image_format_info_iterator_t
+xcb_xvmc_list_subpicture_types_types_iterator (const xcb_xvmc_list_subpicture_types_reply_t *R);
+
+/**
+ * Return the reply
+ * @param c      The connection
+ * @param cookie The cookie
+ * @param e      The xcb_generic_error_t supplied
+ *
+ * Returns the reply of the request asked by
+ *
+ * The parameter @p e supplied to this function must be NULL if
+ * xcb_xvmc_list_subpicture_types_unchecked(). is used.
+ * Otherwise, it stores the error if any.
+ *
+ * The returned value must be freed by the caller using free().
+ */
+xcb_xvmc_list_subpicture_types_reply_t *
+xcb_xvmc_list_subpicture_types_reply (xcb_connection_t                         *c,
+                                      xcb_xvmc_list_subpicture_types_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/**
+ * @}
+ */
diff --git a/depends/libxcb/src/bigreq.c b/depends/libxcb/src/bigreq.c
new file mode 100644
index 0000000..46f66ca
--- /dev/null
+++ b/depends/libxcb/src/bigreq.c
@@ -0,0 +1,75 @@
+/*
+ * This file generated automatically from bigreq.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "bigreq.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+
+xcb_extension_t xcb_big_requests_id = { "BIG-REQUESTS", 0 };
+
+xcb_big_requests_enable_cookie_t
+xcb_big_requests_enable (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_big_requests_id,
+        .opcode = XCB_BIG_REQUESTS_ENABLE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_big_requests_enable_cookie_t xcb_ret;
+    xcb_big_requests_enable_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_big_requests_enable_cookie_t
+xcb_big_requests_enable_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_big_requests_id,
+        .opcode = XCB_BIG_REQUESTS_ENABLE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_big_requests_enable_cookie_t xcb_ret;
+    xcb_big_requests_enable_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_big_requests_enable_reply_t *
+xcb_big_requests_enable_reply (xcb_connection_t                  *c,
+                               xcb_big_requests_enable_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_big_requests_enable_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
diff --git a/depends/libxcb/src/composite.c b/depends/libxcb/src/composite.c
new file mode 100644
index 0000000..db3efbd
--- /dev/null
+++ b/depends/libxcb/src/composite.c
@@ -0,0 +1,541 @@
+/*
+ * This file generated automatically from composite.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "composite.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xproto.h"
+#include "xfixes.h"
+
+xcb_extension_t xcb_composite_id = { "Composite", 0 };
+
+xcb_composite_query_version_cookie_t
+xcb_composite_query_version (xcb_connection_t *c,
+                             uint32_t          client_major_version,
+                             uint32_t          client_minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_composite_id,
+        .opcode = XCB_COMPOSITE_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_composite_query_version_cookie_t xcb_ret;
+    xcb_composite_query_version_request_t xcb_out;
+
+    xcb_out.client_major_version = client_major_version;
+    xcb_out.client_minor_version = client_minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_composite_query_version_cookie_t
+xcb_composite_query_version_unchecked (xcb_connection_t *c,
+                                       uint32_t          client_major_version,
+                                       uint32_t          client_minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_composite_id,
+        .opcode = XCB_COMPOSITE_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_composite_query_version_cookie_t xcb_ret;
+    xcb_composite_query_version_request_t xcb_out;
+
+    xcb_out.client_major_version = client_major_version;
+    xcb_out.client_minor_version = client_minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_composite_query_version_reply_t *
+xcb_composite_query_version_reply (xcb_connection_t                      *c,
+                                   xcb_composite_query_version_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e)
+{
+    return (xcb_composite_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_composite_redirect_window_checked (xcb_connection_t *c,
+                                       xcb_window_t      window,
+                                       uint8_t           update)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_composite_id,
+        .opcode = XCB_COMPOSITE_REDIRECT_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_composite_redirect_window_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.update = update;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_composite_redirect_window (xcb_connection_t *c,
+                               xcb_window_t      window,
+                               uint8_t           update)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_composite_id,
+        .opcode = XCB_COMPOSITE_REDIRECT_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_composite_redirect_window_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.update = update;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_composite_redirect_subwindows_checked (xcb_connection_t *c,
+                                           xcb_window_t      window,
+                                           uint8_t           update)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_composite_id,
+        .opcode = XCB_COMPOSITE_REDIRECT_SUBWINDOWS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_composite_redirect_subwindows_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.update = update;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_composite_redirect_subwindows (xcb_connection_t *c,
+                                   xcb_window_t      window,
+                                   uint8_t           update)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_composite_id,
+        .opcode = XCB_COMPOSITE_REDIRECT_SUBWINDOWS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_composite_redirect_subwindows_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.update = update;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_composite_unredirect_window_checked (xcb_connection_t *c,
+                                         xcb_window_t      window,
+                                         uint8_t           update)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_composite_id,
+        .opcode = XCB_COMPOSITE_UNREDIRECT_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_composite_unredirect_window_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.update = update;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_composite_unredirect_window (xcb_connection_t *c,
+                                 xcb_window_t      window,
+                                 uint8_t           update)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_composite_id,
+        .opcode = XCB_COMPOSITE_UNREDIRECT_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_composite_unredirect_window_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.update = update;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_composite_unredirect_subwindows_checked (xcb_connection_t *c,
+                                             xcb_window_t      window,
+                                             uint8_t           update)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_composite_id,
+        .opcode = XCB_COMPOSITE_UNREDIRECT_SUBWINDOWS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_composite_unredirect_subwindows_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.update = update;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_composite_unredirect_subwindows (xcb_connection_t *c,
+                                     xcb_window_t      window,
+                                     uint8_t           update)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_composite_id,
+        .opcode = XCB_COMPOSITE_UNREDIRECT_SUBWINDOWS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_composite_unredirect_subwindows_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.update = update;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_composite_create_region_from_border_clip_checked (xcb_connection_t    *c,
+                                                      xcb_xfixes_region_t  region,
+                                                      xcb_window_t         window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_composite_id,
+        .opcode = XCB_COMPOSITE_CREATE_REGION_FROM_BORDER_CLIP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_composite_create_region_from_border_clip_request_t xcb_out;
+
+    xcb_out.region = region;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_composite_create_region_from_border_clip (xcb_connection_t    *c,
+                                              xcb_xfixes_region_t  region,
+                                              xcb_window_t         window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_composite_id,
+        .opcode = XCB_COMPOSITE_CREATE_REGION_FROM_BORDER_CLIP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_composite_create_region_from_border_clip_request_t xcb_out;
+
+    xcb_out.region = region;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_composite_name_window_pixmap_checked (xcb_connection_t *c,
+                                          xcb_window_t      window,
+                                          xcb_pixmap_t      pixmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_composite_id,
+        .opcode = XCB_COMPOSITE_NAME_WINDOW_PIXMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_composite_name_window_pixmap_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.pixmap = pixmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_composite_name_window_pixmap (xcb_connection_t *c,
+                                  xcb_window_t      window,
+                                  xcb_pixmap_t      pixmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_composite_id,
+        .opcode = XCB_COMPOSITE_NAME_WINDOW_PIXMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_composite_name_window_pixmap_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.pixmap = pixmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_composite_get_overlay_window_cookie_t
+xcb_composite_get_overlay_window (xcb_connection_t *c,
+                                  xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_composite_id,
+        .opcode = XCB_COMPOSITE_GET_OVERLAY_WINDOW,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_composite_get_overlay_window_cookie_t xcb_ret;
+    xcb_composite_get_overlay_window_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_composite_get_overlay_window_cookie_t
+xcb_composite_get_overlay_window_unchecked (xcb_connection_t *c,
+                                            xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_composite_id,
+        .opcode = XCB_COMPOSITE_GET_OVERLAY_WINDOW,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_composite_get_overlay_window_cookie_t xcb_ret;
+    xcb_composite_get_overlay_window_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_composite_get_overlay_window_reply_t *
+xcb_composite_get_overlay_window_reply (xcb_connection_t                           *c,
+                                        xcb_composite_get_overlay_window_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e)
+{
+    return (xcb_composite_get_overlay_window_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_composite_release_overlay_window_checked (xcb_connection_t *c,
+                                              xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_composite_id,
+        .opcode = XCB_COMPOSITE_RELEASE_OVERLAY_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_composite_release_overlay_window_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_composite_release_overlay_window (xcb_connection_t *c,
+                                      xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_composite_id,
+        .opcode = XCB_COMPOSITE_RELEASE_OVERLAY_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_composite_release_overlay_window_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
diff --git a/depends/libxcb/src/config.h b/depends/libxcb/src/config.h
new file mode 100644
index 0000000..eec1c1e
--- /dev/null
+++ b/depends/libxcb/src/config.h
@@ -0,0 +1,209 @@
+/* src/config.h.  Generated from config.h.in by configure.  */
+/* src/config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Defined if GCC supports the visibility feature */
+#define GCC_HAS_VISIBILITY /**/
+
+/* Has Wraphelp.c needed for XDM AUTH protocols */
+#define HASXDMAUTH 1
+
+/* Define if your platform supports abstract sockets */
+#define HAVE_ABSTRACT_SOCKETS 1
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* getaddrinfo() function is available */
+#define HAVE_GETADDRINFO 1
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the `is_system_labeled' function. */
+/* #undef HAVE_IS_SYSTEM_LABELED */
+
+/* launchd support available */
+/* #undef HAVE_LAUNCHD */
+
+/* Define to 1 if you have the `ws2_32' library (-lws2_32). */
+/* #undef HAVE_LIBWS2_32 */
+
+/* Define to 1 if you have the <minix/config.h> header file. */
+/* #undef HAVE_MINIX_CONFIG_H */
+
+/* Define if your platform supports sendmsg */
+#define HAVE_SENDMSG 1
+
+/* Have the sockaddr_un.sun_len member. */
+/* #undef HAVE_SOCKADDR_SUN_LEN */
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdio.h> header file. */
+#define HAVE_STDIO_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <tsol/label.h> header file. */
+/* #undef HAVE_TSOL_LABEL_H */
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to 1 if you have the <wchar.h> header file. */
+#define HAVE_WCHAR_H 1
+
+/* Define if not provided by <limits.h> */
+/* #undef IOV_MAX */
+
+/* Define to the sub-directory where libtool stores uninstalled libraries. */
+#define LT_OBJDIR ".libs/"
+
+/* Name of package */
+#define PACKAGE "libxcb"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "https://gitlab.freedesktop.org/xorg/lib/libxcb/issues"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "libxcb"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "libxcb 1.15"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "libxcb"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL ""
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "1.15"
+
+/* Major version of this package */
+#define PACKAGE_VERSION_MAJOR 1
+
+/* Minor version of this package */
+#define PACKAGE_VERSION_MINOR 15
+
+/* Patch version of this package */
+#define PACKAGE_VERSION_PATCHLEVEL 0
+
+/* Define to 1 if all of the C90 standard headers exist (not just the ones
+   required in a freestanding environment). This macro is provided for
+   backward compatibility; new code need not use it. */
+#define STDC_HEADERS 1
+
+/* poll() function is available */
+#define USE_POLL 1
+
+/* Enable extensions on AIX 3, Interix.  */
+#ifndef _ALL_SOURCE
+# define _ALL_SOURCE 1
+#endif
+/* Enable general extensions on macOS.  */
+#ifndef _DARWIN_C_SOURCE
+# define _DARWIN_C_SOURCE 1
+#endif
+/* Enable general extensions on Solaris.  */
+#ifndef __EXTENSIONS__
+# define __EXTENSIONS__ 1
+#endif
+/* Enable GNU extensions on systems that have them.  */
+#ifndef _GNU_SOURCE
+# define _GNU_SOURCE 1
+#endif
+/* Enable X/Open compliant socket functions that do not require linking
+   with -lxnet on HP-UX 11.11.  */
+#ifndef _HPUX_ALT_XOPEN_SOCKET_API
+# define _HPUX_ALT_XOPEN_SOCKET_API 1
+#endif
+/* Identify the host operating system as Minix.
+   This macro does not affect the system headers' behavior.
+   A future release of Autoconf may stop defining this macro.  */
+#ifndef _MINIX
+/* # undef _MINIX */
+#endif
+/* Enable general extensions on NetBSD.
+   Enable NetBSD compatibility extensions on Minix.  */
+#ifndef _NETBSD_SOURCE
+# define _NETBSD_SOURCE 1
+#endif
+/* Enable OpenBSD compatibility extensions on NetBSD.
+   Oddly enough, this does nothing on OpenBSD.  */
+#ifndef _OPENBSD_SOURCE
+# define _OPENBSD_SOURCE 1
+#endif
+/* Define to 1 if needed for POSIX-compatible behavior.  */
+#ifndef _POSIX_SOURCE
+/* # undef _POSIX_SOURCE */
+#endif
+/* Define to 2 if needed for POSIX-compatible behavior.  */
+#ifndef _POSIX_1_SOURCE
+/* # undef _POSIX_1_SOURCE */
+#endif
+/* Enable POSIX-compatible threading on Solaris.  */
+#ifndef _POSIX_PTHREAD_SEMANTICS
+# define _POSIX_PTHREAD_SEMANTICS 1
+#endif
+/* Enable extensions specified by ISO/IEC TS 18661-5:2014.  */
+#ifndef __STDC_WANT_IEC_60559_ATTRIBS_EXT__
+# define __STDC_WANT_IEC_60559_ATTRIBS_EXT__ 1
+#endif
+/* Enable extensions specified by ISO/IEC TS 18661-1:2014.  */
+#ifndef __STDC_WANT_IEC_60559_BFP_EXT__
+# define __STDC_WANT_IEC_60559_BFP_EXT__ 1
+#endif
+/* Enable extensions specified by ISO/IEC TS 18661-2:2015.  */
+#ifndef __STDC_WANT_IEC_60559_DFP_EXT__
+# define __STDC_WANT_IEC_60559_DFP_EXT__ 1
+#endif
+/* Enable extensions specified by ISO/IEC TS 18661-4:2015.  */
+#ifndef __STDC_WANT_IEC_60559_FUNCS_EXT__
+# define __STDC_WANT_IEC_60559_FUNCS_EXT__ 1
+#endif
+/* Enable extensions specified by ISO/IEC TS 18661-3:2015.  */
+#ifndef __STDC_WANT_IEC_60559_TYPES_EXT__
+# define __STDC_WANT_IEC_60559_TYPES_EXT__ 1
+#endif
+/* Enable extensions specified by ISO/IEC TR 24731-2:2010.  */
+#ifndef __STDC_WANT_LIB_EXT2__
+# define __STDC_WANT_LIB_EXT2__ 1
+#endif
+/* Enable extensions specified by ISO/IEC 24747:2009.  */
+#ifndef __STDC_WANT_MATH_SPEC_FUNCS__
+# define __STDC_WANT_MATH_SPEC_FUNCS__ 1
+#endif
+/* Enable extensions on HP NonStop.  */
+#ifndef _TANDEM_SOURCE
+# define _TANDEM_SOURCE 1
+#endif
+/* Enable X/Open extensions.  Define to 500 only if necessary
+   to make mbstate_t available.  */
+#ifndef _XOPEN_SOURCE
+/* # undef _XOPEN_SOURCE */
+#endif
+
+
+/* Version number of package */
+#define VERSION "1.15"
+
+/* XCB buffer queue size */
+#define XCB_QUEUE_BUFFER_SIZE 16384
+
+/* Defined if needed to expose struct msghdr.msg_control */
+/* #undef _XOPEN_SOURCE */
diff --git a/depends/libxcb/src/damage.c b/depends/libxcb/src/damage.c
new file mode 100644
index 0000000..e84a5b9
--- /dev/null
+++ b/depends/libxcb/src/damage.c
@@ -0,0 +1,333 @@
+/*
+ * This file generated automatically from damage.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "damage.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xproto.h"
+#include "xfixes.h"
+
+xcb_extension_t xcb_damage_id = { "DAMAGE", 0 };
+
+void
+xcb_damage_damage_next (xcb_damage_damage_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_damage_damage_t);
+}
+
+xcb_generic_iterator_t
+xcb_damage_damage_end (xcb_damage_damage_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+xcb_damage_query_version_cookie_t
+xcb_damage_query_version (xcb_connection_t *c,
+                          uint32_t          client_major_version,
+                          uint32_t          client_minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_damage_id,
+        .opcode = XCB_DAMAGE_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_damage_query_version_cookie_t xcb_ret;
+    xcb_damage_query_version_request_t xcb_out;
+
+    xcb_out.client_major_version = client_major_version;
+    xcb_out.client_minor_version = client_minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_damage_query_version_cookie_t
+xcb_damage_query_version_unchecked (xcb_connection_t *c,
+                                    uint32_t          client_major_version,
+                                    uint32_t          client_minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_damage_id,
+        .opcode = XCB_DAMAGE_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_damage_query_version_cookie_t xcb_ret;
+    xcb_damage_query_version_request_t xcb_out;
+
+    xcb_out.client_major_version = client_major_version;
+    xcb_out.client_minor_version = client_minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_damage_query_version_reply_t *
+xcb_damage_query_version_reply (xcb_connection_t                   *c,
+                                xcb_damage_query_version_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e)
+{
+    return (xcb_damage_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_damage_create_checked (xcb_connection_t    *c,
+                           xcb_damage_damage_t  damage,
+                           xcb_drawable_t       drawable,
+                           uint8_t              level)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_damage_id,
+        .opcode = XCB_DAMAGE_CREATE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_damage_create_request_t xcb_out;
+
+    xcb_out.damage = damage;
+    xcb_out.drawable = drawable;
+    xcb_out.level = level;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_damage_create (xcb_connection_t    *c,
+                   xcb_damage_damage_t  damage,
+                   xcb_drawable_t       drawable,
+                   uint8_t              level)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_damage_id,
+        .opcode = XCB_DAMAGE_CREATE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_damage_create_request_t xcb_out;
+
+    xcb_out.damage = damage;
+    xcb_out.drawable = drawable;
+    xcb_out.level = level;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_damage_destroy_checked (xcb_connection_t    *c,
+                            xcb_damage_damage_t  damage)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_damage_id,
+        .opcode = XCB_DAMAGE_DESTROY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_damage_destroy_request_t xcb_out;
+
+    xcb_out.damage = damage;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_damage_destroy (xcb_connection_t    *c,
+                    xcb_damage_damage_t  damage)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_damage_id,
+        .opcode = XCB_DAMAGE_DESTROY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_damage_destroy_request_t xcb_out;
+
+    xcb_out.damage = damage;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_damage_subtract_checked (xcb_connection_t    *c,
+                             xcb_damage_damage_t  damage,
+                             xcb_xfixes_region_t  repair,
+                             xcb_xfixes_region_t  parts)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_damage_id,
+        .opcode = XCB_DAMAGE_SUBTRACT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_damage_subtract_request_t xcb_out;
+
+    xcb_out.damage = damage;
+    xcb_out.repair = repair;
+    xcb_out.parts = parts;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_damage_subtract (xcb_connection_t    *c,
+                     xcb_damage_damage_t  damage,
+                     xcb_xfixes_region_t  repair,
+                     xcb_xfixes_region_t  parts)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_damage_id,
+        .opcode = XCB_DAMAGE_SUBTRACT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_damage_subtract_request_t xcb_out;
+
+    xcb_out.damage = damage;
+    xcb_out.repair = repair;
+    xcb_out.parts = parts;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_damage_add_checked (xcb_connection_t    *c,
+                        xcb_drawable_t       drawable,
+                        xcb_xfixes_region_t  region)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_damage_id,
+        .opcode = XCB_DAMAGE_ADD,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_damage_add_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.region = region;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_damage_add (xcb_connection_t    *c,
+                xcb_drawable_t       drawable,
+                xcb_xfixes_region_t  region)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_damage_id,
+        .opcode = XCB_DAMAGE_ADD,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_damage_add_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.region = region;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
diff --git a/depends/libxcb/src/dpms.c b/depends/libxcb/src/dpms.c
new file mode 100644
index 0000000..e1020d4
--- /dev/null
+++ b/depends/libxcb/src/dpms.c
@@ -0,0 +1,459 @@
+/*
+ * This file generated automatically from dpms.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "dpms.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+
+xcb_extension_t xcb_dpms_id = { "DPMS", 0 };
+
+xcb_dpms_get_version_cookie_t
+xcb_dpms_get_version (xcb_connection_t *c,
+                      uint16_t          client_major_version,
+                      uint16_t          client_minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dpms_id,
+        .opcode = XCB_DPMS_GET_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dpms_get_version_cookie_t xcb_ret;
+    xcb_dpms_get_version_request_t xcb_out;
+
+    xcb_out.client_major_version = client_major_version;
+    xcb_out.client_minor_version = client_minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dpms_get_version_cookie_t
+xcb_dpms_get_version_unchecked (xcb_connection_t *c,
+                                uint16_t          client_major_version,
+                                uint16_t          client_minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dpms_id,
+        .opcode = XCB_DPMS_GET_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dpms_get_version_cookie_t xcb_ret;
+    xcb_dpms_get_version_request_t xcb_out;
+
+    xcb_out.client_major_version = client_major_version;
+    xcb_out.client_minor_version = client_minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dpms_get_version_reply_t *
+xcb_dpms_get_version_reply (xcb_connection_t               *c,
+                            xcb_dpms_get_version_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e)
+{
+    return (xcb_dpms_get_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_dpms_capable_cookie_t
+xcb_dpms_capable (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dpms_id,
+        .opcode = XCB_DPMS_CAPABLE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dpms_capable_cookie_t xcb_ret;
+    xcb_dpms_capable_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dpms_capable_cookie_t
+xcb_dpms_capable_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dpms_id,
+        .opcode = XCB_DPMS_CAPABLE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dpms_capable_cookie_t xcb_ret;
+    xcb_dpms_capable_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dpms_capable_reply_t *
+xcb_dpms_capable_reply (xcb_connection_t           *c,
+                        xcb_dpms_capable_cookie_t   cookie  /**< */,
+                        xcb_generic_error_t       **e)
+{
+    return (xcb_dpms_capable_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_dpms_get_timeouts_cookie_t
+xcb_dpms_get_timeouts (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dpms_id,
+        .opcode = XCB_DPMS_GET_TIMEOUTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dpms_get_timeouts_cookie_t xcb_ret;
+    xcb_dpms_get_timeouts_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dpms_get_timeouts_cookie_t
+xcb_dpms_get_timeouts_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dpms_id,
+        .opcode = XCB_DPMS_GET_TIMEOUTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dpms_get_timeouts_cookie_t xcb_ret;
+    xcb_dpms_get_timeouts_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dpms_get_timeouts_reply_t *
+xcb_dpms_get_timeouts_reply (xcb_connection_t                *c,
+                             xcb_dpms_get_timeouts_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_dpms_get_timeouts_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_dpms_set_timeouts_checked (xcb_connection_t *c,
+                               uint16_t          standby_timeout,
+                               uint16_t          suspend_timeout,
+                               uint16_t          off_timeout)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dpms_id,
+        .opcode = XCB_DPMS_SET_TIMEOUTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dpms_set_timeouts_request_t xcb_out;
+
+    xcb_out.standby_timeout = standby_timeout;
+    xcb_out.suspend_timeout = suspend_timeout;
+    xcb_out.off_timeout = off_timeout;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_dpms_set_timeouts (xcb_connection_t *c,
+                       uint16_t          standby_timeout,
+                       uint16_t          suspend_timeout,
+                       uint16_t          off_timeout)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dpms_id,
+        .opcode = XCB_DPMS_SET_TIMEOUTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dpms_set_timeouts_request_t xcb_out;
+
+    xcb_out.standby_timeout = standby_timeout;
+    xcb_out.suspend_timeout = suspend_timeout;
+    xcb_out.off_timeout = off_timeout;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_dpms_enable_checked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dpms_id,
+        .opcode = XCB_DPMS_ENABLE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dpms_enable_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_dpms_enable (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dpms_id,
+        .opcode = XCB_DPMS_ENABLE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dpms_enable_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_dpms_disable_checked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dpms_id,
+        .opcode = XCB_DPMS_DISABLE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dpms_disable_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_dpms_disable (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dpms_id,
+        .opcode = XCB_DPMS_DISABLE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dpms_disable_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_dpms_force_level_checked (xcb_connection_t *c,
+                              uint16_t          power_level)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dpms_id,
+        .opcode = XCB_DPMS_FORCE_LEVEL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dpms_force_level_request_t xcb_out;
+
+    xcb_out.power_level = power_level;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_dpms_force_level (xcb_connection_t *c,
+                      uint16_t          power_level)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dpms_id,
+        .opcode = XCB_DPMS_FORCE_LEVEL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dpms_force_level_request_t xcb_out;
+
+    xcb_out.power_level = power_level;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dpms_info_cookie_t
+xcb_dpms_info (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dpms_id,
+        .opcode = XCB_DPMS_INFO,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dpms_info_cookie_t xcb_ret;
+    xcb_dpms_info_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dpms_info_cookie_t
+xcb_dpms_info_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dpms_id,
+        .opcode = XCB_DPMS_INFO,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dpms_info_cookie_t xcb_ret;
+    xcb_dpms_info_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dpms_info_reply_t *
+xcb_dpms_info_reply (xcb_connection_t        *c,
+                     xcb_dpms_info_cookie_t   cookie  /**< */,
+                     xcb_generic_error_t    **e)
+{
+    return (xcb_dpms_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
diff --git a/depends/libxcb/src/dri2.c b/depends/libxcb/src/dri2.c
new file mode 100644
index 0000000..a8bcf6a
--- /dev/null
+++ b/depends/libxcb/src/dri2.c
@@ -0,0 +1,1227 @@
+/*
+ * This file generated automatically from dri2.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "dri2.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xproto.h"
+
+xcb_extension_t xcb_dri2_id = { "DRI2", 0 };
+
+void
+xcb_dri2_dri2_buffer_next (xcb_dri2_dri2_buffer_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_dri2_dri2_buffer_t);
+}
+
+xcb_generic_iterator_t
+xcb_dri2_dri2_buffer_end (xcb_dri2_dri2_buffer_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_dri2_attach_format_next (xcb_dri2_attach_format_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_dri2_attach_format_t);
+}
+
+xcb_generic_iterator_t
+xcb_dri2_attach_format_end (xcb_dri2_attach_format_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+xcb_dri2_query_version_cookie_t
+xcb_dri2_query_version (xcb_connection_t *c,
+                        uint32_t          major_version,
+                        uint32_t          minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri2_query_version_cookie_t xcb_ret;
+    xcb_dri2_query_version_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_query_version_cookie_t
+xcb_dri2_query_version_unchecked (xcb_connection_t *c,
+                                  uint32_t          major_version,
+                                  uint32_t          minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri2_query_version_cookie_t xcb_ret;
+    xcb_dri2_query_version_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_query_version_reply_t *
+xcb_dri2_query_version_reply (xcb_connection_t                 *c,
+                              xcb_dri2_query_version_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_dri2_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_dri2_connect_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_dri2_connect_reply_t *_aux = (xcb_dri2_connect_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_dri2_connect_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* driver_name */
+    xcb_block_len += _aux->driver_name_length * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* alignment_pad */
+    xcb_block_len += (((_aux->driver_name_length + 3) & (~3)) - _aux->driver_name_length) * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* device_name */
+    xcb_block_len += _aux->device_name_length * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_dri2_connect_cookie_t
+xcb_dri2_connect (xcb_connection_t *c,
+                  xcb_window_t      window,
+                  uint32_t          driver_type)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_CONNECT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri2_connect_cookie_t xcb_ret;
+    xcb_dri2_connect_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.driver_type = driver_type;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_connect_cookie_t
+xcb_dri2_connect_unchecked (xcb_connection_t *c,
+                            xcb_window_t      window,
+                            uint32_t          driver_type)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_CONNECT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri2_connect_cookie_t xcb_ret;
+    xcb_dri2_connect_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.driver_type = driver_type;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_dri2_connect_driver_name (const xcb_dri2_connect_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_dri2_connect_driver_name_length (const xcb_dri2_connect_reply_t *R)
+{
+    return R->driver_name_length;
+}
+
+xcb_generic_iterator_t
+xcb_dri2_connect_driver_name_end (const xcb_dri2_connect_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->driver_name_length);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void *
+xcb_dri2_connect_alignment_pad (const xcb_dri2_connect_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_dri2_connect_driver_name_end(R);
+    return (void *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0);
+}
+
+int
+xcb_dri2_connect_alignment_pad_length (const xcb_dri2_connect_reply_t *R)
+{
+    return (((R->driver_name_length + 3) & (~3)) - R->driver_name_length);
+}
+
+xcb_generic_iterator_t
+xcb_dri2_connect_alignment_pad_end (const xcb_dri2_connect_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_dri2_connect_driver_name_end(R);
+    i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + ((((R->driver_name_length + 3) & (~3)) - R->driver_name_length));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+char *
+xcb_dri2_connect_device_name (const xcb_dri2_connect_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_dri2_connect_alignment_pad_end(R);
+    return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0);
+}
+
+int
+xcb_dri2_connect_device_name_length (const xcb_dri2_connect_reply_t *R)
+{
+    return R->device_name_length;
+}
+
+xcb_generic_iterator_t
+xcb_dri2_connect_device_name_end (const xcb_dri2_connect_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_dri2_connect_alignment_pad_end(R);
+    i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->device_name_length);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_dri2_connect_reply_t *
+xcb_dri2_connect_reply (xcb_connection_t           *c,
+                        xcb_dri2_connect_cookie_t   cookie  /**< */,
+                        xcb_generic_error_t       **e)
+{
+    return (xcb_dri2_connect_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_dri2_authenticate_cookie_t
+xcb_dri2_authenticate (xcb_connection_t *c,
+                       xcb_window_t      window,
+                       uint32_t          magic)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_AUTHENTICATE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri2_authenticate_cookie_t xcb_ret;
+    xcb_dri2_authenticate_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.magic = magic;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_authenticate_cookie_t
+xcb_dri2_authenticate_unchecked (xcb_connection_t *c,
+                                 xcb_window_t      window,
+                                 uint32_t          magic)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_AUTHENTICATE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri2_authenticate_cookie_t xcb_ret;
+    xcb_dri2_authenticate_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.magic = magic;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_authenticate_reply_t *
+xcb_dri2_authenticate_reply (xcb_connection_t                *c,
+                             xcb_dri2_authenticate_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_dri2_authenticate_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_dri2_create_drawable_checked (xcb_connection_t *c,
+                                  xcb_drawable_t    drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_CREATE_DRAWABLE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dri2_create_drawable_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_dri2_create_drawable (xcb_connection_t *c,
+                          xcb_drawable_t    drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_CREATE_DRAWABLE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dri2_create_drawable_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_dri2_destroy_drawable_checked (xcb_connection_t *c,
+                                   xcb_drawable_t    drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_DESTROY_DRAWABLE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dri2_destroy_drawable_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_dri2_destroy_drawable (xcb_connection_t *c,
+                           xcb_drawable_t    drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_DESTROY_DRAWABLE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dri2_destroy_drawable_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_dri2_get_buffers_sizeof (const void  *_buffer,
+                             uint32_t     attachments_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_dri2_get_buffers_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* attachments */
+    xcb_block_len += attachments_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_dri2_get_buffers_cookie_t
+xcb_dri2_get_buffers (xcb_connection_t *c,
+                      xcb_drawable_t    drawable,
+                      uint32_t          count,
+                      uint32_t          attachments_len,
+                      const uint32_t   *attachments)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_GET_BUFFERS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_dri2_get_buffers_cookie_t xcb_ret;
+    xcb_dri2_get_buffers_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.count = count;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t attachments */
+    xcb_parts[4].iov_base = (char *) attachments;
+    xcb_parts[4].iov_len = attachments_len * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_get_buffers_cookie_t
+xcb_dri2_get_buffers_unchecked (xcb_connection_t *c,
+                                xcb_drawable_t    drawable,
+                                uint32_t          count,
+                                uint32_t          attachments_len,
+                                const uint32_t   *attachments)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_GET_BUFFERS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_dri2_get_buffers_cookie_t xcb_ret;
+    xcb_dri2_get_buffers_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.count = count;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t attachments */
+    xcb_parts[4].iov_base = (char *) attachments;
+    xcb_parts[4].iov_len = attachments_len * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_dri2_buffer_t *
+xcb_dri2_get_buffers_buffers (const xcb_dri2_get_buffers_reply_t *R)
+{
+    return (xcb_dri2_dri2_buffer_t *) (R + 1);
+}
+
+int
+xcb_dri2_get_buffers_buffers_length (const xcb_dri2_get_buffers_reply_t *R)
+{
+    return R->count;
+}
+
+xcb_dri2_dri2_buffer_iterator_t
+xcb_dri2_get_buffers_buffers_iterator (const xcb_dri2_get_buffers_reply_t *R)
+{
+    xcb_dri2_dri2_buffer_iterator_t i;
+    i.data = (xcb_dri2_dri2_buffer_t *) (R + 1);
+    i.rem = R->count;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_dri2_get_buffers_reply_t *
+xcb_dri2_get_buffers_reply (xcb_connection_t               *c,
+                            xcb_dri2_get_buffers_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e)
+{
+    return (xcb_dri2_get_buffers_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_dri2_copy_region_cookie_t
+xcb_dri2_copy_region (xcb_connection_t *c,
+                      xcb_drawable_t    drawable,
+                      uint32_t          region,
+                      uint32_t          dest,
+                      uint32_t          src)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_COPY_REGION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri2_copy_region_cookie_t xcb_ret;
+    xcb_dri2_copy_region_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.region = region;
+    xcb_out.dest = dest;
+    xcb_out.src = src;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_copy_region_cookie_t
+xcb_dri2_copy_region_unchecked (xcb_connection_t *c,
+                                xcb_drawable_t    drawable,
+                                uint32_t          region,
+                                uint32_t          dest,
+                                uint32_t          src)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_COPY_REGION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri2_copy_region_cookie_t xcb_ret;
+    xcb_dri2_copy_region_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.region = region;
+    xcb_out.dest = dest;
+    xcb_out.src = src;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_copy_region_reply_t *
+xcb_dri2_copy_region_reply (xcb_connection_t               *c,
+                            xcb_dri2_copy_region_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e)
+{
+    return (xcb_dri2_copy_region_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_dri2_get_buffers_with_format_sizeof (const void  *_buffer,
+                                         uint32_t     attachments_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_dri2_get_buffers_with_format_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* attachments */
+    xcb_block_len += attachments_len * sizeof(xcb_dri2_attach_format_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_dri2_attach_format_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_dri2_get_buffers_with_format_cookie_t
+xcb_dri2_get_buffers_with_format (xcb_connection_t               *c,
+                                  xcb_drawable_t                  drawable,
+                                  uint32_t                        count,
+                                  uint32_t                        attachments_len,
+                                  const xcb_dri2_attach_format_t *attachments)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_GET_BUFFERS_WITH_FORMAT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_dri2_get_buffers_with_format_cookie_t xcb_ret;
+    xcb_dri2_get_buffers_with_format_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.count = count;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_dri2_attach_format_t attachments */
+    xcb_parts[4].iov_base = (char *) attachments;
+    xcb_parts[4].iov_len = attachments_len * sizeof(xcb_dri2_attach_format_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_get_buffers_with_format_cookie_t
+xcb_dri2_get_buffers_with_format_unchecked (xcb_connection_t               *c,
+                                            xcb_drawable_t                  drawable,
+                                            uint32_t                        count,
+                                            uint32_t                        attachments_len,
+                                            const xcb_dri2_attach_format_t *attachments)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_GET_BUFFERS_WITH_FORMAT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_dri2_get_buffers_with_format_cookie_t xcb_ret;
+    xcb_dri2_get_buffers_with_format_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.count = count;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_dri2_attach_format_t attachments */
+    xcb_parts[4].iov_base = (char *) attachments;
+    xcb_parts[4].iov_len = attachments_len * sizeof(xcb_dri2_attach_format_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_dri2_buffer_t *
+xcb_dri2_get_buffers_with_format_buffers (const xcb_dri2_get_buffers_with_format_reply_t *R)
+{
+    return (xcb_dri2_dri2_buffer_t *) (R + 1);
+}
+
+int
+xcb_dri2_get_buffers_with_format_buffers_length (const xcb_dri2_get_buffers_with_format_reply_t *R)
+{
+    return R->count;
+}
+
+xcb_dri2_dri2_buffer_iterator_t
+xcb_dri2_get_buffers_with_format_buffers_iterator (const xcb_dri2_get_buffers_with_format_reply_t *R)
+{
+    xcb_dri2_dri2_buffer_iterator_t i;
+    i.data = (xcb_dri2_dri2_buffer_t *) (R + 1);
+    i.rem = R->count;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_dri2_get_buffers_with_format_reply_t *
+xcb_dri2_get_buffers_with_format_reply (xcb_connection_t                           *c,
+                                        xcb_dri2_get_buffers_with_format_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e)
+{
+    return (xcb_dri2_get_buffers_with_format_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_dri2_swap_buffers_cookie_t
+xcb_dri2_swap_buffers (xcb_connection_t *c,
+                       xcb_drawable_t    drawable,
+                       uint32_t          target_msc_hi,
+                       uint32_t          target_msc_lo,
+                       uint32_t          divisor_hi,
+                       uint32_t          divisor_lo,
+                       uint32_t          remainder_hi,
+                       uint32_t          remainder_lo)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_SWAP_BUFFERS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri2_swap_buffers_cookie_t xcb_ret;
+    xcb_dri2_swap_buffers_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.target_msc_hi = target_msc_hi;
+    xcb_out.target_msc_lo = target_msc_lo;
+    xcb_out.divisor_hi = divisor_hi;
+    xcb_out.divisor_lo = divisor_lo;
+    xcb_out.remainder_hi = remainder_hi;
+    xcb_out.remainder_lo = remainder_lo;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_swap_buffers_cookie_t
+xcb_dri2_swap_buffers_unchecked (xcb_connection_t *c,
+                                 xcb_drawable_t    drawable,
+                                 uint32_t          target_msc_hi,
+                                 uint32_t          target_msc_lo,
+                                 uint32_t          divisor_hi,
+                                 uint32_t          divisor_lo,
+                                 uint32_t          remainder_hi,
+                                 uint32_t          remainder_lo)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_SWAP_BUFFERS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri2_swap_buffers_cookie_t xcb_ret;
+    xcb_dri2_swap_buffers_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.target_msc_hi = target_msc_hi;
+    xcb_out.target_msc_lo = target_msc_lo;
+    xcb_out.divisor_hi = divisor_hi;
+    xcb_out.divisor_lo = divisor_lo;
+    xcb_out.remainder_hi = remainder_hi;
+    xcb_out.remainder_lo = remainder_lo;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_swap_buffers_reply_t *
+xcb_dri2_swap_buffers_reply (xcb_connection_t                *c,
+                             xcb_dri2_swap_buffers_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_dri2_swap_buffers_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_dri2_get_msc_cookie_t
+xcb_dri2_get_msc (xcb_connection_t *c,
+                  xcb_drawable_t    drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_GET_MSC,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri2_get_msc_cookie_t xcb_ret;
+    xcb_dri2_get_msc_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_get_msc_cookie_t
+xcb_dri2_get_msc_unchecked (xcb_connection_t *c,
+                            xcb_drawable_t    drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_GET_MSC,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri2_get_msc_cookie_t xcb_ret;
+    xcb_dri2_get_msc_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_get_msc_reply_t *
+xcb_dri2_get_msc_reply (xcb_connection_t           *c,
+                        xcb_dri2_get_msc_cookie_t   cookie  /**< */,
+                        xcb_generic_error_t       **e)
+{
+    return (xcb_dri2_get_msc_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_dri2_wait_msc_cookie_t
+xcb_dri2_wait_msc (xcb_connection_t *c,
+                   xcb_drawable_t    drawable,
+                   uint32_t          target_msc_hi,
+                   uint32_t          target_msc_lo,
+                   uint32_t          divisor_hi,
+                   uint32_t          divisor_lo,
+                   uint32_t          remainder_hi,
+                   uint32_t          remainder_lo)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_WAIT_MSC,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri2_wait_msc_cookie_t xcb_ret;
+    xcb_dri2_wait_msc_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.target_msc_hi = target_msc_hi;
+    xcb_out.target_msc_lo = target_msc_lo;
+    xcb_out.divisor_hi = divisor_hi;
+    xcb_out.divisor_lo = divisor_lo;
+    xcb_out.remainder_hi = remainder_hi;
+    xcb_out.remainder_lo = remainder_lo;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_wait_msc_cookie_t
+xcb_dri2_wait_msc_unchecked (xcb_connection_t *c,
+                             xcb_drawable_t    drawable,
+                             uint32_t          target_msc_hi,
+                             uint32_t          target_msc_lo,
+                             uint32_t          divisor_hi,
+                             uint32_t          divisor_lo,
+                             uint32_t          remainder_hi,
+                             uint32_t          remainder_lo)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_WAIT_MSC,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri2_wait_msc_cookie_t xcb_ret;
+    xcb_dri2_wait_msc_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.target_msc_hi = target_msc_hi;
+    xcb_out.target_msc_lo = target_msc_lo;
+    xcb_out.divisor_hi = divisor_hi;
+    xcb_out.divisor_lo = divisor_lo;
+    xcb_out.remainder_hi = remainder_hi;
+    xcb_out.remainder_lo = remainder_lo;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_wait_msc_reply_t *
+xcb_dri2_wait_msc_reply (xcb_connection_t            *c,
+                         xcb_dri2_wait_msc_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e)
+{
+    return (xcb_dri2_wait_msc_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_dri2_wait_sbc_cookie_t
+xcb_dri2_wait_sbc (xcb_connection_t *c,
+                   xcb_drawable_t    drawable,
+                   uint32_t          target_sbc_hi,
+                   uint32_t          target_sbc_lo)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_WAIT_SBC,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri2_wait_sbc_cookie_t xcb_ret;
+    xcb_dri2_wait_sbc_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.target_sbc_hi = target_sbc_hi;
+    xcb_out.target_sbc_lo = target_sbc_lo;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_wait_sbc_cookie_t
+xcb_dri2_wait_sbc_unchecked (xcb_connection_t *c,
+                             xcb_drawable_t    drawable,
+                             uint32_t          target_sbc_hi,
+                             uint32_t          target_sbc_lo)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_WAIT_SBC,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri2_wait_sbc_cookie_t xcb_ret;
+    xcb_dri2_wait_sbc_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.target_sbc_hi = target_sbc_hi;
+    xcb_out.target_sbc_lo = target_sbc_lo;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_wait_sbc_reply_t *
+xcb_dri2_wait_sbc_reply (xcb_connection_t            *c,
+                         xcb_dri2_wait_sbc_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e)
+{
+    return (xcb_dri2_wait_sbc_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_dri2_swap_interval_checked (xcb_connection_t *c,
+                                xcb_drawable_t    drawable,
+                                uint32_t          interval)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_SWAP_INTERVAL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dri2_swap_interval_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.interval = interval;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_dri2_swap_interval (xcb_connection_t *c,
+                        xcb_drawable_t    drawable,
+                        uint32_t          interval)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_SWAP_INTERVAL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dri2_swap_interval_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.interval = interval;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_get_param_cookie_t
+xcb_dri2_get_param (xcb_connection_t *c,
+                    xcb_drawable_t    drawable,
+                    uint32_t          param)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_GET_PARAM,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri2_get_param_cookie_t xcb_ret;
+    xcb_dri2_get_param_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.param = param;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_get_param_cookie_t
+xcb_dri2_get_param_unchecked (xcb_connection_t *c,
+                              xcb_drawable_t    drawable,
+                              uint32_t          param)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri2_id,
+        .opcode = XCB_DRI2_GET_PARAM,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri2_get_param_cookie_t xcb_ret;
+    xcb_dri2_get_param_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.param = param;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri2_get_param_reply_t *
+xcb_dri2_get_param_reply (xcb_connection_t             *c,
+                          xcb_dri2_get_param_cookie_t   cookie  /**< */,
+                          xcb_generic_error_t         **e)
+{
+    return (xcb_dri2_get_param_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
diff --git a/depends/libxcb/src/dri3.c b/depends/libxcb/src/dri3.c
new file mode 100644
index 0000000..d423935
--- /dev/null
+++ b/depends/libxcb/src/dri3.c
@@ -0,0 +1,979 @@
+/*
+ * This file generated automatically from dri3.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "dri3.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xproto.h"
+
+xcb_extension_t xcb_dri3_id = { "DRI3", 0 };
+
+xcb_dri3_query_version_cookie_t
+xcb_dri3_query_version (xcb_connection_t *c,
+                        uint32_t          major_version,
+                        uint32_t          minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri3_id,
+        .opcode = XCB_DRI3_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri3_query_version_cookie_t xcb_ret;
+    xcb_dri3_query_version_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri3_query_version_cookie_t
+xcb_dri3_query_version_unchecked (xcb_connection_t *c,
+                                  uint32_t          major_version,
+                                  uint32_t          minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri3_id,
+        .opcode = XCB_DRI3_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri3_query_version_cookie_t xcb_ret;
+    xcb_dri3_query_version_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri3_query_version_reply_t *
+xcb_dri3_query_version_reply (xcb_connection_t                 *c,
+                              xcb_dri3_query_version_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_dri3_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_dri3_open_cookie_t
+xcb_dri3_open (xcb_connection_t *c,
+               xcb_drawable_t    drawable,
+               uint32_t          provider)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri3_id,
+        .opcode = XCB_DRI3_OPEN,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri3_open_cookie_t xcb_ret;
+    xcb_dri3_open_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.provider = provider;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED|XCB_REQUEST_REPLY_FDS, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri3_open_cookie_t
+xcb_dri3_open_unchecked (xcb_connection_t *c,
+                         xcb_drawable_t    drawable,
+                         uint32_t          provider)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri3_id,
+        .opcode = XCB_DRI3_OPEN,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri3_open_cookie_t xcb_ret;
+    xcb_dri3_open_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.provider = provider;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_REPLY_FDS, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri3_open_reply_t *
+xcb_dri3_open_reply (xcb_connection_t        *c,
+                     xcb_dri3_open_cookie_t   cookie  /**< */,
+                     xcb_generic_error_t    **e)
+{
+    return (xcb_dri3_open_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int *
+xcb_dri3_open_reply_fds (xcb_connection_t       *c  /**< */,
+                         xcb_dri3_open_reply_t  *reply)
+{
+    return xcb_get_reply_fds(c, reply, sizeof(xcb_dri3_open_reply_t) + 4 * reply->length);
+}
+
+xcb_void_cookie_t
+xcb_dri3_pixmap_from_buffer_checked (xcb_connection_t *c,
+                                     xcb_pixmap_t      pixmap,
+                                     xcb_drawable_t    drawable,
+                                     uint32_t          size,
+                                     uint16_t          width,
+                                     uint16_t          height,
+                                     uint16_t          stride,
+                                     uint8_t           depth,
+                                     uint8_t           bpp,
+                                     int32_t           pixmap_fd)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri3_id,
+        .opcode = XCB_DRI3_PIXMAP_FROM_BUFFER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dri3_pixmap_from_buffer_request_t xcb_out;
+    int fds[1];
+    int fd_index = 0;
+
+    xcb_out.pixmap = pixmap;
+    xcb_out.drawable = drawable;
+    xcb_out.size = size;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.stride = stride;
+    xcb_out.depth = depth;
+    xcb_out.bpp = bpp;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    fds[fd_index++] = pixmap_fd;
+    xcb_ret.sequence = xcb_send_request_with_fds(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req, 1, fds);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_dri3_pixmap_from_buffer (xcb_connection_t *c,
+                             xcb_pixmap_t      pixmap,
+                             xcb_drawable_t    drawable,
+                             uint32_t          size,
+                             uint16_t          width,
+                             uint16_t          height,
+                             uint16_t          stride,
+                             uint8_t           depth,
+                             uint8_t           bpp,
+                             int32_t           pixmap_fd)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri3_id,
+        .opcode = XCB_DRI3_PIXMAP_FROM_BUFFER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dri3_pixmap_from_buffer_request_t xcb_out;
+    int fds[1];
+    int fd_index = 0;
+
+    xcb_out.pixmap = pixmap;
+    xcb_out.drawable = drawable;
+    xcb_out.size = size;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.stride = stride;
+    xcb_out.depth = depth;
+    xcb_out.bpp = bpp;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    fds[fd_index++] = pixmap_fd;
+    xcb_ret.sequence = xcb_send_request_with_fds(c, 0, xcb_parts + 2, &xcb_req, 1, fds);
+    return xcb_ret;
+}
+
+xcb_dri3_buffer_from_pixmap_cookie_t
+xcb_dri3_buffer_from_pixmap (xcb_connection_t *c,
+                             xcb_pixmap_t      pixmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri3_id,
+        .opcode = XCB_DRI3_BUFFER_FROM_PIXMAP,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri3_buffer_from_pixmap_cookie_t xcb_ret;
+    xcb_dri3_buffer_from_pixmap_request_t xcb_out;
+
+    xcb_out.pixmap = pixmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED|XCB_REQUEST_REPLY_FDS, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri3_buffer_from_pixmap_cookie_t
+xcb_dri3_buffer_from_pixmap_unchecked (xcb_connection_t *c,
+                                       xcb_pixmap_t      pixmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri3_id,
+        .opcode = XCB_DRI3_BUFFER_FROM_PIXMAP,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri3_buffer_from_pixmap_cookie_t xcb_ret;
+    xcb_dri3_buffer_from_pixmap_request_t xcb_out;
+
+    xcb_out.pixmap = pixmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_REPLY_FDS, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri3_buffer_from_pixmap_reply_t *
+xcb_dri3_buffer_from_pixmap_reply (xcb_connection_t                      *c,
+                                   xcb_dri3_buffer_from_pixmap_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e)
+{
+    return (xcb_dri3_buffer_from_pixmap_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int *
+xcb_dri3_buffer_from_pixmap_reply_fds (xcb_connection_t                     *c  /**< */,
+                                       xcb_dri3_buffer_from_pixmap_reply_t  *reply)
+{
+    return xcb_get_reply_fds(c, reply, sizeof(xcb_dri3_buffer_from_pixmap_reply_t) + 4 * reply->length);
+}
+
+xcb_void_cookie_t
+xcb_dri3_fence_from_fd_checked (xcb_connection_t *c,
+                                xcb_drawable_t    drawable,
+                                uint32_t          fence,
+                                uint8_t           initially_triggered,
+                                int32_t           fence_fd)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri3_id,
+        .opcode = XCB_DRI3_FENCE_FROM_FD,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dri3_fence_from_fd_request_t xcb_out;
+    int fds[1];
+    int fd_index = 0;
+
+    xcb_out.drawable = drawable;
+    xcb_out.fence = fence;
+    xcb_out.initially_triggered = initially_triggered;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    fds[fd_index++] = fence_fd;
+    xcb_ret.sequence = xcb_send_request_with_fds(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req, 1, fds);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_dri3_fence_from_fd (xcb_connection_t *c,
+                        xcb_drawable_t    drawable,
+                        uint32_t          fence,
+                        uint8_t           initially_triggered,
+                        int32_t           fence_fd)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri3_id,
+        .opcode = XCB_DRI3_FENCE_FROM_FD,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dri3_fence_from_fd_request_t xcb_out;
+    int fds[1];
+    int fd_index = 0;
+
+    xcb_out.drawable = drawable;
+    xcb_out.fence = fence;
+    xcb_out.initially_triggered = initially_triggered;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    fds[fd_index++] = fence_fd;
+    xcb_ret.sequence = xcb_send_request_with_fds(c, 0, xcb_parts + 2, &xcb_req, 1, fds);
+    return xcb_ret;
+}
+
+xcb_dri3_fd_from_fence_cookie_t
+xcb_dri3_fd_from_fence (xcb_connection_t *c,
+                        xcb_drawable_t    drawable,
+                        uint32_t          fence)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri3_id,
+        .opcode = XCB_DRI3_FD_FROM_FENCE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri3_fd_from_fence_cookie_t xcb_ret;
+    xcb_dri3_fd_from_fence_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.fence = fence;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED|XCB_REQUEST_REPLY_FDS, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri3_fd_from_fence_cookie_t
+xcb_dri3_fd_from_fence_unchecked (xcb_connection_t *c,
+                                  xcb_drawable_t    drawable,
+                                  uint32_t          fence)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri3_id,
+        .opcode = XCB_DRI3_FD_FROM_FENCE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri3_fd_from_fence_cookie_t xcb_ret;
+    xcb_dri3_fd_from_fence_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.fence = fence;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_REPLY_FDS, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri3_fd_from_fence_reply_t *
+xcb_dri3_fd_from_fence_reply (xcb_connection_t                 *c,
+                              xcb_dri3_fd_from_fence_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_dri3_fd_from_fence_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int *
+xcb_dri3_fd_from_fence_reply_fds (xcb_connection_t                *c  /**< */,
+                                  xcb_dri3_fd_from_fence_reply_t  *reply)
+{
+    return xcb_get_reply_fds(c, reply, sizeof(xcb_dri3_fd_from_fence_reply_t) + 4 * reply->length);
+}
+
+int
+xcb_dri3_get_supported_modifiers_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_dri3_get_supported_modifiers_reply_t *_aux = (xcb_dri3_get_supported_modifiers_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_dri3_get_supported_modifiers_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* window_modifiers */
+    xcb_block_len += _aux->num_window_modifiers * sizeof(uint64_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint64_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* screen_modifiers */
+    xcb_block_len += _aux->num_screen_modifiers * sizeof(uint64_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint64_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_dri3_get_supported_modifiers_cookie_t
+xcb_dri3_get_supported_modifiers (xcb_connection_t *c,
+                                  uint32_t          window,
+                                  uint8_t           depth,
+                                  uint8_t           bpp)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri3_id,
+        .opcode = XCB_DRI3_GET_SUPPORTED_MODIFIERS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri3_get_supported_modifiers_cookie_t xcb_ret;
+    xcb_dri3_get_supported_modifiers_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.depth = depth;
+    xcb_out.bpp = bpp;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri3_get_supported_modifiers_cookie_t
+xcb_dri3_get_supported_modifiers_unchecked (xcb_connection_t *c,
+                                            uint32_t          window,
+                                            uint8_t           depth,
+                                            uint8_t           bpp)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri3_id,
+        .opcode = XCB_DRI3_GET_SUPPORTED_MODIFIERS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri3_get_supported_modifiers_cookie_t xcb_ret;
+    xcb_dri3_get_supported_modifiers_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.depth = depth;
+    xcb_out.bpp = bpp;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint64_t *
+xcb_dri3_get_supported_modifiers_window_modifiers (const xcb_dri3_get_supported_modifiers_reply_t *R)
+{
+    return (uint64_t *) (R + 1);
+}
+
+int
+xcb_dri3_get_supported_modifiers_window_modifiers_length (const xcb_dri3_get_supported_modifiers_reply_t *R)
+{
+    return R->num_window_modifiers;
+}
+
+xcb_generic_iterator_t
+xcb_dri3_get_supported_modifiers_window_modifiers_end (const xcb_dri3_get_supported_modifiers_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint64_t *) (R + 1)) + (R->num_window_modifiers);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint64_t *
+xcb_dri3_get_supported_modifiers_screen_modifiers (const xcb_dri3_get_supported_modifiers_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_dri3_get_supported_modifiers_window_modifiers_end(R);
+    return (uint64_t *) ((char *) prev.data + XCB_TYPE_PAD(uint64_t, prev.index) + 0);
+}
+
+int
+xcb_dri3_get_supported_modifiers_screen_modifiers_length (const xcb_dri3_get_supported_modifiers_reply_t *R)
+{
+    return R->num_screen_modifiers;
+}
+
+xcb_generic_iterator_t
+xcb_dri3_get_supported_modifiers_screen_modifiers_end (const xcb_dri3_get_supported_modifiers_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_dri3_get_supported_modifiers_window_modifiers_end(R);
+    i.data = ((uint64_t *) ((char*) prev.data + XCB_TYPE_PAD(uint64_t, prev.index))) + (R->num_screen_modifiers);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_dri3_get_supported_modifiers_reply_t *
+xcb_dri3_get_supported_modifiers_reply (xcb_connection_t                           *c,
+                                        xcb_dri3_get_supported_modifiers_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e)
+{
+    return (xcb_dri3_get_supported_modifiers_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_dri3_pixmap_from_buffers_checked (xcb_connection_t *c,
+                                      xcb_pixmap_t      pixmap,
+                                      xcb_window_t      window,
+                                      uint8_t           num_buffers,
+                                      uint16_t          width,
+                                      uint16_t          height,
+                                      uint32_t          stride0,
+                                      uint32_t          offset0,
+                                      uint32_t          stride1,
+                                      uint32_t          offset1,
+                                      uint32_t          stride2,
+                                      uint32_t          offset2,
+                                      uint32_t          stride3,
+                                      uint32_t          offset3,
+                                      uint8_t           depth,
+                                      uint8_t           bpp,
+                                      uint64_t          modifier,
+                                      const int32_t    *buffers)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri3_id,
+        .opcode = XCB_DRI3_PIXMAP_FROM_BUFFERS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dri3_pixmap_from_buffers_request_t xcb_out;
+    unsigned int i;
+    int fds[num_buffers];
+    int fd_index = 0;
+
+    xcb_out.pixmap = pixmap;
+    xcb_out.window = window;
+    xcb_out.num_buffers = num_buffers;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.stride0 = stride0;
+    xcb_out.offset0 = offset0;
+    xcb_out.stride1 = stride1;
+    xcb_out.offset1 = offset1;
+    xcb_out.stride2 = stride2;
+    xcb_out.offset2 = offset2;
+    xcb_out.stride3 = stride3;
+    xcb_out.offset3 = offset3;
+    xcb_out.depth = depth;
+    xcb_out.bpp = bpp;
+    memset(xcb_out.pad1, 0, 2);
+    xcb_out.modifier = modifier;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    for (i = 0; i < num_buffers; i++)
+        fds[fd_index++] = buffers[i];
+    xcb_ret.sequence = xcb_send_request_with_fds(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req, num_buffers, fds);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_dri3_pixmap_from_buffers (xcb_connection_t *c,
+                              xcb_pixmap_t      pixmap,
+                              xcb_window_t      window,
+                              uint8_t           num_buffers,
+                              uint16_t          width,
+                              uint16_t          height,
+                              uint32_t          stride0,
+                              uint32_t          offset0,
+                              uint32_t          stride1,
+                              uint32_t          offset1,
+                              uint32_t          stride2,
+                              uint32_t          offset2,
+                              uint32_t          stride3,
+                              uint32_t          offset3,
+                              uint8_t           depth,
+                              uint8_t           bpp,
+                              uint64_t          modifier,
+                              const int32_t    *buffers)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri3_id,
+        .opcode = XCB_DRI3_PIXMAP_FROM_BUFFERS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dri3_pixmap_from_buffers_request_t xcb_out;
+    unsigned int i;
+    int fds[num_buffers];
+    int fd_index = 0;
+
+    xcb_out.pixmap = pixmap;
+    xcb_out.window = window;
+    xcb_out.num_buffers = num_buffers;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.stride0 = stride0;
+    xcb_out.offset0 = offset0;
+    xcb_out.stride1 = stride1;
+    xcb_out.offset1 = offset1;
+    xcb_out.stride2 = stride2;
+    xcb_out.offset2 = offset2;
+    xcb_out.stride3 = stride3;
+    xcb_out.offset3 = offset3;
+    xcb_out.depth = depth;
+    xcb_out.bpp = bpp;
+    memset(xcb_out.pad1, 0, 2);
+    xcb_out.modifier = modifier;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    for (i = 0; i < num_buffers; i++)
+        fds[fd_index++] = buffers[i];
+    xcb_ret.sequence = xcb_send_request_with_fds(c, 0, xcb_parts + 2, &xcb_req, num_buffers, fds);
+    return xcb_ret;
+}
+
+int
+xcb_dri3_buffers_from_pixmap_sizeof (const void  *_buffer,
+                                     int32_t      buffers)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_dri3_buffers_from_pixmap_reply_t *_aux = (xcb_dri3_buffers_from_pixmap_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_dri3_buffers_from_pixmap_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* strides */
+    xcb_block_len += _aux->nfd * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* offsets */
+    xcb_block_len += _aux->nfd * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_dri3_buffers_from_pixmap_cookie_t
+xcb_dri3_buffers_from_pixmap (xcb_connection_t *c,
+                              xcb_pixmap_t      pixmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri3_id,
+        .opcode = XCB_DRI3_BUFFERS_FROM_PIXMAP,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri3_buffers_from_pixmap_cookie_t xcb_ret;
+    xcb_dri3_buffers_from_pixmap_request_t xcb_out;
+
+    xcb_out.pixmap = pixmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED|XCB_REQUEST_REPLY_FDS, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_dri3_buffers_from_pixmap_cookie_t
+xcb_dri3_buffers_from_pixmap_unchecked (xcb_connection_t *c,
+                                        xcb_pixmap_t      pixmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri3_id,
+        .opcode = XCB_DRI3_BUFFERS_FROM_PIXMAP,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_dri3_buffers_from_pixmap_cookie_t xcb_ret;
+    xcb_dri3_buffers_from_pixmap_request_t xcb_out;
+
+    xcb_out.pixmap = pixmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_REPLY_FDS, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_dri3_buffers_from_pixmap_strides (const xcb_dri3_buffers_from_pixmap_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_dri3_buffers_from_pixmap_strides_length (const xcb_dri3_buffers_from_pixmap_reply_t *R)
+{
+    return R->nfd;
+}
+
+xcb_generic_iterator_t
+xcb_dri3_buffers_from_pixmap_strides_end (const xcb_dri3_buffers_from_pixmap_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->nfd);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint32_t *
+xcb_dri3_buffers_from_pixmap_offsets (const xcb_dri3_buffers_from_pixmap_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_dri3_buffers_from_pixmap_strides_end(R);
+    return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0);
+}
+
+int
+xcb_dri3_buffers_from_pixmap_offsets_length (const xcb_dri3_buffers_from_pixmap_reply_t *R)
+{
+    return R->nfd;
+}
+
+xcb_generic_iterator_t
+xcb_dri3_buffers_from_pixmap_offsets_end (const xcb_dri3_buffers_from_pixmap_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_dri3_buffers_from_pixmap_strides_end(R);
+    i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->nfd);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int32_t *
+xcb_dri3_buffers_from_pixmap_buffers (const xcb_dri3_buffers_from_pixmap_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_dri3_buffers_from_pixmap_offsets_end(R);
+    return (int32_t *) ((char *) prev.data + XCB_TYPE_PAD(int32_t, prev.index) + 0);
+}
+
+int
+xcb_dri3_buffers_from_pixmap_buffers_length (const xcb_dri3_buffers_from_pixmap_reply_t *R)
+{
+    return R->nfd;
+}
+
+xcb_generic_iterator_t
+xcb_dri3_buffers_from_pixmap_buffers_end (const xcb_dri3_buffers_from_pixmap_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_dri3_buffers_from_pixmap_offsets_end(R);
+    i.data = ((int32_t *) ((char*) prev.data + XCB_TYPE_PAD(int32_t, prev.index))) + (R->nfd);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_dri3_buffers_from_pixmap_reply_t *
+xcb_dri3_buffers_from_pixmap_reply (xcb_connection_t                       *c,
+                                    xcb_dri3_buffers_from_pixmap_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e)
+{
+    return (xcb_dri3_buffers_from_pixmap_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int *
+xcb_dri3_buffers_from_pixmap_reply_fds (xcb_connection_t                      *c  /**< */,
+                                        xcb_dri3_buffers_from_pixmap_reply_t  *reply)
+{
+    return xcb_get_reply_fds(c, reply, sizeof(xcb_dri3_buffers_from_pixmap_reply_t) + 4 * reply->length);
+}
+
+xcb_void_cookie_t
+xcb_dri3_set_drm_device_in_use_checked (xcb_connection_t *c,
+                                        xcb_window_t      window,
+                                        uint32_t          drmMajor,
+                                        uint32_t          drmMinor)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri3_id,
+        .opcode = XCB_DRI3_SET_DRM_DEVICE_IN_USE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dri3_set_drm_device_in_use_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.drmMajor = drmMajor;
+    xcb_out.drmMinor = drmMinor;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_dri3_set_drm_device_in_use (xcb_connection_t *c,
+                                xcb_window_t      window,
+                                uint32_t          drmMajor,
+                                uint32_t          drmMinor)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_dri3_id,
+        .opcode = XCB_DRI3_SET_DRM_DEVICE_IN_USE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_dri3_set_drm_device_in_use_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.drmMajor = drmMajor;
+    xcb_out.drmMinor = drmMinor;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
diff --git a/depends/libxcb/src/ge.c b/depends/libxcb/src/ge.c
new file mode 100644
index 0000000..6f370b7
--- /dev/null
+++ b/depends/libxcb/src/ge.c
@@ -0,0 +1,83 @@
+/*
+ * This file generated automatically from ge.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "ge.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+
+xcb_extension_t xcb_genericevent_id = { "Generic Event Extension", 0 };
+
+xcb_genericevent_query_version_cookie_t
+xcb_genericevent_query_version (xcb_connection_t *c,
+                                uint16_t          client_major_version,
+                                uint16_t          client_minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_genericevent_id,
+        .opcode = XCB_GENERICEVENT_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_genericevent_query_version_cookie_t xcb_ret;
+    xcb_genericevent_query_version_request_t xcb_out;
+
+    xcb_out.client_major_version = client_major_version;
+    xcb_out.client_minor_version = client_minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_genericevent_query_version_cookie_t
+xcb_genericevent_query_version_unchecked (xcb_connection_t *c,
+                                          uint16_t          client_major_version,
+                                          uint16_t          client_minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_genericevent_id,
+        .opcode = XCB_GENERICEVENT_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_genericevent_query_version_cookie_t xcb_ret;
+    xcb_genericevent_query_version_request_t xcb_out;
+
+    xcb_out.client_major_version = client_major_version;
+    xcb_out.client_minor_version = client_minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_genericevent_query_version_reply_t *
+xcb_genericevent_query_version_reply (xcb_connection_t                         *c,
+                                      xcb_genericevent_query_version_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e)
+{
+    return (xcb_genericevent_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
diff --git a/depends/libxcb/src/glx.c b/depends/libxcb/src/glx.c
new file mode 100644
index 0000000..ba37e60
--- /dev/null
+++ b/depends/libxcb/src/glx.c
@@ -0,0 +1,10730 @@
+/*
+ * This file generated automatically from glx.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "glx.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xproto.h"
+
+xcb_extension_t xcb_glx_id = { "GLX", 0 };
+
+void
+xcb_glx_pixmap_next (xcb_glx_pixmap_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_glx_pixmap_t);
+}
+
+xcb_generic_iterator_t
+xcb_glx_pixmap_end (xcb_glx_pixmap_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_glx_context_next (xcb_glx_context_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_glx_context_t);
+}
+
+xcb_generic_iterator_t
+xcb_glx_context_end (xcb_glx_context_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_glx_pbuffer_next (xcb_glx_pbuffer_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_glx_pbuffer_t);
+}
+
+xcb_generic_iterator_t
+xcb_glx_pbuffer_end (xcb_glx_pbuffer_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_glx_window_next (xcb_glx_window_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_glx_window_t);
+}
+
+xcb_generic_iterator_t
+xcb_glx_window_end (xcb_glx_window_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_glx_fbconfig_next (xcb_glx_fbconfig_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_glx_fbconfig_t);
+}
+
+xcb_generic_iterator_t
+xcb_glx_fbconfig_end (xcb_glx_fbconfig_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_glx_drawable_next (xcb_glx_drawable_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_glx_drawable_t);
+}
+
+xcb_generic_iterator_t
+xcb_glx_drawable_end (xcb_glx_drawable_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_glx_float32_next (xcb_glx_float32_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_glx_float32_t);
+}
+
+xcb_generic_iterator_t
+xcb_glx_float32_end (xcb_glx_float32_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_glx_float64_next (xcb_glx_float64_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_glx_float64_t);
+}
+
+xcb_generic_iterator_t
+xcb_glx_float64_end (xcb_glx_float64_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_glx_bool32_next (xcb_glx_bool32_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_glx_bool32_t);
+}
+
+xcb_generic_iterator_t
+xcb_glx_bool32_end (xcb_glx_bool32_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_glx_context_tag_next (xcb_glx_context_tag_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_glx_context_tag_t);
+}
+
+xcb_generic_iterator_t
+xcb_glx_context_tag_end (xcb_glx_context_tag_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_glx_render_sizeof (const void  *_buffer,
+                       uint32_t     data_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_render_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += data_len * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_glx_render_checked (xcb_connection_t      *c,
+                        xcb_glx_context_tag_t  context_tag,
+                        uint32_t               data_len,
+                        const uint8_t         *data)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_RENDER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_render_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t data */
+    xcb_parts[4].iov_base = (char *) data;
+    xcb_parts[4].iov_len = data_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_render (xcb_connection_t      *c,
+                xcb_glx_context_tag_t  context_tag,
+                uint32_t               data_len,
+                const uint8_t         *data)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_RENDER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_render_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t data */
+    xcb_parts[4].iov_base = (char *) data;
+    xcb_parts[4].iov_len = data_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_glx_render_data (const xcb_glx_render_request_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_glx_render_data_length (const xcb_glx_render_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_glx_render_request_t))/sizeof(uint8_t));
+}
+
+xcb_generic_iterator_t
+xcb_glx_render_data_end (const xcb_glx_render_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_glx_render_request_t))/sizeof(uint8_t)));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_glx_render_large_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_render_large_request_t *_aux = (xcb_glx_render_large_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_render_large_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->data_len * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_glx_render_large_checked (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              uint16_t               request_num,
+                              uint16_t               request_total,
+                              uint32_t               data_len,
+                              const uint8_t         *data)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_RENDER_LARGE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_render_large_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.request_num = request_num;
+    xcb_out.request_total = request_total;
+    xcb_out.data_len = data_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t data */
+    xcb_parts[4].iov_base = (char *) data;
+    xcb_parts[4].iov_len = data_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_render_large (xcb_connection_t      *c,
+                      xcb_glx_context_tag_t  context_tag,
+                      uint16_t               request_num,
+                      uint16_t               request_total,
+                      uint32_t               data_len,
+                      const uint8_t         *data)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_RENDER_LARGE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_render_large_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.request_num = request_num;
+    xcb_out.request_total = request_total;
+    xcb_out.data_len = data_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t data */
+    xcb_parts[4].iov_base = (char *) data;
+    xcb_parts[4].iov_len = data_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_glx_render_large_data (const xcb_glx_render_large_request_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_glx_render_large_data_length (const xcb_glx_render_large_request_t *R)
+{
+    return R->data_len;
+}
+
+xcb_generic_iterator_t
+xcb_glx_render_large_data_end (const xcb_glx_render_large_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + (R->data_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_glx_create_context_checked (xcb_connection_t  *c,
+                                xcb_glx_context_t  context,
+                                xcb_visualid_t     visual,
+                                uint32_t           screen,
+                                xcb_glx_context_t  share_list,
+                                uint8_t            is_direct)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_CREATE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_create_context_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.visual = visual;
+    xcb_out.screen = screen;
+    xcb_out.share_list = share_list;
+    xcb_out.is_direct = is_direct;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_create_context (xcb_connection_t  *c,
+                        xcb_glx_context_t  context,
+                        xcb_visualid_t     visual,
+                        uint32_t           screen,
+                        xcb_glx_context_t  share_list,
+                        uint8_t            is_direct)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_CREATE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_create_context_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.visual = visual;
+    xcb_out.screen = screen;
+    xcb_out.share_list = share_list;
+    xcb_out.is_direct = is_direct;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_destroy_context_checked (xcb_connection_t  *c,
+                                 xcb_glx_context_t  context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_DESTROY_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_destroy_context_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_destroy_context (xcb_connection_t  *c,
+                         xcb_glx_context_t  context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_DESTROY_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_destroy_context_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_make_current_cookie_t
+xcb_glx_make_current (xcb_connection_t      *c,
+                      xcb_glx_drawable_t     drawable,
+                      xcb_glx_context_t      context,
+                      xcb_glx_context_tag_t  old_context_tag)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_MAKE_CURRENT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_make_current_cookie_t xcb_ret;
+    xcb_glx_make_current_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.context = context;
+    xcb_out.old_context_tag = old_context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_make_current_cookie_t
+xcb_glx_make_current_unchecked (xcb_connection_t      *c,
+                                xcb_glx_drawable_t     drawable,
+                                xcb_glx_context_t      context,
+                                xcb_glx_context_tag_t  old_context_tag)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_MAKE_CURRENT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_make_current_cookie_t xcb_ret;
+    xcb_glx_make_current_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.context = context;
+    xcb_out.old_context_tag = old_context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_make_current_reply_t *
+xcb_glx_make_current_reply (xcb_connection_t               *c,
+                            xcb_glx_make_current_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e)
+{
+    return (xcb_glx_make_current_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_glx_is_direct_cookie_t
+xcb_glx_is_direct (xcb_connection_t  *c,
+                   xcb_glx_context_t  context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_IS_DIRECT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_is_direct_cookie_t xcb_ret;
+    xcb_glx_is_direct_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_is_direct_cookie_t
+xcb_glx_is_direct_unchecked (xcb_connection_t  *c,
+                             xcb_glx_context_t  context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_IS_DIRECT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_is_direct_cookie_t xcb_ret;
+    xcb_glx_is_direct_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_is_direct_reply_t *
+xcb_glx_is_direct_reply (xcb_connection_t            *c,
+                         xcb_glx_is_direct_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e)
+{
+    return (xcb_glx_is_direct_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_glx_query_version_cookie_t
+xcb_glx_query_version (xcb_connection_t *c,
+                       uint32_t          major_version,
+                       uint32_t          minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_query_version_cookie_t xcb_ret;
+    xcb_glx_query_version_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_query_version_cookie_t
+xcb_glx_query_version_unchecked (xcb_connection_t *c,
+                                 uint32_t          major_version,
+                                 uint32_t          minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_query_version_cookie_t xcb_ret;
+    xcb_glx_query_version_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_query_version_reply_t *
+xcb_glx_query_version_reply (xcb_connection_t                *c,
+                             xcb_glx_query_version_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_glx_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_glx_wait_gl_checked (xcb_connection_t      *c,
+                         xcb_glx_context_tag_t  context_tag)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_WAIT_GL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_wait_gl_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_wait_gl (xcb_connection_t      *c,
+                 xcb_glx_context_tag_t  context_tag)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_WAIT_GL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_wait_gl_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_wait_x_checked (xcb_connection_t      *c,
+                        xcb_glx_context_tag_t  context_tag)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_WAIT_X,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_wait_x_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_wait_x (xcb_connection_t      *c,
+                xcb_glx_context_tag_t  context_tag)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_WAIT_X,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_wait_x_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_copy_context_checked (xcb_connection_t      *c,
+                              xcb_glx_context_t      src,
+                              xcb_glx_context_t      dest,
+                              uint32_t               mask,
+                              xcb_glx_context_tag_t  src_context_tag)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_COPY_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_copy_context_request_t xcb_out;
+
+    xcb_out.src = src;
+    xcb_out.dest = dest;
+    xcb_out.mask = mask;
+    xcb_out.src_context_tag = src_context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_copy_context (xcb_connection_t      *c,
+                      xcb_glx_context_t      src,
+                      xcb_glx_context_t      dest,
+                      uint32_t               mask,
+                      xcb_glx_context_tag_t  src_context_tag)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_COPY_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_copy_context_request_t xcb_out;
+
+    xcb_out.src = src;
+    xcb_out.dest = dest;
+    xcb_out.mask = mask;
+    xcb_out.src_context_tag = src_context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_swap_buffers_checked (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              xcb_glx_drawable_t     drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_SWAP_BUFFERS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_swap_buffers_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_swap_buffers (xcb_connection_t      *c,
+                      xcb_glx_context_tag_t  context_tag,
+                      xcb_glx_drawable_t     drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_SWAP_BUFFERS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_swap_buffers_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_use_x_font_checked (xcb_connection_t      *c,
+                            xcb_glx_context_tag_t  context_tag,
+                            xcb_font_t             font,
+                            uint32_t               first,
+                            uint32_t               count,
+                            uint32_t               list_base)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_USE_X_FONT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_use_x_font_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.font = font;
+    xcb_out.first = first;
+    xcb_out.count = count;
+    xcb_out.list_base = list_base;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_use_x_font (xcb_connection_t      *c,
+                    xcb_glx_context_tag_t  context_tag,
+                    xcb_font_t             font,
+                    uint32_t               first,
+                    uint32_t               count,
+                    uint32_t               list_base)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_USE_X_FONT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_use_x_font_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.font = font;
+    xcb_out.first = first;
+    xcb_out.count = count;
+    xcb_out.list_base = list_base;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_create_glx_pixmap_checked (xcb_connection_t *c,
+                                   uint32_t          screen,
+                                   xcb_visualid_t    visual,
+                                   xcb_pixmap_t      pixmap,
+                                   xcb_glx_pixmap_t  glx_pixmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_CREATE_GLX_PIXMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_create_glx_pixmap_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.visual = visual;
+    xcb_out.pixmap = pixmap;
+    xcb_out.glx_pixmap = glx_pixmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_create_glx_pixmap (xcb_connection_t *c,
+                           uint32_t          screen,
+                           xcb_visualid_t    visual,
+                           xcb_pixmap_t      pixmap,
+                           xcb_glx_pixmap_t  glx_pixmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_CREATE_GLX_PIXMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_create_glx_pixmap_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.visual = visual;
+    xcb_out.pixmap = pixmap;
+    xcb_out.glx_pixmap = glx_pixmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_glx_get_visual_configs_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_visual_configs_reply_t *_aux = (xcb_glx_get_visual_configs_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_visual_configs_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* property_list */
+    xcb_block_len += _aux->length * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_visual_configs_cookie_t
+xcb_glx_get_visual_configs (xcb_connection_t *c,
+                            uint32_t          screen)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_VISUAL_CONFIGS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_visual_configs_cookie_t xcb_ret;
+    xcb_glx_get_visual_configs_request_t xcb_out;
+
+    xcb_out.screen = screen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_visual_configs_cookie_t
+xcb_glx_get_visual_configs_unchecked (xcb_connection_t *c,
+                                      uint32_t          screen)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_VISUAL_CONFIGS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_visual_configs_cookie_t xcb_ret;
+    xcb_glx_get_visual_configs_request_t xcb_out;
+
+    xcb_out.screen = screen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_glx_get_visual_configs_property_list (const xcb_glx_get_visual_configs_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_visual_configs_property_list_length (const xcb_glx_get_visual_configs_reply_t *R)
+{
+    return R->length;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_visual_configs_property_list_end (const xcb_glx_get_visual_configs_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->length);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_visual_configs_reply_t *
+xcb_glx_get_visual_configs_reply (xcb_connection_t                     *c,
+                                  xcb_glx_get_visual_configs_cookie_t   cookie  /**< */,
+                                  xcb_generic_error_t                 **e)
+{
+    return (xcb_glx_get_visual_configs_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_glx_destroy_glx_pixmap_checked (xcb_connection_t *c,
+                                    xcb_glx_pixmap_t  glx_pixmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_DESTROY_GLX_PIXMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_destroy_glx_pixmap_request_t xcb_out;
+
+    xcb_out.glx_pixmap = glx_pixmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_destroy_glx_pixmap (xcb_connection_t *c,
+                            xcb_glx_pixmap_t  glx_pixmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_DESTROY_GLX_PIXMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_destroy_glx_pixmap_request_t xcb_out;
+
+    xcb_out.glx_pixmap = glx_pixmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_glx_vendor_private_sizeof (const void  *_buffer,
+                               uint32_t     data_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_vendor_private_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += data_len * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_glx_vendor_private_checked (xcb_connection_t      *c,
+                                uint32_t               vendor_code,
+                                xcb_glx_context_tag_t  context_tag,
+                                uint32_t               data_len,
+                                const uint8_t         *data)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_VENDOR_PRIVATE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_vendor_private_request_t xcb_out;
+
+    xcb_out.vendor_code = vendor_code;
+    xcb_out.context_tag = context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t data */
+    xcb_parts[4].iov_base = (char *) data;
+    xcb_parts[4].iov_len = data_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_vendor_private (xcb_connection_t      *c,
+                        uint32_t               vendor_code,
+                        xcb_glx_context_tag_t  context_tag,
+                        uint32_t               data_len,
+                        const uint8_t         *data)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_VENDOR_PRIVATE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_vendor_private_request_t xcb_out;
+
+    xcb_out.vendor_code = vendor_code;
+    xcb_out.context_tag = context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t data */
+    xcb_parts[4].iov_base = (char *) data;
+    xcb_parts[4].iov_len = data_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_glx_vendor_private_data (const xcb_glx_vendor_private_request_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_glx_vendor_private_data_length (const xcb_glx_vendor_private_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_glx_vendor_private_request_t))/sizeof(uint8_t));
+}
+
+xcb_generic_iterator_t
+xcb_glx_vendor_private_data_end (const xcb_glx_vendor_private_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_glx_vendor_private_request_t))/sizeof(uint8_t)));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_glx_vendor_private_with_reply_sizeof (const void  *_buffer,
+                                          uint32_t     data_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_vendor_private_with_reply_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += data_len * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_vendor_private_with_reply_cookie_t
+xcb_glx_vendor_private_with_reply (xcb_connection_t      *c,
+                                   uint32_t               vendor_code,
+                                   xcb_glx_context_tag_t  context_tag,
+                                   uint32_t               data_len,
+                                   const uint8_t         *data)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_VENDOR_PRIVATE_WITH_REPLY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_glx_vendor_private_with_reply_cookie_t xcb_ret;
+    xcb_glx_vendor_private_with_reply_request_t xcb_out;
+
+    xcb_out.vendor_code = vendor_code;
+    xcb_out.context_tag = context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t data */
+    xcb_parts[4].iov_base = (char *) data;
+    xcb_parts[4].iov_len = data_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_vendor_private_with_reply_cookie_t
+xcb_glx_vendor_private_with_reply_unchecked (xcb_connection_t      *c,
+                                             uint32_t               vendor_code,
+                                             xcb_glx_context_tag_t  context_tag,
+                                             uint32_t               data_len,
+                                             const uint8_t         *data)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_VENDOR_PRIVATE_WITH_REPLY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_glx_vendor_private_with_reply_cookie_t xcb_ret;
+    xcb_glx_vendor_private_with_reply_request_t xcb_out;
+
+    xcb_out.vendor_code = vendor_code;
+    xcb_out.context_tag = context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t data */
+    xcb_parts[4].iov_base = (char *) data;
+    xcb_parts[4].iov_len = data_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_glx_vendor_private_with_reply_data_2 (const xcb_glx_vendor_private_with_reply_reply_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_glx_vendor_private_with_reply_data_2_length (const xcb_glx_vendor_private_with_reply_reply_t *R)
+{
+    return (R->length * 4);
+}
+
+xcb_generic_iterator_t
+xcb_glx_vendor_private_with_reply_data_2_end (const xcb_glx_vendor_private_with_reply_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((R->length * 4));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_vendor_private_with_reply_reply_t *
+xcb_glx_vendor_private_with_reply_reply (xcb_connection_t                            *c,
+                                         xcb_glx_vendor_private_with_reply_cookie_t   cookie  /**< */,
+                                         xcb_generic_error_t                        **e)
+{
+    return (xcb_glx_vendor_private_with_reply_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_glx_query_extensions_string_cookie_t
+xcb_glx_query_extensions_string (xcb_connection_t *c,
+                                 uint32_t          screen)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_QUERY_EXTENSIONS_STRING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_query_extensions_string_cookie_t xcb_ret;
+    xcb_glx_query_extensions_string_request_t xcb_out;
+
+    xcb_out.screen = screen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_query_extensions_string_cookie_t
+xcb_glx_query_extensions_string_unchecked (xcb_connection_t *c,
+                                           uint32_t          screen)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_QUERY_EXTENSIONS_STRING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_query_extensions_string_cookie_t xcb_ret;
+    xcb_glx_query_extensions_string_request_t xcb_out;
+
+    xcb_out.screen = screen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_query_extensions_string_reply_t *
+xcb_glx_query_extensions_string_reply (xcb_connection_t                          *c,
+                                       xcb_glx_query_extensions_string_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e)
+{
+    return (xcb_glx_query_extensions_string_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_query_server_string_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_query_server_string_reply_t *_aux = (xcb_glx_query_server_string_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_query_server_string_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* string */
+    xcb_block_len += _aux->str_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_query_server_string_cookie_t
+xcb_glx_query_server_string (xcb_connection_t *c,
+                             uint32_t          screen,
+                             uint32_t          name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_QUERY_SERVER_STRING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_query_server_string_cookie_t xcb_ret;
+    xcb_glx_query_server_string_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.name = name;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_query_server_string_cookie_t
+xcb_glx_query_server_string_unchecked (xcb_connection_t *c,
+                                       uint32_t          screen,
+                                       uint32_t          name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_QUERY_SERVER_STRING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_query_server_string_cookie_t xcb_ret;
+    xcb_glx_query_server_string_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.name = name;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_glx_query_server_string_string (const xcb_glx_query_server_string_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_glx_query_server_string_string_length (const xcb_glx_query_server_string_reply_t *R)
+{
+    return R->str_len;
+}
+
+xcb_generic_iterator_t
+xcb_glx_query_server_string_string_end (const xcb_glx_query_server_string_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->str_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_query_server_string_reply_t *
+xcb_glx_query_server_string_reply (xcb_connection_t                      *c,
+                                   xcb_glx_query_server_string_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e)
+{
+    return (xcb_glx_query_server_string_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_client_info_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_client_info_request_t *_aux = (xcb_glx_client_info_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_client_info_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* string */
+    xcb_block_len += _aux->str_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_glx_client_info_checked (xcb_connection_t *c,
+                             uint32_t          major_version,
+                             uint32_t          minor_version,
+                             uint32_t          str_len,
+                             const char       *string)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_CLIENT_INFO,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_client_info_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+    xcb_out.str_len = str_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char string */
+    xcb_parts[4].iov_base = (char *) string;
+    xcb_parts[4].iov_len = str_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_client_info (xcb_connection_t *c,
+                     uint32_t          major_version,
+                     uint32_t          minor_version,
+                     uint32_t          str_len,
+                     const char       *string)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_CLIENT_INFO,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_client_info_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+    xcb_out.str_len = str_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char string */
+    xcb_parts[4].iov_base = (char *) string;
+    xcb_parts[4].iov_len = str_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_glx_client_info_string (const xcb_glx_client_info_request_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_glx_client_info_string_length (const xcb_glx_client_info_request_t *R)
+{
+    return R->str_len;
+}
+
+xcb_generic_iterator_t
+xcb_glx_client_info_string_end (const xcb_glx_client_info_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->str_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_glx_get_fb_configs_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_fb_configs_reply_t *_aux = (xcb_glx_get_fb_configs_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_fb_configs_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* property_list */
+    xcb_block_len += _aux->length * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_fb_configs_cookie_t
+xcb_glx_get_fb_configs (xcb_connection_t *c,
+                        uint32_t          screen)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_FB_CONFIGS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_fb_configs_cookie_t xcb_ret;
+    xcb_glx_get_fb_configs_request_t xcb_out;
+
+    xcb_out.screen = screen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_fb_configs_cookie_t
+xcb_glx_get_fb_configs_unchecked (xcb_connection_t *c,
+                                  uint32_t          screen)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_FB_CONFIGS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_fb_configs_cookie_t xcb_ret;
+    xcb_glx_get_fb_configs_request_t xcb_out;
+
+    xcb_out.screen = screen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_glx_get_fb_configs_property_list (const xcb_glx_get_fb_configs_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_fb_configs_property_list_length (const xcb_glx_get_fb_configs_reply_t *R)
+{
+    return R->length;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_fb_configs_property_list_end (const xcb_glx_get_fb_configs_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->length);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_fb_configs_reply_t *
+xcb_glx_get_fb_configs_reply (xcb_connection_t                 *c,
+                              xcb_glx_get_fb_configs_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_glx_get_fb_configs_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_create_pixmap_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_create_pixmap_request_t *_aux = (xcb_glx_create_pixmap_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_create_pixmap_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* attribs */
+    xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_glx_create_pixmap_checked (xcb_connection_t   *c,
+                               uint32_t            screen,
+                               xcb_glx_fbconfig_t  fbconfig,
+                               xcb_pixmap_t        pixmap,
+                               xcb_glx_pixmap_t    glx_pixmap,
+                               uint32_t            num_attribs,
+                               const uint32_t     *attribs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_CREATE_PIXMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_create_pixmap_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.fbconfig = fbconfig;
+    xcb_out.pixmap = pixmap;
+    xcb_out.glx_pixmap = glx_pixmap;
+    xcb_out.num_attribs = num_attribs;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t attribs */
+    xcb_parts[4].iov_base = (char *) attribs;
+    xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_create_pixmap (xcb_connection_t   *c,
+                       uint32_t            screen,
+                       xcb_glx_fbconfig_t  fbconfig,
+                       xcb_pixmap_t        pixmap,
+                       xcb_glx_pixmap_t    glx_pixmap,
+                       uint32_t            num_attribs,
+                       const uint32_t     *attribs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_CREATE_PIXMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_create_pixmap_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.fbconfig = fbconfig;
+    xcb_out.pixmap = pixmap;
+    xcb_out.glx_pixmap = glx_pixmap;
+    xcb_out.num_attribs = num_attribs;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t attribs */
+    xcb_parts[4].iov_base = (char *) attribs;
+    xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_glx_create_pixmap_attribs (const xcb_glx_create_pixmap_request_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_glx_create_pixmap_attribs_length (const xcb_glx_create_pixmap_request_t *R)
+{
+    return (R->num_attribs * 2);
+}
+
+xcb_generic_iterator_t
+xcb_glx_create_pixmap_attribs_end (const xcb_glx_create_pixmap_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_glx_destroy_pixmap_checked (xcb_connection_t *c,
+                                xcb_glx_pixmap_t  glx_pixmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_DESTROY_PIXMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_destroy_pixmap_request_t xcb_out;
+
+    xcb_out.glx_pixmap = glx_pixmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_destroy_pixmap (xcb_connection_t *c,
+                        xcb_glx_pixmap_t  glx_pixmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_DESTROY_PIXMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_destroy_pixmap_request_t xcb_out;
+
+    xcb_out.glx_pixmap = glx_pixmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_create_new_context_checked (xcb_connection_t   *c,
+                                    xcb_glx_context_t   context,
+                                    xcb_glx_fbconfig_t  fbconfig,
+                                    uint32_t            screen,
+                                    uint32_t            render_type,
+                                    xcb_glx_context_t   share_list,
+                                    uint8_t             is_direct)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_CREATE_NEW_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_create_new_context_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.fbconfig = fbconfig;
+    xcb_out.screen = screen;
+    xcb_out.render_type = render_type;
+    xcb_out.share_list = share_list;
+    xcb_out.is_direct = is_direct;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_create_new_context (xcb_connection_t   *c,
+                            xcb_glx_context_t   context,
+                            xcb_glx_fbconfig_t  fbconfig,
+                            uint32_t            screen,
+                            uint32_t            render_type,
+                            xcb_glx_context_t   share_list,
+                            uint8_t             is_direct)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_CREATE_NEW_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_create_new_context_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.fbconfig = fbconfig;
+    xcb_out.screen = screen;
+    xcb_out.render_type = render_type;
+    xcb_out.share_list = share_list;
+    xcb_out.is_direct = is_direct;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_glx_query_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_query_context_reply_t *_aux = (xcb_glx_query_context_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_query_context_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* attribs */
+    xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_query_context_cookie_t
+xcb_glx_query_context (xcb_connection_t  *c,
+                       xcb_glx_context_t  context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_QUERY_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_query_context_cookie_t xcb_ret;
+    xcb_glx_query_context_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_query_context_cookie_t
+xcb_glx_query_context_unchecked (xcb_connection_t  *c,
+                                 xcb_glx_context_t  context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_QUERY_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_query_context_cookie_t xcb_ret;
+    xcb_glx_query_context_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_glx_query_context_attribs (const xcb_glx_query_context_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_glx_query_context_attribs_length (const xcb_glx_query_context_reply_t *R)
+{
+    return (R->num_attribs * 2);
+}
+
+xcb_generic_iterator_t
+xcb_glx_query_context_attribs_end (const xcb_glx_query_context_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_query_context_reply_t *
+xcb_glx_query_context_reply (xcb_connection_t                *c,
+                             xcb_glx_query_context_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_glx_query_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_glx_make_context_current_cookie_t
+xcb_glx_make_context_current (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  old_context_tag,
+                              xcb_glx_drawable_t     drawable,
+                              xcb_glx_drawable_t     read_drawable,
+                              xcb_glx_context_t      context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_MAKE_CONTEXT_CURRENT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_make_context_current_cookie_t xcb_ret;
+    xcb_glx_make_context_current_request_t xcb_out;
+
+    xcb_out.old_context_tag = old_context_tag;
+    xcb_out.drawable = drawable;
+    xcb_out.read_drawable = read_drawable;
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_make_context_current_cookie_t
+xcb_glx_make_context_current_unchecked (xcb_connection_t      *c,
+                                        xcb_glx_context_tag_t  old_context_tag,
+                                        xcb_glx_drawable_t     drawable,
+                                        xcb_glx_drawable_t     read_drawable,
+                                        xcb_glx_context_t      context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_MAKE_CONTEXT_CURRENT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_make_context_current_cookie_t xcb_ret;
+    xcb_glx_make_context_current_request_t xcb_out;
+
+    xcb_out.old_context_tag = old_context_tag;
+    xcb_out.drawable = drawable;
+    xcb_out.read_drawable = read_drawable;
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_make_context_current_reply_t *
+xcb_glx_make_context_current_reply (xcb_connection_t                       *c,
+                                    xcb_glx_make_context_current_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e)
+{
+    return (xcb_glx_make_context_current_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_create_pbuffer_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_create_pbuffer_request_t *_aux = (xcb_glx_create_pbuffer_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_create_pbuffer_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* attribs */
+    xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_glx_create_pbuffer_checked (xcb_connection_t   *c,
+                                uint32_t            screen,
+                                xcb_glx_fbconfig_t  fbconfig,
+                                xcb_glx_pbuffer_t   pbuffer,
+                                uint32_t            num_attribs,
+                                const uint32_t     *attribs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_CREATE_PBUFFER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_create_pbuffer_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.fbconfig = fbconfig;
+    xcb_out.pbuffer = pbuffer;
+    xcb_out.num_attribs = num_attribs;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t attribs */
+    xcb_parts[4].iov_base = (char *) attribs;
+    xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_create_pbuffer (xcb_connection_t   *c,
+                        uint32_t            screen,
+                        xcb_glx_fbconfig_t  fbconfig,
+                        xcb_glx_pbuffer_t   pbuffer,
+                        uint32_t            num_attribs,
+                        const uint32_t     *attribs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_CREATE_PBUFFER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_create_pbuffer_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.fbconfig = fbconfig;
+    xcb_out.pbuffer = pbuffer;
+    xcb_out.num_attribs = num_attribs;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t attribs */
+    xcb_parts[4].iov_base = (char *) attribs;
+    xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_glx_create_pbuffer_attribs (const xcb_glx_create_pbuffer_request_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_glx_create_pbuffer_attribs_length (const xcb_glx_create_pbuffer_request_t *R)
+{
+    return (R->num_attribs * 2);
+}
+
+xcb_generic_iterator_t
+xcb_glx_create_pbuffer_attribs_end (const xcb_glx_create_pbuffer_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_glx_destroy_pbuffer_checked (xcb_connection_t  *c,
+                                 xcb_glx_pbuffer_t  pbuffer)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_DESTROY_PBUFFER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_destroy_pbuffer_request_t xcb_out;
+
+    xcb_out.pbuffer = pbuffer;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_destroy_pbuffer (xcb_connection_t  *c,
+                         xcb_glx_pbuffer_t  pbuffer)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_DESTROY_PBUFFER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_destroy_pbuffer_request_t xcb_out;
+
+    xcb_out.pbuffer = pbuffer;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_glx_get_drawable_attributes_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_drawable_attributes_reply_t *_aux = (xcb_glx_get_drawable_attributes_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_drawable_attributes_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* attribs */
+    xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_drawable_attributes_cookie_t
+xcb_glx_get_drawable_attributes (xcb_connection_t   *c,
+                                 xcb_glx_drawable_t  drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_DRAWABLE_ATTRIBUTES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_drawable_attributes_cookie_t xcb_ret;
+    xcb_glx_get_drawable_attributes_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_drawable_attributes_cookie_t
+xcb_glx_get_drawable_attributes_unchecked (xcb_connection_t   *c,
+                                           xcb_glx_drawable_t  drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_DRAWABLE_ATTRIBUTES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_drawable_attributes_cookie_t xcb_ret;
+    xcb_glx_get_drawable_attributes_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_glx_get_drawable_attributes_attribs (const xcb_glx_get_drawable_attributes_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_drawable_attributes_attribs_length (const xcb_glx_get_drawable_attributes_reply_t *R)
+{
+    return (R->num_attribs * 2);
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_drawable_attributes_attribs_end (const xcb_glx_get_drawable_attributes_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_drawable_attributes_reply_t *
+xcb_glx_get_drawable_attributes_reply (xcb_connection_t                          *c,
+                                       xcb_glx_get_drawable_attributes_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e)
+{
+    return (xcb_glx_get_drawable_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_change_drawable_attributes_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_change_drawable_attributes_request_t *_aux = (xcb_glx_change_drawable_attributes_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_change_drawable_attributes_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* attribs */
+    xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_glx_change_drawable_attributes_checked (xcb_connection_t   *c,
+                                            xcb_glx_drawable_t  drawable,
+                                            uint32_t            num_attribs,
+                                            const uint32_t     *attribs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_CHANGE_DRAWABLE_ATTRIBUTES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_change_drawable_attributes_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.num_attribs = num_attribs;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t attribs */
+    xcb_parts[4].iov_base = (char *) attribs;
+    xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_change_drawable_attributes (xcb_connection_t   *c,
+                                    xcb_glx_drawable_t  drawable,
+                                    uint32_t            num_attribs,
+                                    const uint32_t     *attribs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_CHANGE_DRAWABLE_ATTRIBUTES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_change_drawable_attributes_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.num_attribs = num_attribs;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t attribs */
+    xcb_parts[4].iov_base = (char *) attribs;
+    xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_glx_change_drawable_attributes_attribs (const xcb_glx_change_drawable_attributes_request_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_glx_change_drawable_attributes_attribs_length (const xcb_glx_change_drawable_attributes_request_t *R)
+{
+    return (R->num_attribs * 2);
+}
+
+xcb_generic_iterator_t
+xcb_glx_change_drawable_attributes_attribs_end (const xcb_glx_change_drawable_attributes_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_glx_create_window_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_create_window_request_t *_aux = (xcb_glx_create_window_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_create_window_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* attribs */
+    xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_glx_create_window_checked (xcb_connection_t   *c,
+                               uint32_t            screen,
+                               xcb_glx_fbconfig_t  fbconfig,
+                               xcb_window_t        window,
+                               xcb_glx_window_t    glx_window,
+                               uint32_t            num_attribs,
+                               const uint32_t     *attribs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_CREATE_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_create_window_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.fbconfig = fbconfig;
+    xcb_out.window = window;
+    xcb_out.glx_window = glx_window;
+    xcb_out.num_attribs = num_attribs;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t attribs */
+    xcb_parts[4].iov_base = (char *) attribs;
+    xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_create_window (xcb_connection_t   *c,
+                       uint32_t            screen,
+                       xcb_glx_fbconfig_t  fbconfig,
+                       xcb_window_t        window,
+                       xcb_glx_window_t    glx_window,
+                       uint32_t            num_attribs,
+                       const uint32_t     *attribs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_CREATE_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_create_window_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.fbconfig = fbconfig;
+    xcb_out.window = window;
+    xcb_out.glx_window = glx_window;
+    xcb_out.num_attribs = num_attribs;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t attribs */
+    xcb_parts[4].iov_base = (char *) attribs;
+    xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_glx_create_window_attribs (const xcb_glx_create_window_request_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_glx_create_window_attribs_length (const xcb_glx_create_window_request_t *R)
+{
+    return (R->num_attribs * 2);
+}
+
+xcb_generic_iterator_t
+xcb_glx_create_window_attribs_end (const xcb_glx_create_window_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_glx_delete_window_checked (xcb_connection_t *c,
+                               xcb_glx_window_t  glxwindow)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_DELETE_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_delete_window_request_t xcb_out;
+
+    xcb_out.glxwindow = glxwindow;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_delete_window (xcb_connection_t *c,
+                       xcb_glx_window_t  glxwindow)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_DELETE_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_delete_window_request_t xcb_out;
+
+    xcb_out.glxwindow = glxwindow;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_glx_set_client_info_arb_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_set_client_info_arb_request_t *_aux = (xcb_glx_set_client_info_arb_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_set_client_info_arb_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* gl_versions */
+    xcb_block_len += (_aux->num_versions * 2) * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* gl_extension_string */
+    xcb_block_len += _aux->gl_str_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* glx_extension_string */
+    xcb_block_len += _aux->glx_str_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_glx_set_client_info_arb_checked (xcb_connection_t *c,
+                                     uint32_t          major_version,
+                                     uint32_t          minor_version,
+                                     uint32_t          num_versions,
+                                     uint32_t          gl_str_len,
+                                     uint32_t          glx_str_len,
+                                     const uint32_t   *gl_versions,
+                                     const char       *gl_extension_string,
+                                     const char       *glx_extension_string)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 8,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_SET_CLIENT_INFO_ARB,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[10];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_set_client_info_arb_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+    xcb_out.num_versions = num_versions;
+    xcb_out.gl_str_len = gl_str_len;
+    xcb_out.glx_str_len = glx_str_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t gl_versions */
+    xcb_parts[4].iov_base = (char *) gl_versions;
+    xcb_parts[4].iov_len = (num_versions * 2) * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* char gl_extension_string */
+    xcb_parts[6].iov_base = (char *) gl_extension_string;
+    xcb_parts[6].iov_len = gl_str_len * sizeof(char);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+    /* char glx_extension_string */
+    xcb_parts[8].iov_base = (char *) glx_extension_string;
+    xcb_parts[8].iov_len = glx_str_len * sizeof(char);
+    xcb_parts[9].iov_base = 0;
+    xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_set_client_info_arb (xcb_connection_t *c,
+                             uint32_t          major_version,
+                             uint32_t          minor_version,
+                             uint32_t          num_versions,
+                             uint32_t          gl_str_len,
+                             uint32_t          glx_str_len,
+                             const uint32_t   *gl_versions,
+                             const char       *gl_extension_string,
+                             const char       *glx_extension_string)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 8,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_SET_CLIENT_INFO_ARB,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[10];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_set_client_info_arb_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+    xcb_out.num_versions = num_versions;
+    xcb_out.gl_str_len = gl_str_len;
+    xcb_out.glx_str_len = glx_str_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t gl_versions */
+    xcb_parts[4].iov_base = (char *) gl_versions;
+    xcb_parts[4].iov_len = (num_versions * 2) * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* char gl_extension_string */
+    xcb_parts[6].iov_base = (char *) gl_extension_string;
+    xcb_parts[6].iov_len = gl_str_len * sizeof(char);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+    /* char glx_extension_string */
+    xcb_parts[8].iov_base = (char *) glx_extension_string;
+    xcb_parts[8].iov_len = glx_str_len * sizeof(char);
+    xcb_parts[9].iov_base = 0;
+    xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_glx_set_client_info_arb_gl_versions (const xcb_glx_set_client_info_arb_request_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_glx_set_client_info_arb_gl_versions_length (const xcb_glx_set_client_info_arb_request_t *R)
+{
+    return (R->num_versions * 2);
+}
+
+xcb_generic_iterator_t
+xcb_glx_set_client_info_arb_gl_versions_end (const xcb_glx_set_client_info_arb_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + ((R->num_versions * 2));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+char *
+xcb_glx_set_client_info_arb_gl_extension_string (const xcb_glx_set_client_info_arb_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_glx_set_client_info_arb_gl_versions_end(R);
+    return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0);
+}
+
+int
+xcb_glx_set_client_info_arb_gl_extension_string_length (const xcb_glx_set_client_info_arb_request_t *R)
+{
+    return R->gl_str_len;
+}
+
+xcb_generic_iterator_t
+xcb_glx_set_client_info_arb_gl_extension_string_end (const xcb_glx_set_client_info_arb_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_glx_set_client_info_arb_gl_versions_end(R);
+    i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->gl_str_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+char *
+xcb_glx_set_client_info_arb_glx_extension_string (const xcb_glx_set_client_info_arb_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_glx_set_client_info_arb_gl_extension_string_end(R);
+    return (char *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0);
+}
+
+int
+xcb_glx_set_client_info_arb_glx_extension_string_length (const xcb_glx_set_client_info_arb_request_t *R)
+{
+    return R->glx_str_len;
+}
+
+xcb_generic_iterator_t
+xcb_glx_set_client_info_arb_glx_extension_string_end (const xcb_glx_set_client_info_arb_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_glx_set_client_info_arb_gl_extension_string_end(R);
+    i.data = ((char *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (R->glx_str_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_glx_create_context_attribs_arb_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_create_context_attribs_arb_request_t *_aux = (xcb_glx_create_context_attribs_arb_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_create_context_attribs_arb_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* attribs */
+    xcb_block_len += (_aux->num_attribs * 2) * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_glx_create_context_attribs_arb_checked (xcb_connection_t   *c,
+                                            xcb_glx_context_t   context,
+                                            xcb_glx_fbconfig_t  fbconfig,
+                                            uint32_t            screen,
+                                            xcb_glx_context_t   share_list,
+                                            uint8_t             is_direct,
+                                            uint32_t            num_attribs,
+                                            const uint32_t     *attribs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_CREATE_CONTEXT_ATTRIBS_ARB,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_create_context_attribs_arb_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.fbconfig = fbconfig;
+    xcb_out.screen = screen;
+    xcb_out.share_list = share_list;
+    xcb_out.is_direct = is_direct;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.num_attribs = num_attribs;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t attribs */
+    xcb_parts[4].iov_base = (char *) attribs;
+    xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_create_context_attribs_arb (xcb_connection_t   *c,
+                                    xcb_glx_context_t   context,
+                                    xcb_glx_fbconfig_t  fbconfig,
+                                    uint32_t            screen,
+                                    xcb_glx_context_t   share_list,
+                                    uint8_t             is_direct,
+                                    uint32_t            num_attribs,
+                                    const uint32_t     *attribs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_CREATE_CONTEXT_ATTRIBS_ARB,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_create_context_attribs_arb_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.fbconfig = fbconfig;
+    xcb_out.screen = screen;
+    xcb_out.share_list = share_list;
+    xcb_out.is_direct = is_direct;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.num_attribs = num_attribs;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t attribs */
+    xcb_parts[4].iov_base = (char *) attribs;
+    xcb_parts[4].iov_len = (num_attribs * 2) * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_glx_create_context_attribs_arb_attribs (const xcb_glx_create_context_attribs_arb_request_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_glx_create_context_attribs_arb_attribs_length (const xcb_glx_create_context_attribs_arb_request_t *R)
+{
+    return (R->num_attribs * 2);
+}
+
+xcb_generic_iterator_t
+xcb_glx_create_context_attribs_arb_attribs_end (const xcb_glx_create_context_attribs_arb_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + ((R->num_attribs * 2));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_glx_set_client_info_2arb_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_set_client_info_2arb_request_t *_aux = (xcb_glx_set_client_info_2arb_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_set_client_info_2arb_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* gl_versions */
+    xcb_block_len += (_aux->num_versions * 3) * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* gl_extension_string */
+    xcb_block_len += _aux->gl_str_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* glx_extension_string */
+    xcb_block_len += _aux->glx_str_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_glx_set_client_info_2arb_checked (xcb_connection_t *c,
+                                      uint32_t          major_version,
+                                      uint32_t          minor_version,
+                                      uint32_t          num_versions,
+                                      uint32_t          gl_str_len,
+                                      uint32_t          glx_str_len,
+                                      const uint32_t   *gl_versions,
+                                      const char       *gl_extension_string,
+                                      const char       *glx_extension_string)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 8,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_SET_CLIENT_INFO_2ARB,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[10];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_set_client_info_2arb_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+    xcb_out.num_versions = num_versions;
+    xcb_out.gl_str_len = gl_str_len;
+    xcb_out.glx_str_len = glx_str_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t gl_versions */
+    xcb_parts[4].iov_base = (char *) gl_versions;
+    xcb_parts[4].iov_len = (num_versions * 3) * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* char gl_extension_string */
+    xcb_parts[6].iov_base = (char *) gl_extension_string;
+    xcb_parts[6].iov_len = gl_str_len * sizeof(char);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+    /* char glx_extension_string */
+    xcb_parts[8].iov_base = (char *) glx_extension_string;
+    xcb_parts[8].iov_len = glx_str_len * sizeof(char);
+    xcb_parts[9].iov_base = 0;
+    xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_set_client_info_2arb (xcb_connection_t *c,
+                              uint32_t          major_version,
+                              uint32_t          minor_version,
+                              uint32_t          num_versions,
+                              uint32_t          gl_str_len,
+                              uint32_t          glx_str_len,
+                              const uint32_t   *gl_versions,
+                              const char       *gl_extension_string,
+                              const char       *glx_extension_string)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 8,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_SET_CLIENT_INFO_2ARB,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[10];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_set_client_info_2arb_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+    xcb_out.num_versions = num_versions;
+    xcb_out.gl_str_len = gl_str_len;
+    xcb_out.glx_str_len = glx_str_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t gl_versions */
+    xcb_parts[4].iov_base = (char *) gl_versions;
+    xcb_parts[4].iov_len = (num_versions * 3) * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* char gl_extension_string */
+    xcb_parts[6].iov_base = (char *) gl_extension_string;
+    xcb_parts[6].iov_len = gl_str_len * sizeof(char);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+    /* char glx_extension_string */
+    xcb_parts[8].iov_base = (char *) glx_extension_string;
+    xcb_parts[8].iov_len = glx_str_len * sizeof(char);
+    xcb_parts[9].iov_base = 0;
+    xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_glx_set_client_info_2arb_gl_versions (const xcb_glx_set_client_info_2arb_request_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_glx_set_client_info_2arb_gl_versions_length (const xcb_glx_set_client_info_2arb_request_t *R)
+{
+    return (R->num_versions * 3);
+}
+
+xcb_generic_iterator_t
+xcb_glx_set_client_info_2arb_gl_versions_end (const xcb_glx_set_client_info_2arb_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + ((R->num_versions * 3));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+char *
+xcb_glx_set_client_info_2arb_gl_extension_string (const xcb_glx_set_client_info_2arb_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_glx_set_client_info_2arb_gl_versions_end(R);
+    return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0);
+}
+
+int
+xcb_glx_set_client_info_2arb_gl_extension_string_length (const xcb_glx_set_client_info_2arb_request_t *R)
+{
+    return R->gl_str_len;
+}
+
+xcb_generic_iterator_t
+xcb_glx_set_client_info_2arb_gl_extension_string_end (const xcb_glx_set_client_info_2arb_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_glx_set_client_info_2arb_gl_versions_end(R);
+    i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->gl_str_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+char *
+xcb_glx_set_client_info_2arb_glx_extension_string (const xcb_glx_set_client_info_2arb_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_glx_set_client_info_2arb_gl_extension_string_end(R);
+    return (char *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0);
+}
+
+int
+xcb_glx_set_client_info_2arb_glx_extension_string_length (const xcb_glx_set_client_info_2arb_request_t *R)
+{
+    return R->glx_str_len;
+}
+
+xcb_generic_iterator_t
+xcb_glx_set_client_info_2arb_glx_extension_string_end (const xcb_glx_set_client_info_2arb_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_glx_set_client_info_2arb_gl_extension_string_end(R);
+    i.data = ((char *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (R->glx_str_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_glx_new_list_checked (xcb_connection_t      *c,
+                          xcb_glx_context_tag_t  context_tag,
+                          uint32_t               list,
+                          uint32_t               mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_NEW_LIST,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_new_list_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.list = list;
+    xcb_out.mode = mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_new_list (xcb_connection_t      *c,
+                  xcb_glx_context_tag_t  context_tag,
+                  uint32_t               list,
+                  uint32_t               mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_NEW_LIST,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_new_list_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.list = list;
+    xcb_out.mode = mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_end_list_checked (xcb_connection_t      *c,
+                          xcb_glx_context_tag_t  context_tag)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_END_LIST,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_end_list_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_end_list (xcb_connection_t      *c,
+                  xcb_glx_context_tag_t  context_tag)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_END_LIST,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_end_list_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_delete_lists_checked (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              uint32_t               list,
+                              int32_t                range)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_DELETE_LISTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_delete_lists_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.list = list;
+    xcb_out.range = range;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_delete_lists (xcb_connection_t      *c,
+                      xcb_glx_context_tag_t  context_tag,
+                      uint32_t               list,
+                      int32_t                range)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_DELETE_LISTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_delete_lists_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.list = list;
+    xcb_out.range = range;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_gen_lists_cookie_t
+xcb_glx_gen_lists (xcb_connection_t      *c,
+                   xcb_glx_context_tag_t  context_tag,
+                   int32_t                range)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GEN_LISTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_gen_lists_cookie_t xcb_ret;
+    xcb_glx_gen_lists_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.range = range;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_gen_lists_cookie_t
+xcb_glx_gen_lists_unchecked (xcb_connection_t      *c,
+                             xcb_glx_context_tag_t  context_tag,
+                             int32_t                range)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GEN_LISTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_gen_lists_cookie_t xcb_ret;
+    xcb_glx_gen_lists_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.range = range;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_gen_lists_reply_t *
+xcb_glx_gen_lists_reply (xcb_connection_t            *c,
+                         xcb_glx_gen_lists_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e)
+{
+    return (xcb_glx_gen_lists_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_glx_feedback_buffer_checked (xcb_connection_t      *c,
+                                 xcb_glx_context_tag_t  context_tag,
+                                 int32_t                size,
+                                 int32_t                type)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_FEEDBACK_BUFFER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_feedback_buffer_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.size = size;
+    xcb_out.type = type;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_feedback_buffer (xcb_connection_t      *c,
+                         xcb_glx_context_tag_t  context_tag,
+                         int32_t                size,
+                         int32_t                type)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_FEEDBACK_BUFFER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_feedback_buffer_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.size = size;
+    xcb_out.type = type;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_select_buffer_checked (xcb_connection_t      *c,
+                               xcb_glx_context_tag_t  context_tag,
+                               int32_t                size)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_SELECT_BUFFER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_select_buffer_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.size = size;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_select_buffer (xcb_connection_t      *c,
+                       xcb_glx_context_tag_t  context_tag,
+                       int32_t                size)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_SELECT_BUFFER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_select_buffer_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.size = size;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_glx_render_mode_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_render_mode_reply_t *_aux = (xcb_glx_render_mode_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_render_mode_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_render_mode_cookie_t
+xcb_glx_render_mode (xcb_connection_t      *c,
+                     xcb_glx_context_tag_t  context_tag,
+                     uint32_t               mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_RENDER_MODE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_render_mode_cookie_t xcb_ret;
+    xcb_glx_render_mode_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.mode = mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_render_mode_cookie_t
+xcb_glx_render_mode_unchecked (xcb_connection_t      *c,
+                               xcb_glx_context_tag_t  context_tag,
+                               uint32_t               mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_RENDER_MODE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_render_mode_cookie_t xcb_ret;
+    xcb_glx_render_mode_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.mode = mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_glx_render_mode_data (const xcb_glx_render_mode_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_glx_render_mode_data_length (const xcb_glx_render_mode_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_render_mode_data_end (const xcb_glx_render_mode_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_render_mode_reply_t *
+xcb_glx_render_mode_reply (xcb_connection_t              *c,
+                           xcb_glx_render_mode_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e)
+{
+    return (xcb_glx_render_mode_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_glx_finish_cookie_t
+xcb_glx_finish (xcb_connection_t      *c,
+                xcb_glx_context_tag_t  context_tag)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_FINISH,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_finish_cookie_t xcb_ret;
+    xcb_glx_finish_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_finish_cookie_t
+xcb_glx_finish_unchecked (xcb_connection_t      *c,
+                          xcb_glx_context_tag_t  context_tag)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_FINISH,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_finish_cookie_t xcb_ret;
+    xcb_glx_finish_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_finish_reply_t *
+xcb_glx_finish_reply (xcb_connection_t         *c,
+                      xcb_glx_finish_cookie_t   cookie  /**< */,
+                      xcb_generic_error_t     **e)
+{
+    return (xcb_glx_finish_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_glx_pixel_storef_checked (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              uint32_t               pname,
+                              xcb_glx_float32_t      datum)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_PIXEL_STOREF,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_pixel_storef_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.pname = pname;
+    xcb_out.datum = datum;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_pixel_storef (xcb_connection_t      *c,
+                      xcb_glx_context_tag_t  context_tag,
+                      uint32_t               pname,
+                      xcb_glx_float32_t      datum)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_PIXEL_STOREF,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_pixel_storef_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.pname = pname;
+    xcb_out.datum = datum;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_pixel_storei_checked (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              uint32_t               pname,
+                              int32_t                datum)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_PIXEL_STOREI,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_pixel_storei_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.pname = pname;
+    xcb_out.datum = datum;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_pixel_storei (xcb_connection_t      *c,
+                      xcb_glx_context_tag_t  context_tag,
+                      uint32_t               pname,
+                      int32_t                datum)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_PIXEL_STOREI,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_pixel_storei_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.pname = pname;
+    xcb_out.datum = datum;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_glx_read_pixels_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_read_pixels_reply_t *_aux = (xcb_glx_read_pixels_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_read_pixels_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += (_aux->length * 4) * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_read_pixels_cookie_t
+xcb_glx_read_pixels (xcb_connection_t      *c,
+                     xcb_glx_context_tag_t  context_tag,
+                     int32_t                x,
+                     int32_t                y,
+                     int32_t                width,
+                     int32_t                height,
+                     uint32_t               format,
+                     uint32_t               type,
+                     uint8_t                swap_bytes,
+                     uint8_t                lsb_first)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_READ_PIXELS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_read_pixels_cookie_t xcb_ret;
+    xcb_glx_read_pixels_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.x = x;
+    xcb_out.y = y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.format = format;
+    xcb_out.type = type;
+    xcb_out.swap_bytes = swap_bytes;
+    xcb_out.lsb_first = lsb_first;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_read_pixels_cookie_t
+xcb_glx_read_pixels_unchecked (xcb_connection_t      *c,
+                               xcb_glx_context_tag_t  context_tag,
+                               int32_t                x,
+                               int32_t                y,
+                               int32_t                width,
+                               int32_t                height,
+                               uint32_t               format,
+                               uint32_t               type,
+                               uint8_t                swap_bytes,
+                               uint8_t                lsb_first)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_READ_PIXELS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_read_pixels_cookie_t xcb_ret;
+    xcb_glx_read_pixels_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.x = x;
+    xcb_out.y = y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.format = format;
+    xcb_out.type = type;
+    xcb_out.swap_bytes = swap_bytes;
+    xcb_out.lsb_first = lsb_first;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_glx_read_pixels_data (const xcb_glx_read_pixels_reply_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_glx_read_pixels_data_length (const xcb_glx_read_pixels_reply_t *R)
+{
+    return (R->length * 4);
+}
+
+xcb_generic_iterator_t
+xcb_glx_read_pixels_data_end (const xcb_glx_read_pixels_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((R->length * 4));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_read_pixels_reply_t *
+xcb_glx_read_pixels_reply (xcb_connection_t              *c,
+                           xcb_glx_read_pixels_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e)
+{
+    return (xcb_glx_read_pixels_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_booleanv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_booleanv_reply_t *_aux = (xcb_glx_get_booleanv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_booleanv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_booleanv_cookie_t
+xcb_glx_get_booleanv (xcb_connection_t      *c,
+                      xcb_glx_context_tag_t  context_tag,
+                      int32_t                pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_BOOLEANV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_booleanv_cookie_t xcb_ret;
+    xcb_glx_get_booleanv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_booleanv_cookie_t
+xcb_glx_get_booleanv_unchecked (xcb_connection_t      *c,
+                                xcb_glx_context_tag_t  context_tag,
+                                int32_t                pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_BOOLEANV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_booleanv_cookie_t xcb_ret;
+    xcb_glx_get_booleanv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_glx_get_booleanv_data (const xcb_glx_get_booleanv_reply_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_glx_get_booleanv_data_length (const xcb_glx_get_booleanv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_booleanv_data_end (const xcb_glx_get_booleanv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_booleanv_reply_t *
+xcb_glx_get_booleanv_reply (xcb_connection_t               *c,
+                            xcb_glx_get_booleanv_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e)
+{
+    return (xcb_glx_get_booleanv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_clip_plane_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_clip_plane_reply_t *_aux = (xcb_glx_get_clip_plane_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_clip_plane_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += (_aux->length / 2) * sizeof(xcb_glx_float64_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_glx_float64_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_clip_plane_cookie_t
+xcb_glx_get_clip_plane (xcb_connection_t      *c,
+                        xcb_glx_context_tag_t  context_tag,
+                        int32_t                plane)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_CLIP_PLANE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_clip_plane_cookie_t xcb_ret;
+    xcb_glx_get_clip_plane_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.plane = plane;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_clip_plane_cookie_t
+xcb_glx_get_clip_plane_unchecked (xcb_connection_t      *c,
+                                  xcb_glx_context_tag_t  context_tag,
+                                  int32_t                plane)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_CLIP_PLANE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_clip_plane_cookie_t xcb_ret;
+    xcb_glx_get_clip_plane_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.plane = plane;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_float64_t *
+xcb_glx_get_clip_plane_data (const xcb_glx_get_clip_plane_reply_t *R)
+{
+    return (xcb_glx_float64_t *) (R + 1);
+}
+
+int
+xcb_glx_get_clip_plane_data_length (const xcb_glx_get_clip_plane_reply_t *R)
+{
+    return (R->length / 2);
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_clip_plane_data_end (const xcb_glx_get_clip_plane_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_glx_float64_t *) (R + 1)) + ((R->length / 2));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_clip_plane_reply_t *
+xcb_glx_get_clip_plane_reply (xcb_connection_t                 *c,
+                              xcb_glx_get_clip_plane_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_glx_get_clip_plane_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_doublev_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_doublev_reply_t *_aux = (xcb_glx_get_doublev_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_doublev_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(xcb_glx_float64_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_glx_float64_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_doublev_cookie_t
+xcb_glx_get_doublev (xcb_connection_t      *c,
+                     xcb_glx_context_tag_t  context_tag,
+                     uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_DOUBLEV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_doublev_cookie_t xcb_ret;
+    xcb_glx_get_doublev_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_doublev_cookie_t
+xcb_glx_get_doublev_unchecked (xcb_connection_t      *c,
+                               xcb_glx_context_tag_t  context_tag,
+                               uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_DOUBLEV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_doublev_cookie_t xcb_ret;
+    xcb_glx_get_doublev_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_float64_t *
+xcb_glx_get_doublev_data (const xcb_glx_get_doublev_reply_t *R)
+{
+    return (xcb_glx_float64_t *) (R + 1);
+}
+
+int
+xcb_glx_get_doublev_data_length (const xcb_glx_get_doublev_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_doublev_data_end (const xcb_glx_get_doublev_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_glx_float64_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_doublev_reply_t *
+xcb_glx_get_doublev_reply (xcb_connection_t              *c,
+                           xcb_glx_get_doublev_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e)
+{
+    return (xcb_glx_get_doublev_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_glx_get_error_cookie_t
+xcb_glx_get_error (xcb_connection_t      *c,
+                   xcb_glx_context_tag_t  context_tag)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_ERROR,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_error_cookie_t xcb_ret;
+    xcb_glx_get_error_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_error_cookie_t
+xcb_glx_get_error_unchecked (xcb_connection_t      *c,
+                             xcb_glx_context_tag_t  context_tag)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_ERROR,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_error_cookie_t xcb_ret;
+    xcb_glx_get_error_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_error_reply_t *
+xcb_glx_get_error_reply (xcb_connection_t            *c,
+                         xcb_glx_get_error_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e)
+{
+    return (xcb_glx_get_error_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_floatv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_floatv_reply_t *_aux = (xcb_glx_get_floatv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_floatv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_glx_float32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_floatv_cookie_t
+xcb_glx_get_floatv (xcb_connection_t      *c,
+                    xcb_glx_context_tag_t  context_tag,
+                    uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_FLOATV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_floatv_cookie_t xcb_ret;
+    xcb_glx_get_floatv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_floatv_cookie_t
+xcb_glx_get_floatv_unchecked (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_FLOATV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_floatv_cookie_t xcb_ret;
+    xcb_glx_get_floatv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_float32_t *
+xcb_glx_get_floatv_data (const xcb_glx_get_floatv_reply_t *R)
+{
+    return (xcb_glx_float32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_floatv_data_length (const xcb_glx_get_floatv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_floatv_data_end (const xcb_glx_get_floatv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_floatv_reply_t *
+xcb_glx_get_floatv_reply (xcb_connection_t             *c,
+                          xcb_glx_get_floatv_cookie_t   cookie  /**< */,
+                          xcb_generic_error_t         **e)
+{
+    return (xcb_glx_get_floatv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_integerv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_integerv_reply_t *_aux = (xcb_glx_get_integerv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_integerv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_integerv_cookie_t
+xcb_glx_get_integerv (xcb_connection_t      *c,
+                      xcb_glx_context_tag_t  context_tag,
+                      uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_INTEGERV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_integerv_cookie_t xcb_ret;
+    xcb_glx_get_integerv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_integerv_cookie_t
+xcb_glx_get_integerv_unchecked (xcb_connection_t      *c,
+                                xcb_glx_context_tag_t  context_tag,
+                                uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_INTEGERV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_integerv_cookie_t xcb_ret;
+    xcb_glx_get_integerv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int32_t *
+xcb_glx_get_integerv_data (const xcb_glx_get_integerv_reply_t *R)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_integerv_data_length (const xcb_glx_get_integerv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_integerv_data_end (const xcb_glx_get_integerv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_integerv_reply_t *
+xcb_glx_get_integerv_reply (xcb_connection_t               *c,
+                            xcb_glx_get_integerv_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e)
+{
+    return (xcb_glx_get_integerv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_lightfv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_lightfv_reply_t *_aux = (xcb_glx_get_lightfv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_lightfv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_glx_float32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_lightfv_cookie_t
+xcb_glx_get_lightfv (xcb_connection_t      *c,
+                     xcb_glx_context_tag_t  context_tag,
+                     uint32_t               light,
+                     uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_LIGHTFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_lightfv_cookie_t xcb_ret;
+    xcb_glx_get_lightfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.light = light;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_lightfv_cookie_t
+xcb_glx_get_lightfv_unchecked (xcb_connection_t      *c,
+                               xcb_glx_context_tag_t  context_tag,
+                               uint32_t               light,
+                               uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_LIGHTFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_lightfv_cookie_t xcb_ret;
+    xcb_glx_get_lightfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.light = light;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_float32_t *
+xcb_glx_get_lightfv_data (const xcb_glx_get_lightfv_reply_t *R)
+{
+    return (xcb_glx_float32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_lightfv_data_length (const xcb_glx_get_lightfv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_lightfv_data_end (const xcb_glx_get_lightfv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_lightfv_reply_t *
+xcb_glx_get_lightfv_reply (xcb_connection_t              *c,
+                           xcb_glx_get_lightfv_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e)
+{
+    return (xcb_glx_get_lightfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_lightiv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_lightiv_reply_t *_aux = (xcb_glx_get_lightiv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_lightiv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_lightiv_cookie_t
+xcb_glx_get_lightiv (xcb_connection_t      *c,
+                     xcb_glx_context_tag_t  context_tag,
+                     uint32_t               light,
+                     uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_LIGHTIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_lightiv_cookie_t xcb_ret;
+    xcb_glx_get_lightiv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.light = light;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_lightiv_cookie_t
+xcb_glx_get_lightiv_unchecked (xcb_connection_t      *c,
+                               xcb_glx_context_tag_t  context_tag,
+                               uint32_t               light,
+                               uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_LIGHTIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_lightiv_cookie_t xcb_ret;
+    xcb_glx_get_lightiv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.light = light;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int32_t *
+xcb_glx_get_lightiv_data (const xcb_glx_get_lightiv_reply_t *R)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_lightiv_data_length (const xcb_glx_get_lightiv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_lightiv_data_end (const xcb_glx_get_lightiv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_lightiv_reply_t *
+xcb_glx_get_lightiv_reply (xcb_connection_t              *c,
+                           xcb_glx_get_lightiv_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e)
+{
+    return (xcb_glx_get_lightiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_mapdv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_mapdv_reply_t *_aux = (xcb_glx_get_mapdv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_mapdv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(xcb_glx_float64_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_glx_float64_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_mapdv_cookie_t
+xcb_glx_get_mapdv (xcb_connection_t      *c,
+                   xcb_glx_context_tag_t  context_tag,
+                   uint32_t               target,
+                   uint32_t               query)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_MAPDV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_mapdv_cookie_t xcb_ret;
+    xcb_glx_get_mapdv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.query = query;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_mapdv_cookie_t
+xcb_glx_get_mapdv_unchecked (xcb_connection_t      *c,
+                             xcb_glx_context_tag_t  context_tag,
+                             uint32_t               target,
+                             uint32_t               query)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_MAPDV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_mapdv_cookie_t xcb_ret;
+    xcb_glx_get_mapdv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.query = query;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_float64_t *
+xcb_glx_get_mapdv_data (const xcb_glx_get_mapdv_reply_t *R)
+{
+    return (xcb_glx_float64_t *) (R + 1);
+}
+
+int
+xcb_glx_get_mapdv_data_length (const xcb_glx_get_mapdv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_mapdv_data_end (const xcb_glx_get_mapdv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_glx_float64_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_mapdv_reply_t *
+xcb_glx_get_mapdv_reply (xcb_connection_t            *c,
+                         xcb_glx_get_mapdv_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e)
+{
+    return (xcb_glx_get_mapdv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_mapfv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_mapfv_reply_t *_aux = (xcb_glx_get_mapfv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_mapfv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_glx_float32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_mapfv_cookie_t
+xcb_glx_get_mapfv (xcb_connection_t      *c,
+                   xcb_glx_context_tag_t  context_tag,
+                   uint32_t               target,
+                   uint32_t               query)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_MAPFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_mapfv_cookie_t xcb_ret;
+    xcb_glx_get_mapfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.query = query;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_mapfv_cookie_t
+xcb_glx_get_mapfv_unchecked (xcb_connection_t      *c,
+                             xcb_glx_context_tag_t  context_tag,
+                             uint32_t               target,
+                             uint32_t               query)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_MAPFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_mapfv_cookie_t xcb_ret;
+    xcb_glx_get_mapfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.query = query;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_float32_t *
+xcb_glx_get_mapfv_data (const xcb_glx_get_mapfv_reply_t *R)
+{
+    return (xcb_glx_float32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_mapfv_data_length (const xcb_glx_get_mapfv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_mapfv_data_end (const xcb_glx_get_mapfv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_mapfv_reply_t *
+xcb_glx_get_mapfv_reply (xcb_connection_t            *c,
+                         xcb_glx_get_mapfv_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e)
+{
+    return (xcb_glx_get_mapfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_mapiv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_mapiv_reply_t *_aux = (xcb_glx_get_mapiv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_mapiv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_mapiv_cookie_t
+xcb_glx_get_mapiv (xcb_connection_t      *c,
+                   xcb_glx_context_tag_t  context_tag,
+                   uint32_t               target,
+                   uint32_t               query)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_MAPIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_mapiv_cookie_t xcb_ret;
+    xcb_glx_get_mapiv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.query = query;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_mapiv_cookie_t
+xcb_glx_get_mapiv_unchecked (xcb_connection_t      *c,
+                             xcb_glx_context_tag_t  context_tag,
+                             uint32_t               target,
+                             uint32_t               query)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_MAPIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_mapiv_cookie_t xcb_ret;
+    xcb_glx_get_mapiv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.query = query;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int32_t *
+xcb_glx_get_mapiv_data (const xcb_glx_get_mapiv_reply_t *R)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_mapiv_data_length (const xcb_glx_get_mapiv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_mapiv_data_end (const xcb_glx_get_mapiv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_mapiv_reply_t *
+xcb_glx_get_mapiv_reply (xcb_connection_t            *c,
+                         xcb_glx_get_mapiv_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e)
+{
+    return (xcb_glx_get_mapiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_materialfv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_materialfv_reply_t *_aux = (xcb_glx_get_materialfv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_materialfv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_glx_float32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_materialfv_cookie_t
+xcb_glx_get_materialfv (xcb_connection_t      *c,
+                        xcb_glx_context_tag_t  context_tag,
+                        uint32_t               face,
+                        uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_MATERIALFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_materialfv_cookie_t xcb_ret;
+    xcb_glx_get_materialfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.face = face;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_materialfv_cookie_t
+xcb_glx_get_materialfv_unchecked (xcb_connection_t      *c,
+                                  xcb_glx_context_tag_t  context_tag,
+                                  uint32_t               face,
+                                  uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_MATERIALFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_materialfv_cookie_t xcb_ret;
+    xcb_glx_get_materialfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.face = face;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_float32_t *
+xcb_glx_get_materialfv_data (const xcb_glx_get_materialfv_reply_t *R)
+{
+    return (xcb_glx_float32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_materialfv_data_length (const xcb_glx_get_materialfv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_materialfv_data_end (const xcb_glx_get_materialfv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_materialfv_reply_t *
+xcb_glx_get_materialfv_reply (xcb_connection_t                 *c,
+                              xcb_glx_get_materialfv_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_glx_get_materialfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_materialiv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_materialiv_reply_t *_aux = (xcb_glx_get_materialiv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_materialiv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_materialiv_cookie_t
+xcb_glx_get_materialiv (xcb_connection_t      *c,
+                        xcb_glx_context_tag_t  context_tag,
+                        uint32_t               face,
+                        uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_MATERIALIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_materialiv_cookie_t xcb_ret;
+    xcb_glx_get_materialiv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.face = face;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_materialiv_cookie_t
+xcb_glx_get_materialiv_unchecked (xcb_connection_t      *c,
+                                  xcb_glx_context_tag_t  context_tag,
+                                  uint32_t               face,
+                                  uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_MATERIALIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_materialiv_cookie_t xcb_ret;
+    xcb_glx_get_materialiv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.face = face;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int32_t *
+xcb_glx_get_materialiv_data (const xcb_glx_get_materialiv_reply_t *R)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_materialiv_data_length (const xcb_glx_get_materialiv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_materialiv_data_end (const xcb_glx_get_materialiv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_materialiv_reply_t *
+xcb_glx_get_materialiv_reply (xcb_connection_t                 *c,
+                              xcb_glx_get_materialiv_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_glx_get_materialiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_pixel_mapfv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_pixel_mapfv_reply_t *_aux = (xcb_glx_get_pixel_mapfv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_pixel_mapfv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_glx_float32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_pixel_mapfv_cookie_t
+xcb_glx_get_pixel_mapfv (xcb_connection_t      *c,
+                         xcb_glx_context_tag_t  context_tag,
+                         uint32_t               map)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_PIXEL_MAPFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_pixel_mapfv_cookie_t xcb_ret;
+    xcb_glx_get_pixel_mapfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.map = map;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_pixel_mapfv_cookie_t
+xcb_glx_get_pixel_mapfv_unchecked (xcb_connection_t      *c,
+                                   xcb_glx_context_tag_t  context_tag,
+                                   uint32_t               map)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_PIXEL_MAPFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_pixel_mapfv_cookie_t xcb_ret;
+    xcb_glx_get_pixel_mapfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.map = map;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_float32_t *
+xcb_glx_get_pixel_mapfv_data (const xcb_glx_get_pixel_mapfv_reply_t *R)
+{
+    return (xcb_glx_float32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_pixel_mapfv_data_length (const xcb_glx_get_pixel_mapfv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_pixel_mapfv_data_end (const xcb_glx_get_pixel_mapfv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_pixel_mapfv_reply_t *
+xcb_glx_get_pixel_mapfv_reply (xcb_connection_t                  *c,
+                               xcb_glx_get_pixel_mapfv_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_glx_get_pixel_mapfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_pixel_mapuiv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_pixel_mapuiv_reply_t *_aux = (xcb_glx_get_pixel_mapuiv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_pixel_mapuiv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_pixel_mapuiv_cookie_t
+xcb_glx_get_pixel_mapuiv (xcb_connection_t      *c,
+                          xcb_glx_context_tag_t  context_tag,
+                          uint32_t               map)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_PIXEL_MAPUIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_pixel_mapuiv_cookie_t xcb_ret;
+    xcb_glx_get_pixel_mapuiv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.map = map;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_pixel_mapuiv_cookie_t
+xcb_glx_get_pixel_mapuiv_unchecked (xcb_connection_t      *c,
+                                    xcb_glx_context_tag_t  context_tag,
+                                    uint32_t               map)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_PIXEL_MAPUIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_pixel_mapuiv_cookie_t xcb_ret;
+    xcb_glx_get_pixel_mapuiv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.map = map;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_glx_get_pixel_mapuiv_data (const xcb_glx_get_pixel_mapuiv_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_pixel_mapuiv_data_length (const xcb_glx_get_pixel_mapuiv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_pixel_mapuiv_data_end (const xcb_glx_get_pixel_mapuiv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_pixel_mapuiv_reply_t *
+xcb_glx_get_pixel_mapuiv_reply (xcb_connection_t                   *c,
+                                xcb_glx_get_pixel_mapuiv_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e)
+{
+    return (xcb_glx_get_pixel_mapuiv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_pixel_mapusv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_pixel_mapusv_reply_t *_aux = (xcb_glx_get_pixel_mapusv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_pixel_mapusv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(uint16_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint16_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_pixel_mapusv_cookie_t
+xcb_glx_get_pixel_mapusv (xcb_connection_t      *c,
+                          xcb_glx_context_tag_t  context_tag,
+                          uint32_t               map)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_PIXEL_MAPUSV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_pixel_mapusv_cookie_t xcb_ret;
+    xcb_glx_get_pixel_mapusv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.map = map;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_pixel_mapusv_cookie_t
+xcb_glx_get_pixel_mapusv_unchecked (xcb_connection_t      *c,
+                                    xcb_glx_context_tag_t  context_tag,
+                                    uint32_t               map)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_PIXEL_MAPUSV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_pixel_mapusv_cookie_t xcb_ret;
+    xcb_glx_get_pixel_mapusv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.map = map;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint16_t *
+xcb_glx_get_pixel_mapusv_data (const xcb_glx_get_pixel_mapusv_reply_t *R)
+{
+    return (uint16_t *) (R + 1);
+}
+
+int
+xcb_glx_get_pixel_mapusv_data_length (const xcb_glx_get_pixel_mapusv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_pixel_mapusv_data_end (const xcb_glx_get_pixel_mapusv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint16_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_pixel_mapusv_reply_t *
+xcb_glx_get_pixel_mapusv_reply (xcb_connection_t                   *c,
+                                xcb_glx_get_pixel_mapusv_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e)
+{
+    return (xcb_glx_get_pixel_mapusv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_polygon_stipple_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_polygon_stipple_reply_t *_aux = (xcb_glx_get_polygon_stipple_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_polygon_stipple_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += (_aux->length * 4) * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_polygon_stipple_cookie_t
+xcb_glx_get_polygon_stipple (xcb_connection_t      *c,
+                             xcb_glx_context_tag_t  context_tag,
+                             uint8_t                lsb_first)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_POLYGON_STIPPLE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_polygon_stipple_cookie_t xcb_ret;
+    xcb_glx_get_polygon_stipple_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.lsb_first = lsb_first;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_polygon_stipple_cookie_t
+xcb_glx_get_polygon_stipple_unchecked (xcb_connection_t      *c,
+                                       xcb_glx_context_tag_t  context_tag,
+                                       uint8_t                lsb_first)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_POLYGON_STIPPLE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_polygon_stipple_cookie_t xcb_ret;
+    xcb_glx_get_polygon_stipple_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.lsb_first = lsb_first;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_glx_get_polygon_stipple_data (const xcb_glx_get_polygon_stipple_reply_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_glx_get_polygon_stipple_data_length (const xcb_glx_get_polygon_stipple_reply_t *R)
+{
+    return (R->length * 4);
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_polygon_stipple_data_end (const xcb_glx_get_polygon_stipple_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((R->length * 4));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_polygon_stipple_reply_t *
+xcb_glx_get_polygon_stipple_reply (xcb_connection_t                      *c,
+                                   xcb_glx_get_polygon_stipple_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e)
+{
+    return (xcb_glx_get_polygon_stipple_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_string_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_string_reply_t *_aux = (xcb_glx_get_string_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_string_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* string */
+    xcb_block_len += _aux->n * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_string_cookie_t
+xcb_glx_get_string (xcb_connection_t      *c,
+                    xcb_glx_context_tag_t  context_tag,
+                    uint32_t               name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_STRING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_string_cookie_t xcb_ret;
+    xcb_glx_get_string_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.name = name;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_string_cookie_t
+xcb_glx_get_string_unchecked (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              uint32_t               name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_STRING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_string_cookie_t xcb_ret;
+    xcb_glx_get_string_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.name = name;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_glx_get_string_string (const xcb_glx_get_string_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_glx_get_string_string_length (const xcb_glx_get_string_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_string_string_end (const xcb_glx_get_string_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_string_reply_t *
+xcb_glx_get_string_reply (xcb_connection_t             *c,
+                          xcb_glx_get_string_cookie_t   cookie  /**< */,
+                          xcb_generic_error_t         **e)
+{
+    return (xcb_glx_get_string_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_tex_envfv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_tex_envfv_reply_t *_aux = (xcb_glx_get_tex_envfv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_tex_envfv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_glx_float32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_tex_envfv_cookie_t
+xcb_glx_get_tex_envfv (xcb_connection_t      *c,
+                       xcb_glx_context_tag_t  context_tag,
+                       uint32_t               target,
+                       uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_TEX_ENVFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_tex_envfv_cookie_t xcb_ret;
+    xcb_glx_get_tex_envfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_tex_envfv_cookie_t
+xcb_glx_get_tex_envfv_unchecked (xcb_connection_t      *c,
+                                 xcb_glx_context_tag_t  context_tag,
+                                 uint32_t               target,
+                                 uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_TEX_ENVFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_tex_envfv_cookie_t xcb_ret;
+    xcb_glx_get_tex_envfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_float32_t *
+xcb_glx_get_tex_envfv_data (const xcb_glx_get_tex_envfv_reply_t *R)
+{
+    return (xcb_glx_float32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_tex_envfv_data_length (const xcb_glx_get_tex_envfv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_tex_envfv_data_end (const xcb_glx_get_tex_envfv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_tex_envfv_reply_t *
+xcb_glx_get_tex_envfv_reply (xcb_connection_t                *c,
+                             xcb_glx_get_tex_envfv_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_glx_get_tex_envfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_tex_enviv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_tex_enviv_reply_t *_aux = (xcb_glx_get_tex_enviv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_tex_enviv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_tex_enviv_cookie_t
+xcb_glx_get_tex_enviv (xcb_connection_t      *c,
+                       xcb_glx_context_tag_t  context_tag,
+                       uint32_t               target,
+                       uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_TEX_ENVIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_tex_enviv_cookie_t xcb_ret;
+    xcb_glx_get_tex_enviv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_tex_enviv_cookie_t
+xcb_glx_get_tex_enviv_unchecked (xcb_connection_t      *c,
+                                 xcb_glx_context_tag_t  context_tag,
+                                 uint32_t               target,
+                                 uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_TEX_ENVIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_tex_enviv_cookie_t xcb_ret;
+    xcb_glx_get_tex_enviv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int32_t *
+xcb_glx_get_tex_enviv_data (const xcb_glx_get_tex_enviv_reply_t *R)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_tex_enviv_data_length (const xcb_glx_get_tex_enviv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_tex_enviv_data_end (const xcb_glx_get_tex_enviv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_tex_enviv_reply_t *
+xcb_glx_get_tex_enviv_reply (xcb_connection_t                *c,
+                             xcb_glx_get_tex_enviv_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_glx_get_tex_enviv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_tex_gendv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_tex_gendv_reply_t *_aux = (xcb_glx_get_tex_gendv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_tex_gendv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(xcb_glx_float64_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_glx_float64_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_tex_gendv_cookie_t
+xcb_glx_get_tex_gendv (xcb_connection_t      *c,
+                       xcb_glx_context_tag_t  context_tag,
+                       uint32_t               coord,
+                       uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_TEX_GENDV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_tex_gendv_cookie_t xcb_ret;
+    xcb_glx_get_tex_gendv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.coord = coord;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_tex_gendv_cookie_t
+xcb_glx_get_tex_gendv_unchecked (xcb_connection_t      *c,
+                                 xcb_glx_context_tag_t  context_tag,
+                                 uint32_t               coord,
+                                 uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_TEX_GENDV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_tex_gendv_cookie_t xcb_ret;
+    xcb_glx_get_tex_gendv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.coord = coord;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_float64_t *
+xcb_glx_get_tex_gendv_data (const xcb_glx_get_tex_gendv_reply_t *R)
+{
+    return (xcb_glx_float64_t *) (R + 1);
+}
+
+int
+xcb_glx_get_tex_gendv_data_length (const xcb_glx_get_tex_gendv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_tex_gendv_data_end (const xcb_glx_get_tex_gendv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_glx_float64_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_tex_gendv_reply_t *
+xcb_glx_get_tex_gendv_reply (xcb_connection_t                *c,
+                             xcb_glx_get_tex_gendv_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_glx_get_tex_gendv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_tex_genfv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_tex_genfv_reply_t *_aux = (xcb_glx_get_tex_genfv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_tex_genfv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_glx_float32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_tex_genfv_cookie_t
+xcb_glx_get_tex_genfv (xcb_connection_t      *c,
+                       xcb_glx_context_tag_t  context_tag,
+                       uint32_t               coord,
+                       uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_TEX_GENFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_tex_genfv_cookie_t xcb_ret;
+    xcb_glx_get_tex_genfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.coord = coord;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_tex_genfv_cookie_t
+xcb_glx_get_tex_genfv_unchecked (xcb_connection_t      *c,
+                                 xcb_glx_context_tag_t  context_tag,
+                                 uint32_t               coord,
+                                 uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_TEX_GENFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_tex_genfv_cookie_t xcb_ret;
+    xcb_glx_get_tex_genfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.coord = coord;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_float32_t *
+xcb_glx_get_tex_genfv_data (const xcb_glx_get_tex_genfv_reply_t *R)
+{
+    return (xcb_glx_float32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_tex_genfv_data_length (const xcb_glx_get_tex_genfv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_tex_genfv_data_end (const xcb_glx_get_tex_genfv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_tex_genfv_reply_t *
+xcb_glx_get_tex_genfv_reply (xcb_connection_t                *c,
+                             xcb_glx_get_tex_genfv_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_glx_get_tex_genfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_tex_geniv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_tex_geniv_reply_t *_aux = (xcb_glx_get_tex_geniv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_tex_geniv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_tex_geniv_cookie_t
+xcb_glx_get_tex_geniv (xcb_connection_t      *c,
+                       xcb_glx_context_tag_t  context_tag,
+                       uint32_t               coord,
+                       uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_TEX_GENIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_tex_geniv_cookie_t xcb_ret;
+    xcb_glx_get_tex_geniv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.coord = coord;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_tex_geniv_cookie_t
+xcb_glx_get_tex_geniv_unchecked (xcb_connection_t      *c,
+                                 xcb_glx_context_tag_t  context_tag,
+                                 uint32_t               coord,
+                                 uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_TEX_GENIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_tex_geniv_cookie_t xcb_ret;
+    xcb_glx_get_tex_geniv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.coord = coord;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int32_t *
+xcb_glx_get_tex_geniv_data (const xcb_glx_get_tex_geniv_reply_t *R)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_tex_geniv_data_length (const xcb_glx_get_tex_geniv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_tex_geniv_data_end (const xcb_glx_get_tex_geniv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_tex_geniv_reply_t *
+xcb_glx_get_tex_geniv_reply (xcb_connection_t                *c,
+                             xcb_glx_get_tex_geniv_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_glx_get_tex_geniv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_tex_image_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_tex_image_reply_t *_aux = (xcb_glx_get_tex_image_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_tex_image_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += (_aux->length * 4) * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_tex_image_cookie_t
+xcb_glx_get_tex_image (xcb_connection_t      *c,
+                       xcb_glx_context_tag_t  context_tag,
+                       uint32_t               target,
+                       int32_t                level,
+                       uint32_t               format,
+                       uint32_t               type,
+                       uint8_t                swap_bytes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_TEX_IMAGE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_tex_image_cookie_t xcb_ret;
+    xcb_glx_get_tex_image_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.level = level;
+    xcb_out.format = format;
+    xcb_out.type = type;
+    xcb_out.swap_bytes = swap_bytes;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_tex_image_cookie_t
+xcb_glx_get_tex_image_unchecked (xcb_connection_t      *c,
+                                 xcb_glx_context_tag_t  context_tag,
+                                 uint32_t               target,
+                                 int32_t                level,
+                                 uint32_t               format,
+                                 uint32_t               type,
+                                 uint8_t                swap_bytes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_TEX_IMAGE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_tex_image_cookie_t xcb_ret;
+    xcb_glx_get_tex_image_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.level = level;
+    xcb_out.format = format;
+    xcb_out.type = type;
+    xcb_out.swap_bytes = swap_bytes;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_glx_get_tex_image_data (const xcb_glx_get_tex_image_reply_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_glx_get_tex_image_data_length (const xcb_glx_get_tex_image_reply_t *R)
+{
+    return (R->length * 4);
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_tex_image_data_end (const xcb_glx_get_tex_image_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((R->length * 4));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_tex_image_reply_t *
+xcb_glx_get_tex_image_reply (xcb_connection_t                *c,
+                             xcb_glx_get_tex_image_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_glx_get_tex_image_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_tex_parameterfv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_tex_parameterfv_reply_t *_aux = (xcb_glx_get_tex_parameterfv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_tex_parameterfv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_glx_float32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_tex_parameterfv_cookie_t
+xcb_glx_get_tex_parameterfv (xcb_connection_t      *c,
+                             xcb_glx_context_tag_t  context_tag,
+                             uint32_t               target,
+                             uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_TEX_PARAMETERFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_tex_parameterfv_cookie_t xcb_ret;
+    xcb_glx_get_tex_parameterfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_tex_parameterfv_cookie_t
+xcb_glx_get_tex_parameterfv_unchecked (xcb_connection_t      *c,
+                                       xcb_glx_context_tag_t  context_tag,
+                                       uint32_t               target,
+                                       uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_TEX_PARAMETERFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_tex_parameterfv_cookie_t xcb_ret;
+    xcb_glx_get_tex_parameterfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_float32_t *
+xcb_glx_get_tex_parameterfv_data (const xcb_glx_get_tex_parameterfv_reply_t *R)
+{
+    return (xcb_glx_float32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_tex_parameterfv_data_length (const xcb_glx_get_tex_parameterfv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_tex_parameterfv_data_end (const xcb_glx_get_tex_parameterfv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_tex_parameterfv_reply_t *
+xcb_glx_get_tex_parameterfv_reply (xcb_connection_t                      *c,
+                                   xcb_glx_get_tex_parameterfv_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e)
+{
+    return (xcb_glx_get_tex_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_tex_parameteriv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_tex_parameteriv_reply_t *_aux = (xcb_glx_get_tex_parameteriv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_tex_parameteriv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_tex_parameteriv_cookie_t
+xcb_glx_get_tex_parameteriv (xcb_connection_t      *c,
+                             xcb_glx_context_tag_t  context_tag,
+                             uint32_t               target,
+                             uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_TEX_PARAMETERIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_tex_parameteriv_cookie_t xcb_ret;
+    xcb_glx_get_tex_parameteriv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_tex_parameteriv_cookie_t
+xcb_glx_get_tex_parameteriv_unchecked (xcb_connection_t      *c,
+                                       xcb_glx_context_tag_t  context_tag,
+                                       uint32_t               target,
+                                       uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_TEX_PARAMETERIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_tex_parameteriv_cookie_t xcb_ret;
+    xcb_glx_get_tex_parameteriv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int32_t *
+xcb_glx_get_tex_parameteriv_data (const xcb_glx_get_tex_parameteriv_reply_t *R)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_tex_parameteriv_data_length (const xcb_glx_get_tex_parameteriv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_tex_parameteriv_data_end (const xcb_glx_get_tex_parameteriv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_tex_parameteriv_reply_t *
+xcb_glx_get_tex_parameteriv_reply (xcb_connection_t                      *c,
+                                   xcb_glx_get_tex_parameteriv_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e)
+{
+    return (xcb_glx_get_tex_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_tex_level_parameterfv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_tex_level_parameterfv_reply_t *_aux = (xcb_glx_get_tex_level_parameterfv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_tex_level_parameterfv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_glx_float32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_tex_level_parameterfv_cookie_t
+xcb_glx_get_tex_level_parameterfv (xcb_connection_t      *c,
+                                   xcb_glx_context_tag_t  context_tag,
+                                   uint32_t               target,
+                                   int32_t                level,
+                                   uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_TEX_LEVEL_PARAMETERFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_tex_level_parameterfv_cookie_t xcb_ret;
+    xcb_glx_get_tex_level_parameterfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.level = level;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_tex_level_parameterfv_cookie_t
+xcb_glx_get_tex_level_parameterfv_unchecked (xcb_connection_t      *c,
+                                             xcb_glx_context_tag_t  context_tag,
+                                             uint32_t               target,
+                                             int32_t                level,
+                                             uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_TEX_LEVEL_PARAMETERFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_tex_level_parameterfv_cookie_t xcb_ret;
+    xcb_glx_get_tex_level_parameterfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.level = level;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_float32_t *
+xcb_glx_get_tex_level_parameterfv_data (const xcb_glx_get_tex_level_parameterfv_reply_t *R)
+{
+    return (xcb_glx_float32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_tex_level_parameterfv_data_length (const xcb_glx_get_tex_level_parameterfv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_tex_level_parameterfv_data_end (const xcb_glx_get_tex_level_parameterfv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_tex_level_parameterfv_reply_t *
+xcb_glx_get_tex_level_parameterfv_reply (xcb_connection_t                            *c,
+                                         xcb_glx_get_tex_level_parameterfv_cookie_t   cookie  /**< */,
+                                         xcb_generic_error_t                        **e)
+{
+    return (xcb_glx_get_tex_level_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_tex_level_parameteriv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_tex_level_parameteriv_reply_t *_aux = (xcb_glx_get_tex_level_parameteriv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_tex_level_parameteriv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_tex_level_parameteriv_cookie_t
+xcb_glx_get_tex_level_parameteriv (xcb_connection_t      *c,
+                                   xcb_glx_context_tag_t  context_tag,
+                                   uint32_t               target,
+                                   int32_t                level,
+                                   uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_TEX_LEVEL_PARAMETERIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_tex_level_parameteriv_cookie_t xcb_ret;
+    xcb_glx_get_tex_level_parameteriv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.level = level;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_tex_level_parameteriv_cookie_t
+xcb_glx_get_tex_level_parameteriv_unchecked (xcb_connection_t      *c,
+                                             xcb_glx_context_tag_t  context_tag,
+                                             uint32_t               target,
+                                             int32_t                level,
+                                             uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_TEX_LEVEL_PARAMETERIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_tex_level_parameteriv_cookie_t xcb_ret;
+    xcb_glx_get_tex_level_parameteriv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.level = level;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int32_t *
+xcb_glx_get_tex_level_parameteriv_data (const xcb_glx_get_tex_level_parameteriv_reply_t *R)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_tex_level_parameteriv_data_length (const xcb_glx_get_tex_level_parameteriv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_tex_level_parameteriv_data_end (const xcb_glx_get_tex_level_parameteriv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_tex_level_parameteriv_reply_t *
+xcb_glx_get_tex_level_parameteriv_reply (xcb_connection_t                            *c,
+                                         xcb_glx_get_tex_level_parameteriv_cookie_t   cookie  /**< */,
+                                         xcb_generic_error_t                        **e)
+{
+    return (xcb_glx_get_tex_level_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_glx_is_enabled_cookie_t
+xcb_glx_is_enabled (xcb_connection_t      *c,
+                    xcb_glx_context_tag_t  context_tag,
+                    uint32_t               capability)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_IS_ENABLED,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_is_enabled_cookie_t xcb_ret;
+    xcb_glx_is_enabled_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.capability = capability;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_is_enabled_cookie_t
+xcb_glx_is_enabled_unchecked (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              uint32_t               capability)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_IS_ENABLED,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_is_enabled_cookie_t xcb_ret;
+    xcb_glx_is_enabled_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.capability = capability;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_is_enabled_reply_t *
+xcb_glx_is_enabled_reply (xcb_connection_t             *c,
+                          xcb_glx_is_enabled_cookie_t   cookie  /**< */,
+                          xcb_generic_error_t         **e)
+{
+    return (xcb_glx_is_enabled_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_glx_is_list_cookie_t
+xcb_glx_is_list (xcb_connection_t      *c,
+                 xcb_glx_context_tag_t  context_tag,
+                 uint32_t               list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_IS_LIST,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_is_list_cookie_t xcb_ret;
+    xcb_glx_is_list_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.list = list;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_is_list_cookie_t
+xcb_glx_is_list_unchecked (xcb_connection_t      *c,
+                           xcb_glx_context_tag_t  context_tag,
+                           uint32_t               list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_IS_LIST,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_is_list_cookie_t xcb_ret;
+    xcb_glx_is_list_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.list = list;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_is_list_reply_t *
+xcb_glx_is_list_reply (xcb_connection_t          *c,
+                       xcb_glx_is_list_cookie_t   cookie  /**< */,
+                       xcb_generic_error_t      **e)
+{
+    return (xcb_glx_is_list_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_glx_flush_checked (xcb_connection_t      *c,
+                       xcb_glx_context_tag_t  context_tag)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_FLUSH,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_flush_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_flush (xcb_connection_t      *c,
+               xcb_glx_context_tag_t  context_tag)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_FLUSH,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_flush_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_glx_are_textures_resident_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_are_textures_resident_request_t *_aux = (xcb_glx_are_textures_resident_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_are_textures_resident_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* textures */
+    xcb_block_len += _aux->n * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_are_textures_resident_cookie_t
+xcb_glx_are_textures_resident (xcb_connection_t      *c,
+                               xcb_glx_context_tag_t  context_tag,
+                               int32_t                n,
+                               const uint32_t        *textures)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_ARE_TEXTURES_RESIDENT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_glx_are_textures_resident_cookie_t xcb_ret;
+    xcb_glx_are_textures_resident_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.n = n;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t textures */
+    xcb_parts[4].iov_base = (char *) textures;
+    xcb_parts[4].iov_len = n * sizeof(xcb_glx_bool32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_are_textures_resident_cookie_t
+xcb_glx_are_textures_resident_unchecked (xcb_connection_t      *c,
+                                         xcb_glx_context_tag_t  context_tag,
+                                         int32_t                n,
+                                         const uint32_t        *textures)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_ARE_TEXTURES_RESIDENT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_glx_are_textures_resident_cookie_t xcb_ret;
+    xcb_glx_are_textures_resident_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.n = n;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t textures */
+    xcb_parts[4].iov_base = (char *) textures;
+    xcb_parts[4].iov_len = n * sizeof(xcb_glx_bool32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_glx_are_textures_resident_data (const xcb_glx_are_textures_resident_reply_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_glx_are_textures_resident_data_length (const xcb_glx_are_textures_resident_reply_t *R)
+{
+    return (R->length * 4);
+}
+
+xcb_generic_iterator_t
+xcb_glx_are_textures_resident_data_end (const xcb_glx_are_textures_resident_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((R->length * 4));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_are_textures_resident_reply_t *
+xcb_glx_are_textures_resident_reply (xcb_connection_t                        *c,
+                                     xcb_glx_are_textures_resident_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e)
+{
+    return (xcb_glx_are_textures_resident_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_delete_textures_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_delete_textures_request_t *_aux = (xcb_glx_delete_textures_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_delete_textures_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* textures */
+    xcb_block_len += _aux->n * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_glx_delete_textures_checked (xcb_connection_t      *c,
+                                 xcb_glx_context_tag_t  context_tag,
+                                 int32_t                n,
+                                 const uint32_t        *textures)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_DELETE_TEXTURES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_delete_textures_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.n = n;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t textures */
+    xcb_parts[4].iov_base = (char *) textures;
+    xcb_parts[4].iov_len = n * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_delete_textures (xcb_connection_t      *c,
+                         xcb_glx_context_tag_t  context_tag,
+                         int32_t                n,
+                         const uint32_t        *textures)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_DELETE_TEXTURES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_delete_textures_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.n = n;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t textures */
+    xcb_parts[4].iov_base = (char *) textures;
+    xcb_parts[4].iov_len = n * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_glx_delete_textures_textures (const xcb_glx_delete_textures_request_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_glx_delete_textures_textures_length (const xcb_glx_delete_textures_request_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_delete_textures_textures_end (const xcb_glx_delete_textures_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_glx_gen_textures_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_gen_textures_reply_t *_aux = (xcb_glx_gen_textures_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_gen_textures_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->length * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_gen_textures_cookie_t
+xcb_glx_gen_textures (xcb_connection_t      *c,
+                      xcb_glx_context_tag_t  context_tag,
+                      int32_t                n)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GEN_TEXTURES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_gen_textures_cookie_t xcb_ret;
+    xcb_glx_gen_textures_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.n = n;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_gen_textures_cookie_t
+xcb_glx_gen_textures_unchecked (xcb_connection_t      *c,
+                                xcb_glx_context_tag_t  context_tag,
+                                int32_t                n)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GEN_TEXTURES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_gen_textures_cookie_t xcb_ret;
+    xcb_glx_gen_textures_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.n = n;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_glx_gen_textures_data (const xcb_glx_gen_textures_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_glx_gen_textures_data_length (const xcb_glx_gen_textures_reply_t *R)
+{
+    return R->length;
+}
+
+xcb_generic_iterator_t
+xcb_glx_gen_textures_data_end (const xcb_glx_gen_textures_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->length);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_gen_textures_reply_t *
+xcb_glx_gen_textures_reply (xcb_connection_t               *c,
+                            xcb_glx_gen_textures_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e)
+{
+    return (xcb_glx_gen_textures_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_glx_is_texture_cookie_t
+xcb_glx_is_texture (xcb_connection_t      *c,
+                    xcb_glx_context_tag_t  context_tag,
+                    uint32_t               texture)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_IS_TEXTURE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_is_texture_cookie_t xcb_ret;
+    xcb_glx_is_texture_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.texture = texture;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_is_texture_cookie_t
+xcb_glx_is_texture_unchecked (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              uint32_t               texture)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_IS_TEXTURE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_is_texture_cookie_t xcb_ret;
+    xcb_glx_is_texture_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.texture = texture;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_is_texture_reply_t *
+xcb_glx_is_texture_reply (xcb_connection_t             *c,
+                          xcb_glx_is_texture_cookie_t   cookie  /**< */,
+                          xcb_generic_error_t         **e)
+{
+    return (xcb_glx_is_texture_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_color_table_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_color_table_reply_t *_aux = (xcb_glx_get_color_table_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_color_table_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += (_aux->length * 4) * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_color_table_cookie_t
+xcb_glx_get_color_table (xcb_connection_t      *c,
+                         xcb_glx_context_tag_t  context_tag,
+                         uint32_t               target,
+                         uint32_t               format,
+                         uint32_t               type,
+                         uint8_t                swap_bytes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_COLOR_TABLE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_color_table_cookie_t xcb_ret;
+    xcb_glx_get_color_table_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.format = format;
+    xcb_out.type = type;
+    xcb_out.swap_bytes = swap_bytes;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_color_table_cookie_t
+xcb_glx_get_color_table_unchecked (xcb_connection_t      *c,
+                                   xcb_glx_context_tag_t  context_tag,
+                                   uint32_t               target,
+                                   uint32_t               format,
+                                   uint32_t               type,
+                                   uint8_t                swap_bytes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_COLOR_TABLE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_color_table_cookie_t xcb_ret;
+    xcb_glx_get_color_table_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.format = format;
+    xcb_out.type = type;
+    xcb_out.swap_bytes = swap_bytes;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_glx_get_color_table_data (const xcb_glx_get_color_table_reply_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_glx_get_color_table_data_length (const xcb_glx_get_color_table_reply_t *R)
+{
+    return (R->length * 4);
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_color_table_data_end (const xcb_glx_get_color_table_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((R->length * 4));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_color_table_reply_t *
+xcb_glx_get_color_table_reply (xcb_connection_t                  *c,
+                               xcb_glx_get_color_table_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_glx_get_color_table_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_color_table_parameterfv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_color_table_parameterfv_reply_t *_aux = (xcb_glx_get_color_table_parameterfv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_color_table_parameterfv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_glx_float32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_color_table_parameterfv_cookie_t
+xcb_glx_get_color_table_parameterfv (xcb_connection_t      *c,
+                                     xcb_glx_context_tag_t  context_tag,
+                                     uint32_t               target,
+                                     uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_COLOR_TABLE_PARAMETERFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_color_table_parameterfv_cookie_t xcb_ret;
+    xcb_glx_get_color_table_parameterfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_color_table_parameterfv_cookie_t
+xcb_glx_get_color_table_parameterfv_unchecked (xcb_connection_t      *c,
+                                               xcb_glx_context_tag_t  context_tag,
+                                               uint32_t               target,
+                                               uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_COLOR_TABLE_PARAMETERFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_color_table_parameterfv_cookie_t xcb_ret;
+    xcb_glx_get_color_table_parameterfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_float32_t *
+xcb_glx_get_color_table_parameterfv_data (const xcb_glx_get_color_table_parameterfv_reply_t *R)
+{
+    return (xcb_glx_float32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_color_table_parameterfv_data_length (const xcb_glx_get_color_table_parameterfv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_color_table_parameterfv_data_end (const xcb_glx_get_color_table_parameterfv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_color_table_parameterfv_reply_t *
+xcb_glx_get_color_table_parameterfv_reply (xcb_connection_t                              *c,
+                                           xcb_glx_get_color_table_parameterfv_cookie_t   cookie  /**< */,
+                                           xcb_generic_error_t                          **e)
+{
+    return (xcb_glx_get_color_table_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_color_table_parameteriv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_color_table_parameteriv_reply_t *_aux = (xcb_glx_get_color_table_parameteriv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_color_table_parameteriv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_color_table_parameteriv_cookie_t
+xcb_glx_get_color_table_parameteriv (xcb_connection_t      *c,
+                                     xcb_glx_context_tag_t  context_tag,
+                                     uint32_t               target,
+                                     uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_COLOR_TABLE_PARAMETERIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_color_table_parameteriv_cookie_t xcb_ret;
+    xcb_glx_get_color_table_parameteriv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_color_table_parameteriv_cookie_t
+xcb_glx_get_color_table_parameteriv_unchecked (xcb_connection_t      *c,
+                                               xcb_glx_context_tag_t  context_tag,
+                                               uint32_t               target,
+                                               uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_COLOR_TABLE_PARAMETERIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_color_table_parameteriv_cookie_t xcb_ret;
+    xcb_glx_get_color_table_parameteriv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int32_t *
+xcb_glx_get_color_table_parameteriv_data (const xcb_glx_get_color_table_parameteriv_reply_t *R)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_color_table_parameteriv_data_length (const xcb_glx_get_color_table_parameteriv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_color_table_parameteriv_data_end (const xcb_glx_get_color_table_parameteriv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_color_table_parameteriv_reply_t *
+xcb_glx_get_color_table_parameteriv_reply (xcb_connection_t                              *c,
+                                           xcb_glx_get_color_table_parameteriv_cookie_t   cookie  /**< */,
+                                           xcb_generic_error_t                          **e)
+{
+    return (xcb_glx_get_color_table_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_convolution_filter_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_convolution_filter_reply_t *_aux = (xcb_glx_get_convolution_filter_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_convolution_filter_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += (_aux->length * 4) * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_convolution_filter_cookie_t
+xcb_glx_get_convolution_filter (xcb_connection_t      *c,
+                                xcb_glx_context_tag_t  context_tag,
+                                uint32_t               target,
+                                uint32_t               format,
+                                uint32_t               type,
+                                uint8_t                swap_bytes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_CONVOLUTION_FILTER,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_convolution_filter_cookie_t xcb_ret;
+    xcb_glx_get_convolution_filter_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.format = format;
+    xcb_out.type = type;
+    xcb_out.swap_bytes = swap_bytes;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_convolution_filter_cookie_t
+xcb_glx_get_convolution_filter_unchecked (xcb_connection_t      *c,
+                                          xcb_glx_context_tag_t  context_tag,
+                                          uint32_t               target,
+                                          uint32_t               format,
+                                          uint32_t               type,
+                                          uint8_t                swap_bytes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_CONVOLUTION_FILTER,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_convolution_filter_cookie_t xcb_ret;
+    xcb_glx_get_convolution_filter_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.format = format;
+    xcb_out.type = type;
+    xcb_out.swap_bytes = swap_bytes;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_glx_get_convolution_filter_data (const xcb_glx_get_convolution_filter_reply_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_glx_get_convolution_filter_data_length (const xcb_glx_get_convolution_filter_reply_t *R)
+{
+    return (R->length * 4);
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_convolution_filter_data_end (const xcb_glx_get_convolution_filter_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((R->length * 4));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_convolution_filter_reply_t *
+xcb_glx_get_convolution_filter_reply (xcb_connection_t                         *c,
+                                      xcb_glx_get_convolution_filter_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e)
+{
+    return (xcb_glx_get_convolution_filter_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_convolution_parameterfv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_convolution_parameterfv_reply_t *_aux = (xcb_glx_get_convolution_parameterfv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_convolution_parameterfv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_glx_float32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_convolution_parameterfv_cookie_t
+xcb_glx_get_convolution_parameterfv (xcb_connection_t      *c,
+                                     xcb_glx_context_tag_t  context_tag,
+                                     uint32_t               target,
+                                     uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_CONVOLUTION_PARAMETERFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_convolution_parameterfv_cookie_t xcb_ret;
+    xcb_glx_get_convolution_parameterfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_convolution_parameterfv_cookie_t
+xcb_glx_get_convolution_parameterfv_unchecked (xcb_connection_t      *c,
+                                               xcb_glx_context_tag_t  context_tag,
+                                               uint32_t               target,
+                                               uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_CONVOLUTION_PARAMETERFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_convolution_parameterfv_cookie_t xcb_ret;
+    xcb_glx_get_convolution_parameterfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_float32_t *
+xcb_glx_get_convolution_parameterfv_data (const xcb_glx_get_convolution_parameterfv_reply_t *R)
+{
+    return (xcb_glx_float32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_convolution_parameterfv_data_length (const xcb_glx_get_convolution_parameterfv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_convolution_parameterfv_data_end (const xcb_glx_get_convolution_parameterfv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_convolution_parameterfv_reply_t *
+xcb_glx_get_convolution_parameterfv_reply (xcb_connection_t                              *c,
+                                           xcb_glx_get_convolution_parameterfv_cookie_t   cookie  /**< */,
+                                           xcb_generic_error_t                          **e)
+{
+    return (xcb_glx_get_convolution_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_convolution_parameteriv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_convolution_parameteriv_reply_t *_aux = (xcb_glx_get_convolution_parameteriv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_convolution_parameteriv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_convolution_parameteriv_cookie_t
+xcb_glx_get_convolution_parameteriv (xcb_connection_t      *c,
+                                     xcb_glx_context_tag_t  context_tag,
+                                     uint32_t               target,
+                                     uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_CONVOLUTION_PARAMETERIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_convolution_parameteriv_cookie_t xcb_ret;
+    xcb_glx_get_convolution_parameteriv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_convolution_parameteriv_cookie_t
+xcb_glx_get_convolution_parameteriv_unchecked (xcb_connection_t      *c,
+                                               xcb_glx_context_tag_t  context_tag,
+                                               uint32_t               target,
+                                               uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_CONVOLUTION_PARAMETERIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_convolution_parameteriv_cookie_t xcb_ret;
+    xcb_glx_get_convolution_parameteriv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int32_t *
+xcb_glx_get_convolution_parameteriv_data (const xcb_glx_get_convolution_parameteriv_reply_t *R)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_convolution_parameteriv_data_length (const xcb_glx_get_convolution_parameteriv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_convolution_parameteriv_data_end (const xcb_glx_get_convolution_parameteriv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_convolution_parameteriv_reply_t *
+xcb_glx_get_convolution_parameteriv_reply (xcb_connection_t                              *c,
+                                           xcb_glx_get_convolution_parameteriv_cookie_t   cookie  /**< */,
+                                           xcb_generic_error_t                          **e)
+{
+    return (xcb_glx_get_convolution_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_separable_filter_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_separable_filter_reply_t *_aux = (xcb_glx_get_separable_filter_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_separable_filter_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* rows_and_cols */
+    xcb_block_len += (_aux->length * 4) * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_separable_filter_cookie_t
+xcb_glx_get_separable_filter (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              uint32_t               target,
+                              uint32_t               format,
+                              uint32_t               type,
+                              uint8_t                swap_bytes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_SEPARABLE_FILTER,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_separable_filter_cookie_t xcb_ret;
+    xcb_glx_get_separable_filter_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.format = format;
+    xcb_out.type = type;
+    xcb_out.swap_bytes = swap_bytes;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_separable_filter_cookie_t
+xcb_glx_get_separable_filter_unchecked (xcb_connection_t      *c,
+                                        xcb_glx_context_tag_t  context_tag,
+                                        uint32_t               target,
+                                        uint32_t               format,
+                                        uint32_t               type,
+                                        uint8_t                swap_bytes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_SEPARABLE_FILTER,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_separable_filter_cookie_t xcb_ret;
+    xcb_glx_get_separable_filter_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.format = format;
+    xcb_out.type = type;
+    xcb_out.swap_bytes = swap_bytes;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_glx_get_separable_filter_rows_and_cols (const xcb_glx_get_separable_filter_reply_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_glx_get_separable_filter_rows_and_cols_length (const xcb_glx_get_separable_filter_reply_t *R)
+{
+    return (R->length * 4);
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_separable_filter_rows_and_cols_end (const xcb_glx_get_separable_filter_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((R->length * 4));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_separable_filter_reply_t *
+xcb_glx_get_separable_filter_reply (xcb_connection_t                       *c,
+                                    xcb_glx_get_separable_filter_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e)
+{
+    return (xcb_glx_get_separable_filter_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_histogram_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_histogram_reply_t *_aux = (xcb_glx_get_histogram_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_histogram_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += (_aux->length * 4) * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_histogram_cookie_t
+xcb_glx_get_histogram (xcb_connection_t      *c,
+                       xcb_glx_context_tag_t  context_tag,
+                       uint32_t               target,
+                       uint32_t               format,
+                       uint32_t               type,
+                       uint8_t                swap_bytes,
+                       uint8_t                reset)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_HISTOGRAM,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_histogram_cookie_t xcb_ret;
+    xcb_glx_get_histogram_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.format = format;
+    xcb_out.type = type;
+    xcb_out.swap_bytes = swap_bytes;
+    xcb_out.reset = reset;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_histogram_cookie_t
+xcb_glx_get_histogram_unchecked (xcb_connection_t      *c,
+                                 xcb_glx_context_tag_t  context_tag,
+                                 uint32_t               target,
+                                 uint32_t               format,
+                                 uint32_t               type,
+                                 uint8_t                swap_bytes,
+                                 uint8_t                reset)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_HISTOGRAM,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_histogram_cookie_t xcb_ret;
+    xcb_glx_get_histogram_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.format = format;
+    xcb_out.type = type;
+    xcb_out.swap_bytes = swap_bytes;
+    xcb_out.reset = reset;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_glx_get_histogram_data (const xcb_glx_get_histogram_reply_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_glx_get_histogram_data_length (const xcb_glx_get_histogram_reply_t *R)
+{
+    return (R->length * 4);
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_histogram_data_end (const xcb_glx_get_histogram_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((R->length * 4));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_histogram_reply_t *
+xcb_glx_get_histogram_reply (xcb_connection_t                *c,
+                             xcb_glx_get_histogram_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_glx_get_histogram_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_histogram_parameterfv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_histogram_parameterfv_reply_t *_aux = (xcb_glx_get_histogram_parameterfv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_histogram_parameterfv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_glx_float32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_histogram_parameterfv_cookie_t
+xcb_glx_get_histogram_parameterfv (xcb_connection_t      *c,
+                                   xcb_glx_context_tag_t  context_tag,
+                                   uint32_t               target,
+                                   uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_HISTOGRAM_PARAMETERFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_histogram_parameterfv_cookie_t xcb_ret;
+    xcb_glx_get_histogram_parameterfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_histogram_parameterfv_cookie_t
+xcb_glx_get_histogram_parameterfv_unchecked (xcb_connection_t      *c,
+                                             xcb_glx_context_tag_t  context_tag,
+                                             uint32_t               target,
+                                             uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_HISTOGRAM_PARAMETERFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_histogram_parameterfv_cookie_t xcb_ret;
+    xcb_glx_get_histogram_parameterfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_float32_t *
+xcb_glx_get_histogram_parameterfv_data (const xcb_glx_get_histogram_parameterfv_reply_t *R)
+{
+    return (xcb_glx_float32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_histogram_parameterfv_data_length (const xcb_glx_get_histogram_parameterfv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_histogram_parameterfv_data_end (const xcb_glx_get_histogram_parameterfv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_histogram_parameterfv_reply_t *
+xcb_glx_get_histogram_parameterfv_reply (xcb_connection_t                            *c,
+                                         xcb_glx_get_histogram_parameterfv_cookie_t   cookie  /**< */,
+                                         xcb_generic_error_t                        **e)
+{
+    return (xcb_glx_get_histogram_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_histogram_parameteriv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_histogram_parameteriv_reply_t *_aux = (xcb_glx_get_histogram_parameteriv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_histogram_parameteriv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_histogram_parameteriv_cookie_t
+xcb_glx_get_histogram_parameteriv (xcb_connection_t      *c,
+                                   xcb_glx_context_tag_t  context_tag,
+                                   uint32_t               target,
+                                   uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_HISTOGRAM_PARAMETERIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_histogram_parameteriv_cookie_t xcb_ret;
+    xcb_glx_get_histogram_parameteriv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_histogram_parameteriv_cookie_t
+xcb_glx_get_histogram_parameteriv_unchecked (xcb_connection_t      *c,
+                                             xcb_glx_context_tag_t  context_tag,
+                                             uint32_t               target,
+                                             uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_HISTOGRAM_PARAMETERIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_histogram_parameteriv_cookie_t xcb_ret;
+    xcb_glx_get_histogram_parameteriv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int32_t *
+xcb_glx_get_histogram_parameteriv_data (const xcb_glx_get_histogram_parameteriv_reply_t *R)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_histogram_parameteriv_data_length (const xcb_glx_get_histogram_parameteriv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_histogram_parameteriv_data_end (const xcb_glx_get_histogram_parameteriv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_histogram_parameteriv_reply_t *
+xcb_glx_get_histogram_parameteriv_reply (xcb_connection_t                            *c,
+                                         xcb_glx_get_histogram_parameteriv_cookie_t   cookie  /**< */,
+                                         xcb_generic_error_t                        **e)
+{
+    return (xcb_glx_get_histogram_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_minmax_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_minmax_reply_t *_aux = (xcb_glx_get_minmax_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_minmax_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += (_aux->length * 4) * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_minmax_cookie_t
+xcb_glx_get_minmax (xcb_connection_t      *c,
+                    xcb_glx_context_tag_t  context_tag,
+                    uint32_t               target,
+                    uint32_t               format,
+                    uint32_t               type,
+                    uint8_t                swap_bytes,
+                    uint8_t                reset)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_MINMAX,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_minmax_cookie_t xcb_ret;
+    xcb_glx_get_minmax_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.format = format;
+    xcb_out.type = type;
+    xcb_out.swap_bytes = swap_bytes;
+    xcb_out.reset = reset;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_minmax_cookie_t
+xcb_glx_get_minmax_unchecked (xcb_connection_t      *c,
+                              xcb_glx_context_tag_t  context_tag,
+                              uint32_t               target,
+                              uint32_t               format,
+                              uint32_t               type,
+                              uint8_t                swap_bytes,
+                              uint8_t                reset)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_MINMAX,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_minmax_cookie_t xcb_ret;
+    xcb_glx_get_minmax_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.format = format;
+    xcb_out.type = type;
+    xcb_out.swap_bytes = swap_bytes;
+    xcb_out.reset = reset;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_glx_get_minmax_data (const xcb_glx_get_minmax_reply_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_glx_get_minmax_data_length (const xcb_glx_get_minmax_reply_t *R)
+{
+    return (R->length * 4);
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_minmax_data_end (const xcb_glx_get_minmax_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((R->length * 4));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_minmax_reply_t *
+xcb_glx_get_minmax_reply (xcb_connection_t             *c,
+                          xcb_glx_get_minmax_cookie_t   cookie  /**< */,
+                          xcb_generic_error_t         **e)
+{
+    return (xcb_glx_get_minmax_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_minmax_parameterfv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_minmax_parameterfv_reply_t *_aux = (xcb_glx_get_minmax_parameterfv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_minmax_parameterfv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(xcb_glx_float32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_glx_float32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_minmax_parameterfv_cookie_t
+xcb_glx_get_minmax_parameterfv (xcb_connection_t      *c,
+                                xcb_glx_context_tag_t  context_tag,
+                                uint32_t               target,
+                                uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_MINMAX_PARAMETERFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_minmax_parameterfv_cookie_t xcb_ret;
+    xcb_glx_get_minmax_parameterfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_minmax_parameterfv_cookie_t
+xcb_glx_get_minmax_parameterfv_unchecked (xcb_connection_t      *c,
+                                          xcb_glx_context_tag_t  context_tag,
+                                          uint32_t               target,
+                                          uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_MINMAX_PARAMETERFV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_minmax_parameterfv_cookie_t xcb_ret;
+    xcb_glx_get_minmax_parameterfv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_float32_t *
+xcb_glx_get_minmax_parameterfv_data (const xcb_glx_get_minmax_parameterfv_reply_t *R)
+{
+    return (xcb_glx_float32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_minmax_parameterfv_data_length (const xcb_glx_get_minmax_parameterfv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_minmax_parameterfv_data_end (const xcb_glx_get_minmax_parameterfv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_glx_float32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_minmax_parameterfv_reply_t *
+xcb_glx_get_minmax_parameterfv_reply (xcb_connection_t                         *c,
+                                      xcb_glx_get_minmax_parameterfv_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e)
+{
+    return (xcb_glx_get_minmax_parameterfv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_minmax_parameteriv_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_minmax_parameteriv_reply_t *_aux = (xcb_glx_get_minmax_parameteriv_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_minmax_parameteriv_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_minmax_parameteriv_cookie_t
+xcb_glx_get_minmax_parameteriv (xcb_connection_t      *c,
+                                xcb_glx_context_tag_t  context_tag,
+                                uint32_t               target,
+                                uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_MINMAX_PARAMETERIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_minmax_parameteriv_cookie_t xcb_ret;
+    xcb_glx_get_minmax_parameteriv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_minmax_parameteriv_cookie_t
+xcb_glx_get_minmax_parameteriv_unchecked (xcb_connection_t      *c,
+                                          xcb_glx_context_tag_t  context_tag,
+                                          uint32_t               target,
+                                          uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_MINMAX_PARAMETERIV,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_minmax_parameteriv_cookie_t xcb_ret;
+    xcb_glx_get_minmax_parameteriv_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int32_t *
+xcb_glx_get_minmax_parameteriv_data (const xcb_glx_get_minmax_parameteriv_reply_t *R)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_minmax_parameteriv_data_length (const xcb_glx_get_minmax_parameteriv_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_minmax_parameteriv_data_end (const xcb_glx_get_minmax_parameteriv_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_minmax_parameteriv_reply_t *
+xcb_glx_get_minmax_parameteriv_reply (xcb_connection_t                         *c,
+                                      xcb_glx_get_minmax_parameteriv_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e)
+{
+    return (xcb_glx_get_minmax_parameteriv_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_compressed_tex_image_arb_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_compressed_tex_image_arb_reply_t *_aux = (xcb_glx_get_compressed_tex_image_arb_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_compressed_tex_image_arb_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += (_aux->length * 4) * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_compressed_tex_image_arb_cookie_t
+xcb_glx_get_compressed_tex_image_arb (xcb_connection_t      *c,
+                                      xcb_glx_context_tag_t  context_tag,
+                                      uint32_t               target,
+                                      int32_t                level)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_COMPRESSED_TEX_IMAGE_ARB,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_compressed_tex_image_arb_cookie_t xcb_ret;
+    xcb_glx_get_compressed_tex_image_arb_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.level = level;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_compressed_tex_image_arb_cookie_t
+xcb_glx_get_compressed_tex_image_arb_unchecked (xcb_connection_t      *c,
+                                                xcb_glx_context_tag_t  context_tag,
+                                                uint32_t               target,
+                                                int32_t                level)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_COMPRESSED_TEX_IMAGE_ARB,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_compressed_tex_image_arb_cookie_t xcb_ret;
+    xcb_glx_get_compressed_tex_image_arb_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.level = level;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_glx_get_compressed_tex_image_arb_data (const xcb_glx_get_compressed_tex_image_arb_reply_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_glx_get_compressed_tex_image_arb_data_length (const xcb_glx_get_compressed_tex_image_arb_reply_t *R)
+{
+    return (R->length * 4);
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_compressed_tex_image_arb_data_end (const xcb_glx_get_compressed_tex_image_arb_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((R->length * 4));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_compressed_tex_image_arb_reply_t *
+xcb_glx_get_compressed_tex_image_arb_reply (xcb_connection_t                               *c,
+                                            xcb_glx_get_compressed_tex_image_arb_cookie_t   cookie  /**< */,
+                                            xcb_generic_error_t                           **e)
+{
+    return (xcb_glx_get_compressed_tex_image_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_delete_queries_arb_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_delete_queries_arb_request_t *_aux = (xcb_glx_delete_queries_arb_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_delete_queries_arb_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* ids */
+    xcb_block_len += _aux->n * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_glx_delete_queries_arb_checked (xcb_connection_t      *c,
+                                    xcb_glx_context_tag_t  context_tag,
+                                    int32_t                n,
+                                    const uint32_t        *ids)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_DELETE_QUERIES_ARB,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_delete_queries_arb_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.n = n;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t ids */
+    xcb_parts[4].iov_base = (char *) ids;
+    xcb_parts[4].iov_len = n * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_glx_delete_queries_arb (xcb_connection_t      *c,
+                            xcb_glx_context_tag_t  context_tag,
+                            int32_t                n,
+                            const uint32_t        *ids)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_DELETE_QUERIES_ARB,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_glx_delete_queries_arb_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.n = n;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t ids */
+    xcb_parts[4].iov_base = (char *) ids;
+    xcb_parts[4].iov_len = n * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_glx_delete_queries_arb_ids (const xcb_glx_delete_queries_arb_request_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_glx_delete_queries_arb_ids_length (const xcb_glx_delete_queries_arb_request_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_delete_queries_arb_ids_end (const xcb_glx_delete_queries_arb_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_glx_gen_queries_arb_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_gen_queries_arb_reply_t *_aux = (xcb_glx_gen_queries_arb_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_gen_queries_arb_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->length * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_gen_queries_arb_cookie_t
+xcb_glx_gen_queries_arb (xcb_connection_t      *c,
+                         xcb_glx_context_tag_t  context_tag,
+                         int32_t                n)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GEN_QUERIES_ARB,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_gen_queries_arb_cookie_t xcb_ret;
+    xcb_glx_gen_queries_arb_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.n = n;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_gen_queries_arb_cookie_t
+xcb_glx_gen_queries_arb_unchecked (xcb_connection_t      *c,
+                                   xcb_glx_context_tag_t  context_tag,
+                                   int32_t                n)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GEN_QUERIES_ARB,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_gen_queries_arb_cookie_t xcb_ret;
+    xcb_glx_gen_queries_arb_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.n = n;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_glx_gen_queries_arb_data (const xcb_glx_gen_queries_arb_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_glx_gen_queries_arb_data_length (const xcb_glx_gen_queries_arb_reply_t *R)
+{
+    return R->length;
+}
+
+xcb_generic_iterator_t
+xcb_glx_gen_queries_arb_data_end (const xcb_glx_gen_queries_arb_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->length);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_gen_queries_arb_reply_t *
+xcb_glx_gen_queries_arb_reply (xcb_connection_t                  *c,
+                               xcb_glx_gen_queries_arb_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_glx_gen_queries_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_glx_is_query_arb_cookie_t
+xcb_glx_is_query_arb (xcb_connection_t      *c,
+                      xcb_glx_context_tag_t  context_tag,
+                      uint32_t               id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_IS_QUERY_ARB,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_is_query_arb_cookie_t xcb_ret;
+    xcb_glx_is_query_arb_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.id = id;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_is_query_arb_cookie_t
+xcb_glx_is_query_arb_unchecked (xcb_connection_t      *c,
+                                xcb_glx_context_tag_t  context_tag,
+                                uint32_t               id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_IS_QUERY_ARB,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_is_query_arb_cookie_t xcb_ret;
+    xcb_glx_is_query_arb_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.id = id;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_is_query_arb_reply_t *
+xcb_glx_is_query_arb_reply (xcb_connection_t               *c,
+                            xcb_glx_is_query_arb_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e)
+{
+    return (xcb_glx_is_query_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_queryiv_arb_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_queryiv_arb_reply_t *_aux = (xcb_glx_get_queryiv_arb_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_queryiv_arb_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_queryiv_arb_cookie_t
+xcb_glx_get_queryiv_arb (xcb_connection_t      *c,
+                         xcb_glx_context_tag_t  context_tag,
+                         uint32_t               target,
+                         uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_QUERYIV_ARB,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_queryiv_arb_cookie_t xcb_ret;
+    xcb_glx_get_queryiv_arb_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_queryiv_arb_cookie_t
+xcb_glx_get_queryiv_arb_unchecked (xcb_connection_t      *c,
+                                   xcb_glx_context_tag_t  context_tag,
+                                   uint32_t               target,
+                                   uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_QUERYIV_ARB,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_queryiv_arb_cookie_t xcb_ret;
+    xcb_glx_get_queryiv_arb_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.target = target;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int32_t *
+xcb_glx_get_queryiv_arb_data (const xcb_glx_get_queryiv_arb_reply_t *R)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_queryiv_arb_data_length (const xcb_glx_get_queryiv_arb_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_queryiv_arb_data_end (const xcb_glx_get_queryiv_arb_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_queryiv_arb_reply_t *
+xcb_glx_get_queryiv_arb_reply (xcb_connection_t                  *c,
+                               xcb_glx_get_queryiv_arb_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_glx_get_queryiv_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_query_objectiv_arb_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_query_objectiv_arb_reply_t *_aux = (xcb_glx_get_query_objectiv_arb_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_query_objectiv_arb_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_query_objectiv_arb_cookie_t
+xcb_glx_get_query_objectiv_arb (xcb_connection_t      *c,
+                                xcb_glx_context_tag_t  context_tag,
+                                uint32_t               id,
+                                uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_QUERY_OBJECTIV_ARB,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_query_objectiv_arb_cookie_t xcb_ret;
+    xcb_glx_get_query_objectiv_arb_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.id = id;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_query_objectiv_arb_cookie_t
+xcb_glx_get_query_objectiv_arb_unchecked (xcb_connection_t      *c,
+                                          xcb_glx_context_tag_t  context_tag,
+                                          uint32_t               id,
+                                          uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_QUERY_OBJECTIV_ARB,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_query_objectiv_arb_cookie_t xcb_ret;
+    xcb_glx_get_query_objectiv_arb_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.id = id;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int32_t *
+xcb_glx_get_query_objectiv_arb_data (const xcb_glx_get_query_objectiv_arb_reply_t *R)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_query_objectiv_arb_data_length (const xcb_glx_get_query_objectiv_arb_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_query_objectiv_arb_data_end (const xcb_glx_get_query_objectiv_arb_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_query_objectiv_arb_reply_t *
+xcb_glx_get_query_objectiv_arb_reply (xcb_connection_t                         *c,
+                                      xcb_glx_get_query_objectiv_arb_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e)
+{
+    return (xcb_glx_get_query_objectiv_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_glx_get_query_objectuiv_arb_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_glx_get_query_objectuiv_arb_reply_t *_aux = (xcb_glx_get_query_objectuiv_arb_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_glx_get_query_objectuiv_arb_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->n * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_glx_get_query_objectuiv_arb_cookie_t
+xcb_glx_get_query_objectuiv_arb (xcb_connection_t      *c,
+                                 xcb_glx_context_tag_t  context_tag,
+                                 uint32_t               id,
+                                 uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_QUERY_OBJECTUIV_ARB,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_query_objectuiv_arb_cookie_t xcb_ret;
+    xcb_glx_get_query_objectuiv_arb_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.id = id;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_glx_get_query_objectuiv_arb_cookie_t
+xcb_glx_get_query_objectuiv_arb_unchecked (xcb_connection_t      *c,
+                                           xcb_glx_context_tag_t  context_tag,
+                                           uint32_t               id,
+                                           uint32_t               pname)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_glx_id,
+        .opcode = XCB_GLX_GET_QUERY_OBJECTUIV_ARB,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_glx_get_query_objectuiv_arb_cookie_t xcb_ret;
+    xcb_glx_get_query_objectuiv_arb_request_t xcb_out;
+
+    xcb_out.context_tag = context_tag;
+    xcb_out.id = id;
+    xcb_out.pname = pname;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_glx_get_query_objectuiv_arb_data (const xcb_glx_get_query_objectuiv_arb_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_glx_get_query_objectuiv_arb_data_length (const xcb_glx_get_query_objectuiv_arb_reply_t *R)
+{
+    return R->n;
+}
+
+xcb_generic_iterator_t
+xcb_glx_get_query_objectuiv_arb_data_end (const xcb_glx_get_query_objectuiv_arb_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->n);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_glx_get_query_objectuiv_arb_reply_t *
+xcb_glx_get_query_objectuiv_arb_reply (xcb_connection_t                          *c,
+                                       xcb_glx_get_query_objectuiv_arb_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e)
+{
+    return (xcb_glx_get_query_objectuiv_arb_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
diff --git a/depends/libxcb/src/present.c b/depends/libxcb/src/present.c
new file mode 100644
index 0000000..27aeecc
--- /dev/null
+++ b/depends/libxcb/src/present.c
@@ -0,0 +1,539 @@
+/*
+ * This file generated automatically from present.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "present.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xproto.h"
+#include "randr.h"
+#include "xfixes.h"
+#include "sync.h"
+
+xcb_extension_t xcb_present_id = { "Present", 0 };
+
+void
+xcb_present_notify_next (xcb_present_notify_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_present_notify_t);
+}
+
+xcb_generic_iterator_t
+xcb_present_notify_end (xcb_present_notify_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+xcb_present_query_version_cookie_t
+xcb_present_query_version (xcb_connection_t *c,
+                           uint32_t          major_version,
+                           uint32_t          minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_present_id,
+        .opcode = XCB_PRESENT_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_present_query_version_cookie_t xcb_ret;
+    xcb_present_query_version_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_present_query_version_cookie_t
+xcb_present_query_version_unchecked (xcb_connection_t *c,
+                                     uint32_t          major_version,
+                                     uint32_t          minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_present_id,
+        .opcode = XCB_PRESENT_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_present_query_version_cookie_t xcb_ret;
+    xcb_present_query_version_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_present_query_version_reply_t *
+xcb_present_query_version_reply (xcb_connection_t                    *c,
+                                 xcb_present_query_version_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e)
+{
+    return (xcb_present_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_present_pixmap_sizeof (const void  *_buffer,
+                           uint32_t     notifies_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_present_pixmap_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* notifies */
+    xcb_block_len += notifies_len * sizeof(xcb_present_notify_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_present_notify_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_present_pixmap_checked (xcb_connection_t           *c,
+                            xcb_window_t                window,
+                            xcb_pixmap_t                pixmap,
+                            uint32_t                    serial,
+                            xcb_xfixes_region_t         valid,
+                            xcb_xfixes_region_t         update,
+                            int16_t                     x_off,
+                            int16_t                     y_off,
+                            xcb_randr_crtc_t            target_crtc,
+                            xcb_sync_fence_t            wait_fence,
+                            xcb_sync_fence_t            idle_fence,
+                            uint32_t                    options,
+                            uint64_t                    target_msc,
+                            uint64_t                    divisor,
+                            uint64_t                    remainder,
+                            uint32_t                    notifies_len,
+                            const xcb_present_notify_t *notifies)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_present_id,
+        .opcode = XCB_PRESENT_PIXMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_present_pixmap_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.pixmap = pixmap;
+    xcb_out.serial = serial;
+    xcb_out.valid = valid;
+    xcb_out.update = update;
+    xcb_out.x_off = x_off;
+    xcb_out.y_off = y_off;
+    xcb_out.target_crtc = target_crtc;
+    xcb_out.wait_fence = wait_fence;
+    xcb_out.idle_fence = idle_fence;
+    xcb_out.options = options;
+    memset(xcb_out.pad0, 0, 4);
+    xcb_out.target_msc = target_msc;
+    xcb_out.divisor = divisor;
+    xcb_out.remainder = remainder;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_present_notify_t notifies */
+    xcb_parts[4].iov_base = (char *) notifies;
+    xcb_parts[4].iov_len = notifies_len * sizeof(xcb_present_notify_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_present_pixmap (xcb_connection_t           *c,
+                    xcb_window_t                window,
+                    xcb_pixmap_t                pixmap,
+                    uint32_t                    serial,
+                    xcb_xfixes_region_t         valid,
+                    xcb_xfixes_region_t         update,
+                    int16_t                     x_off,
+                    int16_t                     y_off,
+                    xcb_randr_crtc_t            target_crtc,
+                    xcb_sync_fence_t            wait_fence,
+                    xcb_sync_fence_t            idle_fence,
+                    uint32_t                    options,
+                    uint64_t                    target_msc,
+                    uint64_t                    divisor,
+                    uint64_t                    remainder,
+                    uint32_t                    notifies_len,
+                    const xcb_present_notify_t *notifies)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_present_id,
+        .opcode = XCB_PRESENT_PIXMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_present_pixmap_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.pixmap = pixmap;
+    xcb_out.serial = serial;
+    xcb_out.valid = valid;
+    xcb_out.update = update;
+    xcb_out.x_off = x_off;
+    xcb_out.y_off = y_off;
+    xcb_out.target_crtc = target_crtc;
+    xcb_out.wait_fence = wait_fence;
+    xcb_out.idle_fence = idle_fence;
+    xcb_out.options = options;
+    memset(xcb_out.pad0, 0, 4);
+    xcb_out.target_msc = target_msc;
+    xcb_out.divisor = divisor;
+    xcb_out.remainder = remainder;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_present_notify_t notifies */
+    xcb_parts[4].iov_base = (char *) notifies;
+    xcb_parts[4].iov_len = notifies_len * sizeof(xcb_present_notify_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_present_notify_t *
+xcb_present_pixmap_notifies (const xcb_present_pixmap_request_t *R)
+{
+    return (xcb_present_notify_t *) (R + 1);
+}
+
+int
+xcb_present_pixmap_notifies_length (const xcb_present_pixmap_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_present_pixmap_request_t))/sizeof(xcb_present_notify_t));
+}
+
+xcb_present_notify_iterator_t
+xcb_present_pixmap_notifies_iterator (const xcb_present_pixmap_request_t *R)
+{
+    xcb_present_notify_iterator_t i;
+    i.data = (xcb_present_notify_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_present_pixmap_request_t))/sizeof(xcb_present_notify_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_present_notify_msc_checked (xcb_connection_t *c,
+                                xcb_window_t      window,
+                                uint32_t          serial,
+                                uint64_t          target_msc,
+                                uint64_t          divisor,
+                                uint64_t          remainder)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_present_id,
+        .opcode = XCB_PRESENT_NOTIFY_MSC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_present_notify_msc_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.serial = serial;
+    memset(xcb_out.pad0, 0, 4);
+    xcb_out.target_msc = target_msc;
+    xcb_out.divisor = divisor;
+    xcb_out.remainder = remainder;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_present_notify_msc (xcb_connection_t *c,
+                        xcb_window_t      window,
+                        uint32_t          serial,
+                        uint64_t          target_msc,
+                        uint64_t          divisor,
+                        uint64_t          remainder)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_present_id,
+        .opcode = XCB_PRESENT_NOTIFY_MSC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_present_notify_msc_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.serial = serial;
+    memset(xcb_out.pad0, 0, 4);
+    xcb_out.target_msc = target_msc;
+    xcb_out.divisor = divisor;
+    xcb_out.remainder = remainder;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+void
+xcb_present_event_next (xcb_present_event_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_present_event_t);
+}
+
+xcb_generic_iterator_t
+xcb_present_event_end (xcb_present_event_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+xcb_void_cookie_t
+xcb_present_select_input_checked (xcb_connection_t    *c,
+                                  xcb_present_event_t  eid,
+                                  xcb_window_t         window,
+                                  uint32_t             event_mask)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_present_id,
+        .opcode = XCB_PRESENT_SELECT_INPUT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_present_select_input_request_t xcb_out;
+
+    xcb_out.eid = eid;
+    xcb_out.window = window;
+    xcb_out.event_mask = event_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_present_select_input (xcb_connection_t    *c,
+                          xcb_present_event_t  eid,
+                          xcb_window_t         window,
+                          uint32_t             event_mask)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_present_id,
+        .opcode = XCB_PRESENT_SELECT_INPUT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_present_select_input_request_t xcb_out;
+
+    xcb_out.eid = eid;
+    xcb_out.window = window;
+    xcb_out.event_mask = event_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_present_query_capabilities_cookie_t
+xcb_present_query_capabilities (xcb_connection_t *c,
+                                uint32_t          target)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_present_id,
+        .opcode = XCB_PRESENT_QUERY_CAPABILITIES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_present_query_capabilities_cookie_t xcb_ret;
+    xcb_present_query_capabilities_request_t xcb_out;
+
+    xcb_out.target = target;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_present_query_capabilities_cookie_t
+xcb_present_query_capabilities_unchecked (xcb_connection_t *c,
+                                          uint32_t          target)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_present_id,
+        .opcode = XCB_PRESENT_QUERY_CAPABILITIES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_present_query_capabilities_cookie_t xcb_ret;
+    xcb_present_query_capabilities_request_t xcb_out;
+
+    xcb_out.target = target;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_present_query_capabilities_reply_t *
+xcb_present_query_capabilities_reply (xcb_connection_t                         *c,
+                                      xcb_present_query_capabilities_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e)
+{
+    return (xcb_present_query_capabilities_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_present_redirect_notify_sizeof (const void  *_buffer,
+                                    uint32_t     notifies_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_present_redirect_notify_event_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* notifies */
+    xcb_block_len += notifies_len * sizeof(xcb_present_notify_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_present_notify_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_present_notify_t *
+xcb_present_redirect_notify_notifies (const xcb_present_redirect_notify_event_t *R)
+{
+    return (xcb_present_notify_t *) (R + 1);
+}
+
+int
+xcb_present_redirect_notify_notifies_length (const xcb_present_redirect_notify_event_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_present_redirect_notify_event_t))/sizeof(xcb_present_notify_t));
+}
+
+xcb_present_notify_iterator_t
+xcb_present_redirect_notify_notifies_iterator (const xcb_present_redirect_notify_event_t *R)
+{
+    xcb_present_notify_iterator_t i;
+    i.data = (xcb_present_notify_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_present_redirect_notify_event_t))/sizeof(xcb_present_notify_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
diff --git a/depends/libxcb/src/randr.c b/depends/libxcb/src/randr.c
new file mode 100644
index 0000000..efff1aa
--- /dev/null
+++ b/depends/libxcb/src/randr.c
@@ -0,0 +1,5684 @@
+/*
+ * This file generated automatically from randr.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "randr.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xproto.h"
+#include "render.h"
+
+xcb_extension_t xcb_randr_id = { "RANDR", 0 };
+
+void
+xcb_randr_mode_next (xcb_randr_mode_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_randr_mode_t);
+}
+
+xcb_generic_iterator_t
+xcb_randr_mode_end (xcb_randr_mode_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_randr_crtc_next (xcb_randr_crtc_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_randr_crtc_t);
+}
+
+xcb_generic_iterator_t
+xcb_randr_crtc_end (xcb_randr_crtc_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_randr_output_next (xcb_randr_output_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_randr_output_t);
+}
+
+xcb_generic_iterator_t
+xcb_randr_output_end (xcb_randr_output_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_randr_provider_next (xcb_randr_provider_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_randr_provider_t);
+}
+
+xcb_generic_iterator_t
+xcb_randr_provider_end (xcb_randr_provider_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_randr_lease_next (xcb_randr_lease_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_randr_lease_t);
+}
+
+xcb_generic_iterator_t
+xcb_randr_lease_end (xcb_randr_lease_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_randr_screen_size_next (xcb_randr_screen_size_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_randr_screen_size_t);
+}
+
+xcb_generic_iterator_t
+xcb_randr_screen_size_end (xcb_randr_screen_size_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_randr_refresh_rates_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_refresh_rates_t *_aux = (xcb_randr_refresh_rates_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_refresh_rates_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* rates */
+    xcb_block_len += _aux->nRates * sizeof(uint16_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint16_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+uint16_t *
+xcb_randr_refresh_rates_rates (const xcb_randr_refresh_rates_t *R)
+{
+    return (uint16_t *) (R + 1);
+}
+
+int
+xcb_randr_refresh_rates_rates_length (const xcb_randr_refresh_rates_t *R)
+{
+    return R->nRates;
+}
+
+xcb_generic_iterator_t
+xcb_randr_refresh_rates_rates_end (const xcb_randr_refresh_rates_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint16_t *) (R + 1)) + (R->nRates);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_randr_refresh_rates_next (xcb_randr_refresh_rates_iterator_t *i)
+{
+    xcb_randr_refresh_rates_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_randr_refresh_rates_t *)(((char *)R) + xcb_randr_refresh_rates_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_randr_refresh_rates_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_randr_refresh_rates_end (xcb_randr_refresh_rates_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_randr_refresh_rates_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+xcb_randr_query_version_cookie_t
+xcb_randr_query_version (xcb_connection_t *c,
+                         uint32_t          major_version,
+                         uint32_t          minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_query_version_cookie_t xcb_ret;
+    xcb_randr_query_version_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_query_version_cookie_t
+xcb_randr_query_version_unchecked (xcb_connection_t *c,
+                                   uint32_t          major_version,
+                                   uint32_t          minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_query_version_cookie_t xcb_ret;
+    xcb_randr_query_version_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_query_version_reply_t *
+xcb_randr_query_version_reply (xcb_connection_t                  *c,
+                               xcb_randr_query_version_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_randr_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_randr_set_screen_config_cookie_t
+xcb_randr_set_screen_config (xcb_connection_t *c,
+                             xcb_window_t      window,
+                             xcb_timestamp_t   timestamp,
+                             xcb_timestamp_t   config_timestamp,
+                             uint16_t          sizeID,
+                             uint16_t          rotation,
+                             uint16_t          rate)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SET_SCREEN_CONFIG,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_set_screen_config_cookie_t xcb_ret;
+    xcb_randr_set_screen_config_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.timestamp = timestamp;
+    xcb_out.config_timestamp = config_timestamp;
+    xcb_out.sizeID = sizeID;
+    xcb_out.rotation = rotation;
+    xcb_out.rate = rate;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_set_screen_config_cookie_t
+xcb_randr_set_screen_config_unchecked (xcb_connection_t *c,
+                                       xcb_window_t      window,
+                                       xcb_timestamp_t   timestamp,
+                                       xcb_timestamp_t   config_timestamp,
+                                       uint16_t          sizeID,
+                                       uint16_t          rotation,
+                                       uint16_t          rate)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SET_SCREEN_CONFIG,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_set_screen_config_cookie_t xcb_ret;
+    xcb_randr_set_screen_config_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.timestamp = timestamp;
+    xcb_out.config_timestamp = config_timestamp;
+    xcb_out.sizeID = sizeID;
+    xcb_out.rotation = rotation;
+    xcb_out.rate = rate;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_set_screen_config_reply_t *
+xcb_randr_set_screen_config_reply (xcb_connection_t                      *c,
+                                   xcb_randr_set_screen_config_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e)
+{
+    return (xcb_randr_set_screen_config_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_randr_select_input_checked (xcb_connection_t *c,
+                                xcb_window_t      window,
+                                uint16_t          enable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SELECT_INPUT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_select_input_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.enable = enable;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_select_input (xcb_connection_t *c,
+                        xcb_window_t      window,
+                        uint16_t          enable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SELECT_INPUT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_select_input_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.enable = enable;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_randr_get_screen_info_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_get_screen_info_reply_t *_aux = (xcb_randr_get_screen_info_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_randr_get_screen_info_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* sizes */
+    xcb_block_len += _aux->nSizes * sizeof(xcb_randr_screen_size_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_screen_size_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* rates */
+    for(i=0; i<(_aux->nInfo - _aux->nSizes); i++) {
+        xcb_tmp_len = xcb_randr_refresh_rates_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_randr_refresh_rates_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_randr_get_screen_info_cookie_t
+xcb_randr_get_screen_info (xcb_connection_t *c,
+                           xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_SCREEN_INFO,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_screen_info_cookie_t xcb_ret;
+    xcb_randr_get_screen_info_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_screen_info_cookie_t
+xcb_randr_get_screen_info_unchecked (xcb_connection_t *c,
+                                     xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_SCREEN_INFO,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_screen_info_cookie_t xcb_ret;
+    xcb_randr_get_screen_info_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_screen_size_t *
+xcb_randr_get_screen_info_sizes (const xcb_randr_get_screen_info_reply_t *R)
+{
+    return (xcb_randr_screen_size_t *) (R + 1);
+}
+
+int
+xcb_randr_get_screen_info_sizes_length (const xcb_randr_get_screen_info_reply_t *R)
+{
+    return R->nSizes;
+}
+
+xcb_randr_screen_size_iterator_t
+xcb_randr_get_screen_info_sizes_iterator (const xcb_randr_get_screen_info_reply_t *R)
+{
+    xcb_randr_screen_size_iterator_t i;
+    i.data = (xcb_randr_screen_size_t *) (R + 1);
+    i.rem = R->nSizes;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_randr_get_screen_info_rates_length (const xcb_randr_get_screen_info_reply_t *R)
+{
+    return (R->nInfo - R->nSizes);
+}
+
+xcb_randr_refresh_rates_iterator_t
+xcb_randr_get_screen_info_rates_iterator (const xcb_randr_get_screen_info_reply_t *R)
+{
+    xcb_randr_refresh_rates_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_screen_size_end(xcb_randr_get_screen_info_sizes_iterator(R));
+    i.data = (xcb_randr_refresh_rates_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_refresh_rates_t, prev.index));
+    i.rem = (R->nInfo - R->nSizes);
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_get_screen_info_reply_t *
+xcb_randr_get_screen_info_reply (xcb_connection_t                    *c,
+                                 xcb_randr_get_screen_info_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e)
+{
+    return (xcb_randr_get_screen_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_randr_get_screen_size_range_cookie_t
+xcb_randr_get_screen_size_range (xcb_connection_t *c,
+                                 xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_SCREEN_SIZE_RANGE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_screen_size_range_cookie_t xcb_ret;
+    xcb_randr_get_screen_size_range_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_screen_size_range_cookie_t
+xcb_randr_get_screen_size_range_unchecked (xcb_connection_t *c,
+                                           xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_SCREEN_SIZE_RANGE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_screen_size_range_cookie_t xcb_ret;
+    xcb_randr_get_screen_size_range_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_screen_size_range_reply_t *
+xcb_randr_get_screen_size_range_reply (xcb_connection_t                          *c,
+                                       xcb_randr_get_screen_size_range_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e)
+{
+    return (xcb_randr_get_screen_size_range_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_randr_set_screen_size_checked (xcb_connection_t *c,
+                                   xcb_window_t      window,
+                                   uint16_t          width,
+                                   uint16_t          height,
+                                   uint32_t          mm_width,
+                                   uint32_t          mm_height)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SET_SCREEN_SIZE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_set_screen_size_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.mm_width = mm_width;
+    xcb_out.mm_height = mm_height;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_set_screen_size (xcb_connection_t *c,
+                           xcb_window_t      window,
+                           uint16_t          width,
+                           uint16_t          height,
+                           uint32_t          mm_width,
+                           uint32_t          mm_height)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SET_SCREEN_SIZE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_set_screen_size_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.mm_width = mm_width;
+    xcb_out.mm_height = mm_height;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+void
+xcb_randr_mode_info_next (xcb_randr_mode_info_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_randr_mode_info_t);
+}
+
+xcb_generic_iterator_t
+xcb_randr_mode_info_end (xcb_randr_mode_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_randr_get_screen_resources_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_get_screen_resources_reply_t *_aux = (xcb_randr_get_screen_resources_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_get_screen_resources_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* crtcs */
+    xcb_block_len += _aux->num_crtcs * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_crtc_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* outputs */
+    xcb_block_len += _aux->num_outputs * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_output_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* modes */
+    xcb_block_len += _aux->num_modes * sizeof(xcb_randr_mode_info_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_mode_info_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* names */
+    xcb_block_len += _aux->names_len * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_randr_get_screen_resources_cookie_t
+xcb_randr_get_screen_resources (xcb_connection_t *c,
+                                xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_SCREEN_RESOURCES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_screen_resources_cookie_t xcb_ret;
+    xcb_randr_get_screen_resources_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_screen_resources_cookie_t
+xcb_randr_get_screen_resources_unchecked (xcb_connection_t *c,
+                                          xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_SCREEN_RESOURCES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_screen_resources_cookie_t xcb_ret;
+    xcb_randr_get_screen_resources_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_crtc_t *
+xcb_randr_get_screen_resources_crtcs (const xcb_randr_get_screen_resources_reply_t *R)
+{
+    return (xcb_randr_crtc_t *) (R + 1);
+}
+
+int
+xcb_randr_get_screen_resources_crtcs_length (const xcb_randr_get_screen_resources_reply_t *R)
+{
+    return R->num_crtcs;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_screen_resources_crtcs_end (const xcb_randr_get_screen_resources_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_randr_crtc_t *) (R + 1)) + (R->num_crtcs);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_output_t *
+xcb_randr_get_screen_resources_outputs (const xcb_randr_get_screen_resources_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_crtcs_end(R);
+    return (xcb_randr_output_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index) + 0);
+}
+
+int
+xcb_randr_get_screen_resources_outputs_length (const xcb_randr_get_screen_resources_reply_t *R)
+{
+    return R->num_outputs;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_screen_resources_outputs_end (const xcb_randr_get_screen_resources_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_crtcs_end(R);
+    i.data = ((xcb_randr_output_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index))) + (R->num_outputs);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_mode_info_t *
+xcb_randr_get_screen_resources_modes (const xcb_randr_get_screen_resources_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_outputs_end(R);
+    return (xcb_randr_mode_info_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_mode_info_t, prev.index) + 0);
+}
+
+int
+xcb_randr_get_screen_resources_modes_length (const xcb_randr_get_screen_resources_reply_t *R)
+{
+    return R->num_modes;
+}
+
+xcb_randr_mode_info_iterator_t
+xcb_randr_get_screen_resources_modes_iterator (const xcb_randr_get_screen_resources_reply_t *R)
+{
+    xcb_randr_mode_info_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_outputs_end(R);
+    i.data = (xcb_randr_mode_info_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_mode_info_t, prev.index));
+    i.rem = R->num_modes;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint8_t *
+xcb_randr_get_screen_resources_names (const xcb_randr_get_screen_resources_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_mode_info_end(xcb_randr_get_screen_resources_modes_iterator(R));
+    return (uint8_t *) ((char *) prev.data + XCB_TYPE_PAD(uint8_t, prev.index) + 0);
+}
+
+int
+xcb_randr_get_screen_resources_names_length (const xcb_randr_get_screen_resources_reply_t *R)
+{
+    return R->names_len;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_screen_resources_names_end (const xcb_randr_get_screen_resources_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_mode_info_end(xcb_randr_get_screen_resources_modes_iterator(R));
+    i.data = ((uint8_t *) ((char*) prev.data + XCB_TYPE_PAD(uint8_t, prev.index))) + (R->names_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_get_screen_resources_reply_t *
+xcb_randr_get_screen_resources_reply (xcb_connection_t                         *c,
+                                      xcb_randr_get_screen_resources_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e)
+{
+    return (xcb_randr_get_screen_resources_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_randr_get_output_info_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_get_output_info_reply_t *_aux = (xcb_randr_get_output_info_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_get_output_info_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* crtcs */
+    xcb_block_len += _aux->num_crtcs * sizeof(xcb_randr_output_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_crtc_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* modes */
+    xcb_block_len += _aux->num_modes * sizeof(xcb_randr_output_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_mode_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* clones */
+    xcb_block_len += _aux->num_clones * sizeof(xcb_randr_output_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_output_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->name_len * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_randr_get_output_info_cookie_t
+xcb_randr_get_output_info (xcb_connection_t   *c,
+                           xcb_randr_output_t  output,
+                           xcb_timestamp_t     config_timestamp)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_OUTPUT_INFO,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_output_info_cookie_t xcb_ret;
+    xcb_randr_get_output_info_request_t xcb_out;
+
+    xcb_out.output = output;
+    xcb_out.config_timestamp = config_timestamp;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_output_info_cookie_t
+xcb_randr_get_output_info_unchecked (xcb_connection_t   *c,
+                                     xcb_randr_output_t  output,
+                                     xcb_timestamp_t     config_timestamp)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_OUTPUT_INFO,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_output_info_cookie_t xcb_ret;
+    xcb_randr_get_output_info_request_t xcb_out;
+
+    xcb_out.output = output;
+    xcb_out.config_timestamp = config_timestamp;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_crtc_t *
+xcb_randr_get_output_info_crtcs (const xcb_randr_get_output_info_reply_t *R)
+{
+    return (xcb_randr_crtc_t *) (R + 1);
+}
+
+int
+xcb_randr_get_output_info_crtcs_length (const xcb_randr_get_output_info_reply_t *R)
+{
+    return R->num_crtcs;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_output_info_crtcs_end (const xcb_randr_get_output_info_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_randr_crtc_t *) (R + 1)) + (R->num_crtcs);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_mode_t *
+xcb_randr_get_output_info_modes (const xcb_randr_get_output_info_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_get_output_info_crtcs_end(R);
+    return (xcb_randr_mode_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_mode_t, prev.index) + 0);
+}
+
+int
+xcb_randr_get_output_info_modes_length (const xcb_randr_get_output_info_reply_t *R)
+{
+    return R->num_modes;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_output_info_modes_end (const xcb_randr_get_output_info_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_get_output_info_crtcs_end(R);
+    i.data = ((xcb_randr_mode_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_randr_mode_t, prev.index))) + (R->num_modes);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_output_t *
+xcb_randr_get_output_info_clones (const xcb_randr_get_output_info_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_get_output_info_modes_end(R);
+    return (xcb_randr_output_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index) + 0);
+}
+
+int
+xcb_randr_get_output_info_clones_length (const xcb_randr_get_output_info_reply_t *R)
+{
+    return R->num_clones;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_output_info_clones_end (const xcb_randr_get_output_info_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_get_output_info_modes_end(R);
+    i.data = ((xcb_randr_output_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index))) + (R->num_clones);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint8_t *
+xcb_randr_get_output_info_name (const xcb_randr_get_output_info_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_get_output_info_clones_end(R);
+    return (uint8_t *) ((char *) prev.data + XCB_TYPE_PAD(uint8_t, prev.index) + 0);
+}
+
+int
+xcb_randr_get_output_info_name_length (const xcb_randr_get_output_info_reply_t *R)
+{
+    return R->name_len;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_output_info_name_end (const xcb_randr_get_output_info_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_get_output_info_clones_end(R);
+    i.data = ((uint8_t *) ((char*) prev.data + XCB_TYPE_PAD(uint8_t, prev.index))) + (R->name_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_get_output_info_reply_t *
+xcb_randr_get_output_info_reply (xcb_connection_t                    *c,
+                                 xcb_randr_get_output_info_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e)
+{
+    return (xcb_randr_get_output_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_randr_list_output_properties_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_list_output_properties_reply_t *_aux = (xcb_randr_list_output_properties_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_list_output_properties_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* atoms */
+    xcb_block_len += _aux->num_atoms * sizeof(xcb_atom_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_atom_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_randr_list_output_properties_cookie_t
+xcb_randr_list_output_properties (xcb_connection_t   *c,
+                                  xcb_randr_output_t  output)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_LIST_OUTPUT_PROPERTIES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_list_output_properties_cookie_t xcb_ret;
+    xcb_randr_list_output_properties_request_t xcb_out;
+
+    xcb_out.output = output;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_list_output_properties_cookie_t
+xcb_randr_list_output_properties_unchecked (xcb_connection_t   *c,
+                                            xcb_randr_output_t  output)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_LIST_OUTPUT_PROPERTIES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_list_output_properties_cookie_t xcb_ret;
+    xcb_randr_list_output_properties_request_t xcb_out;
+
+    xcb_out.output = output;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_atom_t *
+xcb_randr_list_output_properties_atoms (const xcb_randr_list_output_properties_reply_t *R)
+{
+    return (xcb_atom_t *) (R + 1);
+}
+
+int
+xcb_randr_list_output_properties_atoms_length (const xcb_randr_list_output_properties_reply_t *R)
+{
+    return R->num_atoms;
+}
+
+xcb_generic_iterator_t
+xcb_randr_list_output_properties_atoms_end (const xcb_randr_list_output_properties_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_atom_t *) (R + 1)) + (R->num_atoms);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_list_output_properties_reply_t *
+xcb_randr_list_output_properties_reply (xcb_connection_t                           *c,
+                                        xcb_randr_list_output_properties_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e)
+{
+    return (xcb_randr_list_output_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_randr_query_output_property_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_query_output_property_reply_t *_aux = (xcb_randr_query_output_property_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_query_output_property_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* validValues */
+    xcb_block_len += _aux->length * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_randr_query_output_property_cookie_t
+xcb_randr_query_output_property (xcb_connection_t   *c,
+                                 xcb_randr_output_t  output,
+                                 xcb_atom_t          property)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_QUERY_OUTPUT_PROPERTY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_query_output_property_cookie_t xcb_ret;
+    xcb_randr_query_output_property_request_t xcb_out;
+
+    xcb_out.output = output;
+    xcb_out.property = property;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_query_output_property_cookie_t
+xcb_randr_query_output_property_unchecked (xcb_connection_t   *c,
+                                           xcb_randr_output_t  output,
+                                           xcb_atom_t          property)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_QUERY_OUTPUT_PROPERTY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_query_output_property_cookie_t xcb_ret;
+    xcb_randr_query_output_property_request_t xcb_out;
+
+    xcb_out.output = output;
+    xcb_out.property = property;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int32_t *
+xcb_randr_query_output_property_valid_values (const xcb_randr_query_output_property_reply_t *R)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_randr_query_output_property_valid_values_length (const xcb_randr_query_output_property_reply_t *R)
+{
+    return R->length;
+}
+
+xcb_generic_iterator_t
+xcb_randr_query_output_property_valid_values_end (const xcb_randr_query_output_property_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + (R->length);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_query_output_property_reply_t *
+xcb_randr_query_output_property_reply (xcb_connection_t                          *c,
+                                       xcb_randr_query_output_property_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e)
+{
+    return (xcb_randr_query_output_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_randr_configure_output_property_sizeof (const void  *_buffer,
+                                            uint32_t     values_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_configure_output_property_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* values */
+    xcb_block_len += values_len * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_randr_configure_output_property_checked (xcb_connection_t   *c,
+                                             xcb_randr_output_t  output,
+                                             xcb_atom_t          property,
+                                             uint8_t             pending,
+                                             uint8_t             range,
+                                             uint32_t            values_len,
+                                             const int32_t      *values)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_CONFIGURE_OUTPUT_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_configure_output_property_request_t xcb_out;
+
+    xcb_out.output = output;
+    xcb_out.property = property;
+    xcb_out.pending = pending;
+    xcb_out.range = range;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* int32_t values */
+    xcb_parts[4].iov_base = (char *) values;
+    xcb_parts[4].iov_len = values_len * sizeof(int32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_configure_output_property (xcb_connection_t   *c,
+                                     xcb_randr_output_t  output,
+                                     xcb_atom_t          property,
+                                     uint8_t             pending,
+                                     uint8_t             range,
+                                     uint32_t            values_len,
+                                     const int32_t      *values)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_CONFIGURE_OUTPUT_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_configure_output_property_request_t xcb_out;
+
+    xcb_out.output = output;
+    xcb_out.property = property;
+    xcb_out.pending = pending;
+    xcb_out.range = range;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* int32_t values */
+    xcb_parts[4].iov_base = (char *) values;
+    xcb_parts[4].iov_len = values_len * sizeof(int32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int32_t *
+xcb_randr_configure_output_property_values (const xcb_randr_configure_output_property_request_t *R)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_randr_configure_output_property_values_length (const xcb_randr_configure_output_property_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_randr_configure_output_property_request_t))/sizeof(int32_t));
+}
+
+xcb_generic_iterator_t
+xcb_randr_configure_output_property_values_end (const xcb_randr_configure_output_property_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_randr_configure_output_property_request_t))/sizeof(int32_t)));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_randr_change_output_property_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_change_output_property_request_t *_aux = (xcb_randr_change_output_property_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_change_output_property_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += ((_aux->num_units * _aux->format) / 8) * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_randr_change_output_property_checked (xcb_connection_t   *c,
+                                          xcb_randr_output_t  output,
+                                          xcb_atom_t          property,
+                                          xcb_atom_t          type,
+                                          uint8_t             format,
+                                          uint8_t             mode,
+                                          uint32_t            num_units,
+                                          const void         *data)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_CHANGE_OUTPUT_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_change_output_property_request_t xcb_out;
+
+    xcb_out.output = output;
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.format = format;
+    xcb_out.mode = mode;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.num_units = num_units;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* void data */
+    xcb_parts[4].iov_base = (char *) data;
+    xcb_parts[4].iov_len = ((num_units * format) / 8) * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_change_output_property (xcb_connection_t   *c,
+                                  xcb_randr_output_t  output,
+                                  xcb_atom_t          property,
+                                  xcb_atom_t          type,
+                                  uint8_t             format,
+                                  uint8_t             mode,
+                                  uint32_t            num_units,
+                                  const void         *data)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_CHANGE_OUTPUT_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_change_output_property_request_t xcb_out;
+
+    xcb_out.output = output;
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.format = format;
+    xcb_out.mode = mode;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.num_units = num_units;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* void data */
+    xcb_parts[4].iov_base = (char *) data;
+    xcb_parts[4].iov_len = ((num_units * format) / 8) * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+void *
+xcb_randr_change_output_property_data (const xcb_randr_change_output_property_request_t *R)
+{
+    return (void *) (R + 1);
+}
+
+int
+xcb_randr_change_output_property_data_length (const xcb_randr_change_output_property_request_t *R)
+{
+    return ((R->num_units * R->format) / 8);
+}
+
+xcb_generic_iterator_t
+xcb_randr_change_output_property_data_end (const xcb_randr_change_output_property_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (((R->num_units * R->format) / 8));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_randr_delete_output_property_checked (xcb_connection_t   *c,
+                                          xcb_randr_output_t  output,
+                                          xcb_atom_t          property)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_DELETE_OUTPUT_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_delete_output_property_request_t xcb_out;
+
+    xcb_out.output = output;
+    xcb_out.property = property;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_delete_output_property (xcb_connection_t   *c,
+                                  xcb_randr_output_t  output,
+                                  xcb_atom_t          property)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_DELETE_OUTPUT_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_delete_output_property_request_t xcb_out;
+
+    xcb_out.output = output;
+    xcb_out.property = property;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_randr_get_output_property_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_get_output_property_reply_t *_aux = (xcb_randr_get_output_property_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_get_output_property_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += (_aux->num_items * (_aux->format / 8)) * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_randr_get_output_property_cookie_t
+xcb_randr_get_output_property (xcb_connection_t   *c,
+                               xcb_randr_output_t  output,
+                               xcb_atom_t          property,
+                               xcb_atom_t          type,
+                               uint32_t            long_offset,
+                               uint32_t            long_length,
+                               uint8_t             _delete,
+                               uint8_t             pending)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_OUTPUT_PROPERTY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_output_property_cookie_t xcb_ret;
+    xcb_randr_get_output_property_request_t xcb_out;
+
+    xcb_out.output = output;
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.long_offset = long_offset;
+    xcb_out.long_length = long_length;
+    xcb_out._delete = _delete;
+    xcb_out.pending = pending;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_output_property_cookie_t
+xcb_randr_get_output_property_unchecked (xcb_connection_t   *c,
+                                         xcb_randr_output_t  output,
+                                         xcb_atom_t          property,
+                                         xcb_atom_t          type,
+                                         uint32_t            long_offset,
+                                         uint32_t            long_length,
+                                         uint8_t             _delete,
+                                         uint8_t             pending)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_OUTPUT_PROPERTY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_output_property_cookie_t xcb_ret;
+    xcb_randr_get_output_property_request_t xcb_out;
+
+    xcb_out.output = output;
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.long_offset = long_offset;
+    xcb_out.long_length = long_length;
+    xcb_out._delete = _delete;
+    xcb_out.pending = pending;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_randr_get_output_property_data (const xcb_randr_get_output_property_reply_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_randr_get_output_property_data_length (const xcb_randr_get_output_property_reply_t *R)
+{
+    return (R->num_items * (R->format / 8));
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_output_property_data_end (const xcb_randr_get_output_property_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((R->num_items * (R->format / 8)));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_get_output_property_reply_t *
+xcb_randr_get_output_property_reply (xcb_connection_t                        *c,
+                                     xcb_randr_get_output_property_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e)
+{
+    return (xcb_randr_get_output_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_randr_create_mode_sizeof (const void  *_buffer,
+                              uint32_t     name_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_create_mode_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += name_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_randr_create_mode_cookie_t
+xcb_randr_create_mode (xcb_connection_t      *c,
+                       xcb_window_t           window,
+                       xcb_randr_mode_info_t  mode_info,
+                       uint32_t               name_len,
+                       const char            *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_CREATE_MODE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_randr_create_mode_cookie_t xcb_ret;
+    xcb_randr_create_mode_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.mode_info = mode_info;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = name_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_create_mode_cookie_t
+xcb_randr_create_mode_unchecked (xcb_connection_t      *c,
+                                 xcb_window_t           window,
+                                 xcb_randr_mode_info_t  mode_info,
+                                 uint32_t               name_len,
+                                 const char            *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_CREATE_MODE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_randr_create_mode_cookie_t xcb_ret;
+    xcb_randr_create_mode_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.mode_info = mode_info;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = name_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_create_mode_reply_t *
+xcb_randr_create_mode_reply (xcb_connection_t                *c,
+                             xcb_randr_create_mode_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_randr_create_mode_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_randr_destroy_mode_checked (xcb_connection_t *c,
+                                xcb_randr_mode_t  mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_DESTROY_MODE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_destroy_mode_request_t xcb_out;
+
+    xcb_out.mode = mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_destroy_mode (xcb_connection_t *c,
+                        xcb_randr_mode_t  mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_DESTROY_MODE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_destroy_mode_request_t xcb_out;
+
+    xcb_out.mode = mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_add_output_mode_checked (xcb_connection_t   *c,
+                                   xcb_randr_output_t  output,
+                                   xcb_randr_mode_t    mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_ADD_OUTPUT_MODE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_add_output_mode_request_t xcb_out;
+
+    xcb_out.output = output;
+    xcb_out.mode = mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_add_output_mode (xcb_connection_t   *c,
+                           xcb_randr_output_t  output,
+                           xcb_randr_mode_t    mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_ADD_OUTPUT_MODE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_add_output_mode_request_t xcb_out;
+
+    xcb_out.output = output;
+    xcb_out.mode = mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_delete_output_mode_checked (xcb_connection_t   *c,
+                                      xcb_randr_output_t  output,
+                                      xcb_randr_mode_t    mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_DELETE_OUTPUT_MODE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_delete_output_mode_request_t xcb_out;
+
+    xcb_out.output = output;
+    xcb_out.mode = mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_delete_output_mode (xcb_connection_t   *c,
+                              xcb_randr_output_t  output,
+                              xcb_randr_mode_t    mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_DELETE_OUTPUT_MODE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_delete_output_mode_request_t xcb_out;
+
+    xcb_out.output = output;
+    xcb_out.mode = mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_randr_get_crtc_info_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_get_crtc_info_reply_t *_aux = (xcb_randr_get_crtc_info_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_get_crtc_info_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* outputs */
+    xcb_block_len += _aux->num_outputs * sizeof(xcb_randr_output_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_output_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* possible */
+    xcb_block_len += _aux->num_possible_outputs * sizeof(xcb_randr_output_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_output_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_randr_get_crtc_info_cookie_t
+xcb_randr_get_crtc_info (xcb_connection_t *c,
+                         xcb_randr_crtc_t  crtc,
+                         xcb_timestamp_t   config_timestamp)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_CRTC_INFO,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_crtc_info_cookie_t xcb_ret;
+    xcb_randr_get_crtc_info_request_t xcb_out;
+
+    xcb_out.crtc = crtc;
+    xcb_out.config_timestamp = config_timestamp;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_crtc_info_cookie_t
+xcb_randr_get_crtc_info_unchecked (xcb_connection_t *c,
+                                   xcb_randr_crtc_t  crtc,
+                                   xcb_timestamp_t   config_timestamp)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_CRTC_INFO,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_crtc_info_cookie_t xcb_ret;
+    xcb_randr_get_crtc_info_request_t xcb_out;
+
+    xcb_out.crtc = crtc;
+    xcb_out.config_timestamp = config_timestamp;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_output_t *
+xcb_randr_get_crtc_info_outputs (const xcb_randr_get_crtc_info_reply_t *R)
+{
+    return (xcb_randr_output_t *) (R + 1);
+}
+
+int
+xcb_randr_get_crtc_info_outputs_length (const xcb_randr_get_crtc_info_reply_t *R)
+{
+    return R->num_outputs;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_crtc_info_outputs_end (const xcb_randr_get_crtc_info_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_randr_output_t *) (R + 1)) + (R->num_outputs);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_output_t *
+xcb_randr_get_crtc_info_possible (const xcb_randr_get_crtc_info_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_get_crtc_info_outputs_end(R);
+    return (xcb_randr_output_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index) + 0);
+}
+
+int
+xcb_randr_get_crtc_info_possible_length (const xcb_randr_get_crtc_info_reply_t *R)
+{
+    return R->num_possible_outputs;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_crtc_info_possible_end (const xcb_randr_get_crtc_info_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_get_crtc_info_outputs_end(R);
+    i.data = ((xcb_randr_output_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index))) + (R->num_possible_outputs);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_get_crtc_info_reply_t *
+xcb_randr_get_crtc_info_reply (xcb_connection_t                  *c,
+                               xcb_randr_get_crtc_info_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_randr_get_crtc_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_randr_set_crtc_config_sizeof (const void  *_buffer,
+                                  uint32_t     outputs_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_set_crtc_config_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* outputs */
+    xcb_block_len += outputs_len * sizeof(xcb_randr_output_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_output_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_randr_set_crtc_config_cookie_t
+xcb_randr_set_crtc_config (xcb_connection_t         *c,
+                           xcb_randr_crtc_t          crtc,
+                           xcb_timestamp_t           timestamp,
+                           xcb_timestamp_t           config_timestamp,
+                           int16_t                   x,
+                           int16_t                   y,
+                           xcb_randr_mode_t          mode,
+                           uint16_t                  rotation,
+                           uint32_t                  outputs_len,
+                           const xcb_randr_output_t *outputs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SET_CRTC_CONFIG,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_randr_set_crtc_config_cookie_t xcb_ret;
+    xcb_randr_set_crtc_config_request_t xcb_out;
+
+    xcb_out.crtc = crtc;
+    xcb_out.timestamp = timestamp;
+    xcb_out.config_timestamp = config_timestamp;
+    xcb_out.x = x;
+    xcb_out.y = y;
+    xcb_out.mode = mode;
+    xcb_out.rotation = rotation;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_randr_output_t outputs */
+    xcb_parts[4].iov_base = (char *) outputs;
+    xcb_parts[4].iov_len = outputs_len * sizeof(xcb_timestamp_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_set_crtc_config_cookie_t
+xcb_randr_set_crtc_config_unchecked (xcb_connection_t         *c,
+                                     xcb_randr_crtc_t          crtc,
+                                     xcb_timestamp_t           timestamp,
+                                     xcb_timestamp_t           config_timestamp,
+                                     int16_t                   x,
+                                     int16_t                   y,
+                                     xcb_randr_mode_t          mode,
+                                     uint16_t                  rotation,
+                                     uint32_t                  outputs_len,
+                                     const xcb_randr_output_t *outputs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SET_CRTC_CONFIG,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_randr_set_crtc_config_cookie_t xcb_ret;
+    xcb_randr_set_crtc_config_request_t xcb_out;
+
+    xcb_out.crtc = crtc;
+    xcb_out.timestamp = timestamp;
+    xcb_out.config_timestamp = config_timestamp;
+    xcb_out.x = x;
+    xcb_out.y = y;
+    xcb_out.mode = mode;
+    xcb_out.rotation = rotation;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_randr_output_t outputs */
+    xcb_parts[4].iov_base = (char *) outputs;
+    xcb_parts[4].iov_len = outputs_len * sizeof(xcb_timestamp_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_set_crtc_config_reply_t *
+xcb_randr_set_crtc_config_reply (xcb_connection_t                    *c,
+                                 xcb_randr_set_crtc_config_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e)
+{
+    return (xcb_randr_set_crtc_config_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_randr_get_crtc_gamma_size_cookie_t
+xcb_randr_get_crtc_gamma_size (xcb_connection_t *c,
+                               xcb_randr_crtc_t  crtc)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_CRTC_GAMMA_SIZE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_crtc_gamma_size_cookie_t xcb_ret;
+    xcb_randr_get_crtc_gamma_size_request_t xcb_out;
+
+    xcb_out.crtc = crtc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_crtc_gamma_size_cookie_t
+xcb_randr_get_crtc_gamma_size_unchecked (xcb_connection_t *c,
+                                         xcb_randr_crtc_t  crtc)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_CRTC_GAMMA_SIZE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_crtc_gamma_size_cookie_t xcb_ret;
+    xcb_randr_get_crtc_gamma_size_request_t xcb_out;
+
+    xcb_out.crtc = crtc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_crtc_gamma_size_reply_t *
+xcb_randr_get_crtc_gamma_size_reply (xcb_connection_t                        *c,
+                                     xcb_randr_get_crtc_gamma_size_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e)
+{
+    return (xcb_randr_get_crtc_gamma_size_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_randr_get_crtc_gamma_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_get_crtc_gamma_reply_t *_aux = (xcb_randr_get_crtc_gamma_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_get_crtc_gamma_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* red */
+    xcb_block_len += _aux->size * sizeof(uint16_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint16_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* green */
+    xcb_block_len += _aux->size * sizeof(uint16_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint16_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* blue */
+    xcb_block_len += _aux->size * sizeof(uint16_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint16_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_randr_get_crtc_gamma_cookie_t
+xcb_randr_get_crtc_gamma (xcb_connection_t *c,
+                          xcb_randr_crtc_t  crtc)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_CRTC_GAMMA,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_crtc_gamma_cookie_t xcb_ret;
+    xcb_randr_get_crtc_gamma_request_t xcb_out;
+
+    xcb_out.crtc = crtc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_crtc_gamma_cookie_t
+xcb_randr_get_crtc_gamma_unchecked (xcb_connection_t *c,
+                                    xcb_randr_crtc_t  crtc)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_CRTC_GAMMA,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_crtc_gamma_cookie_t xcb_ret;
+    xcb_randr_get_crtc_gamma_request_t xcb_out;
+
+    xcb_out.crtc = crtc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint16_t *
+xcb_randr_get_crtc_gamma_red (const xcb_randr_get_crtc_gamma_reply_t *R)
+{
+    return (uint16_t *) (R + 1);
+}
+
+int
+xcb_randr_get_crtc_gamma_red_length (const xcb_randr_get_crtc_gamma_reply_t *R)
+{
+    return R->size;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_crtc_gamma_red_end (const xcb_randr_get_crtc_gamma_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint16_t *) (R + 1)) + (R->size);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint16_t *
+xcb_randr_get_crtc_gamma_green (const xcb_randr_get_crtc_gamma_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_get_crtc_gamma_red_end(R);
+    return (uint16_t *) ((char *) prev.data + XCB_TYPE_PAD(uint16_t, prev.index) + 0);
+}
+
+int
+xcb_randr_get_crtc_gamma_green_length (const xcb_randr_get_crtc_gamma_reply_t *R)
+{
+    return R->size;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_crtc_gamma_green_end (const xcb_randr_get_crtc_gamma_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_get_crtc_gamma_red_end(R);
+    i.data = ((uint16_t *) ((char*) prev.data + XCB_TYPE_PAD(uint16_t, prev.index))) + (R->size);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint16_t *
+xcb_randr_get_crtc_gamma_blue (const xcb_randr_get_crtc_gamma_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_get_crtc_gamma_green_end(R);
+    return (uint16_t *) ((char *) prev.data + XCB_TYPE_PAD(uint16_t, prev.index) + 0);
+}
+
+int
+xcb_randr_get_crtc_gamma_blue_length (const xcb_randr_get_crtc_gamma_reply_t *R)
+{
+    return R->size;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_crtc_gamma_blue_end (const xcb_randr_get_crtc_gamma_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_get_crtc_gamma_green_end(R);
+    i.data = ((uint16_t *) ((char*) prev.data + XCB_TYPE_PAD(uint16_t, prev.index))) + (R->size);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_get_crtc_gamma_reply_t *
+xcb_randr_get_crtc_gamma_reply (xcb_connection_t                   *c,
+                                xcb_randr_get_crtc_gamma_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e)
+{
+    return (xcb_randr_get_crtc_gamma_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_randr_set_crtc_gamma_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_set_crtc_gamma_request_t *_aux = (xcb_randr_set_crtc_gamma_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_set_crtc_gamma_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* red */
+    xcb_block_len += _aux->size * sizeof(uint16_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint16_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* green */
+    xcb_block_len += _aux->size * sizeof(uint16_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint16_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* blue */
+    xcb_block_len += _aux->size * sizeof(uint16_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint16_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_randr_set_crtc_gamma_checked (xcb_connection_t *c,
+                                  xcb_randr_crtc_t  crtc,
+                                  uint16_t          size,
+                                  const uint16_t   *red,
+                                  const uint16_t   *green,
+                                  const uint16_t   *blue)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 8,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SET_CRTC_GAMMA,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[10];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_set_crtc_gamma_request_t xcb_out;
+
+    xcb_out.crtc = crtc;
+    xcb_out.size = size;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint16_t red */
+    xcb_parts[4].iov_base = (char *) red;
+    xcb_parts[4].iov_len = size * sizeof(uint16_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* uint16_t green */
+    xcb_parts[6].iov_base = (char *) green;
+    xcb_parts[6].iov_len = size * sizeof(uint16_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+    /* uint16_t blue */
+    xcb_parts[8].iov_base = (char *) blue;
+    xcb_parts[8].iov_len = size * sizeof(uint16_t);
+    xcb_parts[9].iov_base = 0;
+    xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_set_crtc_gamma (xcb_connection_t *c,
+                          xcb_randr_crtc_t  crtc,
+                          uint16_t          size,
+                          const uint16_t   *red,
+                          const uint16_t   *green,
+                          const uint16_t   *blue)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 8,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SET_CRTC_GAMMA,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[10];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_set_crtc_gamma_request_t xcb_out;
+
+    xcb_out.crtc = crtc;
+    xcb_out.size = size;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint16_t red */
+    xcb_parts[4].iov_base = (char *) red;
+    xcb_parts[4].iov_len = size * sizeof(uint16_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* uint16_t green */
+    xcb_parts[6].iov_base = (char *) green;
+    xcb_parts[6].iov_len = size * sizeof(uint16_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+    /* uint16_t blue */
+    xcb_parts[8].iov_base = (char *) blue;
+    xcb_parts[8].iov_len = size * sizeof(uint16_t);
+    xcb_parts[9].iov_base = 0;
+    xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint16_t *
+xcb_randr_set_crtc_gamma_red (const xcb_randr_set_crtc_gamma_request_t *R)
+{
+    return (uint16_t *) (R + 1);
+}
+
+int
+xcb_randr_set_crtc_gamma_red_length (const xcb_randr_set_crtc_gamma_request_t *R)
+{
+    return R->size;
+}
+
+xcb_generic_iterator_t
+xcb_randr_set_crtc_gamma_red_end (const xcb_randr_set_crtc_gamma_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint16_t *) (R + 1)) + (R->size);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint16_t *
+xcb_randr_set_crtc_gamma_green (const xcb_randr_set_crtc_gamma_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_set_crtc_gamma_red_end(R);
+    return (uint16_t *) ((char *) prev.data + XCB_TYPE_PAD(uint16_t, prev.index) + 0);
+}
+
+int
+xcb_randr_set_crtc_gamma_green_length (const xcb_randr_set_crtc_gamma_request_t *R)
+{
+    return R->size;
+}
+
+xcb_generic_iterator_t
+xcb_randr_set_crtc_gamma_green_end (const xcb_randr_set_crtc_gamma_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_set_crtc_gamma_red_end(R);
+    i.data = ((uint16_t *) ((char*) prev.data + XCB_TYPE_PAD(uint16_t, prev.index))) + (R->size);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint16_t *
+xcb_randr_set_crtc_gamma_blue (const xcb_randr_set_crtc_gamma_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_set_crtc_gamma_green_end(R);
+    return (uint16_t *) ((char *) prev.data + XCB_TYPE_PAD(uint16_t, prev.index) + 0);
+}
+
+int
+xcb_randr_set_crtc_gamma_blue_length (const xcb_randr_set_crtc_gamma_request_t *R)
+{
+    return R->size;
+}
+
+xcb_generic_iterator_t
+xcb_randr_set_crtc_gamma_blue_end (const xcb_randr_set_crtc_gamma_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_set_crtc_gamma_green_end(R);
+    i.data = ((uint16_t *) ((char*) prev.data + XCB_TYPE_PAD(uint16_t, prev.index))) + (R->size);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_randr_get_screen_resources_current_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_get_screen_resources_current_reply_t *_aux = (xcb_randr_get_screen_resources_current_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_get_screen_resources_current_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* crtcs */
+    xcb_block_len += _aux->num_crtcs * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_crtc_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* outputs */
+    xcb_block_len += _aux->num_outputs * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_output_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* modes */
+    xcb_block_len += _aux->num_modes * sizeof(xcb_randr_mode_info_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_mode_info_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* names */
+    xcb_block_len += _aux->names_len * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_randr_get_screen_resources_current_cookie_t
+xcb_randr_get_screen_resources_current (xcb_connection_t *c,
+                                        xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_SCREEN_RESOURCES_CURRENT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_screen_resources_current_cookie_t xcb_ret;
+    xcb_randr_get_screen_resources_current_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_screen_resources_current_cookie_t
+xcb_randr_get_screen_resources_current_unchecked (xcb_connection_t *c,
+                                                  xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_SCREEN_RESOURCES_CURRENT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_screen_resources_current_cookie_t xcb_ret;
+    xcb_randr_get_screen_resources_current_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_crtc_t *
+xcb_randr_get_screen_resources_current_crtcs (const xcb_randr_get_screen_resources_current_reply_t *R)
+{
+    return (xcb_randr_crtc_t *) (R + 1);
+}
+
+int
+xcb_randr_get_screen_resources_current_crtcs_length (const xcb_randr_get_screen_resources_current_reply_t *R)
+{
+    return R->num_crtcs;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_screen_resources_current_crtcs_end (const xcb_randr_get_screen_resources_current_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_randr_crtc_t *) (R + 1)) + (R->num_crtcs);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_output_t *
+xcb_randr_get_screen_resources_current_outputs (const xcb_randr_get_screen_resources_current_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_current_crtcs_end(R);
+    return (xcb_randr_output_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index) + 0);
+}
+
+int
+xcb_randr_get_screen_resources_current_outputs_length (const xcb_randr_get_screen_resources_current_reply_t *R)
+{
+    return R->num_outputs;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_screen_resources_current_outputs_end (const xcb_randr_get_screen_resources_current_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_current_crtcs_end(R);
+    i.data = ((xcb_randr_output_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index))) + (R->num_outputs);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_mode_info_t *
+xcb_randr_get_screen_resources_current_modes (const xcb_randr_get_screen_resources_current_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_current_outputs_end(R);
+    return (xcb_randr_mode_info_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_mode_info_t, prev.index) + 0);
+}
+
+int
+xcb_randr_get_screen_resources_current_modes_length (const xcb_randr_get_screen_resources_current_reply_t *R)
+{
+    return R->num_modes;
+}
+
+xcb_randr_mode_info_iterator_t
+xcb_randr_get_screen_resources_current_modes_iterator (const xcb_randr_get_screen_resources_current_reply_t *R)
+{
+    xcb_randr_mode_info_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_get_screen_resources_current_outputs_end(R);
+    i.data = (xcb_randr_mode_info_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_mode_info_t, prev.index));
+    i.rem = R->num_modes;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint8_t *
+xcb_randr_get_screen_resources_current_names (const xcb_randr_get_screen_resources_current_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_mode_info_end(xcb_randr_get_screen_resources_current_modes_iterator(R));
+    return (uint8_t *) ((char *) prev.data + XCB_TYPE_PAD(uint8_t, prev.index) + 0);
+}
+
+int
+xcb_randr_get_screen_resources_current_names_length (const xcb_randr_get_screen_resources_current_reply_t *R)
+{
+    return R->names_len;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_screen_resources_current_names_end (const xcb_randr_get_screen_resources_current_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_mode_info_end(xcb_randr_get_screen_resources_current_modes_iterator(R));
+    i.data = ((uint8_t *) ((char*) prev.data + XCB_TYPE_PAD(uint8_t, prev.index))) + (R->names_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_get_screen_resources_current_reply_t *
+xcb_randr_get_screen_resources_current_reply (xcb_connection_t                                 *c,
+                                              xcb_randr_get_screen_resources_current_cookie_t   cookie  /**< */,
+                                              xcb_generic_error_t                             **e)
+{
+    return (xcb_randr_get_screen_resources_current_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_randr_set_crtc_transform_sizeof (const void  *_buffer,
+                                     uint32_t     filter_params_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_set_crtc_transform_request_t *_aux = (xcb_randr_set_crtc_transform_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_set_crtc_transform_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* filter_name */
+    xcb_block_len += _aux->filter_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* filter_params */
+    xcb_block_len += filter_params_len * sizeof(xcb_render_fixed_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_fixed_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_randr_set_crtc_transform_checked (xcb_connection_t         *c,
+                                      xcb_randr_crtc_t          crtc,
+                                      xcb_render_transform_t    transform,
+                                      uint16_t                  filter_len,
+                                      const char               *filter_name,
+                                      uint32_t                  filter_params_len,
+                                      const xcb_render_fixed_t *filter_params)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SET_CRTC_TRANSFORM,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_set_crtc_transform_request_t xcb_out;
+
+    xcb_out.crtc = crtc;
+    xcb_out.transform = transform;
+    xcb_out.filter_len = filter_len;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char filter_name */
+    xcb_parts[4].iov_base = (char *) filter_name;
+    xcb_parts[4].iov_len = filter_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_render_fixed_t filter_params */
+    xcb_parts[6].iov_base = (char *) filter_params;
+    xcb_parts[6].iov_len = filter_params_len * sizeof(xcb_render_fixed_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_set_crtc_transform (xcb_connection_t         *c,
+                              xcb_randr_crtc_t          crtc,
+                              xcb_render_transform_t    transform,
+                              uint16_t                  filter_len,
+                              const char               *filter_name,
+                              uint32_t                  filter_params_len,
+                              const xcb_render_fixed_t *filter_params)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SET_CRTC_TRANSFORM,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_set_crtc_transform_request_t xcb_out;
+
+    xcb_out.crtc = crtc;
+    xcb_out.transform = transform;
+    xcb_out.filter_len = filter_len;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char filter_name */
+    xcb_parts[4].iov_base = (char *) filter_name;
+    xcb_parts[4].iov_len = filter_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_render_fixed_t filter_params */
+    xcb_parts[6].iov_base = (char *) filter_params;
+    xcb_parts[6].iov_len = filter_params_len * sizeof(xcb_render_fixed_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_randr_set_crtc_transform_filter_name (const xcb_randr_set_crtc_transform_request_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_randr_set_crtc_transform_filter_name_length (const xcb_randr_set_crtc_transform_request_t *R)
+{
+    return R->filter_len;
+}
+
+xcb_generic_iterator_t
+xcb_randr_set_crtc_transform_filter_name_end (const xcb_randr_set_crtc_transform_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->filter_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_render_fixed_t *
+xcb_randr_set_crtc_transform_filter_params (const xcb_randr_set_crtc_transform_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_set_crtc_transform_filter_name_end(R);
+    return (xcb_render_fixed_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0);
+}
+
+int
+xcb_randr_set_crtc_transform_filter_params_length (const xcb_randr_set_crtc_transform_request_t *R)
+{
+    return ((((char*)R) + R->length * 4) - (char*)(xcb_randr_set_crtc_transform_filter_params(R))) / sizeof(xcb_render_fixed_t);
+}
+
+xcb_generic_iterator_t
+xcb_randr_set_crtc_transform_filter_params_end (const xcb_randr_set_crtc_transform_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_set_crtc_transform_filter_name_end(R);
+    i.data = ((xcb_render_fixed_t *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (((((char*)R) + R->length * 4) - (char*)(xcb_randr_set_crtc_transform_filter_params(R))) / sizeof(xcb_render_fixed_t));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_randr_get_crtc_transform_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_get_crtc_transform_reply_t *_aux = (xcb_randr_get_crtc_transform_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_get_crtc_transform_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* pending_filter_name */
+    xcb_block_len += _aux->pending_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* pending_params */
+    xcb_block_len += _aux->pending_nparams * sizeof(xcb_render_fixed_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_fixed_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* current_filter_name */
+    xcb_block_len += _aux->current_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* current_params */
+    xcb_block_len += _aux->current_nparams * sizeof(xcb_render_fixed_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_fixed_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_randr_get_crtc_transform_cookie_t
+xcb_randr_get_crtc_transform (xcb_connection_t *c,
+                              xcb_randr_crtc_t  crtc)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_CRTC_TRANSFORM,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_crtc_transform_cookie_t xcb_ret;
+    xcb_randr_get_crtc_transform_request_t xcb_out;
+
+    xcb_out.crtc = crtc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_crtc_transform_cookie_t
+xcb_randr_get_crtc_transform_unchecked (xcb_connection_t *c,
+                                        xcb_randr_crtc_t  crtc)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_CRTC_TRANSFORM,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_crtc_transform_cookie_t xcb_ret;
+    xcb_randr_get_crtc_transform_request_t xcb_out;
+
+    xcb_out.crtc = crtc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_randr_get_crtc_transform_pending_filter_name (const xcb_randr_get_crtc_transform_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_randr_get_crtc_transform_pending_filter_name_length (const xcb_randr_get_crtc_transform_reply_t *R)
+{
+    return R->pending_len;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_crtc_transform_pending_filter_name_end (const xcb_randr_get_crtc_transform_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->pending_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_render_fixed_t *
+xcb_randr_get_crtc_transform_pending_params (const xcb_randr_get_crtc_transform_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_get_crtc_transform_pending_filter_name_end(R);
+    return (xcb_render_fixed_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0);
+}
+
+int
+xcb_randr_get_crtc_transform_pending_params_length (const xcb_randr_get_crtc_transform_reply_t *R)
+{
+    return R->pending_nparams;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_crtc_transform_pending_params_end (const xcb_randr_get_crtc_transform_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_get_crtc_transform_pending_filter_name_end(R);
+    i.data = ((xcb_render_fixed_t *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (R->pending_nparams);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+char *
+xcb_randr_get_crtc_transform_current_filter_name (const xcb_randr_get_crtc_transform_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_get_crtc_transform_pending_params_end(R);
+    return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0);
+}
+
+int
+xcb_randr_get_crtc_transform_current_filter_name_length (const xcb_randr_get_crtc_transform_reply_t *R)
+{
+    return R->current_len;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_crtc_transform_current_filter_name_end (const xcb_randr_get_crtc_transform_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_get_crtc_transform_pending_params_end(R);
+    i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->current_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_render_fixed_t *
+xcb_randr_get_crtc_transform_current_params (const xcb_randr_get_crtc_transform_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_get_crtc_transform_current_filter_name_end(R);
+    return (xcb_render_fixed_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0);
+}
+
+int
+xcb_randr_get_crtc_transform_current_params_length (const xcb_randr_get_crtc_transform_reply_t *R)
+{
+    return R->current_nparams;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_crtc_transform_current_params_end (const xcb_randr_get_crtc_transform_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_get_crtc_transform_current_filter_name_end(R);
+    i.data = ((xcb_render_fixed_t *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (R->current_nparams);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_get_crtc_transform_reply_t *
+xcb_randr_get_crtc_transform_reply (xcb_connection_t                       *c,
+                                    xcb_randr_get_crtc_transform_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e)
+{
+    return (xcb_randr_get_crtc_transform_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_randr_get_panning_cookie_t
+xcb_randr_get_panning (xcb_connection_t *c,
+                       xcb_randr_crtc_t  crtc)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_PANNING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_panning_cookie_t xcb_ret;
+    xcb_randr_get_panning_request_t xcb_out;
+
+    xcb_out.crtc = crtc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_panning_cookie_t
+xcb_randr_get_panning_unchecked (xcb_connection_t *c,
+                                 xcb_randr_crtc_t  crtc)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_PANNING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_panning_cookie_t xcb_ret;
+    xcb_randr_get_panning_request_t xcb_out;
+
+    xcb_out.crtc = crtc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_panning_reply_t *
+xcb_randr_get_panning_reply (xcb_connection_t                *c,
+                             xcb_randr_get_panning_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_randr_get_panning_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_randr_set_panning_cookie_t
+xcb_randr_set_panning (xcb_connection_t *c,
+                       xcb_randr_crtc_t  crtc,
+                       xcb_timestamp_t   timestamp,
+                       uint16_t          left,
+                       uint16_t          top,
+                       uint16_t          width,
+                       uint16_t          height,
+                       uint16_t          track_left,
+                       uint16_t          track_top,
+                       uint16_t          track_width,
+                       uint16_t          track_height,
+                       int16_t           border_left,
+                       int16_t           border_top,
+                       int16_t           border_right,
+                       int16_t           border_bottom)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SET_PANNING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_set_panning_cookie_t xcb_ret;
+    xcb_randr_set_panning_request_t xcb_out;
+
+    xcb_out.crtc = crtc;
+    xcb_out.timestamp = timestamp;
+    xcb_out.left = left;
+    xcb_out.top = top;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.track_left = track_left;
+    xcb_out.track_top = track_top;
+    xcb_out.track_width = track_width;
+    xcb_out.track_height = track_height;
+    xcb_out.border_left = border_left;
+    xcb_out.border_top = border_top;
+    xcb_out.border_right = border_right;
+    xcb_out.border_bottom = border_bottom;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_set_panning_cookie_t
+xcb_randr_set_panning_unchecked (xcb_connection_t *c,
+                                 xcb_randr_crtc_t  crtc,
+                                 xcb_timestamp_t   timestamp,
+                                 uint16_t          left,
+                                 uint16_t          top,
+                                 uint16_t          width,
+                                 uint16_t          height,
+                                 uint16_t          track_left,
+                                 uint16_t          track_top,
+                                 uint16_t          track_width,
+                                 uint16_t          track_height,
+                                 int16_t           border_left,
+                                 int16_t           border_top,
+                                 int16_t           border_right,
+                                 int16_t           border_bottom)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SET_PANNING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_set_panning_cookie_t xcb_ret;
+    xcb_randr_set_panning_request_t xcb_out;
+
+    xcb_out.crtc = crtc;
+    xcb_out.timestamp = timestamp;
+    xcb_out.left = left;
+    xcb_out.top = top;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.track_left = track_left;
+    xcb_out.track_top = track_top;
+    xcb_out.track_width = track_width;
+    xcb_out.track_height = track_height;
+    xcb_out.border_left = border_left;
+    xcb_out.border_top = border_top;
+    xcb_out.border_right = border_right;
+    xcb_out.border_bottom = border_bottom;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_set_panning_reply_t *
+xcb_randr_set_panning_reply (xcb_connection_t                *c,
+                             xcb_randr_set_panning_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_randr_set_panning_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_randr_set_output_primary_checked (xcb_connection_t   *c,
+                                      xcb_window_t        window,
+                                      xcb_randr_output_t  output)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SET_OUTPUT_PRIMARY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_set_output_primary_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.output = output;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_set_output_primary (xcb_connection_t   *c,
+                              xcb_window_t        window,
+                              xcb_randr_output_t  output)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SET_OUTPUT_PRIMARY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_set_output_primary_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.output = output;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_output_primary_cookie_t
+xcb_randr_get_output_primary (xcb_connection_t *c,
+                              xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_OUTPUT_PRIMARY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_output_primary_cookie_t xcb_ret;
+    xcb_randr_get_output_primary_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_output_primary_cookie_t
+xcb_randr_get_output_primary_unchecked (xcb_connection_t *c,
+                                        xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_OUTPUT_PRIMARY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_output_primary_cookie_t xcb_ret;
+    xcb_randr_get_output_primary_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_output_primary_reply_t *
+xcb_randr_get_output_primary_reply (xcb_connection_t                       *c,
+                                    xcb_randr_get_output_primary_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e)
+{
+    return (xcb_randr_get_output_primary_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_randr_get_providers_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_get_providers_reply_t *_aux = (xcb_randr_get_providers_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_get_providers_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* providers */
+    xcb_block_len += _aux->num_providers * sizeof(xcb_randr_provider_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_provider_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_randr_get_providers_cookie_t
+xcb_randr_get_providers (xcb_connection_t *c,
+                         xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_PROVIDERS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_providers_cookie_t xcb_ret;
+    xcb_randr_get_providers_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_providers_cookie_t
+xcb_randr_get_providers_unchecked (xcb_connection_t *c,
+                                   xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_PROVIDERS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_providers_cookie_t xcb_ret;
+    xcb_randr_get_providers_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_provider_t *
+xcb_randr_get_providers_providers (const xcb_randr_get_providers_reply_t *R)
+{
+    return (xcb_randr_provider_t *) (R + 1);
+}
+
+int
+xcb_randr_get_providers_providers_length (const xcb_randr_get_providers_reply_t *R)
+{
+    return R->num_providers;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_providers_providers_end (const xcb_randr_get_providers_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_randr_provider_t *) (R + 1)) + (R->num_providers);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_get_providers_reply_t *
+xcb_randr_get_providers_reply (xcb_connection_t                  *c,
+                               xcb_randr_get_providers_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_randr_get_providers_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_randr_get_provider_info_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_get_provider_info_reply_t *_aux = (xcb_randr_get_provider_info_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_get_provider_info_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* crtcs */
+    xcb_block_len += _aux->num_crtcs * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_crtc_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* outputs */
+    xcb_block_len += _aux->num_outputs * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_output_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* associated_providers */
+    xcb_block_len += _aux->num_associated_providers * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_provider_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* associated_capability */
+    xcb_block_len += _aux->num_associated_providers * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->name_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_randr_get_provider_info_cookie_t
+xcb_randr_get_provider_info (xcb_connection_t     *c,
+                             xcb_randr_provider_t  provider,
+                             xcb_timestamp_t       config_timestamp)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_PROVIDER_INFO,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_provider_info_cookie_t xcb_ret;
+    xcb_randr_get_provider_info_request_t xcb_out;
+
+    xcb_out.provider = provider;
+    xcb_out.config_timestamp = config_timestamp;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_provider_info_cookie_t
+xcb_randr_get_provider_info_unchecked (xcb_connection_t     *c,
+                                       xcb_randr_provider_t  provider,
+                                       xcb_timestamp_t       config_timestamp)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_PROVIDER_INFO,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_provider_info_cookie_t xcb_ret;
+    xcb_randr_get_provider_info_request_t xcb_out;
+
+    xcb_out.provider = provider;
+    xcb_out.config_timestamp = config_timestamp;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_crtc_t *
+xcb_randr_get_provider_info_crtcs (const xcb_randr_get_provider_info_reply_t *R)
+{
+    return (xcb_randr_crtc_t *) (R + 1);
+}
+
+int
+xcb_randr_get_provider_info_crtcs_length (const xcb_randr_get_provider_info_reply_t *R)
+{
+    return R->num_crtcs;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_provider_info_crtcs_end (const xcb_randr_get_provider_info_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_randr_crtc_t *) (R + 1)) + (R->num_crtcs);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_output_t *
+xcb_randr_get_provider_info_outputs (const xcb_randr_get_provider_info_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_get_provider_info_crtcs_end(R);
+    return (xcb_randr_output_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index) + 0);
+}
+
+int
+xcb_randr_get_provider_info_outputs_length (const xcb_randr_get_provider_info_reply_t *R)
+{
+    return R->num_outputs;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_provider_info_outputs_end (const xcb_randr_get_provider_info_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_get_provider_info_crtcs_end(R);
+    i.data = ((xcb_randr_output_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_randr_output_t, prev.index))) + (R->num_outputs);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_provider_t *
+xcb_randr_get_provider_info_associated_providers (const xcb_randr_get_provider_info_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_get_provider_info_outputs_end(R);
+    return (xcb_randr_provider_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_randr_provider_t, prev.index) + 0);
+}
+
+int
+xcb_randr_get_provider_info_associated_providers_length (const xcb_randr_get_provider_info_reply_t *R)
+{
+    return R->num_associated_providers;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_provider_info_associated_providers_end (const xcb_randr_get_provider_info_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_get_provider_info_outputs_end(R);
+    i.data = ((xcb_randr_provider_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_randr_provider_t, prev.index))) + (R->num_associated_providers);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint32_t *
+xcb_randr_get_provider_info_associated_capability (const xcb_randr_get_provider_info_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_get_provider_info_associated_providers_end(R);
+    return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0);
+}
+
+int
+xcb_randr_get_provider_info_associated_capability_length (const xcb_randr_get_provider_info_reply_t *R)
+{
+    return R->num_associated_providers;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_provider_info_associated_capability_end (const xcb_randr_get_provider_info_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_get_provider_info_associated_providers_end(R);
+    i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->num_associated_providers);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+char *
+xcb_randr_get_provider_info_name (const xcb_randr_get_provider_info_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_randr_get_provider_info_associated_capability_end(R);
+    return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0);
+}
+
+int
+xcb_randr_get_provider_info_name_length (const xcb_randr_get_provider_info_reply_t *R)
+{
+    return R->name_len;
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_provider_info_name_end (const xcb_randr_get_provider_info_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_randr_get_provider_info_associated_capability_end(R);
+    i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->name_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_get_provider_info_reply_t *
+xcb_randr_get_provider_info_reply (xcb_connection_t                      *c,
+                                   xcb_randr_get_provider_info_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e)
+{
+    return (xcb_randr_get_provider_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_randr_set_provider_offload_sink_checked (xcb_connection_t     *c,
+                                             xcb_randr_provider_t  provider,
+                                             xcb_randr_provider_t  sink_provider,
+                                             xcb_timestamp_t       config_timestamp)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SET_PROVIDER_OFFLOAD_SINK,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_set_provider_offload_sink_request_t xcb_out;
+
+    xcb_out.provider = provider;
+    xcb_out.sink_provider = sink_provider;
+    xcb_out.config_timestamp = config_timestamp;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_set_provider_offload_sink (xcb_connection_t     *c,
+                                     xcb_randr_provider_t  provider,
+                                     xcb_randr_provider_t  sink_provider,
+                                     xcb_timestamp_t       config_timestamp)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SET_PROVIDER_OFFLOAD_SINK,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_set_provider_offload_sink_request_t xcb_out;
+
+    xcb_out.provider = provider;
+    xcb_out.sink_provider = sink_provider;
+    xcb_out.config_timestamp = config_timestamp;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_set_provider_output_source_checked (xcb_connection_t     *c,
+                                              xcb_randr_provider_t  provider,
+                                              xcb_randr_provider_t  source_provider,
+                                              xcb_timestamp_t       config_timestamp)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SET_PROVIDER_OUTPUT_SOURCE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_set_provider_output_source_request_t xcb_out;
+
+    xcb_out.provider = provider;
+    xcb_out.source_provider = source_provider;
+    xcb_out.config_timestamp = config_timestamp;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_set_provider_output_source (xcb_connection_t     *c,
+                                      xcb_randr_provider_t  provider,
+                                      xcb_randr_provider_t  source_provider,
+                                      xcb_timestamp_t       config_timestamp)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SET_PROVIDER_OUTPUT_SOURCE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_set_provider_output_source_request_t xcb_out;
+
+    xcb_out.provider = provider;
+    xcb_out.source_provider = source_provider;
+    xcb_out.config_timestamp = config_timestamp;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_randr_list_provider_properties_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_list_provider_properties_reply_t *_aux = (xcb_randr_list_provider_properties_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_list_provider_properties_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* atoms */
+    xcb_block_len += _aux->num_atoms * sizeof(xcb_atom_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_atom_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_randr_list_provider_properties_cookie_t
+xcb_randr_list_provider_properties (xcb_connection_t     *c,
+                                    xcb_randr_provider_t  provider)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_LIST_PROVIDER_PROPERTIES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_list_provider_properties_cookie_t xcb_ret;
+    xcb_randr_list_provider_properties_request_t xcb_out;
+
+    xcb_out.provider = provider;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_list_provider_properties_cookie_t
+xcb_randr_list_provider_properties_unchecked (xcb_connection_t     *c,
+                                              xcb_randr_provider_t  provider)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_LIST_PROVIDER_PROPERTIES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_list_provider_properties_cookie_t xcb_ret;
+    xcb_randr_list_provider_properties_request_t xcb_out;
+
+    xcb_out.provider = provider;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_atom_t *
+xcb_randr_list_provider_properties_atoms (const xcb_randr_list_provider_properties_reply_t *R)
+{
+    return (xcb_atom_t *) (R + 1);
+}
+
+int
+xcb_randr_list_provider_properties_atoms_length (const xcb_randr_list_provider_properties_reply_t *R)
+{
+    return R->num_atoms;
+}
+
+xcb_generic_iterator_t
+xcb_randr_list_provider_properties_atoms_end (const xcb_randr_list_provider_properties_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_atom_t *) (R + 1)) + (R->num_atoms);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_list_provider_properties_reply_t *
+xcb_randr_list_provider_properties_reply (xcb_connection_t                             *c,
+                                          xcb_randr_list_provider_properties_cookie_t   cookie  /**< */,
+                                          xcb_generic_error_t                         **e)
+{
+    return (xcb_randr_list_provider_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_randr_query_provider_property_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_query_provider_property_reply_t *_aux = (xcb_randr_query_provider_property_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_query_provider_property_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* valid_values */
+    xcb_block_len += _aux->length * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_randr_query_provider_property_cookie_t
+xcb_randr_query_provider_property (xcb_connection_t     *c,
+                                   xcb_randr_provider_t  provider,
+                                   xcb_atom_t            property)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_QUERY_PROVIDER_PROPERTY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_query_provider_property_cookie_t xcb_ret;
+    xcb_randr_query_provider_property_request_t xcb_out;
+
+    xcb_out.provider = provider;
+    xcb_out.property = property;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_query_provider_property_cookie_t
+xcb_randr_query_provider_property_unchecked (xcb_connection_t     *c,
+                                             xcb_randr_provider_t  provider,
+                                             xcb_atom_t            property)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_QUERY_PROVIDER_PROPERTY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_query_provider_property_cookie_t xcb_ret;
+    xcb_randr_query_provider_property_request_t xcb_out;
+
+    xcb_out.provider = provider;
+    xcb_out.property = property;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int32_t *
+xcb_randr_query_provider_property_valid_values (const xcb_randr_query_provider_property_reply_t *R)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_randr_query_provider_property_valid_values_length (const xcb_randr_query_provider_property_reply_t *R)
+{
+    return R->length;
+}
+
+xcb_generic_iterator_t
+xcb_randr_query_provider_property_valid_values_end (const xcb_randr_query_provider_property_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + (R->length);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_query_provider_property_reply_t *
+xcb_randr_query_provider_property_reply (xcb_connection_t                            *c,
+                                         xcb_randr_query_provider_property_cookie_t   cookie  /**< */,
+                                         xcb_generic_error_t                        **e)
+{
+    return (xcb_randr_query_provider_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_randr_configure_provider_property_sizeof (const void  *_buffer,
+                                              uint32_t     values_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_configure_provider_property_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* values */
+    xcb_block_len += values_len * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_randr_configure_provider_property_checked (xcb_connection_t     *c,
+                                               xcb_randr_provider_t  provider,
+                                               xcb_atom_t            property,
+                                               uint8_t               pending,
+                                               uint8_t               range,
+                                               uint32_t              values_len,
+                                               const int32_t        *values)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_CONFIGURE_PROVIDER_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_configure_provider_property_request_t xcb_out;
+
+    xcb_out.provider = provider;
+    xcb_out.property = property;
+    xcb_out.pending = pending;
+    xcb_out.range = range;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* int32_t values */
+    xcb_parts[4].iov_base = (char *) values;
+    xcb_parts[4].iov_len = values_len * sizeof(int32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_configure_provider_property (xcb_connection_t     *c,
+                                       xcb_randr_provider_t  provider,
+                                       xcb_atom_t            property,
+                                       uint8_t               pending,
+                                       uint8_t               range,
+                                       uint32_t              values_len,
+                                       const int32_t        *values)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_CONFIGURE_PROVIDER_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_configure_provider_property_request_t xcb_out;
+
+    xcb_out.provider = provider;
+    xcb_out.property = property;
+    xcb_out.pending = pending;
+    xcb_out.range = range;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* int32_t values */
+    xcb_parts[4].iov_base = (char *) values;
+    xcb_parts[4].iov_len = values_len * sizeof(int32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int32_t *
+xcb_randr_configure_provider_property_values (const xcb_randr_configure_provider_property_request_t *R)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_randr_configure_provider_property_values_length (const xcb_randr_configure_provider_property_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_randr_configure_provider_property_request_t))/sizeof(int32_t));
+}
+
+xcb_generic_iterator_t
+xcb_randr_configure_provider_property_values_end (const xcb_randr_configure_provider_property_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_randr_configure_provider_property_request_t))/sizeof(int32_t)));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_randr_change_provider_property_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_change_provider_property_request_t *_aux = (xcb_randr_change_provider_property_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_change_provider_property_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += (_aux->num_items * (_aux->format / 8)) * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_randr_change_provider_property_checked (xcb_connection_t     *c,
+                                            xcb_randr_provider_t  provider,
+                                            xcb_atom_t            property,
+                                            xcb_atom_t            type,
+                                            uint8_t               format,
+                                            uint8_t               mode,
+                                            uint32_t              num_items,
+                                            const void           *data)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_CHANGE_PROVIDER_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_change_provider_property_request_t xcb_out;
+
+    xcb_out.provider = provider;
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.format = format;
+    xcb_out.mode = mode;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.num_items = num_items;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* void data */
+    xcb_parts[4].iov_base = (char *) data;
+    xcb_parts[4].iov_len = (num_items * (format / 8)) * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_change_provider_property (xcb_connection_t     *c,
+                                    xcb_randr_provider_t  provider,
+                                    xcb_atom_t            property,
+                                    xcb_atom_t            type,
+                                    uint8_t               format,
+                                    uint8_t               mode,
+                                    uint32_t              num_items,
+                                    const void           *data)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_CHANGE_PROVIDER_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_change_provider_property_request_t xcb_out;
+
+    xcb_out.provider = provider;
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.format = format;
+    xcb_out.mode = mode;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.num_items = num_items;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* void data */
+    xcb_parts[4].iov_base = (char *) data;
+    xcb_parts[4].iov_len = (num_items * (format / 8)) * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+void *
+xcb_randr_change_provider_property_data (const xcb_randr_change_provider_property_request_t *R)
+{
+    return (void *) (R + 1);
+}
+
+int
+xcb_randr_change_provider_property_data_length (const xcb_randr_change_provider_property_request_t *R)
+{
+    return (R->num_items * (R->format / 8));
+}
+
+xcb_generic_iterator_t
+xcb_randr_change_provider_property_data_end (const xcb_randr_change_provider_property_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + ((R->num_items * (R->format / 8)));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_randr_delete_provider_property_checked (xcb_connection_t     *c,
+                                            xcb_randr_provider_t  provider,
+                                            xcb_atom_t            property)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_DELETE_PROVIDER_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_delete_provider_property_request_t xcb_out;
+
+    xcb_out.provider = provider;
+    xcb_out.property = property;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_delete_provider_property (xcb_connection_t     *c,
+                                    xcb_randr_provider_t  provider,
+                                    xcb_atom_t            property)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_DELETE_PROVIDER_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_delete_provider_property_request_t xcb_out;
+
+    xcb_out.provider = provider;
+    xcb_out.property = property;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_randr_get_provider_property_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_get_provider_property_reply_t *_aux = (xcb_randr_get_provider_property_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_get_provider_property_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += (_aux->num_items * (_aux->format / 8)) * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_randr_get_provider_property_cookie_t
+xcb_randr_get_provider_property (xcb_connection_t     *c,
+                                 xcb_randr_provider_t  provider,
+                                 xcb_atom_t            property,
+                                 xcb_atom_t            type,
+                                 uint32_t              long_offset,
+                                 uint32_t              long_length,
+                                 uint8_t               _delete,
+                                 uint8_t               pending)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_PROVIDER_PROPERTY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_provider_property_cookie_t xcb_ret;
+    xcb_randr_get_provider_property_request_t xcb_out;
+
+    xcb_out.provider = provider;
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.long_offset = long_offset;
+    xcb_out.long_length = long_length;
+    xcb_out._delete = _delete;
+    xcb_out.pending = pending;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_provider_property_cookie_t
+xcb_randr_get_provider_property_unchecked (xcb_connection_t     *c,
+                                           xcb_randr_provider_t  provider,
+                                           xcb_atom_t            property,
+                                           xcb_atom_t            type,
+                                           uint32_t              long_offset,
+                                           uint32_t              long_length,
+                                           uint8_t               _delete,
+                                           uint8_t               pending)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_PROVIDER_PROPERTY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_provider_property_cookie_t xcb_ret;
+    xcb_randr_get_provider_property_request_t xcb_out;
+
+    xcb_out.provider = provider;
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.long_offset = long_offset;
+    xcb_out.long_length = long_length;
+    xcb_out._delete = _delete;
+    xcb_out.pending = pending;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+void *
+xcb_randr_get_provider_property_data (const xcb_randr_get_provider_property_reply_t *R)
+{
+    return (void *) (R + 1);
+}
+
+int
+xcb_randr_get_provider_property_data_length (const xcb_randr_get_provider_property_reply_t *R)
+{
+    return (R->num_items * (R->format / 8));
+}
+
+xcb_generic_iterator_t
+xcb_randr_get_provider_property_data_end (const xcb_randr_get_provider_property_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + ((R->num_items * (R->format / 8)));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_get_provider_property_reply_t *
+xcb_randr_get_provider_property_reply (xcb_connection_t                          *c,
+                                       xcb_randr_get_provider_property_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e)
+{
+    return (xcb_randr_get_provider_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+void
+xcb_randr_crtc_change_next (xcb_randr_crtc_change_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_randr_crtc_change_t);
+}
+
+xcb_generic_iterator_t
+xcb_randr_crtc_change_end (xcb_randr_crtc_change_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_randr_output_change_next (xcb_randr_output_change_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_randr_output_change_t);
+}
+
+xcb_generic_iterator_t
+xcb_randr_output_change_end (xcb_randr_output_change_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_randr_output_property_next (xcb_randr_output_property_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_randr_output_property_t);
+}
+
+xcb_generic_iterator_t
+xcb_randr_output_property_end (xcb_randr_output_property_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_randr_provider_change_next (xcb_randr_provider_change_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_randr_provider_change_t);
+}
+
+xcb_generic_iterator_t
+xcb_randr_provider_change_end (xcb_randr_provider_change_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_randr_provider_property_next (xcb_randr_provider_property_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_randr_provider_property_t);
+}
+
+xcb_generic_iterator_t
+xcb_randr_provider_property_end (xcb_randr_provider_property_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_randr_resource_change_next (xcb_randr_resource_change_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_randr_resource_change_t);
+}
+
+xcb_generic_iterator_t
+xcb_randr_resource_change_end (xcb_randr_resource_change_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_randr_monitor_info_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_monitor_info_t *_aux = (xcb_randr_monitor_info_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_monitor_info_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* outputs */
+    xcb_block_len += _aux->nOutput * sizeof(xcb_randr_output_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_output_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_randr_output_t *
+xcb_randr_monitor_info_outputs (const xcb_randr_monitor_info_t *R)
+{
+    return (xcb_randr_output_t *) (R + 1);
+}
+
+int
+xcb_randr_monitor_info_outputs_length (const xcb_randr_monitor_info_t *R)
+{
+    return R->nOutput;
+}
+
+xcb_generic_iterator_t
+xcb_randr_monitor_info_outputs_end (const xcb_randr_monitor_info_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_randr_output_t *) (R + 1)) + (R->nOutput);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_randr_monitor_info_next (xcb_randr_monitor_info_iterator_t *i)
+{
+    xcb_randr_monitor_info_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_randr_monitor_info_t *)(((char *)R) + xcb_randr_monitor_info_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_randr_monitor_info_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_randr_monitor_info_end (xcb_randr_monitor_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_randr_monitor_info_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_randr_get_monitors_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_get_monitors_reply_t *_aux = (xcb_randr_get_monitors_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_randr_get_monitors_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* monitors */
+    for(i=0; i<_aux->nMonitors; i++) {
+        xcb_tmp_len = xcb_randr_monitor_info_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_randr_monitor_info_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_randr_get_monitors_cookie_t
+xcb_randr_get_monitors (xcb_connection_t *c,
+                        xcb_window_t      window,
+                        uint8_t           get_active)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_MONITORS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_monitors_cookie_t xcb_ret;
+    xcb_randr_get_monitors_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.get_active = get_active;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_get_monitors_cookie_t
+xcb_randr_get_monitors_unchecked (xcb_connection_t *c,
+                                  xcb_window_t      window,
+                                  uint8_t           get_active)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_GET_MONITORS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_randr_get_monitors_cookie_t xcb_ret;
+    xcb_randr_get_monitors_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.get_active = get_active;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_randr_get_monitors_monitors_length (const xcb_randr_get_monitors_reply_t *R)
+{
+    return R->nMonitors;
+}
+
+xcb_randr_monitor_info_iterator_t
+xcb_randr_get_monitors_monitors_iterator (const xcb_randr_get_monitors_reply_t *R)
+{
+    xcb_randr_monitor_info_iterator_t i;
+    i.data = (xcb_randr_monitor_info_t *) (R + 1);
+    i.rem = R->nMonitors;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_randr_get_monitors_reply_t *
+xcb_randr_get_monitors_reply (xcb_connection_t                 *c,
+                              xcb_randr_get_monitors_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_randr_get_monitors_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_randr_set_monitor_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_set_monitor_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* monitorinfo */
+    xcb_block_len += xcb_randr_monitor_info_sizeof(xcb_tmp);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_monitor_info_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_randr_set_monitor_checked (xcb_connection_t         *c,
+                               xcb_window_t              window,
+                               xcb_randr_monitor_info_t *monitorinfo)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SET_MONITOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_set_monitor_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_randr_monitor_info_t monitorinfo */
+    xcb_parts[4].iov_base = (char *) monitorinfo;
+    xcb_parts[4].iov_len =
+      xcb_randr_monitor_info_sizeof (monitorinfo);
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_set_monitor (xcb_connection_t         *c,
+                       xcb_window_t              window,
+                       xcb_randr_monitor_info_t *monitorinfo)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_SET_MONITOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_set_monitor_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_randr_monitor_info_t monitorinfo */
+    xcb_parts[4].iov_base = (char *) monitorinfo;
+    xcb_parts[4].iov_len =
+      xcb_randr_monitor_info_sizeof (monitorinfo);
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_monitor_info_t *
+xcb_randr_set_monitor_monitorinfo (const xcb_randr_set_monitor_request_t *R)
+{
+    return (xcb_randr_monitor_info_t *) (R + 1);
+}
+
+xcb_void_cookie_t
+xcb_randr_delete_monitor_checked (xcb_connection_t *c,
+                                  xcb_window_t      window,
+                                  xcb_atom_t        name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_DELETE_MONITOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_delete_monitor_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.name = name;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_delete_monitor (xcb_connection_t *c,
+                          xcb_window_t      window,
+                          xcb_atom_t        name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_DELETE_MONITOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_delete_monitor_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.name = name;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_randr_create_lease_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_randr_create_lease_request_t *_aux = (xcb_randr_create_lease_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_randr_create_lease_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* crtcs */
+    xcb_block_len += _aux->num_crtcs * sizeof(xcb_randr_output_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_crtc_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* outputs */
+    xcb_block_len += _aux->num_outputs * sizeof(xcb_randr_output_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_randr_output_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_randr_create_lease_cookie_t
+xcb_randr_create_lease (xcb_connection_t         *c,
+                        xcb_window_t              window,
+                        xcb_randr_lease_t         lid,
+                        uint16_t                  num_crtcs,
+                        uint16_t                  num_outputs,
+                        const xcb_randr_crtc_t   *crtcs,
+                        const xcb_randr_output_t *outputs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_CREATE_LEASE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_randr_create_lease_cookie_t xcb_ret;
+    xcb_randr_create_lease_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.lid = lid;
+    xcb_out.num_crtcs = num_crtcs;
+    xcb_out.num_outputs = num_outputs;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_randr_crtc_t crtcs */
+    xcb_parts[4].iov_base = (char *) crtcs;
+    xcb_parts[4].iov_len = num_crtcs * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_randr_output_t outputs */
+    xcb_parts[6].iov_base = (char *) outputs;
+    xcb_parts[6].iov_len = num_outputs * sizeof(uint32_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED|XCB_REQUEST_REPLY_FDS, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_create_lease_cookie_t
+xcb_randr_create_lease_unchecked (xcb_connection_t         *c,
+                                  xcb_window_t              window,
+                                  xcb_randr_lease_t         lid,
+                                  uint16_t                  num_crtcs,
+                                  uint16_t                  num_outputs,
+                                  const xcb_randr_crtc_t   *crtcs,
+                                  const xcb_randr_output_t *outputs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_CREATE_LEASE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_randr_create_lease_cookie_t xcb_ret;
+    xcb_randr_create_lease_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.lid = lid;
+    xcb_out.num_crtcs = num_crtcs;
+    xcb_out.num_outputs = num_outputs;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_randr_crtc_t crtcs */
+    xcb_parts[4].iov_base = (char *) crtcs;
+    xcb_parts[4].iov_len = num_crtcs * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_randr_output_t outputs */
+    xcb_parts[6].iov_base = (char *) outputs;
+    xcb_parts[6].iov_len = num_outputs * sizeof(uint32_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_REPLY_FDS, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_randr_create_lease_reply_t *
+xcb_randr_create_lease_reply (xcb_connection_t                 *c,
+                              xcb_randr_create_lease_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_randr_create_lease_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int *
+xcb_randr_create_lease_reply_fds (xcb_connection_t                *c  /**< */,
+                                  xcb_randr_create_lease_reply_t  *reply)
+{
+    return xcb_get_reply_fds(c, reply, sizeof(xcb_randr_create_lease_reply_t) + 4 * reply->length);
+}
+
+xcb_void_cookie_t
+xcb_randr_free_lease_checked (xcb_connection_t  *c,
+                              xcb_randr_lease_t  lid,
+                              uint8_t            terminate)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_FREE_LEASE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_free_lease_request_t xcb_out;
+
+    xcb_out.lid = lid;
+    xcb_out.terminate = terminate;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_randr_free_lease (xcb_connection_t  *c,
+                      xcb_randr_lease_t  lid,
+                      uint8_t            terminate)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_randr_id,
+        .opcode = XCB_RANDR_FREE_LEASE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_randr_free_lease_request_t xcb_out;
+
+    xcb_out.lid = lid;
+    xcb_out.terminate = terminate;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+void
+xcb_randr_lease_notify_next (xcb_randr_lease_notify_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_randr_lease_notify_t);
+}
+
+xcb_generic_iterator_t
+xcb_randr_lease_notify_end (xcb_randr_lease_notify_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_randr_notify_data_next (xcb_randr_notify_data_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_randr_notify_data_t);
+}
+
+xcb_generic_iterator_t
+xcb_randr_notify_data_end (xcb_randr_notify_data_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
diff --git a/depends/libxcb/src/record.c b/depends/libxcb/src/record.c
new file mode 100644
index 0000000..8c934d5
--- /dev/null
+++ b/depends/libxcb/src/record.c
@@ -0,0 +1,1093 @@
+/*
+ * This file generated automatically from record.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "record.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+
+xcb_extension_t xcb_record_id = { "RECORD", 0 };
+
+void
+xcb_record_context_next (xcb_record_context_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_record_context_t);
+}
+
+xcb_generic_iterator_t
+xcb_record_context_end (xcb_record_context_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_record_range_8_next (xcb_record_range_8_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_record_range_8_t);
+}
+
+xcb_generic_iterator_t
+xcb_record_range_8_end (xcb_record_range_8_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_record_range_16_next (xcb_record_range_16_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_record_range_16_t);
+}
+
+xcb_generic_iterator_t
+xcb_record_range_16_end (xcb_record_range_16_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_record_ext_range_next (xcb_record_ext_range_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_record_ext_range_t);
+}
+
+xcb_generic_iterator_t
+xcb_record_ext_range_end (xcb_record_ext_range_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_record_range_next (xcb_record_range_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_record_range_t);
+}
+
+xcb_generic_iterator_t
+xcb_record_range_end (xcb_record_range_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_record_element_header_next (xcb_record_element_header_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_record_element_header_t);
+}
+
+xcb_generic_iterator_t
+xcb_record_element_header_end (xcb_record_element_header_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_record_client_spec_next (xcb_record_client_spec_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_record_client_spec_t);
+}
+
+xcb_generic_iterator_t
+xcb_record_client_spec_end (xcb_record_client_spec_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_record_client_info_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_record_client_info_t *_aux = (xcb_record_client_info_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_record_client_info_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* ranges */
+    xcb_block_len += _aux->num_ranges * sizeof(xcb_record_range_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_record_range_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_record_range_t *
+xcb_record_client_info_ranges (const xcb_record_client_info_t *R)
+{
+    return (xcb_record_range_t *) (R + 1);
+}
+
+int
+xcb_record_client_info_ranges_length (const xcb_record_client_info_t *R)
+{
+    return R->num_ranges;
+}
+
+xcb_record_range_iterator_t
+xcb_record_client_info_ranges_iterator (const xcb_record_client_info_t *R)
+{
+    xcb_record_range_iterator_t i;
+    i.data = (xcb_record_range_t *) (R + 1);
+    i.rem = R->num_ranges;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_record_client_info_next (xcb_record_client_info_iterator_t *i)
+{
+    xcb_record_client_info_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_record_client_info_t *)(((char *)R) + xcb_record_client_info_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_record_client_info_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_record_client_info_end (xcb_record_client_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_record_client_info_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+xcb_record_query_version_cookie_t
+xcb_record_query_version (xcb_connection_t *c,
+                          uint16_t          major_version,
+                          uint16_t          minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_record_id,
+        .opcode = XCB_RECORD_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_record_query_version_cookie_t xcb_ret;
+    xcb_record_query_version_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_record_query_version_cookie_t
+xcb_record_query_version_unchecked (xcb_connection_t *c,
+                                    uint16_t          major_version,
+                                    uint16_t          minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_record_id,
+        .opcode = XCB_RECORD_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_record_query_version_cookie_t xcb_ret;
+    xcb_record_query_version_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_record_query_version_reply_t *
+xcb_record_query_version_reply (xcb_connection_t                   *c,
+                                xcb_record_query_version_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e)
+{
+    return (xcb_record_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_record_create_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_record_create_context_request_t *_aux = (xcb_record_create_context_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_record_create_context_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* client_specs */
+    xcb_block_len += _aux->num_client_specs * sizeof(xcb_record_client_spec_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_record_client_spec_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* ranges */
+    xcb_block_len += _aux->num_ranges * sizeof(xcb_record_range_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_record_range_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_record_create_context_checked (xcb_connection_t               *c,
+                                   xcb_record_context_t            context,
+                                   xcb_record_element_header_t     element_header,
+                                   uint32_t                        num_client_specs,
+                                   uint32_t                        num_ranges,
+                                   const xcb_record_client_spec_t *client_specs,
+                                   const xcb_record_range_t       *ranges)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_record_id,
+        .opcode = XCB_RECORD_CREATE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_record_create_context_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.element_header = element_header;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.num_client_specs = num_client_specs;
+    xcb_out.num_ranges = num_ranges;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_record_client_spec_t client_specs */
+    xcb_parts[4].iov_base = (char *) client_specs;
+    xcb_parts[4].iov_len = num_client_specs * sizeof(xcb_record_client_spec_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_record_range_t ranges */
+    xcb_parts[6].iov_base = (char *) ranges;
+    xcb_parts[6].iov_len = num_ranges * sizeof(xcb_record_range_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_record_create_context (xcb_connection_t               *c,
+                           xcb_record_context_t            context,
+                           xcb_record_element_header_t     element_header,
+                           uint32_t                        num_client_specs,
+                           uint32_t                        num_ranges,
+                           const xcb_record_client_spec_t *client_specs,
+                           const xcb_record_range_t       *ranges)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_record_id,
+        .opcode = XCB_RECORD_CREATE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_record_create_context_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.element_header = element_header;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.num_client_specs = num_client_specs;
+    xcb_out.num_ranges = num_ranges;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_record_client_spec_t client_specs */
+    xcb_parts[4].iov_base = (char *) client_specs;
+    xcb_parts[4].iov_len = num_client_specs * sizeof(xcb_record_client_spec_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_record_range_t ranges */
+    xcb_parts[6].iov_base = (char *) ranges;
+    xcb_parts[6].iov_len = num_ranges * sizeof(xcb_record_range_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_record_client_spec_t *
+xcb_record_create_context_client_specs (const xcb_record_create_context_request_t *R)
+{
+    return (xcb_record_client_spec_t *) (R + 1);
+}
+
+int
+xcb_record_create_context_client_specs_length (const xcb_record_create_context_request_t *R)
+{
+    return R->num_client_specs;
+}
+
+xcb_generic_iterator_t
+xcb_record_create_context_client_specs_end (const xcb_record_create_context_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_record_client_spec_t *) (R + 1)) + (R->num_client_specs);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_record_range_t *
+xcb_record_create_context_ranges (const xcb_record_create_context_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_record_create_context_client_specs_end(R);
+    return (xcb_record_range_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_record_range_t, prev.index) + 0);
+}
+
+int
+xcb_record_create_context_ranges_length (const xcb_record_create_context_request_t *R)
+{
+    return R->num_ranges;
+}
+
+xcb_record_range_iterator_t
+xcb_record_create_context_ranges_iterator (const xcb_record_create_context_request_t *R)
+{
+    xcb_record_range_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_record_create_context_client_specs_end(R);
+    i.data = (xcb_record_range_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_record_range_t, prev.index));
+    i.rem = R->num_ranges;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_record_register_clients_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_record_register_clients_request_t *_aux = (xcb_record_register_clients_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_record_register_clients_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* client_specs */
+    xcb_block_len += _aux->num_client_specs * sizeof(xcb_record_client_spec_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_record_client_spec_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* ranges */
+    xcb_block_len += _aux->num_ranges * sizeof(xcb_record_range_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_record_range_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_record_register_clients_checked (xcb_connection_t               *c,
+                                     xcb_record_context_t            context,
+                                     xcb_record_element_header_t     element_header,
+                                     uint32_t                        num_client_specs,
+                                     uint32_t                        num_ranges,
+                                     const xcb_record_client_spec_t *client_specs,
+                                     const xcb_record_range_t       *ranges)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_record_id,
+        .opcode = XCB_RECORD_REGISTER_CLIENTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_record_register_clients_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.element_header = element_header;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.num_client_specs = num_client_specs;
+    xcb_out.num_ranges = num_ranges;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_record_client_spec_t client_specs */
+    xcb_parts[4].iov_base = (char *) client_specs;
+    xcb_parts[4].iov_len = num_client_specs * sizeof(xcb_record_client_spec_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_record_range_t ranges */
+    xcb_parts[6].iov_base = (char *) ranges;
+    xcb_parts[6].iov_len = num_ranges * sizeof(xcb_record_range_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_record_register_clients (xcb_connection_t               *c,
+                             xcb_record_context_t            context,
+                             xcb_record_element_header_t     element_header,
+                             uint32_t                        num_client_specs,
+                             uint32_t                        num_ranges,
+                             const xcb_record_client_spec_t *client_specs,
+                             const xcb_record_range_t       *ranges)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_record_id,
+        .opcode = XCB_RECORD_REGISTER_CLIENTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_record_register_clients_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.element_header = element_header;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.num_client_specs = num_client_specs;
+    xcb_out.num_ranges = num_ranges;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_record_client_spec_t client_specs */
+    xcb_parts[4].iov_base = (char *) client_specs;
+    xcb_parts[4].iov_len = num_client_specs * sizeof(xcb_record_client_spec_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_record_range_t ranges */
+    xcb_parts[6].iov_base = (char *) ranges;
+    xcb_parts[6].iov_len = num_ranges * sizeof(xcb_record_range_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_record_client_spec_t *
+xcb_record_register_clients_client_specs (const xcb_record_register_clients_request_t *R)
+{
+    return (xcb_record_client_spec_t *) (R + 1);
+}
+
+int
+xcb_record_register_clients_client_specs_length (const xcb_record_register_clients_request_t *R)
+{
+    return R->num_client_specs;
+}
+
+xcb_generic_iterator_t
+xcb_record_register_clients_client_specs_end (const xcb_record_register_clients_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_record_client_spec_t *) (R + 1)) + (R->num_client_specs);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_record_range_t *
+xcb_record_register_clients_ranges (const xcb_record_register_clients_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_record_register_clients_client_specs_end(R);
+    return (xcb_record_range_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_record_range_t, prev.index) + 0);
+}
+
+int
+xcb_record_register_clients_ranges_length (const xcb_record_register_clients_request_t *R)
+{
+    return R->num_ranges;
+}
+
+xcb_record_range_iterator_t
+xcb_record_register_clients_ranges_iterator (const xcb_record_register_clients_request_t *R)
+{
+    xcb_record_range_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_record_register_clients_client_specs_end(R);
+    i.data = (xcb_record_range_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_record_range_t, prev.index));
+    i.rem = R->num_ranges;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_record_unregister_clients_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_record_unregister_clients_request_t *_aux = (xcb_record_unregister_clients_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_record_unregister_clients_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* client_specs */
+    xcb_block_len += _aux->num_client_specs * sizeof(xcb_record_client_spec_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_record_client_spec_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_record_unregister_clients_checked (xcb_connection_t               *c,
+                                       xcb_record_context_t            context,
+                                       uint32_t                        num_client_specs,
+                                       const xcb_record_client_spec_t *client_specs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_record_id,
+        .opcode = XCB_RECORD_UNREGISTER_CLIENTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_record_unregister_clients_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.num_client_specs = num_client_specs;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_record_client_spec_t client_specs */
+    xcb_parts[4].iov_base = (char *) client_specs;
+    xcb_parts[4].iov_len = num_client_specs * sizeof(xcb_record_client_spec_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_record_unregister_clients (xcb_connection_t               *c,
+                               xcb_record_context_t            context,
+                               uint32_t                        num_client_specs,
+                               const xcb_record_client_spec_t *client_specs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_record_id,
+        .opcode = XCB_RECORD_UNREGISTER_CLIENTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_record_unregister_clients_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.num_client_specs = num_client_specs;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_record_client_spec_t client_specs */
+    xcb_parts[4].iov_base = (char *) client_specs;
+    xcb_parts[4].iov_len = num_client_specs * sizeof(xcb_record_client_spec_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_record_client_spec_t *
+xcb_record_unregister_clients_client_specs (const xcb_record_unregister_clients_request_t *R)
+{
+    return (xcb_record_client_spec_t *) (R + 1);
+}
+
+int
+xcb_record_unregister_clients_client_specs_length (const xcb_record_unregister_clients_request_t *R)
+{
+    return R->num_client_specs;
+}
+
+xcb_generic_iterator_t
+xcb_record_unregister_clients_client_specs_end (const xcb_record_unregister_clients_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_record_client_spec_t *) (R + 1)) + (R->num_client_specs);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_record_get_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_record_get_context_reply_t *_aux = (xcb_record_get_context_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_record_get_context_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* intercepted_clients */
+    for(i=0; i<_aux->num_intercepted_clients; i++) {
+        xcb_tmp_len = xcb_record_client_info_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_record_client_info_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_record_get_context_cookie_t
+xcb_record_get_context (xcb_connection_t     *c,
+                        xcb_record_context_t  context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_record_id,
+        .opcode = XCB_RECORD_GET_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_record_get_context_cookie_t xcb_ret;
+    xcb_record_get_context_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_record_get_context_cookie_t
+xcb_record_get_context_unchecked (xcb_connection_t     *c,
+                                  xcb_record_context_t  context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_record_id,
+        .opcode = XCB_RECORD_GET_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_record_get_context_cookie_t xcb_ret;
+    xcb_record_get_context_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_record_get_context_intercepted_clients_length (const xcb_record_get_context_reply_t *R)
+{
+    return R->num_intercepted_clients;
+}
+
+xcb_record_client_info_iterator_t
+xcb_record_get_context_intercepted_clients_iterator (const xcb_record_get_context_reply_t *R)
+{
+    xcb_record_client_info_iterator_t i;
+    i.data = (xcb_record_client_info_t *) (R + 1);
+    i.rem = R->num_intercepted_clients;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_record_get_context_reply_t *
+xcb_record_get_context_reply (xcb_connection_t                 *c,
+                              xcb_record_get_context_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_record_get_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_record_enable_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_record_enable_context_reply_t *_aux = (xcb_record_enable_context_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_record_enable_context_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += (_aux->length * 4) * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_record_enable_context_cookie_t
+xcb_record_enable_context (xcb_connection_t     *c,
+                           xcb_record_context_t  context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_record_id,
+        .opcode = XCB_RECORD_ENABLE_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_record_enable_context_cookie_t xcb_ret;
+    xcb_record_enable_context_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_record_enable_context_cookie_t
+xcb_record_enable_context_unchecked (xcb_connection_t     *c,
+                                     xcb_record_context_t  context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_record_id,
+        .opcode = XCB_RECORD_ENABLE_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_record_enable_context_cookie_t xcb_ret;
+    xcb_record_enable_context_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_record_enable_context_data (const xcb_record_enable_context_reply_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_record_enable_context_data_length (const xcb_record_enable_context_reply_t *R)
+{
+    return (R->length * 4);
+}
+
+xcb_generic_iterator_t
+xcb_record_enable_context_data_end (const xcb_record_enable_context_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((R->length * 4));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_record_enable_context_reply_t *
+xcb_record_enable_context_reply (xcb_connection_t                    *c,
+                                 xcb_record_enable_context_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e)
+{
+    return (xcb_record_enable_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_record_disable_context_checked (xcb_connection_t     *c,
+                                    xcb_record_context_t  context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_record_id,
+        .opcode = XCB_RECORD_DISABLE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_record_disable_context_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_record_disable_context (xcb_connection_t     *c,
+                            xcb_record_context_t  context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_record_id,
+        .opcode = XCB_RECORD_DISABLE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_record_disable_context_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_record_free_context_checked (xcb_connection_t     *c,
+                                 xcb_record_context_t  context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_record_id,
+        .opcode = XCB_RECORD_FREE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_record_free_context_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_record_free_context (xcb_connection_t     *c,
+                         xcb_record_context_t  context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_record_id,
+        .opcode = XCB_RECORD_FREE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_record_free_context_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
diff --git a/depends/libxcb/src/render.c b/depends/libxcb/src/render.c
new file mode 100644
index 0000000..1f0d7fe
--- /dev/null
+++ b/depends/libxcb/src/render.c
@@ -0,0 +1,4982 @@
+/*
+ * This file generated automatically from render.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "render.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xproto.h"
+
+xcb_extension_t xcb_render_id = { "RENDER", 0 };
+
+void
+xcb_render_glyph_next (xcb_render_glyph_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_render_glyph_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_glyph_end (xcb_render_glyph_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_render_glyphset_next (xcb_render_glyphset_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_render_glyphset_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_glyphset_end (xcb_render_glyphset_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_render_picture_next (xcb_render_picture_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_render_picture_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_picture_end (xcb_render_picture_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_render_pictformat_next (xcb_render_pictformat_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_render_pictformat_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_pictformat_end (xcb_render_pictformat_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_render_fixed_next (xcb_render_fixed_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_render_fixed_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_fixed_end (xcb_render_fixed_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_render_directformat_next (xcb_render_directformat_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_render_directformat_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_directformat_end (xcb_render_directformat_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_render_pictforminfo_next (xcb_render_pictforminfo_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_render_pictforminfo_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_pictforminfo_end (xcb_render_pictforminfo_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_render_pictvisual_next (xcb_render_pictvisual_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_render_pictvisual_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_pictvisual_end (xcb_render_pictvisual_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_render_pictdepth_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_render_pictdepth_t *_aux = (xcb_render_pictdepth_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_pictdepth_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* visuals */
+    xcb_block_len += _aux->num_visuals * sizeof(xcb_render_pictvisual_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_pictvisual_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_render_pictvisual_t *
+xcb_render_pictdepth_visuals (const xcb_render_pictdepth_t *R)
+{
+    return (xcb_render_pictvisual_t *) (R + 1);
+}
+
+int
+xcb_render_pictdepth_visuals_length (const xcb_render_pictdepth_t *R)
+{
+    return R->num_visuals;
+}
+
+xcb_render_pictvisual_iterator_t
+xcb_render_pictdepth_visuals_iterator (const xcb_render_pictdepth_t *R)
+{
+    xcb_render_pictvisual_iterator_t i;
+    i.data = (xcb_render_pictvisual_t *) (R + 1);
+    i.rem = R->num_visuals;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_render_pictdepth_next (xcb_render_pictdepth_iterator_t *i)
+{
+    xcb_render_pictdepth_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_render_pictdepth_t *)(((char *)R) + xcb_render_pictdepth_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_render_pictdepth_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_render_pictdepth_end (xcb_render_pictdepth_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_render_pictdepth_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_render_pictscreen_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_render_pictscreen_t *_aux = (xcb_render_pictscreen_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_render_pictscreen_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* depths */
+    for(i=0; i<_aux->num_depths; i++) {
+        xcb_tmp_len = xcb_render_pictdepth_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_render_pictdepth_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_render_pictscreen_depths_length (const xcb_render_pictscreen_t *R)
+{
+    return R->num_depths;
+}
+
+xcb_render_pictdepth_iterator_t
+xcb_render_pictscreen_depths_iterator (const xcb_render_pictscreen_t *R)
+{
+    xcb_render_pictdepth_iterator_t i;
+    i.data = (xcb_render_pictdepth_t *) (R + 1);
+    i.rem = R->num_depths;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_render_pictscreen_next (xcb_render_pictscreen_iterator_t *i)
+{
+    xcb_render_pictscreen_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_render_pictscreen_t *)(((char *)R) + xcb_render_pictscreen_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_render_pictscreen_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_render_pictscreen_end (xcb_render_pictscreen_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_render_pictscreen_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+void
+xcb_render_indexvalue_next (xcb_render_indexvalue_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_render_indexvalue_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_indexvalue_end (xcb_render_indexvalue_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_render_color_next (xcb_render_color_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_render_color_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_color_end (xcb_render_color_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_render_pointfix_next (xcb_render_pointfix_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_render_pointfix_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_pointfix_end (xcb_render_pointfix_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_render_linefix_next (xcb_render_linefix_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_render_linefix_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_linefix_end (xcb_render_linefix_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_render_triangle_next (xcb_render_triangle_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_render_triangle_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_triangle_end (xcb_render_triangle_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_render_trapezoid_next (xcb_render_trapezoid_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_render_trapezoid_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_trapezoid_end (xcb_render_trapezoid_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_render_glyphinfo_next (xcb_render_glyphinfo_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_render_glyphinfo_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_glyphinfo_end (xcb_render_glyphinfo_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+xcb_render_query_version_cookie_t
+xcb_render_query_version (xcb_connection_t *c,
+                          uint32_t          client_major_version,
+                          uint32_t          client_minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_render_query_version_cookie_t xcb_ret;
+    xcb_render_query_version_request_t xcb_out;
+
+    xcb_out.client_major_version = client_major_version;
+    xcb_out.client_minor_version = client_minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_render_query_version_cookie_t
+xcb_render_query_version_unchecked (xcb_connection_t *c,
+                                    uint32_t          client_major_version,
+                                    uint32_t          client_minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_render_query_version_cookie_t xcb_ret;
+    xcb_render_query_version_request_t xcb_out;
+
+    xcb_out.client_major_version = client_major_version;
+    xcb_out.client_minor_version = client_minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_render_query_version_reply_t *
+xcb_render_query_version_reply (xcb_connection_t                   *c,
+                                xcb_render_query_version_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e)
+{
+    return (xcb_render_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_render_query_pict_formats_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_render_query_pict_formats_reply_t *_aux = (xcb_render_query_pict_formats_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_render_query_pict_formats_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* formats */
+    xcb_block_len += _aux->num_formats * sizeof(xcb_render_pictforminfo_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_pictforminfo_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* screens */
+    for(i=0; i<_aux->num_screens; i++) {
+        xcb_tmp_len = xcb_render_pictscreen_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_render_pictscreen_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* subpixels */
+    xcb_block_len += _aux->num_subpixel * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_render_query_pict_formats_cookie_t
+xcb_render_query_pict_formats (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_QUERY_PICT_FORMATS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_render_query_pict_formats_cookie_t xcb_ret;
+    xcb_render_query_pict_formats_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_render_query_pict_formats_cookie_t
+xcb_render_query_pict_formats_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_QUERY_PICT_FORMATS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_render_query_pict_formats_cookie_t xcb_ret;
+    xcb_render_query_pict_formats_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_render_pictforminfo_t *
+xcb_render_query_pict_formats_formats (const xcb_render_query_pict_formats_reply_t *R)
+{
+    return (xcb_render_pictforminfo_t *) (R + 1);
+}
+
+int
+xcb_render_query_pict_formats_formats_length (const xcb_render_query_pict_formats_reply_t *R)
+{
+    return R->num_formats;
+}
+
+xcb_render_pictforminfo_iterator_t
+xcb_render_query_pict_formats_formats_iterator (const xcb_render_query_pict_formats_reply_t *R)
+{
+    xcb_render_pictforminfo_iterator_t i;
+    i.data = (xcb_render_pictforminfo_t *) (R + 1);
+    i.rem = R->num_formats;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_render_query_pict_formats_screens_length (const xcb_render_query_pict_formats_reply_t *R)
+{
+    return R->num_screens;
+}
+
+xcb_render_pictscreen_iterator_t
+xcb_render_query_pict_formats_screens_iterator (const xcb_render_query_pict_formats_reply_t *R)
+{
+    xcb_render_pictscreen_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_render_pictforminfo_end(xcb_render_query_pict_formats_formats_iterator(R));
+    i.data = (xcb_render_pictscreen_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_pictscreen_t, prev.index));
+    i.rem = R->num_screens;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint32_t *
+xcb_render_query_pict_formats_subpixels (const xcb_render_query_pict_formats_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_render_pictscreen_end(xcb_render_query_pict_formats_screens_iterator(R));
+    return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0);
+}
+
+int
+xcb_render_query_pict_formats_subpixels_length (const xcb_render_query_pict_formats_reply_t *R)
+{
+    return R->num_subpixel;
+}
+
+xcb_generic_iterator_t
+xcb_render_query_pict_formats_subpixels_end (const xcb_render_query_pict_formats_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_render_pictscreen_end(xcb_render_query_pict_formats_screens_iterator(R));
+    i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->num_subpixel);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_render_query_pict_formats_reply_t *
+xcb_render_query_pict_formats_reply (xcb_connection_t                        *c,
+                                     xcb_render_query_pict_formats_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e)
+{
+    return (xcb_render_query_pict_formats_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_render_query_pict_index_values_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_render_query_pict_index_values_reply_t *_aux = (xcb_render_query_pict_index_values_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_query_pict_index_values_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* values */
+    xcb_block_len += _aux->num_values * sizeof(xcb_render_indexvalue_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_indexvalue_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_render_query_pict_index_values_cookie_t
+xcb_render_query_pict_index_values (xcb_connection_t        *c,
+                                    xcb_render_pictformat_t  format)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_QUERY_PICT_INDEX_VALUES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_render_query_pict_index_values_cookie_t xcb_ret;
+    xcb_render_query_pict_index_values_request_t xcb_out;
+
+    xcb_out.format = format;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_render_query_pict_index_values_cookie_t
+xcb_render_query_pict_index_values_unchecked (xcb_connection_t        *c,
+                                              xcb_render_pictformat_t  format)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_QUERY_PICT_INDEX_VALUES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_render_query_pict_index_values_cookie_t xcb_ret;
+    xcb_render_query_pict_index_values_request_t xcb_out;
+
+    xcb_out.format = format;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_render_indexvalue_t *
+xcb_render_query_pict_index_values_values (const xcb_render_query_pict_index_values_reply_t *R)
+{
+    return (xcb_render_indexvalue_t *) (R + 1);
+}
+
+int
+xcb_render_query_pict_index_values_values_length (const xcb_render_query_pict_index_values_reply_t *R)
+{
+    return R->num_values;
+}
+
+xcb_render_indexvalue_iterator_t
+xcb_render_query_pict_index_values_values_iterator (const xcb_render_query_pict_index_values_reply_t *R)
+{
+    xcb_render_indexvalue_iterator_t i;
+    i.data = (xcb_render_indexvalue_t *) (R + 1);
+    i.rem = R->num_values;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_render_query_pict_index_values_reply_t *
+xcb_render_query_pict_index_values_reply (xcb_connection_t                             *c,
+                                          xcb_render_query_pict_index_values_cookie_t   cookie  /**< */,
+                                          xcb_generic_error_t                         **e)
+{
+    return (xcb_render_query_pict_index_values_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_render_create_picture_value_list_serialize (void                                         **_buffer,
+                                                uint32_t                                       value_mask,
+                                                const xcb_render_create_picture_value_list_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[14];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(value_mask & XCB_RENDER_CP_REPEAT) {
+        /* xcb_render_create_picture_value_list_t.repeat */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->repeat;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_ALPHA_MAP) {
+        /* xcb_render_create_picture_value_list_t.alphamap */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->alphamap;
+        xcb_block_len += sizeof(xcb_render_picture_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_render_picture_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_render_picture_t);
+    }
+    if(value_mask & XCB_RENDER_CP_ALPHA_X_ORIGIN) {
+        /* xcb_render_create_picture_value_list_t.alphaxorigin */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->alphaxorigin;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_ALPHA_Y_ORIGIN) {
+        /* xcb_render_create_picture_value_list_t.alphayorigin */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->alphayorigin;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_CLIP_X_ORIGIN) {
+        /* xcb_render_create_picture_value_list_t.clipxorigin */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clipxorigin;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_CLIP_Y_ORIGIN) {
+        /* xcb_render_create_picture_value_list_t.clipyorigin */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clipyorigin;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_CLIP_MASK) {
+        /* xcb_render_create_picture_value_list_t.clipmask */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clipmask;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_RENDER_CP_GRAPHICS_EXPOSURE) {
+        /* xcb_render_create_picture_value_list_t.graphicsexposure */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->graphicsexposure;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_SUBWINDOW_MODE) {
+        /* xcb_render_create_picture_value_list_t.subwindowmode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->subwindowmode;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_POLY_EDGE) {
+        /* xcb_render_create_picture_value_list_t.polyedge */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->polyedge;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_POLY_MODE) {
+        /* xcb_render_create_picture_value_list_t.polymode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->polymode;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_DITHER) {
+        /* xcb_render_create_picture_value_list_t.dither */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->dither;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(value_mask & XCB_RENDER_CP_COMPONENT_ALPHA) {
+        /* xcb_render_create_picture_value_list_t.componentalpha */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->componentalpha;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_render_create_picture_value_list_unpack (const void                              *_buffer,
+                                             uint32_t                                 value_mask,
+                                             xcb_render_create_picture_value_list_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if(value_mask & XCB_RENDER_CP_REPEAT) {
+        /* xcb_render_create_picture_value_list_t.repeat */
+        _aux->repeat = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_ALPHA_MAP) {
+        /* xcb_render_create_picture_value_list_t.alphamap */
+        _aux->alphamap = *(xcb_render_picture_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_render_picture_t);
+        xcb_tmp += sizeof(xcb_render_picture_t);
+        xcb_align_to = ALIGNOF(xcb_render_picture_t);
+    }
+    if(value_mask & XCB_RENDER_CP_ALPHA_X_ORIGIN) {
+        /* xcb_render_create_picture_value_list_t.alphaxorigin */
+        _aux->alphaxorigin = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_ALPHA_Y_ORIGIN) {
+        /* xcb_render_create_picture_value_list_t.alphayorigin */
+        _aux->alphayorigin = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_CLIP_X_ORIGIN) {
+        /* xcb_render_create_picture_value_list_t.clipxorigin */
+        _aux->clipxorigin = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_CLIP_Y_ORIGIN) {
+        /* xcb_render_create_picture_value_list_t.clipyorigin */
+        _aux->clipyorigin = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_CLIP_MASK) {
+        /* xcb_render_create_picture_value_list_t.clipmask */
+        _aux->clipmask = *(xcb_pixmap_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_tmp += sizeof(xcb_pixmap_t);
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_RENDER_CP_GRAPHICS_EXPOSURE) {
+        /* xcb_render_create_picture_value_list_t.graphicsexposure */
+        _aux->graphicsexposure = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_SUBWINDOW_MODE) {
+        /* xcb_render_create_picture_value_list_t.subwindowmode */
+        _aux->subwindowmode = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_POLY_EDGE) {
+        /* xcb_render_create_picture_value_list_t.polyedge */
+        _aux->polyedge = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_POLY_MODE) {
+        /* xcb_render_create_picture_value_list_t.polymode */
+        _aux->polymode = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_DITHER) {
+        /* xcb_render_create_picture_value_list_t.dither */
+        _aux->dither = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(value_mask & XCB_RENDER_CP_COMPONENT_ALPHA) {
+        /* xcb_render_create_picture_value_list_t.componentalpha */
+        _aux->componentalpha = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_render_create_picture_value_list_sizeof (const void  *_buffer,
+                                             uint32_t     value_mask)
+{
+    xcb_render_create_picture_value_list_t _aux;
+    return xcb_render_create_picture_value_list_unpack(_buffer, value_mask, &_aux);
+}
+
+int
+xcb_render_create_picture_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_render_create_picture_request_t *_aux = (xcb_render_create_picture_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_create_picture_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* value_list */
+    xcb_block_len += xcb_render_create_picture_value_list_sizeof(xcb_tmp, _aux->value_mask);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_render_create_picture_checked (xcb_connection_t        *c,
+                                   xcb_render_picture_t     pid,
+                                   xcb_drawable_t           drawable,
+                                   xcb_render_pictformat_t  format,
+                                   uint32_t                 value_mask,
+                                   const void              *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CREATE_PICTURE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_create_picture_request_t xcb_out;
+
+    xcb_out.pid = pid;
+    xcb_out.drawable = drawable;
+    xcb_out.format = format;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_create_picture_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_render_create_picture_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_create_picture (xcb_connection_t        *c,
+                           xcb_render_picture_t     pid,
+                           xcb_drawable_t           drawable,
+                           xcb_render_pictformat_t  format,
+                           uint32_t                 value_mask,
+                           const void              *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CREATE_PICTURE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_create_picture_request_t xcb_out;
+
+    xcb_out.pid = pid;
+    xcb_out.drawable = drawable;
+    xcb_out.format = format;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_create_picture_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_render_create_picture_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_create_picture_aux_checked (xcb_connection_t                             *c,
+                                       xcb_render_picture_t                          pid,
+                                       xcb_drawable_t                                drawable,
+                                       xcb_render_pictformat_t                       format,
+                                       uint32_t                                      value_mask,
+                                       const xcb_render_create_picture_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CREATE_PICTURE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_create_picture_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.pid = pid;
+    xcb_out.drawable = drawable;
+    xcb_out.format = format;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_create_picture_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_render_create_picture_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_create_picture_aux (xcb_connection_t                             *c,
+                               xcb_render_picture_t                          pid,
+                               xcb_drawable_t                                drawable,
+                               xcb_render_pictformat_t                       format,
+                               uint32_t                                      value_mask,
+                               const xcb_render_create_picture_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CREATE_PICTURE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_create_picture_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.pid = pid;
+    xcb_out.drawable = drawable;
+    xcb_out.format = format;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_create_picture_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_render_create_picture_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+void *
+xcb_render_create_picture_value_list (const xcb_render_create_picture_request_t *R)
+{
+    return (void *) (R + 1);
+}
+
+int
+xcb_render_change_picture_value_list_serialize (void                                         **_buffer,
+                                                uint32_t                                       value_mask,
+                                                const xcb_render_change_picture_value_list_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[14];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(value_mask & XCB_RENDER_CP_REPEAT) {
+        /* xcb_render_change_picture_value_list_t.repeat */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->repeat;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_ALPHA_MAP) {
+        /* xcb_render_change_picture_value_list_t.alphamap */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->alphamap;
+        xcb_block_len += sizeof(xcb_render_picture_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_render_picture_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_render_picture_t);
+    }
+    if(value_mask & XCB_RENDER_CP_ALPHA_X_ORIGIN) {
+        /* xcb_render_change_picture_value_list_t.alphaxorigin */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->alphaxorigin;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_ALPHA_Y_ORIGIN) {
+        /* xcb_render_change_picture_value_list_t.alphayorigin */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->alphayorigin;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_CLIP_X_ORIGIN) {
+        /* xcb_render_change_picture_value_list_t.clipxorigin */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clipxorigin;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_CLIP_Y_ORIGIN) {
+        /* xcb_render_change_picture_value_list_t.clipyorigin */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clipyorigin;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_CLIP_MASK) {
+        /* xcb_render_change_picture_value_list_t.clipmask */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clipmask;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_RENDER_CP_GRAPHICS_EXPOSURE) {
+        /* xcb_render_change_picture_value_list_t.graphicsexposure */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->graphicsexposure;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_SUBWINDOW_MODE) {
+        /* xcb_render_change_picture_value_list_t.subwindowmode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->subwindowmode;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_POLY_EDGE) {
+        /* xcb_render_change_picture_value_list_t.polyedge */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->polyedge;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_POLY_MODE) {
+        /* xcb_render_change_picture_value_list_t.polymode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->polymode;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_DITHER) {
+        /* xcb_render_change_picture_value_list_t.dither */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->dither;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(value_mask & XCB_RENDER_CP_COMPONENT_ALPHA) {
+        /* xcb_render_change_picture_value_list_t.componentalpha */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->componentalpha;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_render_change_picture_value_list_unpack (const void                              *_buffer,
+                                             uint32_t                                 value_mask,
+                                             xcb_render_change_picture_value_list_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if(value_mask & XCB_RENDER_CP_REPEAT) {
+        /* xcb_render_change_picture_value_list_t.repeat */
+        _aux->repeat = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_ALPHA_MAP) {
+        /* xcb_render_change_picture_value_list_t.alphamap */
+        _aux->alphamap = *(xcb_render_picture_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_render_picture_t);
+        xcb_tmp += sizeof(xcb_render_picture_t);
+        xcb_align_to = ALIGNOF(xcb_render_picture_t);
+    }
+    if(value_mask & XCB_RENDER_CP_ALPHA_X_ORIGIN) {
+        /* xcb_render_change_picture_value_list_t.alphaxorigin */
+        _aux->alphaxorigin = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_ALPHA_Y_ORIGIN) {
+        /* xcb_render_change_picture_value_list_t.alphayorigin */
+        _aux->alphayorigin = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_CLIP_X_ORIGIN) {
+        /* xcb_render_change_picture_value_list_t.clipxorigin */
+        _aux->clipxorigin = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_CLIP_Y_ORIGIN) {
+        /* xcb_render_change_picture_value_list_t.clipyorigin */
+        _aux->clipyorigin = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_CLIP_MASK) {
+        /* xcb_render_change_picture_value_list_t.clipmask */
+        _aux->clipmask = *(xcb_pixmap_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_tmp += sizeof(xcb_pixmap_t);
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_RENDER_CP_GRAPHICS_EXPOSURE) {
+        /* xcb_render_change_picture_value_list_t.graphicsexposure */
+        _aux->graphicsexposure = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_SUBWINDOW_MODE) {
+        /* xcb_render_change_picture_value_list_t.subwindowmode */
+        _aux->subwindowmode = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_POLY_EDGE) {
+        /* xcb_render_change_picture_value_list_t.polyedge */
+        _aux->polyedge = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_POLY_MODE) {
+        /* xcb_render_change_picture_value_list_t.polymode */
+        _aux->polymode = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_RENDER_CP_DITHER) {
+        /* xcb_render_change_picture_value_list_t.dither */
+        _aux->dither = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(value_mask & XCB_RENDER_CP_COMPONENT_ALPHA) {
+        /* xcb_render_change_picture_value_list_t.componentalpha */
+        _aux->componentalpha = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_render_change_picture_value_list_sizeof (const void  *_buffer,
+                                             uint32_t     value_mask)
+{
+    xcb_render_change_picture_value_list_t _aux;
+    return xcb_render_change_picture_value_list_unpack(_buffer, value_mask, &_aux);
+}
+
+int
+xcb_render_change_picture_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_render_change_picture_request_t *_aux = (xcb_render_change_picture_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_change_picture_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* value_list */
+    xcb_block_len += xcb_render_change_picture_value_list_sizeof(xcb_tmp, _aux->value_mask);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_render_change_picture_checked (xcb_connection_t     *c,
+                                   xcb_render_picture_t  picture,
+                                   uint32_t              value_mask,
+                                   const void           *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CHANGE_PICTURE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_change_picture_request_t xcb_out;
+
+    xcb_out.picture = picture;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_change_picture_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_render_change_picture_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_change_picture (xcb_connection_t     *c,
+                           xcb_render_picture_t  picture,
+                           uint32_t              value_mask,
+                           const void           *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CHANGE_PICTURE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_change_picture_request_t xcb_out;
+
+    xcb_out.picture = picture;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_change_picture_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_render_change_picture_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_change_picture_aux_checked (xcb_connection_t                             *c,
+                                       xcb_render_picture_t                          picture,
+                                       uint32_t                                      value_mask,
+                                       const xcb_render_change_picture_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CHANGE_PICTURE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_change_picture_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.picture = picture;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_change_picture_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_render_change_picture_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_change_picture_aux (xcb_connection_t                             *c,
+                               xcb_render_picture_t                          picture,
+                               uint32_t                                      value_mask,
+                               const xcb_render_change_picture_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CHANGE_PICTURE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_change_picture_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.picture = picture;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_change_picture_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_render_change_picture_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+void *
+xcb_render_change_picture_value_list (const xcb_render_change_picture_request_t *R)
+{
+    return (void *) (R + 1);
+}
+
+int
+xcb_render_set_picture_clip_rectangles_sizeof (const void  *_buffer,
+                                               uint32_t     rectangles_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_set_picture_clip_rectangles_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* rectangles */
+    xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_rectangle_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_render_set_picture_clip_rectangles_checked (xcb_connection_t      *c,
+                                                xcb_render_picture_t   picture,
+                                                int16_t                clip_x_origin,
+                                                int16_t                clip_y_origin,
+                                                uint32_t               rectangles_len,
+                                                const xcb_rectangle_t *rectangles)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_SET_PICTURE_CLIP_RECTANGLES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_set_picture_clip_rectangles_request_t xcb_out;
+
+    xcb_out.picture = picture;
+    xcb_out.clip_x_origin = clip_x_origin;
+    xcb_out.clip_y_origin = clip_y_origin;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_rectangle_t rectangles */
+    xcb_parts[4].iov_base = (char *) rectangles;
+    xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_set_picture_clip_rectangles (xcb_connection_t      *c,
+                                        xcb_render_picture_t   picture,
+                                        int16_t                clip_x_origin,
+                                        int16_t                clip_y_origin,
+                                        uint32_t               rectangles_len,
+                                        const xcb_rectangle_t *rectangles)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_SET_PICTURE_CLIP_RECTANGLES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_set_picture_clip_rectangles_request_t xcb_out;
+
+    xcb_out.picture = picture;
+    xcb_out.clip_x_origin = clip_x_origin;
+    xcb_out.clip_y_origin = clip_y_origin;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_rectangle_t rectangles */
+    xcb_parts[4].iov_base = (char *) rectangles;
+    xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_rectangle_t *
+xcb_render_set_picture_clip_rectangles_rectangles (const xcb_render_set_picture_clip_rectangles_request_t *R)
+{
+    return (xcb_rectangle_t *) (R + 1);
+}
+
+int
+xcb_render_set_picture_clip_rectangles_rectangles_length (const xcb_render_set_picture_clip_rectangles_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_render_set_picture_clip_rectangles_request_t))/sizeof(xcb_rectangle_t));
+}
+
+xcb_rectangle_iterator_t
+xcb_render_set_picture_clip_rectangles_rectangles_iterator (const xcb_render_set_picture_clip_rectangles_request_t *R)
+{
+    xcb_rectangle_iterator_t i;
+    i.data = (xcb_rectangle_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_render_set_picture_clip_rectangles_request_t))/sizeof(xcb_rectangle_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_render_free_picture_checked (xcb_connection_t     *c,
+                                 xcb_render_picture_t  picture)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_FREE_PICTURE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_free_picture_request_t xcb_out;
+
+    xcb_out.picture = picture;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_free_picture (xcb_connection_t     *c,
+                         xcb_render_picture_t  picture)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_FREE_PICTURE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_free_picture_request_t xcb_out;
+
+    xcb_out.picture = picture;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_composite_checked (xcb_connection_t     *c,
+                              uint8_t               op,
+                              xcb_render_picture_t  src,
+                              xcb_render_picture_t  mask,
+                              xcb_render_picture_t  dst,
+                              int16_t               src_x,
+                              int16_t               src_y,
+                              int16_t               mask_x,
+                              int16_t               mask_y,
+                              int16_t               dst_x,
+                              int16_t               dst_y,
+                              uint16_t              width,
+                              uint16_t              height)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_COMPOSITE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_composite_request_t xcb_out;
+
+    xcb_out.op = op;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.src = src;
+    xcb_out.mask = mask;
+    xcb_out.dst = dst;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+    xcb_out.mask_x = mask_x;
+    xcb_out.mask_y = mask_y;
+    xcb_out.dst_x = dst_x;
+    xcb_out.dst_y = dst_y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_composite (xcb_connection_t     *c,
+                      uint8_t               op,
+                      xcb_render_picture_t  src,
+                      xcb_render_picture_t  mask,
+                      xcb_render_picture_t  dst,
+                      int16_t               src_x,
+                      int16_t               src_y,
+                      int16_t               mask_x,
+                      int16_t               mask_y,
+                      int16_t               dst_x,
+                      int16_t               dst_y,
+                      uint16_t              width,
+                      uint16_t              height)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_COMPOSITE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_composite_request_t xcb_out;
+
+    xcb_out.op = op;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.src = src;
+    xcb_out.mask = mask;
+    xcb_out.dst = dst;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+    xcb_out.mask_x = mask_x;
+    xcb_out.mask_y = mask_y;
+    xcb_out.dst_x = dst_x;
+    xcb_out.dst_y = dst_y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_render_trapezoids_sizeof (const void  *_buffer,
+                              uint32_t     traps_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_trapezoids_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* traps */
+    xcb_block_len += traps_len * sizeof(xcb_render_trapezoid_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_trapezoid_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_render_trapezoids_checked (xcb_connection_t             *c,
+                               uint8_t                       op,
+                               xcb_render_picture_t          src,
+                               xcb_render_picture_t          dst,
+                               xcb_render_pictformat_t       mask_format,
+                               int16_t                       src_x,
+                               int16_t                       src_y,
+                               uint32_t                      traps_len,
+                               const xcb_render_trapezoid_t *traps)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_TRAPEZOIDS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_trapezoids_request_t xcb_out;
+
+    xcb_out.op = op;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.src = src;
+    xcb_out.dst = dst;
+    xcb_out.mask_format = mask_format;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_trapezoid_t traps */
+    xcb_parts[4].iov_base = (char *) traps;
+    xcb_parts[4].iov_len = traps_len * sizeof(xcb_render_trapezoid_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_trapezoids (xcb_connection_t             *c,
+                       uint8_t                       op,
+                       xcb_render_picture_t          src,
+                       xcb_render_picture_t          dst,
+                       xcb_render_pictformat_t       mask_format,
+                       int16_t                       src_x,
+                       int16_t                       src_y,
+                       uint32_t                      traps_len,
+                       const xcb_render_trapezoid_t *traps)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_TRAPEZOIDS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_trapezoids_request_t xcb_out;
+
+    xcb_out.op = op;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.src = src;
+    xcb_out.dst = dst;
+    xcb_out.mask_format = mask_format;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_trapezoid_t traps */
+    xcb_parts[4].iov_base = (char *) traps;
+    xcb_parts[4].iov_len = traps_len * sizeof(xcb_render_trapezoid_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_render_trapezoid_t *
+xcb_render_trapezoids_traps (const xcb_render_trapezoids_request_t *R)
+{
+    return (xcb_render_trapezoid_t *) (R + 1);
+}
+
+int
+xcb_render_trapezoids_traps_length (const xcb_render_trapezoids_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_render_trapezoids_request_t))/sizeof(xcb_render_trapezoid_t));
+}
+
+xcb_render_trapezoid_iterator_t
+xcb_render_trapezoids_traps_iterator (const xcb_render_trapezoids_request_t *R)
+{
+    xcb_render_trapezoid_iterator_t i;
+    i.data = (xcb_render_trapezoid_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_render_trapezoids_request_t))/sizeof(xcb_render_trapezoid_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_render_triangles_sizeof (const void  *_buffer,
+                             uint32_t     triangles_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_triangles_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* triangles */
+    xcb_block_len += triangles_len * sizeof(xcb_render_triangle_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_triangle_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_render_triangles_checked (xcb_connection_t            *c,
+                              uint8_t                      op,
+                              xcb_render_picture_t         src,
+                              xcb_render_picture_t         dst,
+                              xcb_render_pictformat_t      mask_format,
+                              int16_t                      src_x,
+                              int16_t                      src_y,
+                              uint32_t                     triangles_len,
+                              const xcb_render_triangle_t *triangles)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_TRIANGLES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_triangles_request_t xcb_out;
+
+    xcb_out.op = op;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.src = src;
+    xcb_out.dst = dst;
+    xcb_out.mask_format = mask_format;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_triangle_t triangles */
+    xcb_parts[4].iov_base = (char *) triangles;
+    xcb_parts[4].iov_len = triangles_len * sizeof(xcb_render_triangle_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_triangles (xcb_connection_t            *c,
+                      uint8_t                      op,
+                      xcb_render_picture_t         src,
+                      xcb_render_picture_t         dst,
+                      xcb_render_pictformat_t      mask_format,
+                      int16_t                      src_x,
+                      int16_t                      src_y,
+                      uint32_t                     triangles_len,
+                      const xcb_render_triangle_t *triangles)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_TRIANGLES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_triangles_request_t xcb_out;
+
+    xcb_out.op = op;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.src = src;
+    xcb_out.dst = dst;
+    xcb_out.mask_format = mask_format;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_triangle_t triangles */
+    xcb_parts[4].iov_base = (char *) triangles;
+    xcb_parts[4].iov_len = triangles_len * sizeof(xcb_render_triangle_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_render_triangle_t *
+xcb_render_triangles_triangles (const xcb_render_triangles_request_t *R)
+{
+    return (xcb_render_triangle_t *) (R + 1);
+}
+
+int
+xcb_render_triangles_triangles_length (const xcb_render_triangles_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_render_triangles_request_t))/sizeof(xcb_render_triangle_t));
+}
+
+xcb_render_triangle_iterator_t
+xcb_render_triangles_triangles_iterator (const xcb_render_triangles_request_t *R)
+{
+    xcb_render_triangle_iterator_t i;
+    i.data = (xcb_render_triangle_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_render_triangles_request_t))/sizeof(xcb_render_triangle_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_render_tri_strip_sizeof (const void  *_buffer,
+                             uint32_t     points_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_tri_strip_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* points */
+    xcb_block_len += points_len * sizeof(xcb_render_pointfix_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_pointfix_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_render_tri_strip_checked (xcb_connection_t            *c,
+                              uint8_t                      op,
+                              xcb_render_picture_t         src,
+                              xcb_render_picture_t         dst,
+                              xcb_render_pictformat_t      mask_format,
+                              int16_t                      src_x,
+                              int16_t                      src_y,
+                              uint32_t                     points_len,
+                              const xcb_render_pointfix_t *points)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_TRI_STRIP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_tri_strip_request_t xcb_out;
+
+    xcb_out.op = op;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.src = src;
+    xcb_out.dst = dst;
+    xcb_out.mask_format = mask_format;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_pointfix_t points */
+    xcb_parts[4].iov_base = (char *) points;
+    xcb_parts[4].iov_len = points_len * sizeof(xcb_render_pointfix_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_tri_strip (xcb_connection_t            *c,
+                      uint8_t                      op,
+                      xcb_render_picture_t         src,
+                      xcb_render_picture_t         dst,
+                      xcb_render_pictformat_t      mask_format,
+                      int16_t                      src_x,
+                      int16_t                      src_y,
+                      uint32_t                     points_len,
+                      const xcb_render_pointfix_t *points)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_TRI_STRIP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_tri_strip_request_t xcb_out;
+
+    xcb_out.op = op;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.src = src;
+    xcb_out.dst = dst;
+    xcb_out.mask_format = mask_format;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_pointfix_t points */
+    xcb_parts[4].iov_base = (char *) points;
+    xcb_parts[4].iov_len = points_len * sizeof(xcb_render_pointfix_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_render_pointfix_t *
+xcb_render_tri_strip_points (const xcb_render_tri_strip_request_t *R)
+{
+    return (xcb_render_pointfix_t *) (R + 1);
+}
+
+int
+xcb_render_tri_strip_points_length (const xcb_render_tri_strip_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_render_tri_strip_request_t))/sizeof(xcb_render_pointfix_t));
+}
+
+xcb_render_pointfix_iterator_t
+xcb_render_tri_strip_points_iterator (const xcb_render_tri_strip_request_t *R)
+{
+    xcb_render_pointfix_iterator_t i;
+    i.data = (xcb_render_pointfix_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_render_tri_strip_request_t))/sizeof(xcb_render_pointfix_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_render_tri_fan_sizeof (const void  *_buffer,
+                           uint32_t     points_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_tri_fan_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* points */
+    xcb_block_len += points_len * sizeof(xcb_render_pointfix_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_pointfix_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_render_tri_fan_checked (xcb_connection_t            *c,
+                            uint8_t                      op,
+                            xcb_render_picture_t         src,
+                            xcb_render_picture_t         dst,
+                            xcb_render_pictformat_t      mask_format,
+                            int16_t                      src_x,
+                            int16_t                      src_y,
+                            uint32_t                     points_len,
+                            const xcb_render_pointfix_t *points)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_TRI_FAN,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_tri_fan_request_t xcb_out;
+
+    xcb_out.op = op;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.src = src;
+    xcb_out.dst = dst;
+    xcb_out.mask_format = mask_format;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_pointfix_t points */
+    xcb_parts[4].iov_base = (char *) points;
+    xcb_parts[4].iov_len = points_len * sizeof(xcb_render_pointfix_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_tri_fan (xcb_connection_t            *c,
+                    uint8_t                      op,
+                    xcb_render_picture_t         src,
+                    xcb_render_picture_t         dst,
+                    xcb_render_pictformat_t      mask_format,
+                    int16_t                      src_x,
+                    int16_t                      src_y,
+                    uint32_t                     points_len,
+                    const xcb_render_pointfix_t *points)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_TRI_FAN,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_tri_fan_request_t xcb_out;
+
+    xcb_out.op = op;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.src = src;
+    xcb_out.dst = dst;
+    xcb_out.mask_format = mask_format;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_pointfix_t points */
+    xcb_parts[4].iov_base = (char *) points;
+    xcb_parts[4].iov_len = points_len * sizeof(xcb_render_pointfix_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_render_pointfix_t *
+xcb_render_tri_fan_points (const xcb_render_tri_fan_request_t *R)
+{
+    return (xcb_render_pointfix_t *) (R + 1);
+}
+
+int
+xcb_render_tri_fan_points_length (const xcb_render_tri_fan_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_render_tri_fan_request_t))/sizeof(xcb_render_pointfix_t));
+}
+
+xcb_render_pointfix_iterator_t
+xcb_render_tri_fan_points_iterator (const xcb_render_tri_fan_request_t *R)
+{
+    xcb_render_pointfix_iterator_t i;
+    i.data = (xcb_render_pointfix_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_render_tri_fan_request_t))/sizeof(xcb_render_pointfix_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_render_create_glyph_set_checked (xcb_connection_t        *c,
+                                     xcb_render_glyphset_t    gsid,
+                                     xcb_render_pictformat_t  format)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CREATE_GLYPH_SET,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_create_glyph_set_request_t xcb_out;
+
+    xcb_out.gsid = gsid;
+    xcb_out.format = format;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_create_glyph_set (xcb_connection_t        *c,
+                             xcb_render_glyphset_t    gsid,
+                             xcb_render_pictformat_t  format)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CREATE_GLYPH_SET,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_create_glyph_set_request_t xcb_out;
+
+    xcb_out.gsid = gsid;
+    xcb_out.format = format;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_reference_glyph_set_checked (xcb_connection_t      *c,
+                                        xcb_render_glyphset_t  gsid,
+                                        xcb_render_glyphset_t  existing)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_REFERENCE_GLYPH_SET,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_reference_glyph_set_request_t xcb_out;
+
+    xcb_out.gsid = gsid;
+    xcb_out.existing = existing;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_reference_glyph_set (xcb_connection_t      *c,
+                                xcb_render_glyphset_t  gsid,
+                                xcb_render_glyphset_t  existing)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_REFERENCE_GLYPH_SET,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_reference_glyph_set_request_t xcb_out;
+
+    xcb_out.gsid = gsid;
+    xcb_out.existing = existing;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_free_glyph_set_checked (xcb_connection_t      *c,
+                                   xcb_render_glyphset_t  glyphset)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_FREE_GLYPH_SET,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_free_glyph_set_request_t xcb_out;
+
+    xcb_out.glyphset = glyphset;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_free_glyph_set (xcb_connection_t      *c,
+                           xcb_render_glyphset_t  glyphset)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_FREE_GLYPH_SET,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_free_glyph_set_request_t xcb_out;
+
+    xcb_out.glyphset = glyphset;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_render_add_glyphs_sizeof (const void  *_buffer,
+                              uint32_t     data_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_render_add_glyphs_request_t *_aux = (xcb_render_add_glyphs_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_add_glyphs_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* glyphids */
+    xcb_block_len += _aux->glyphs_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* glyphs */
+    xcb_block_len += _aux->glyphs_len * sizeof(xcb_render_glyphinfo_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_glyphinfo_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += data_len * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_render_add_glyphs_checked (xcb_connection_t             *c,
+                               xcb_render_glyphset_t         glyphset,
+                               uint32_t                      glyphs_len,
+                               const uint32_t               *glyphids,
+                               const xcb_render_glyphinfo_t *glyphs,
+                               uint32_t                      data_len,
+                               const uint8_t                *data)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 8,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_ADD_GLYPHS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[10];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_add_glyphs_request_t xcb_out;
+
+    xcb_out.glyphset = glyphset;
+    xcb_out.glyphs_len = glyphs_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t glyphids */
+    xcb_parts[4].iov_base = (char *) glyphids;
+    xcb_parts[4].iov_len = glyphs_len * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_render_glyphinfo_t glyphs */
+    xcb_parts[6].iov_base = (char *) glyphs;
+    xcb_parts[6].iov_len = glyphs_len * sizeof(xcb_render_glyphinfo_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+    /* uint8_t data */
+    xcb_parts[8].iov_base = (char *) data;
+    xcb_parts[8].iov_len = data_len * sizeof(uint8_t);
+    xcb_parts[9].iov_base = 0;
+    xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_add_glyphs (xcb_connection_t             *c,
+                       xcb_render_glyphset_t         glyphset,
+                       uint32_t                      glyphs_len,
+                       const uint32_t               *glyphids,
+                       const xcb_render_glyphinfo_t *glyphs,
+                       uint32_t                      data_len,
+                       const uint8_t                *data)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 8,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_ADD_GLYPHS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[10];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_add_glyphs_request_t xcb_out;
+
+    xcb_out.glyphset = glyphset;
+    xcb_out.glyphs_len = glyphs_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t glyphids */
+    xcb_parts[4].iov_base = (char *) glyphids;
+    xcb_parts[4].iov_len = glyphs_len * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_render_glyphinfo_t glyphs */
+    xcb_parts[6].iov_base = (char *) glyphs;
+    xcb_parts[6].iov_len = glyphs_len * sizeof(xcb_render_glyphinfo_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+    /* uint8_t data */
+    xcb_parts[8].iov_base = (char *) data;
+    xcb_parts[8].iov_len = data_len * sizeof(uint8_t);
+    xcb_parts[9].iov_base = 0;
+    xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_render_add_glyphs_glyphids (const xcb_render_add_glyphs_request_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_render_add_glyphs_glyphids_length (const xcb_render_add_glyphs_request_t *R)
+{
+    return R->glyphs_len;
+}
+
+xcb_generic_iterator_t
+xcb_render_add_glyphs_glyphids_end (const xcb_render_add_glyphs_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->glyphs_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_render_glyphinfo_t *
+xcb_render_add_glyphs_glyphs (const xcb_render_add_glyphs_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_render_add_glyphs_glyphids_end(R);
+    return (xcb_render_glyphinfo_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_glyphinfo_t, prev.index) + 0);
+}
+
+int
+xcb_render_add_glyphs_glyphs_length (const xcb_render_add_glyphs_request_t *R)
+{
+    return R->glyphs_len;
+}
+
+xcb_render_glyphinfo_iterator_t
+xcb_render_add_glyphs_glyphs_iterator (const xcb_render_add_glyphs_request_t *R)
+{
+    xcb_render_glyphinfo_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_render_add_glyphs_glyphids_end(R);
+    i.data = (xcb_render_glyphinfo_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_glyphinfo_t, prev.index));
+    i.rem = R->glyphs_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint8_t *
+xcb_render_add_glyphs_data (const xcb_render_add_glyphs_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_render_glyphinfo_end(xcb_render_add_glyphs_glyphs_iterator(R));
+    return (uint8_t *) ((char *) prev.data + XCB_TYPE_PAD(uint8_t, prev.index) + 0);
+}
+
+int
+xcb_render_add_glyphs_data_length (const xcb_render_add_glyphs_request_t *R)
+{
+    return ((((char*)R) + R->length * 4) - (char*)(xcb_render_add_glyphs_data(R))) / sizeof(uint8_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_add_glyphs_data_end (const xcb_render_add_glyphs_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_render_glyphinfo_end(xcb_render_add_glyphs_glyphs_iterator(R));
+    i.data = ((uint8_t *) ((char*) prev.data + XCB_TYPE_PAD(uint8_t, prev.index))) + (((((char*)R) + R->length * 4) - (char*)(xcb_render_add_glyphs_data(R))) / sizeof(uint8_t));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_render_free_glyphs_sizeof (const void  *_buffer,
+                               uint32_t     glyphs_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_free_glyphs_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* glyphs */
+    xcb_block_len += glyphs_len * sizeof(xcb_render_glyph_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_glyph_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_render_free_glyphs_checked (xcb_connection_t         *c,
+                                xcb_render_glyphset_t     glyphset,
+                                uint32_t                  glyphs_len,
+                                const xcb_render_glyph_t *glyphs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_FREE_GLYPHS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_free_glyphs_request_t xcb_out;
+
+    xcb_out.glyphset = glyphset;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_glyph_t glyphs */
+    xcb_parts[4].iov_base = (char *) glyphs;
+    xcb_parts[4].iov_len = glyphs_len * sizeof(xcb_render_glyph_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_free_glyphs (xcb_connection_t         *c,
+                        xcb_render_glyphset_t     glyphset,
+                        uint32_t                  glyphs_len,
+                        const xcb_render_glyph_t *glyphs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_FREE_GLYPHS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_free_glyphs_request_t xcb_out;
+
+    xcb_out.glyphset = glyphset;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_glyph_t glyphs */
+    xcb_parts[4].iov_base = (char *) glyphs;
+    xcb_parts[4].iov_len = glyphs_len * sizeof(xcb_render_glyph_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_render_glyph_t *
+xcb_render_free_glyphs_glyphs (const xcb_render_free_glyphs_request_t *R)
+{
+    return (xcb_render_glyph_t *) (R + 1);
+}
+
+int
+xcb_render_free_glyphs_glyphs_length (const xcb_render_free_glyphs_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_render_free_glyphs_request_t))/sizeof(xcb_render_glyph_t));
+}
+
+xcb_generic_iterator_t
+xcb_render_free_glyphs_glyphs_end (const xcb_render_free_glyphs_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_render_glyph_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_render_free_glyphs_request_t))/sizeof(xcb_render_glyph_t)));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_render_composite_glyphs_8_sizeof (const void  *_buffer,
+                                      uint32_t     glyphcmds_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_composite_glyphs_8_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* glyphcmds */
+    xcb_block_len += glyphcmds_len * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_render_composite_glyphs_8_checked (xcb_connection_t        *c,
+                                       uint8_t                  op,
+                                       xcb_render_picture_t     src,
+                                       xcb_render_picture_t     dst,
+                                       xcb_render_pictformat_t  mask_format,
+                                       xcb_render_glyphset_t    glyphset,
+                                       int16_t                  src_x,
+                                       int16_t                  src_y,
+                                       uint32_t                 glyphcmds_len,
+                                       const uint8_t           *glyphcmds)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_COMPOSITE_GLYPHS_8,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_composite_glyphs_8_request_t xcb_out;
+
+    xcb_out.op = op;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.src = src;
+    xcb_out.dst = dst;
+    xcb_out.mask_format = mask_format;
+    xcb_out.glyphset = glyphset;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t glyphcmds */
+    xcb_parts[4].iov_base = (char *) glyphcmds;
+    xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_composite_glyphs_8 (xcb_connection_t        *c,
+                               uint8_t                  op,
+                               xcb_render_picture_t     src,
+                               xcb_render_picture_t     dst,
+                               xcb_render_pictformat_t  mask_format,
+                               xcb_render_glyphset_t    glyphset,
+                               int16_t                  src_x,
+                               int16_t                  src_y,
+                               uint32_t                 glyphcmds_len,
+                               const uint8_t           *glyphcmds)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_COMPOSITE_GLYPHS_8,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_composite_glyphs_8_request_t xcb_out;
+
+    xcb_out.op = op;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.src = src;
+    xcb_out.dst = dst;
+    xcb_out.mask_format = mask_format;
+    xcb_out.glyphset = glyphset;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t glyphcmds */
+    xcb_parts[4].iov_base = (char *) glyphcmds;
+    xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_render_composite_glyphs_8_glyphcmds (const xcb_render_composite_glyphs_8_request_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_render_composite_glyphs_8_glyphcmds_length (const xcb_render_composite_glyphs_8_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_render_composite_glyphs_8_request_t))/sizeof(uint8_t));
+}
+
+xcb_generic_iterator_t
+xcb_render_composite_glyphs_8_glyphcmds_end (const xcb_render_composite_glyphs_8_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_render_composite_glyphs_8_request_t))/sizeof(uint8_t)));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_render_composite_glyphs_16_sizeof (const void  *_buffer,
+                                       uint32_t     glyphcmds_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_composite_glyphs_16_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* glyphcmds */
+    xcb_block_len += glyphcmds_len * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_render_composite_glyphs_16_checked (xcb_connection_t        *c,
+                                        uint8_t                  op,
+                                        xcb_render_picture_t     src,
+                                        xcb_render_picture_t     dst,
+                                        xcb_render_pictformat_t  mask_format,
+                                        xcb_render_glyphset_t    glyphset,
+                                        int16_t                  src_x,
+                                        int16_t                  src_y,
+                                        uint32_t                 glyphcmds_len,
+                                        const uint8_t           *glyphcmds)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_COMPOSITE_GLYPHS_16,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_composite_glyphs_16_request_t xcb_out;
+
+    xcb_out.op = op;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.src = src;
+    xcb_out.dst = dst;
+    xcb_out.mask_format = mask_format;
+    xcb_out.glyphset = glyphset;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t glyphcmds */
+    xcb_parts[4].iov_base = (char *) glyphcmds;
+    xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_composite_glyphs_16 (xcb_connection_t        *c,
+                                uint8_t                  op,
+                                xcb_render_picture_t     src,
+                                xcb_render_picture_t     dst,
+                                xcb_render_pictformat_t  mask_format,
+                                xcb_render_glyphset_t    glyphset,
+                                int16_t                  src_x,
+                                int16_t                  src_y,
+                                uint32_t                 glyphcmds_len,
+                                const uint8_t           *glyphcmds)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_COMPOSITE_GLYPHS_16,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_composite_glyphs_16_request_t xcb_out;
+
+    xcb_out.op = op;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.src = src;
+    xcb_out.dst = dst;
+    xcb_out.mask_format = mask_format;
+    xcb_out.glyphset = glyphset;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t glyphcmds */
+    xcb_parts[4].iov_base = (char *) glyphcmds;
+    xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_render_composite_glyphs_16_glyphcmds (const xcb_render_composite_glyphs_16_request_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_render_composite_glyphs_16_glyphcmds_length (const xcb_render_composite_glyphs_16_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_render_composite_glyphs_16_request_t))/sizeof(uint8_t));
+}
+
+xcb_generic_iterator_t
+xcb_render_composite_glyphs_16_glyphcmds_end (const xcb_render_composite_glyphs_16_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_render_composite_glyphs_16_request_t))/sizeof(uint8_t)));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_render_composite_glyphs_32_sizeof (const void  *_buffer,
+                                       uint32_t     glyphcmds_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_composite_glyphs_32_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* glyphcmds */
+    xcb_block_len += glyphcmds_len * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_render_composite_glyphs_32_checked (xcb_connection_t        *c,
+                                        uint8_t                  op,
+                                        xcb_render_picture_t     src,
+                                        xcb_render_picture_t     dst,
+                                        xcb_render_pictformat_t  mask_format,
+                                        xcb_render_glyphset_t    glyphset,
+                                        int16_t                  src_x,
+                                        int16_t                  src_y,
+                                        uint32_t                 glyphcmds_len,
+                                        const uint8_t           *glyphcmds)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_COMPOSITE_GLYPHS_32,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_composite_glyphs_32_request_t xcb_out;
+
+    xcb_out.op = op;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.src = src;
+    xcb_out.dst = dst;
+    xcb_out.mask_format = mask_format;
+    xcb_out.glyphset = glyphset;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t glyphcmds */
+    xcb_parts[4].iov_base = (char *) glyphcmds;
+    xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_composite_glyphs_32 (xcb_connection_t        *c,
+                                uint8_t                  op,
+                                xcb_render_picture_t     src,
+                                xcb_render_picture_t     dst,
+                                xcb_render_pictformat_t  mask_format,
+                                xcb_render_glyphset_t    glyphset,
+                                int16_t                  src_x,
+                                int16_t                  src_y,
+                                uint32_t                 glyphcmds_len,
+                                const uint8_t           *glyphcmds)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_COMPOSITE_GLYPHS_32,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_composite_glyphs_32_request_t xcb_out;
+
+    xcb_out.op = op;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.src = src;
+    xcb_out.dst = dst;
+    xcb_out.mask_format = mask_format;
+    xcb_out.glyphset = glyphset;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t glyphcmds */
+    xcb_parts[4].iov_base = (char *) glyphcmds;
+    xcb_parts[4].iov_len = glyphcmds_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_render_composite_glyphs_32_glyphcmds (const xcb_render_composite_glyphs_32_request_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_render_composite_glyphs_32_glyphcmds_length (const xcb_render_composite_glyphs_32_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_render_composite_glyphs_32_request_t))/sizeof(uint8_t));
+}
+
+xcb_generic_iterator_t
+xcb_render_composite_glyphs_32_glyphcmds_end (const xcb_render_composite_glyphs_32_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_render_composite_glyphs_32_request_t))/sizeof(uint8_t)));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_render_fill_rectangles_sizeof (const void  *_buffer,
+                                   uint32_t     rects_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_fill_rectangles_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* rects */
+    xcb_block_len += rects_len * sizeof(xcb_rectangle_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_rectangle_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_render_fill_rectangles_checked (xcb_connection_t      *c,
+                                    uint8_t                op,
+                                    xcb_render_picture_t   dst,
+                                    xcb_render_color_t     color,
+                                    uint32_t               rects_len,
+                                    const xcb_rectangle_t *rects)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_FILL_RECTANGLES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_fill_rectangles_request_t xcb_out;
+
+    xcb_out.op = op;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.dst = dst;
+    xcb_out.color = color;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_rectangle_t rects */
+    xcb_parts[4].iov_base = (char *) rects;
+    xcb_parts[4].iov_len = rects_len * sizeof(xcb_rectangle_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_fill_rectangles (xcb_connection_t      *c,
+                            uint8_t                op,
+                            xcb_render_picture_t   dst,
+                            xcb_render_color_t     color,
+                            uint32_t               rects_len,
+                            const xcb_rectangle_t *rects)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_FILL_RECTANGLES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_fill_rectangles_request_t xcb_out;
+
+    xcb_out.op = op;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.dst = dst;
+    xcb_out.color = color;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_rectangle_t rects */
+    xcb_parts[4].iov_base = (char *) rects;
+    xcb_parts[4].iov_len = rects_len * sizeof(xcb_rectangle_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_rectangle_t *
+xcb_render_fill_rectangles_rects (const xcb_render_fill_rectangles_request_t *R)
+{
+    return (xcb_rectangle_t *) (R + 1);
+}
+
+int
+xcb_render_fill_rectangles_rects_length (const xcb_render_fill_rectangles_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_render_fill_rectangles_request_t))/sizeof(xcb_rectangle_t));
+}
+
+xcb_rectangle_iterator_t
+xcb_render_fill_rectangles_rects_iterator (const xcb_render_fill_rectangles_request_t *R)
+{
+    xcb_rectangle_iterator_t i;
+    i.data = (xcb_rectangle_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_render_fill_rectangles_request_t))/sizeof(xcb_rectangle_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_render_create_cursor_checked (xcb_connection_t     *c,
+                                  xcb_cursor_t          cid,
+                                  xcb_render_picture_t  source,
+                                  uint16_t              x,
+                                  uint16_t              y)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CREATE_CURSOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_create_cursor_request_t xcb_out;
+
+    xcb_out.cid = cid;
+    xcb_out.source = source;
+    xcb_out.x = x;
+    xcb_out.y = y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_create_cursor (xcb_connection_t     *c,
+                          xcb_cursor_t          cid,
+                          xcb_render_picture_t  source,
+                          uint16_t              x,
+                          uint16_t              y)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CREATE_CURSOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_create_cursor_request_t xcb_out;
+
+    xcb_out.cid = cid;
+    xcb_out.source = source;
+    xcb_out.x = x;
+    xcb_out.y = y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+void
+xcb_render_transform_next (xcb_render_transform_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_render_transform_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_transform_end (xcb_render_transform_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+xcb_void_cookie_t
+xcb_render_set_picture_transform_checked (xcb_connection_t       *c,
+                                          xcb_render_picture_t    picture,
+                                          xcb_render_transform_t  transform)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_SET_PICTURE_TRANSFORM,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_set_picture_transform_request_t xcb_out;
+
+    xcb_out.picture = picture;
+    xcb_out.transform = transform;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_set_picture_transform (xcb_connection_t       *c,
+                                  xcb_render_picture_t    picture,
+                                  xcb_render_transform_t  transform)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_SET_PICTURE_TRANSFORM,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_set_picture_transform_request_t xcb_out;
+
+    xcb_out.picture = picture;
+    xcb_out.transform = transform;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_render_query_filters_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_render_query_filters_reply_t *_aux = (xcb_render_query_filters_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_render_query_filters_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* aliases */
+    xcb_block_len += _aux->num_aliases * sizeof(uint16_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint16_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* filters */
+    for(i=0; i<_aux->num_filters; i++) {
+        xcb_tmp_len = xcb_str_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_str_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_render_query_filters_cookie_t
+xcb_render_query_filters (xcb_connection_t *c,
+                          xcb_drawable_t    drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_QUERY_FILTERS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_render_query_filters_cookie_t xcb_ret;
+    xcb_render_query_filters_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_render_query_filters_cookie_t
+xcb_render_query_filters_unchecked (xcb_connection_t *c,
+                                    xcb_drawable_t    drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_QUERY_FILTERS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_render_query_filters_cookie_t xcb_ret;
+    xcb_render_query_filters_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint16_t *
+xcb_render_query_filters_aliases (const xcb_render_query_filters_reply_t *R)
+{
+    return (uint16_t *) (R + 1);
+}
+
+int
+xcb_render_query_filters_aliases_length (const xcb_render_query_filters_reply_t *R)
+{
+    return R->num_aliases;
+}
+
+xcb_generic_iterator_t
+xcb_render_query_filters_aliases_end (const xcb_render_query_filters_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint16_t *) (R + 1)) + (R->num_aliases);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_render_query_filters_filters_length (const xcb_render_query_filters_reply_t *R)
+{
+    return R->num_filters;
+}
+
+xcb_str_iterator_t
+xcb_render_query_filters_filters_iterator (const xcb_render_query_filters_reply_t *R)
+{
+    xcb_str_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_render_query_filters_aliases_end(R);
+    i.data = (xcb_str_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_str_t, prev.index));
+    i.rem = R->num_filters;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_render_query_filters_reply_t *
+xcb_render_query_filters_reply (xcb_connection_t                   *c,
+                                xcb_render_query_filters_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e)
+{
+    return (xcb_render_query_filters_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_render_set_picture_filter_sizeof (const void  *_buffer,
+                                      uint32_t     values_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_render_set_picture_filter_request_t *_aux = (xcb_render_set_picture_filter_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_set_picture_filter_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* filter */
+    xcb_block_len += _aux->filter_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* values */
+    xcb_block_len += values_len * sizeof(xcb_render_fixed_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_fixed_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_render_set_picture_filter_checked (xcb_connection_t         *c,
+                                       xcb_render_picture_t      picture,
+                                       uint16_t                  filter_len,
+                                       const char               *filter,
+                                       uint32_t                  values_len,
+                                       const xcb_render_fixed_t *values)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_SET_PICTURE_FILTER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_set_picture_filter_request_t xcb_out;
+
+    xcb_out.picture = picture;
+    xcb_out.filter_len = filter_len;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char filter */
+    xcb_parts[4].iov_base = (char *) filter;
+    xcb_parts[4].iov_len = filter_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_render_fixed_t values */
+    xcb_parts[6].iov_base = (char *) values;
+    xcb_parts[6].iov_len = values_len * sizeof(xcb_render_fixed_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_set_picture_filter (xcb_connection_t         *c,
+                               xcb_render_picture_t      picture,
+                               uint16_t                  filter_len,
+                               const char               *filter,
+                               uint32_t                  values_len,
+                               const xcb_render_fixed_t *values)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_SET_PICTURE_FILTER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_set_picture_filter_request_t xcb_out;
+
+    xcb_out.picture = picture;
+    xcb_out.filter_len = filter_len;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char filter */
+    xcb_parts[4].iov_base = (char *) filter;
+    xcb_parts[4].iov_len = filter_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_render_fixed_t values */
+    xcb_parts[6].iov_base = (char *) values;
+    xcb_parts[6].iov_len = values_len * sizeof(xcb_render_fixed_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_render_set_picture_filter_filter (const xcb_render_set_picture_filter_request_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_render_set_picture_filter_filter_length (const xcb_render_set_picture_filter_request_t *R)
+{
+    return R->filter_len;
+}
+
+xcb_generic_iterator_t
+xcb_render_set_picture_filter_filter_end (const xcb_render_set_picture_filter_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->filter_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_render_fixed_t *
+xcb_render_set_picture_filter_values (const xcb_render_set_picture_filter_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_render_set_picture_filter_filter_end(R);
+    return (xcb_render_fixed_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0);
+}
+
+int
+xcb_render_set_picture_filter_values_length (const xcb_render_set_picture_filter_request_t *R)
+{
+    return ((((char*)R) + R->length * 4) - (char*)(xcb_render_set_picture_filter_values(R))) / sizeof(xcb_render_fixed_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_set_picture_filter_values_end (const xcb_render_set_picture_filter_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_render_set_picture_filter_filter_end(R);
+    i.data = ((xcb_render_fixed_t *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (((((char*)R) + R->length * 4) - (char*)(xcb_render_set_picture_filter_values(R))) / sizeof(xcb_render_fixed_t));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_render_animcursorelt_next (xcb_render_animcursorelt_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_render_animcursorelt_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_animcursorelt_end (xcb_render_animcursorelt_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_render_create_anim_cursor_sizeof (const void  *_buffer,
+                                      uint32_t     cursors_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_create_anim_cursor_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* cursors */
+    xcb_block_len += cursors_len * sizeof(xcb_render_animcursorelt_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_animcursorelt_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_render_create_anim_cursor_checked (xcb_connection_t                 *c,
+                                       xcb_cursor_t                      cid,
+                                       uint32_t                          cursors_len,
+                                       const xcb_render_animcursorelt_t *cursors)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CREATE_ANIM_CURSOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_create_anim_cursor_request_t xcb_out;
+
+    xcb_out.cid = cid;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_animcursorelt_t cursors */
+    xcb_parts[4].iov_base = (char *) cursors;
+    xcb_parts[4].iov_len = cursors_len * sizeof(xcb_render_animcursorelt_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_create_anim_cursor (xcb_connection_t                 *c,
+                               xcb_cursor_t                      cid,
+                               uint32_t                          cursors_len,
+                               const xcb_render_animcursorelt_t *cursors)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CREATE_ANIM_CURSOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_create_anim_cursor_request_t xcb_out;
+
+    xcb_out.cid = cid;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_animcursorelt_t cursors */
+    xcb_parts[4].iov_base = (char *) cursors;
+    xcb_parts[4].iov_len = cursors_len * sizeof(xcb_render_animcursorelt_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_render_animcursorelt_t *
+xcb_render_create_anim_cursor_cursors (const xcb_render_create_anim_cursor_request_t *R)
+{
+    return (xcb_render_animcursorelt_t *) (R + 1);
+}
+
+int
+xcb_render_create_anim_cursor_cursors_length (const xcb_render_create_anim_cursor_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_render_create_anim_cursor_request_t))/sizeof(xcb_render_animcursorelt_t));
+}
+
+xcb_render_animcursorelt_iterator_t
+xcb_render_create_anim_cursor_cursors_iterator (const xcb_render_create_anim_cursor_request_t *R)
+{
+    xcb_render_animcursorelt_iterator_t i;
+    i.data = (xcb_render_animcursorelt_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_render_create_anim_cursor_request_t))/sizeof(xcb_render_animcursorelt_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_render_spanfix_next (xcb_render_spanfix_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_render_spanfix_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_spanfix_end (xcb_render_spanfix_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_render_trap_next (xcb_render_trap_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_render_trap_t);
+}
+
+xcb_generic_iterator_t
+xcb_render_trap_end (xcb_render_trap_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_render_add_traps_sizeof (const void  *_buffer,
+                             uint32_t     traps_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_add_traps_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* traps */
+    xcb_block_len += traps_len * sizeof(xcb_render_trap_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_trap_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_render_add_traps_checked (xcb_connection_t        *c,
+                              xcb_render_picture_t     picture,
+                              int16_t                  x_off,
+                              int16_t                  y_off,
+                              uint32_t                 traps_len,
+                              const xcb_render_trap_t *traps)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_ADD_TRAPS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_add_traps_request_t xcb_out;
+
+    xcb_out.picture = picture;
+    xcb_out.x_off = x_off;
+    xcb_out.y_off = y_off;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_trap_t traps */
+    xcb_parts[4].iov_base = (char *) traps;
+    xcb_parts[4].iov_len = traps_len * sizeof(xcb_render_trap_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_add_traps (xcb_connection_t        *c,
+                      xcb_render_picture_t     picture,
+                      int16_t                  x_off,
+                      int16_t                  y_off,
+                      uint32_t                 traps_len,
+                      const xcb_render_trap_t *traps)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_ADD_TRAPS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_add_traps_request_t xcb_out;
+
+    xcb_out.picture = picture;
+    xcb_out.x_off = x_off;
+    xcb_out.y_off = y_off;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_trap_t traps */
+    xcb_parts[4].iov_base = (char *) traps;
+    xcb_parts[4].iov_len = traps_len * sizeof(xcb_render_trap_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_render_trap_t *
+xcb_render_add_traps_traps (const xcb_render_add_traps_request_t *R)
+{
+    return (xcb_render_trap_t *) (R + 1);
+}
+
+int
+xcb_render_add_traps_traps_length (const xcb_render_add_traps_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_render_add_traps_request_t))/sizeof(xcb_render_trap_t));
+}
+
+xcb_render_trap_iterator_t
+xcb_render_add_traps_traps_iterator (const xcb_render_add_traps_request_t *R)
+{
+    xcb_render_trap_iterator_t i;
+    i.data = (xcb_render_trap_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_render_add_traps_request_t))/sizeof(xcb_render_trap_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_render_create_solid_fill_checked (xcb_connection_t     *c,
+                                      xcb_render_picture_t  picture,
+                                      xcb_render_color_t    color)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CREATE_SOLID_FILL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_create_solid_fill_request_t xcb_out;
+
+    xcb_out.picture = picture;
+    xcb_out.color = color;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_create_solid_fill (xcb_connection_t     *c,
+                              xcb_render_picture_t  picture,
+                              xcb_render_color_t    color)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CREATE_SOLID_FILL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_create_solid_fill_request_t xcb_out;
+
+    xcb_out.picture = picture;
+    xcb_out.color = color;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_render_create_linear_gradient_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_render_create_linear_gradient_request_t *_aux = (xcb_render_create_linear_gradient_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_create_linear_gradient_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* stops */
+    xcb_block_len += _aux->num_stops * sizeof(xcb_render_fixed_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_fixed_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* colors */
+    xcb_block_len += _aux->num_stops * sizeof(xcb_render_color_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_color_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_render_create_linear_gradient_checked (xcb_connection_t         *c,
+                                           xcb_render_picture_t      picture,
+                                           xcb_render_pointfix_t     p1,
+                                           xcb_render_pointfix_t     p2,
+                                           uint32_t                  num_stops,
+                                           const xcb_render_fixed_t *stops,
+                                           const xcb_render_color_t *colors)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CREATE_LINEAR_GRADIENT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_create_linear_gradient_request_t xcb_out;
+
+    xcb_out.picture = picture;
+    xcb_out.p1 = p1;
+    xcb_out.p2 = p2;
+    xcb_out.num_stops = num_stops;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_fixed_t stops */
+    xcb_parts[4].iov_base = (char *) stops;
+    xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_render_color_t colors */
+    xcb_parts[6].iov_base = (char *) colors;
+    xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_create_linear_gradient (xcb_connection_t         *c,
+                                   xcb_render_picture_t      picture,
+                                   xcb_render_pointfix_t     p1,
+                                   xcb_render_pointfix_t     p2,
+                                   uint32_t                  num_stops,
+                                   const xcb_render_fixed_t *stops,
+                                   const xcb_render_color_t *colors)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CREATE_LINEAR_GRADIENT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_create_linear_gradient_request_t xcb_out;
+
+    xcb_out.picture = picture;
+    xcb_out.p1 = p1;
+    xcb_out.p2 = p2;
+    xcb_out.num_stops = num_stops;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_fixed_t stops */
+    xcb_parts[4].iov_base = (char *) stops;
+    xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_render_color_t colors */
+    xcb_parts[6].iov_base = (char *) colors;
+    xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_render_fixed_t *
+xcb_render_create_linear_gradient_stops (const xcb_render_create_linear_gradient_request_t *R)
+{
+    return (xcb_render_fixed_t *) (R + 1);
+}
+
+int
+xcb_render_create_linear_gradient_stops_length (const xcb_render_create_linear_gradient_request_t *R)
+{
+    return R->num_stops;
+}
+
+xcb_generic_iterator_t
+xcb_render_create_linear_gradient_stops_end (const xcb_render_create_linear_gradient_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_render_fixed_t *) (R + 1)) + (R->num_stops);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_render_color_t *
+xcb_render_create_linear_gradient_colors (const xcb_render_create_linear_gradient_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_render_create_linear_gradient_stops_end(R);
+    return (xcb_render_color_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_color_t, prev.index) + 0);
+}
+
+int
+xcb_render_create_linear_gradient_colors_length (const xcb_render_create_linear_gradient_request_t *R)
+{
+    return R->num_stops;
+}
+
+xcb_render_color_iterator_t
+xcb_render_create_linear_gradient_colors_iterator (const xcb_render_create_linear_gradient_request_t *R)
+{
+    xcb_render_color_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_render_create_linear_gradient_stops_end(R);
+    i.data = (xcb_render_color_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_color_t, prev.index));
+    i.rem = R->num_stops;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_render_create_radial_gradient_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_render_create_radial_gradient_request_t *_aux = (xcb_render_create_radial_gradient_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_create_radial_gradient_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* stops */
+    xcb_block_len += _aux->num_stops * sizeof(xcb_render_fixed_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_fixed_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* colors */
+    xcb_block_len += _aux->num_stops * sizeof(xcb_render_color_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_color_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_render_create_radial_gradient_checked (xcb_connection_t         *c,
+                                           xcb_render_picture_t      picture,
+                                           xcb_render_pointfix_t     inner,
+                                           xcb_render_pointfix_t     outer,
+                                           xcb_render_fixed_t        inner_radius,
+                                           xcb_render_fixed_t        outer_radius,
+                                           uint32_t                  num_stops,
+                                           const xcb_render_fixed_t *stops,
+                                           const xcb_render_color_t *colors)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CREATE_RADIAL_GRADIENT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_create_radial_gradient_request_t xcb_out;
+
+    xcb_out.picture = picture;
+    xcb_out.inner = inner;
+    xcb_out.outer = outer;
+    xcb_out.inner_radius = inner_radius;
+    xcb_out.outer_radius = outer_radius;
+    xcb_out.num_stops = num_stops;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_fixed_t stops */
+    xcb_parts[4].iov_base = (char *) stops;
+    xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_render_color_t colors */
+    xcb_parts[6].iov_base = (char *) colors;
+    xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_create_radial_gradient (xcb_connection_t         *c,
+                                   xcb_render_picture_t      picture,
+                                   xcb_render_pointfix_t     inner,
+                                   xcb_render_pointfix_t     outer,
+                                   xcb_render_fixed_t        inner_radius,
+                                   xcb_render_fixed_t        outer_radius,
+                                   uint32_t                  num_stops,
+                                   const xcb_render_fixed_t *stops,
+                                   const xcb_render_color_t *colors)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CREATE_RADIAL_GRADIENT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_create_radial_gradient_request_t xcb_out;
+
+    xcb_out.picture = picture;
+    xcb_out.inner = inner;
+    xcb_out.outer = outer;
+    xcb_out.inner_radius = inner_radius;
+    xcb_out.outer_radius = outer_radius;
+    xcb_out.num_stops = num_stops;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_fixed_t stops */
+    xcb_parts[4].iov_base = (char *) stops;
+    xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_render_color_t colors */
+    xcb_parts[6].iov_base = (char *) colors;
+    xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_render_fixed_t *
+xcb_render_create_radial_gradient_stops (const xcb_render_create_radial_gradient_request_t *R)
+{
+    return (xcb_render_fixed_t *) (R + 1);
+}
+
+int
+xcb_render_create_radial_gradient_stops_length (const xcb_render_create_radial_gradient_request_t *R)
+{
+    return R->num_stops;
+}
+
+xcb_generic_iterator_t
+xcb_render_create_radial_gradient_stops_end (const xcb_render_create_radial_gradient_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_render_fixed_t *) (R + 1)) + (R->num_stops);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_render_color_t *
+xcb_render_create_radial_gradient_colors (const xcb_render_create_radial_gradient_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_render_create_radial_gradient_stops_end(R);
+    return (xcb_render_color_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_color_t, prev.index) + 0);
+}
+
+int
+xcb_render_create_radial_gradient_colors_length (const xcb_render_create_radial_gradient_request_t *R)
+{
+    return R->num_stops;
+}
+
+xcb_render_color_iterator_t
+xcb_render_create_radial_gradient_colors_iterator (const xcb_render_create_radial_gradient_request_t *R)
+{
+    xcb_render_color_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_render_create_radial_gradient_stops_end(R);
+    i.data = (xcb_render_color_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_color_t, prev.index));
+    i.rem = R->num_stops;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_render_create_conical_gradient_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_render_create_conical_gradient_request_t *_aux = (xcb_render_create_conical_gradient_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_render_create_conical_gradient_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* stops */
+    xcb_block_len += _aux->num_stops * sizeof(xcb_render_fixed_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_fixed_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* colors */
+    xcb_block_len += _aux->num_stops * sizeof(xcb_render_color_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_render_color_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_render_create_conical_gradient_checked (xcb_connection_t         *c,
+                                            xcb_render_picture_t      picture,
+                                            xcb_render_pointfix_t     center,
+                                            xcb_render_fixed_t        angle,
+                                            uint32_t                  num_stops,
+                                            const xcb_render_fixed_t *stops,
+                                            const xcb_render_color_t *colors)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CREATE_CONICAL_GRADIENT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_create_conical_gradient_request_t xcb_out;
+
+    xcb_out.picture = picture;
+    xcb_out.center = center;
+    xcb_out.angle = angle;
+    xcb_out.num_stops = num_stops;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_fixed_t stops */
+    xcb_parts[4].iov_base = (char *) stops;
+    xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_render_color_t colors */
+    xcb_parts[6].iov_base = (char *) colors;
+    xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_render_create_conical_gradient (xcb_connection_t         *c,
+                                    xcb_render_picture_t      picture,
+                                    xcb_render_pointfix_t     center,
+                                    xcb_render_fixed_t        angle,
+                                    uint32_t                  num_stops,
+                                    const xcb_render_fixed_t *stops,
+                                    const xcb_render_color_t *colors)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_render_id,
+        .opcode = XCB_RENDER_CREATE_CONICAL_GRADIENT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_render_create_conical_gradient_request_t xcb_out;
+
+    xcb_out.picture = picture;
+    xcb_out.center = center;
+    xcb_out.angle = angle;
+    xcb_out.num_stops = num_stops;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_render_fixed_t stops */
+    xcb_parts[4].iov_base = (char *) stops;
+    xcb_parts[4].iov_len = num_stops * sizeof(xcb_render_fixed_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_render_color_t colors */
+    xcb_parts[6].iov_base = (char *) colors;
+    xcb_parts[6].iov_len = num_stops * sizeof(xcb_render_color_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_render_fixed_t *
+xcb_render_create_conical_gradient_stops (const xcb_render_create_conical_gradient_request_t *R)
+{
+    return (xcb_render_fixed_t *) (R + 1);
+}
+
+int
+xcb_render_create_conical_gradient_stops_length (const xcb_render_create_conical_gradient_request_t *R)
+{
+    return R->num_stops;
+}
+
+xcb_generic_iterator_t
+xcb_render_create_conical_gradient_stops_end (const xcb_render_create_conical_gradient_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_render_fixed_t *) (R + 1)) + (R->num_stops);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_render_color_t *
+xcb_render_create_conical_gradient_colors (const xcb_render_create_conical_gradient_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_render_create_conical_gradient_stops_end(R);
+    return (xcb_render_color_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_color_t, prev.index) + 0);
+}
+
+int
+xcb_render_create_conical_gradient_colors_length (const xcb_render_create_conical_gradient_request_t *R)
+{
+    return R->num_stops;
+}
+
+xcb_render_color_iterator_t
+xcb_render_create_conical_gradient_colors_iterator (const xcb_render_create_conical_gradient_request_t *R)
+{
+    xcb_render_color_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_render_create_conical_gradient_stops_end(R);
+    i.data = (xcb_render_color_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_render_color_t, prev.index));
+    i.rem = R->num_stops;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
diff --git a/depends/libxcb/src/res.c b/depends/libxcb/src/res.c
new file mode 100644
index 0000000..5b5da81
--- /dev/null
+++ b/depends/libxcb/src/res.c
@@ -0,0 +1,850 @@
+/*
+ * This file generated automatically from res.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "res.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xproto.h"
+
+xcb_extension_t xcb_res_id = { "X-Resource", 0 };
+
+void
+xcb_res_client_next (xcb_res_client_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_res_client_t);
+}
+
+xcb_generic_iterator_t
+xcb_res_client_end (xcb_res_client_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_res_type_next (xcb_res_type_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_res_type_t);
+}
+
+xcb_generic_iterator_t
+xcb_res_type_end (xcb_res_type_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_res_client_id_spec_next (xcb_res_client_id_spec_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_res_client_id_spec_t);
+}
+
+xcb_generic_iterator_t
+xcb_res_client_id_spec_end (xcb_res_client_id_spec_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_res_client_id_value_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_res_client_id_value_t *_aux = (xcb_res_client_id_value_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_res_client_id_value_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* value */
+    xcb_block_len += (_aux->length / 4) * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+uint32_t *
+xcb_res_client_id_value_value (const xcb_res_client_id_value_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_res_client_id_value_value_length (const xcb_res_client_id_value_t *R)
+{
+    return (R->length / 4);
+}
+
+xcb_generic_iterator_t
+xcb_res_client_id_value_value_end (const xcb_res_client_id_value_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + ((R->length / 4));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_res_client_id_value_next (xcb_res_client_id_value_iterator_t *i)
+{
+    xcb_res_client_id_value_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_res_client_id_value_t *)(((char *)R) + xcb_res_client_id_value_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_res_client_id_value_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_res_client_id_value_end (xcb_res_client_id_value_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_res_client_id_value_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+void
+xcb_res_resource_id_spec_next (xcb_res_resource_id_spec_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_res_resource_id_spec_t);
+}
+
+xcb_generic_iterator_t
+xcb_res_resource_id_spec_end (xcb_res_resource_id_spec_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_res_resource_size_spec_next (xcb_res_resource_size_spec_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_res_resource_size_spec_t);
+}
+
+xcb_generic_iterator_t
+xcb_res_resource_size_spec_end (xcb_res_resource_size_spec_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_res_resource_size_value_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_res_resource_size_value_t *_aux = (xcb_res_resource_size_value_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_res_resource_size_value_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* cross_references */
+    xcb_block_len += _aux->num_cross_references * sizeof(xcb_res_resource_size_spec_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_res_resource_size_spec_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_res_resource_size_spec_t *
+xcb_res_resource_size_value_cross_references (const xcb_res_resource_size_value_t *R)
+{
+    return (xcb_res_resource_size_spec_t *) (R + 1);
+}
+
+int
+xcb_res_resource_size_value_cross_references_length (const xcb_res_resource_size_value_t *R)
+{
+    return R->num_cross_references;
+}
+
+xcb_res_resource_size_spec_iterator_t
+xcb_res_resource_size_value_cross_references_iterator (const xcb_res_resource_size_value_t *R)
+{
+    xcb_res_resource_size_spec_iterator_t i;
+    i.data = (xcb_res_resource_size_spec_t *) (R + 1);
+    i.rem = R->num_cross_references;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_res_resource_size_value_next (xcb_res_resource_size_value_iterator_t *i)
+{
+    xcb_res_resource_size_value_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_res_resource_size_value_t *)(((char *)R) + xcb_res_resource_size_value_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_res_resource_size_value_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_res_resource_size_value_end (xcb_res_resource_size_value_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_res_resource_size_value_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+xcb_res_query_version_cookie_t
+xcb_res_query_version (xcb_connection_t *c,
+                       uint8_t           client_major,
+                       uint8_t           client_minor)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_res_id,
+        .opcode = XCB_RES_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_res_query_version_cookie_t xcb_ret;
+    xcb_res_query_version_request_t xcb_out;
+
+    xcb_out.client_major = client_major;
+    xcb_out.client_minor = client_minor;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_res_query_version_cookie_t
+xcb_res_query_version_unchecked (xcb_connection_t *c,
+                                 uint8_t           client_major,
+                                 uint8_t           client_minor)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_res_id,
+        .opcode = XCB_RES_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_res_query_version_cookie_t xcb_ret;
+    xcb_res_query_version_request_t xcb_out;
+
+    xcb_out.client_major = client_major;
+    xcb_out.client_minor = client_minor;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_res_query_version_reply_t *
+xcb_res_query_version_reply (xcb_connection_t                *c,
+                             xcb_res_query_version_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_res_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_res_query_clients_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_res_query_clients_reply_t *_aux = (xcb_res_query_clients_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_res_query_clients_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* clients */
+    xcb_block_len += _aux->num_clients * sizeof(xcb_res_client_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_res_client_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_res_query_clients_cookie_t
+xcb_res_query_clients (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_res_id,
+        .opcode = XCB_RES_QUERY_CLIENTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_res_query_clients_cookie_t xcb_ret;
+    xcb_res_query_clients_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_res_query_clients_cookie_t
+xcb_res_query_clients_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_res_id,
+        .opcode = XCB_RES_QUERY_CLIENTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_res_query_clients_cookie_t xcb_ret;
+    xcb_res_query_clients_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_res_client_t *
+xcb_res_query_clients_clients (const xcb_res_query_clients_reply_t *R)
+{
+    return (xcb_res_client_t *) (R + 1);
+}
+
+int
+xcb_res_query_clients_clients_length (const xcb_res_query_clients_reply_t *R)
+{
+    return R->num_clients;
+}
+
+xcb_res_client_iterator_t
+xcb_res_query_clients_clients_iterator (const xcb_res_query_clients_reply_t *R)
+{
+    xcb_res_client_iterator_t i;
+    i.data = (xcb_res_client_t *) (R + 1);
+    i.rem = R->num_clients;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_res_query_clients_reply_t *
+xcb_res_query_clients_reply (xcb_connection_t                *c,
+                             xcb_res_query_clients_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_res_query_clients_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_res_query_client_resources_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_res_query_client_resources_reply_t *_aux = (xcb_res_query_client_resources_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_res_query_client_resources_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* types */
+    xcb_block_len += _aux->num_types * sizeof(xcb_res_type_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_res_type_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_res_query_client_resources_cookie_t
+xcb_res_query_client_resources (xcb_connection_t *c,
+                                uint32_t          xid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_res_id,
+        .opcode = XCB_RES_QUERY_CLIENT_RESOURCES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_res_query_client_resources_cookie_t xcb_ret;
+    xcb_res_query_client_resources_request_t xcb_out;
+
+    xcb_out.xid = xid;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_res_query_client_resources_cookie_t
+xcb_res_query_client_resources_unchecked (xcb_connection_t *c,
+                                          uint32_t          xid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_res_id,
+        .opcode = XCB_RES_QUERY_CLIENT_RESOURCES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_res_query_client_resources_cookie_t xcb_ret;
+    xcb_res_query_client_resources_request_t xcb_out;
+
+    xcb_out.xid = xid;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_res_type_t *
+xcb_res_query_client_resources_types (const xcb_res_query_client_resources_reply_t *R)
+{
+    return (xcb_res_type_t *) (R + 1);
+}
+
+int
+xcb_res_query_client_resources_types_length (const xcb_res_query_client_resources_reply_t *R)
+{
+    return R->num_types;
+}
+
+xcb_res_type_iterator_t
+xcb_res_query_client_resources_types_iterator (const xcb_res_query_client_resources_reply_t *R)
+{
+    xcb_res_type_iterator_t i;
+    i.data = (xcb_res_type_t *) (R + 1);
+    i.rem = R->num_types;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_res_query_client_resources_reply_t *
+xcb_res_query_client_resources_reply (xcb_connection_t                         *c,
+                                      xcb_res_query_client_resources_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e)
+{
+    return (xcb_res_query_client_resources_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_res_query_client_pixmap_bytes_cookie_t
+xcb_res_query_client_pixmap_bytes (xcb_connection_t *c,
+                                   uint32_t          xid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_res_id,
+        .opcode = XCB_RES_QUERY_CLIENT_PIXMAP_BYTES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_res_query_client_pixmap_bytes_cookie_t xcb_ret;
+    xcb_res_query_client_pixmap_bytes_request_t xcb_out;
+
+    xcb_out.xid = xid;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_res_query_client_pixmap_bytes_cookie_t
+xcb_res_query_client_pixmap_bytes_unchecked (xcb_connection_t *c,
+                                             uint32_t          xid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_res_id,
+        .opcode = XCB_RES_QUERY_CLIENT_PIXMAP_BYTES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_res_query_client_pixmap_bytes_cookie_t xcb_ret;
+    xcb_res_query_client_pixmap_bytes_request_t xcb_out;
+
+    xcb_out.xid = xid;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_res_query_client_pixmap_bytes_reply_t *
+xcb_res_query_client_pixmap_bytes_reply (xcb_connection_t                            *c,
+                                         xcb_res_query_client_pixmap_bytes_cookie_t   cookie  /**< */,
+                                         xcb_generic_error_t                        **e)
+{
+    return (xcb_res_query_client_pixmap_bytes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_res_query_client_ids_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_res_query_client_ids_request_t *_aux = (xcb_res_query_client_ids_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_res_query_client_ids_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* specs */
+    xcb_block_len += _aux->num_specs * sizeof(xcb_res_client_id_spec_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_res_client_id_spec_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_res_query_client_ids_cookie_t
+xcb_res_query_client_ids (xcb_connection_t               *c,
+                          uint32_t                        num_specs,
+                          const xcb_res_client_id_spec_t *specs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_res_id,
+        .opcode = XCB_RES_QUERY_CLIENT_IDS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_res_query_client_ids_cookie_t xcb_ret;
+    xcb_res_query_client_ids_request_t xcb_out;
+
+    xcb_out.num_specs = num_specs;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_res_client_id_spec_t specs */
+    xcb_parts[4].iov_base = (char *) specs;
+    xcb_parts[4].iov_len = num_specs * sizeof(xcb_res_client_id_spec_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_res_query_client_ids_cookie_t
+xcb_res_query_client_ids_unchecked (xcb_connection_t               *c,
+                                    uint32_t                        num_specs,
+                                    const xcb_res_client_id_spec_t *specs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_res_id,
+        .opcode = XCB_RES_QUERY_CLIENT_IDS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_res_query_client_ids_cookie_t xcb_ret;
+    xcb_res_query_client_ids_request_t xcb_out;
+
+    xcb_out.num_specs = num_specs;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_res_client_id_spec_t specs */
+    xcb_parts[4].iov_base = (char *) specs;
+    xcb_parts[4].iov_len = num_specs * sizeof(xcb_res_client_id_spec_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_res_query_client_ids_ids_length (const xcb_res_query_client_ids_reply_t *R)
+{
+    return R->num_ids;
+}
+
+xcb_res_client_id_value_iterator_t
+xcb_res_query_client_ids_ids_iterator (const xcb_res_query_client_ids_reply_t *R)
+{
+    xcb_res_client_id_value_iterator_t i;
+    i.data = (xcb_res_client_id_value_t *) (R + 1);
+    i.rem = R->num_ids;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_res_query_client_ids_reply_t *
+xcb_res_query_client_ids_reply (xcb_connection_t                   *c,
+                                xcb_res_query_client_ids_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e)
+{
+    return (xcb_res_query_client_ids_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_res_query_resource_bytes_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_res_query_resource_bytes_request_t *_aux = (xcb_res_query_resource_bytes_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_res_query_resource_bytes_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* specs */
+    xcb_block_len += _aux->num_specs * sizeof(xcb_res_resource_id_spec_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_res_resource_id_spec_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_res_query_resource_bytes_cookie_t
+xcb_res_query_resource_bytes (xcb_connection_t                 *c,
+                              uint32_t                          client,
+                              uint32_t                          num_specs,
+                              const xcb_res_resource_id_spec_t *specs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_res_id,
+        .opcode = XCB_RES_QUERY_RESOURCE_BYTES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_res_query_resource_bytes_cookie_t xcb_ret;
+    xcb_res_query_resource_bytes_request_t xcb_out;
+
+    xcb_out.client = client;
+    xcb_out.num_specs = num_specs;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_res_resource_id_spec_t specs */
+    xcb_parts[4].iov_base = (char *) specs;
+    xcb_parts[4].iov_len = num_specs * sizeof(xcb_res_resource_id_spec_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_res_query_resource_bytes_cookie_t
+xcb_res_query_resource_bytes_unchecked (xcb_connection_t                 *c,
+                                        uint32_t                          client,
+                                        uint32_t                          num_specs,
+                                        const xcb_res_resource_id_spec_t *specs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_res_id,
+        .opcode = XCB_RES_QUERY_RESOURCE_BYTES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_res_query_resource_bytes_cookie_t xcb_ret;
+    xcb_res_query_resource_bytes_request_t xcb_out;
+
+    xcb_out.client = client;
+    xcb_out.num_specs = num_specs;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_res_resource_id_spec_t specs */
+    xcb_parts[4].iov_base = (char *) specs;
+    xcb_parts[4].iov_len = num_specs * sizeof(xcb_res_resource_id_spec_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_res_query_resource_bytes_sizes_length (const xcb_res_query_resource_bytes_reply_t *R)
+{
+    return R->num_sizes;
+}
+
+xcb_res_resource_size_value_iterator_t
+xcb_res_query_resource_bytes_sizes_iterator (const xcb_res_query_resource_bytes_reply_t *R)
+{
+    xcb_res_resource_size_value_iterator_t i;
+    i.data = (xcb_res_resource_size_value_t *) (R + 1);
+    i.rem = R->num_sizes;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_res_query_resource_bytes_reply_t *
+xcb_res_query_resource_bytes_reply (xcb_connection_t                       *c,
+                                    xcb_res_query_resource_bytes_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e)
+{
+    return (xcb_res_query_resource_bytes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
diff --git a/depends/libxcb/src/screensaver.c b/depends/libxcb/src/screensaver.c
new file mode 100644
index 0000000..9d84576
--- /dev/null
+++ b/depends/libxcb/src/screensaver.c
@@ -0,0 +1,849 @@
+/*
+ * This file generated automatically from screensaver.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "screensaver.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xproto.h"
+
+xcb_extension_t xcb_screensaver_id = { "MIT-SCREEN-SAVER", 0 };
+
+xcb_screensaver_query_version_cookie_t
+xcb_screensaver_query_version (xcb_connection_t *c,
+                               uint8_t           client_major_version,
+                               uint8_t           client_minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_screensaver_id,
+        .opcode = XCB_SCREENSAVER_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_screensaver_query_version_cookie_t xcb_ret;
+    xcb_screensaver_query_version_request_t xcb_out;
+
+    xcb_out.client_major_version = client_major_version;
+    xcb_out.client_minor_version = client_minor_version;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_screensaver_query_version_cookie_t
+xcb_screensaver_query_version_unchecked (xcb_connection_t *c,
+                                         uint8_t           client_major_version,
+                                         uint8_t           client_minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_screensaver_id,
+        .opcode = XCB_SCREENSAVER_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_screensaver_query_version_cookie_t xcb_ret;
+    xcb_screensaver_query_version_request_t xcb_out;
+
+    xcb_out.client_major_version = client_major_version;
+    xcb_out.client_minor_version = client_minor_version;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_screensaver_query_version_reply_t *
+xcb_screensaver_query_version_reply (xcb_connection_t                        *c,
+                                     xcb_screensaver_query_version_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e)
+{
+    return (xcb_screensaver_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_screensaver_query_info_cookie_t
+xcb_screensaver_query_info (xcb_connection_t *c,
+                            xcb_drawable_t    drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_screensaver_id,
+        .opcode = XCB_SCREENSAVER_QUERY_INFO,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_screensaver_query_info_cookie_t xcb_ret;
+    xcb_screensaver_query_info_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_screensaver_query_info_cookie_t
+xcb_screensaver_query_info_unchecked (xcb_connection_t *c,
+                                      xcb_drawable_t    drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_screensaver_id,
+        .opcode = XCB_SCREENSAVER_QUERY_INFO,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_screensaver_query_info_cookie_t xcb_ret;
+    xcb_screensaver_query_info_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_screensaver_query_info_reply_t *
+xcb_screensaver_query_info_reply (xcb_connection_t                     *c,
+                                  xcb_screensaver_query_info_cookie_t   cookie  /**< */,
+                                  xcb_generic_error_t                 **e)
+{
+    return (xcb_screensaver_query_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_screensaver_select_input_checked (xcb_connection_t *c,
+                                      xcb_drawable_t    drawable,
+                                      uint32_t          event_mask)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_screensaver_id,
+        .opcode = XCB_SCREENSAVER_SELECT_INPUT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_screensaver_select_input_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.event_mask = event_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_screensaver_select_input (xcb_connection_t *c,
+                              xcb_drawable_t    drawable,
+                              uint32_t          event_mask)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_screensaver_id,
+        .opcode = XCB_SCREENSAVER_SELECT_INPUT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_screensaver_select_input_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.event_mask = event_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_screensaver_set_attributes_value_list_serialize (void                                              **_buffer,
+                                                     uint32_t                                            value_mask,
+                                                     const xcb_screensaver_set_attributes_value_list_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[16];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(value_mask & XCB_CW_BACK_PIXMAP) {
+        /* xcb_screensaver_set_attributes_value_list_t.background_pixmap */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background_pixmap;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_CW_BACK_PIXEL) {
+        /* xcb_screensaver_set_attributes_value_list_t.background_pixel */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background_pixel;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BORDER_PIXMAP) {
+        /* xcb_screensaver_set_attributes_value_list_t.border_pixmap */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_pixmap;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_CW_BORDER_PIXEL) {
+        /* xcb_screensaver_set_attributes_value_list_t.border_pixel */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_pixel;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BIT_GRAVITY) {
+        /* xcb_screensaver_set_attributes_value_list_t.bit_gravity */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bit_gravity;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_WIN_GRAVITY) {
+        /* xcb_screensaver_set_attributes_value_list_t.win_gravity */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->win_gravity;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BACKING_STORE) {
+        /* xcb_screensaver_set_attributes_value_list_t.backing_store */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_store;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BACKING_PLANES) {
+        /* xcb_screensaver_set_attributes_value_list_t.backing_planes */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_planes;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BACKING_PIXEL) {
+        /* xcb_screensaver_set_attributes_value_list_t.backing_pixel */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_pixel;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_OVERRIDE_REDIRECT) {
+        /* xcb_screensaver_set_attributes_value_list_t.override_redirect */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->override_redirect;
+        xcb_block_len += sizeof(xcb_bool32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_bool32_t);
+    }
+    if(value_mask & XCB_CW_SAVE_UNDER) {
+        /* xcb_screensaver_set_attributes_value_list_t.save_under */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->save_under;
+        xcb_block_len += sizeof(xcb_bool32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_bool32_t);
+    }
+    if(value_mask & XCB_CW_EVENT_MASK) {
+        /* xcb_screensaver_set_attributes_value_list_t.event_mask */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->event_mask;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_DONT_PROPAGATE) {
+        /* xcb_screensaver_set_attributes_value_list_t.do_not_propogate_mask */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->do_not_propogate_mask;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_COLORMAP) {
+        /* xcb_screensaver_set_attributes_value_list_t.colormap */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->colormap;
+        xcb_block_len += sizeof(xcb_colormap_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_colormap_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_colormap_t);
+    }
+    if(value_mask & XCB_CW_CURSOR) {
+        /* xcb_screensaver_set_attributes_value_list_t.cursor */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->cursor;
+        xcb_block_len += sizeof(xcb_cursor_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_cursor_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_cursor_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_screensaver_set_attributes_value_list_unpack (const void                                   *_buffer,
+                                                  uint32_t                                      value_mask,
+                                                  xcb_screensaver_set_attributes_value_list_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if(value_mask & XCB_CW_BACK_PIXMAP) {
+        /* xcb_screensaver_set_attributes_value_list_t.background_pixmap */
+        _aux->background_pixmap = *(xcb_pixmap_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_tmp += sizeof(xcb_pixmap_t);
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_CW_BACK_PIXEL) {
+        /* xcb_screensaver_set_attributes_value_list_t.background_pixel */
+        _aux->background_pixel = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BORDER_PIXMAP) {
+        /* xcb_screensaver_set_attributes_value_list_t.border_pixmap */
+        _aux->border_pixmap = *(xcb_pixmap_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_tmp += sizeof(xcb_pixmap_t);
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_CW_BORDER_PIXEL) {
+        /* xcb_screensaver_set_attributes_value_list_t.border_pixel */
+        _aux->border_pixel = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BIT_GRAVITY) {
+        /* xcb_screensaver_set_attributes_value_list_t.bit_gravity */
+        _aux->bit_gravity = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_WIN_GRAVITY) {
+        /* xcb_screensaver_set_attributes_value_list_t.win_gravity */
+        _aux->win_gravity = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BACKING_STORE) {
+        /* xcb_screensaver_set_attributes_value_list_t.backing_store */
+        _aux->backing_store = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BACKING_PLANES) {
+        /* xcb_screensaver_set_attributes_value_list_t.backing_planes */
+        _aux->backing_planes = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BACKING_PIXEL) {
+        /* xcb_screensaver_set_attributes_value_list_t.backing_pixel */
+        _aux->backing_pixel = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_OVERRIDE_REDIRECT) {
+        /* xcb_screensaver_set_attributes_value_list_t.override_redirect */
+        _aux->override_redirect = *(xcb_bool32_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_bool32_t);
+        xcb_tmp += sizeof(xcb_bool32_t);
+        xcb_align_to = ALIGNOF(xcb_bool32_t);
+    }
+    if(value_mask & XCB_CW_SAVE_UNDER) {
+        /* xcb_screensaver_set_attributes_value_list_t.save_under */
+        _aux->save_under = *(xcb_bool32_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_bool32_t);
+        xcb_tmp += sizeof(xcb_bool32_t);
+        xcb_align_to = ALIGNOF(xcb_bool32_t);
+    }
+    if(value_mask & XCB_CW_EVENT_MASK) {
+        /* xcb_screensaver_set_attributes_value_list_t.event_mask */
+        _aux->event_mask = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_DONT_PROPAGATE) {
+        /* xcb_screensaver_set_attributes_value_list_t.do_not_propogate_mask */
+        _aux->do_not_propogate_mask = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_COLORMAP) {
+        /* xcb_screensaver_set_attributes_value_list_t.colormap */
+        _aux->colormap = *(xcb_colormap_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_colormap_t);
+        xcb_tmp += sizeof(xcb_colormap_t);
+        xcb_align_to = ALIGNOF(xcb_colormap_t);
+    }
+    if(value_mask & XCB_CW_CURSOR) {
+        /* xcb_screensaver_set_attributes_value_list_t.cursor */
+        _aux->cursor = *(xcb_cursor_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_cursor_t);
+        xcb_tmp += sizeof(xcb_cursor_t);
+        xcb_align_to = ALIGNOF(xcb_cursor_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_screensaver_set_attributes_value_list_sizeof (const void  *_buffer,
+                                                  uint32_t     value_mask)
+{
+    xcb_screensaver_set_attributes_value_list_t _aux;
+    return xcb_screensaver_set_attributes_value_list_unpack(_buffer, value_mask, &_aux);
+}
+
+int
+xcb_screensaver_set_attributes_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_screensaver_set_attributes_request_t *_aux = (xcb_screensaver_set_attributes_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_screensaver_set_attributes_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* value_list */
+    xcb_block_len += xcb_screensaver_set_attributes_value_list_sizeof(xcb_tmp, _aux->value_mask);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_screensaver_set_attributes_checked (xcb_connection_t *c,
+                                        xcb_drawable_t    drawable,
+                                        int16_t           x,
+                                        int16_t           y,
+                                        uint16_t          width,
+                                        uint16_t          height,
+                                        uint16_t          border_width,
+                                        uint8_t           _class,
+                                        uint8_t           depth,
+                                        xcb_visualid_t    visual,
+                                        uint32_t          value_mask,
+                                        const void       *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_screensaver_id,
+        .opcode = XCB_SCREENSAVER_SET_ATTRIBUTES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_screensaver_set_attributes_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.x = x;
+    xcb_out.y = y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.border_width = border_width;
+    xcb_out._class = _class;
+    xcb_out.depth = depth;
+    xcb_out.visual = visual;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_screensaver_set_attributes_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_screensaver_set_attributes_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_screensaver_set_attributes (xcb_connection_t *c,
+                                xcb_drawable_t    drawable,
+                                int16_t           x,
+                                int16_t           y,
+                                uint16_t          width,
+                                uint16_t          height,
+                                uint16_t          border_width,
+                                uint8_t           _class,
+                                uint8_t           depth,
+                                xcb_visualid_t    visual,
+                                uint32_t          value_mask,
+                                const void       *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_screensaver_id,
+        .opcode = XCB_SCREENSAVER_SET_ATTRIBUTES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_screensaver_set_attributes_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.x = x;
+    xcb_out.y = y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.border_width = border_width;
+    xcb_out._class = _class;
+    xcb_out.depth = depth;
+    xcb_out.visual = visual;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_screensaver_set_attributes_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_screensaver_set_attributes_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_screensaver_set_attributes_aux_checked (xcb_connection_t                                  *c,
+                                            xcb_drawable_t                                     drawable,
+                                            int16_t                                            x,
+                                            int16_t                                            y,
+                                            uint16_t                                           width,
+                                            uint16_t                                           height,
+                                            uint16_t                                           border_width,
+                                            uint8_t                                            _class,
+                                            uint8_t                                            depth,
+                                            xcb_visualid_t                                     visual,
+                                            uint32_t                                           value_mask,
+                                            const xcb_screensaver_set_attributes_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_screensaver_id,
+        .opcode = XCB_SCREENSAVER_SET_ATTRIBUTES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_screensaver_set_attributes_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.drawable = drawable;
+    xcb_out.x = x;
+    xcb_out.y = y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.border_width = border_width;
+    xcb_out._class = _class;
+    xcb_out.depth = depth;
+    xcb_out.visual = visual;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_screensaver_set_attributes_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_screensaver_set_attributes_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_screensaver_set_attributes_aux (xcb_connection_t                                  *c,
+                                    xcb_drawable_t                                     drawable,
+                                    int16_t                                            x,
+                                    int16_t                                            y,
+                                    uint16_t                                           width,
+                                    uint16_t                                           height,
+                                    uint16_t                                           border_width,
+                                    uint8_t                                            _class,
+                                    uint8_t                                            depth,
+                                    xcb_visualid_t                                     visual,
+                                    uint32_t                                           value_mask,
+                                    const xcb_screensaver_set_attributes_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_screensaver_id,
+        .opcode = XCB_SCREENSAVER_SET_ATTRIBUTES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_screensaver_set_attributes_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.drawable = drawable;
+    xcb_out.x = x;
+    xcb_out.y = y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.border_width = border_width;
+    xcb_out._class = _class;
+    xcb_out.depth = depth;
+    xcb_out.visual = visual;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_screensaver_set_attributes_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_screensaver_set_attributes_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+void *
+xcb_screensaver_set_attributes_value_list (const xcb_screensaver_set_attributes_request_t *R)
+{
+    return (void *) (R + 1);
+}
+
+xcb_void_cookie_t
+xcb_screensaver_unset_attributes_checked (xcb_connection_t *c,
+                                          xcb_drawable_t    drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_screensaver_id,
+        .opcode = XCB_SCREENSAVER_UNSET_ATTRIBUTES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_screensaver_unset_attributes_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_screensaver_unset_attributes (xcb_connection_t *c,
+                                  xcb_drawable_t    drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_screensaver_id,
+        .opcode = XCB_SCREENSAVER_UNSET_ATTRIBUTES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_screensaver_unset_attributes_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_screensaver_suspend_checked (xcb_connection_t *c,
+                                 uint32_t          suspend)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_screensaver_id,
+        .opcode = XCB_SCREENSAVER_SUSPEND,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_screensaver_suspend_request_t xcb_out;
+
+    xcb_out.suspend = suspend;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_screensaver_suspend (xcb_connection_t *c,
+                         uint32_t          suspend)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_screensaver_id,
+        .opcode = XCB_SCREENSAVER_SUSPEND,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_screensaver_suspend_request_t xcb_out;
+
+    xcb_out.suspend = suspend;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
diff --git a/depends/libxcb/src/shape.c b/depends/libxcb/src/shape.c
new file mode 100644
index 0000000..df199f4
--- /dev/null
+++ b/depends/libxcb/src/shape.c
@@ -0,0 +1,768 @@
+/*
+ * This file generated automatically from shape.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "shape.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xproto.h"
+
+xcb_extension_t xcb_shape_id = { "SHAPE", 0 };
+
+void
+xcb_shape_op_next (xcb_shape_op_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_shape_op_t);
+}
+
+xcb_generic_iterator_t
+xcb_shape_op_end (xcb_shape_op_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_shape_kind_next (xcb_shape_kind_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_shape_kind_t);
+}
+
+xcb_generic_iterator_t
+xcb_shape_kind_end (xcb_shape_kind_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+xcb_shape_query_version_cookie_t
+xcb_shape_query_version (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shape_id,
+        .opcode = XCB_SHAPE_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_shape_query_version_cookie_t xcb_ret;
+    xcb_shape_query_version_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_shape_query_version_cookie_t
+xcb_shape_query_version_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shape_id,
+        .opcode = XCB_SHAPE_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_shape_query_version_cookie_t xcb_ret;
+    xcb_shape_query_version_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_shape_query_version_reply_t *
+xcb_shape_query_version_reply (xcb_connection_t                  *c,
+                               xcb_shape_query_version_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_shape_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_shape_rectangles_sizeof (const void  *_buffer,
+                             uint32_t     rectangles_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_shape_rectangles_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* rectangles */
+    xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_rectangle_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_shape_rectangles_checked (xcb_connection_t      *c,
+                              xcb_shape_op_t         operation,
+                              xcb_shape_kind_t       destination_kind,
+                              uint8_t                ordering,
+                              xcb_window_t           destination_window,
+                              int16_t                x_offset,
+                              int16_t                y_offset,
+                              uint32_t               rectangles_len,
+                              const xcb_rectangle_t *rectangles)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_shape_id,
+        .opcode = XCB_SHAPE_RECTANGLES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_shape_rectangles_request_t xcb_out;
+
+    xcb_out.operation = operation;
+    xcb_out.destination_kind = destination_kind;
+    xcb_out.ordering = ordering;
+    xcb_out.pad0 = 0;
+    xcb_out.destination_window = destination_window;
+    xcb_out.x_offset = x_offset;
+    xcb_out.y_offset = y_offset;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_rectangle_t rectangles */
+    xcb_parts[4].iov_base = (char *) rectangles;
+    xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_shape_rectangles (xcb_connection_t      *c,
+                      xcb_shape_op_t         operation,
+                      xcb_shape_kind_t       destination_kind,
+                      uint8_t                ordering,
+                      xcb_window_t           destination_window,
+                      int16_t                x_offset,
+                      int16_t                y_offset,
+                      uint32_t               rectangles_len,
+                      const xcb_rectangle_t *rectangles)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_shape_id,
+        .opcode = XCB_SHAPE_RECTANGLES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_shape_rectangles_request_t xcb_out;
+
+    xcb_out.operation = operation;
+    xcb_out.destination_kind = destination_kind;
+    xcb_out.ordering = ordering;
+    xcb_out.pad0 = 0;
+    xcb_out.destination_window = destination_window;
+    xcb_out.x_offset = x_offset;
+    xcb_out.y_offset = y_offset;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_rectangle_t rectangles */
+    xcb_parts[4].iov_base = (char *) rectangles;
+    xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_rectangle_t *
+xcb_shape_rectangles_rectangles (const xcb_shape_rectangles_request_t *R)
+{
+    return (xcb_rectangle_t *) (R + 1);
+}
+
+int
+xcb_shape_rectangles_rectangles_length (const xcb_shape_rectangles_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_shape_rectangles_request_t))/sizeof(xcb_rectangle_t));
+}
+
+xcb_rectangle_iterator_t
+xcb_shape_rectangles_rectangles_iterator (const xcb_shape_rectangles_request_t *R)
+{
+    xcb_rectangle_iterator_t i;
+    i.data = (xcb_rectangle_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_shape_rectangles_request_t))/sizeof(xcb_rectangle_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_shape_mask_checked (xcb_connection_t *c,
+                        xcb_shape_op_t    operation,
+                        xcb_shape_kind_t  destination_kind,
+                        xcb_window_t      destination_window,
+                        int16_t           x_offset,
+                        int16_t           y_offset,
+                        xcb_pixmap_t      source_bitmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shape_id,
+        .opcode = XCB_SHAPE_MASK,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_shape_mask_request_t xcb_out;
+
+    xcb_out.operation = operation;
+    xcb_out.destination_kind = destination_kind;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.destination_window = destination_window;
+    xcb_out.x_offset = x_offset;
+    xcb_out.y_offset = y_offset;
+    xcb_out.source_bitmap = source_bitmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_shape_mask (xcb_connection_t *c,
+                xcb_shape_op_t    operation,
+                xcb_shape_kind_t  destination_kind,
+                xcb_window_t      destination_window,
+                int16_t           x_offset,
+                int16_t           y_offset,
+                xcb_pixmap_t      source_bitmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shape_id,
+        .opcode = XCB_SHAPE_MASK,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_shape_mask_request_t xcb_out;
+
+    xcb_out.operation = operation;
+    xcb_out.destination_kind = destination_kind;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.destination_window = destination_window;
+    xcb_out.x_offset = x_offset;
+    xcb_out.y_offset = y_offset;
+    xcb_out.source_bitmap = source_bitmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_shape_combine_checked (xcb_connection_t *c,
+                           xcb_shape_op_t    operation,
+                           xcb_shape_kind_t  destination_kind,
+                           xcb_shape_kind_t  source_kind,
+                           xcb_window_t      destination_window,
+                           int16_t           x_offset,
+                           int16_t           y_offset,
+                           xcb_window_t      source_window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shape_id,
+        .opcode = XCB_SHAPE_COMBINE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_shape_combine_request_t xcb_out;
+
+    xcb_out.operation = operation;
+    xcb_out.destination_kind = destination_kind;
+    xcb_out.source_kind = source_kind;
+    xcb_out.pad0 = 0;
+    xcb_out.destination_window = destination_window;
+    xcb_out.x_offset = x_offset;
+    xcb_out.y_offset = y_offset;
+    xcb_out.source_window = source_window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_shape_combine (xcb_connection_t *c,
+                   xcb_shape_op_t    operation,
+                   xcb_shape_kind_t  destination_kind,
+                   xcb_shape_kind_t  source_kind,
+                   xcb_window_t      destination_window,
+                   int16_t           x_offset,
+                   int16_t           y_offset,
+                   xcb_window_t      source_window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shape_id,
+        .opcode = XCB_SHAPE_COMBINE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_shape_combine_request_t xcb_out;
+
+    xcb_out.operation = operation;
+    xcb_out.destination_kind = destination_kind;
+    xcb_out.source_kind = source_kind;
+    xcb_out.pad0 = 0;
+    xcb_out.destination_window = destination_window;
+    xcb_out.x_offset = x_offset;
+    xcb_out.y_offset = y_offset;
+    xcb_out.source_window = source_window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_shape_offset_checked (xcb_connection_t *c,
+                          xcb_shape_kind_t  destination_kind,
+                          xcb_window_t      destination_window,
+                          int16_t           x_offset,
+                          int16_t           y_offset)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shape_id,
+        .opcode = XCB_SHAPE_OFFSET,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_shape_offset_request_t xcb_out;
+
+    xcb_out.destination_kind = destination_kind;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.destination_window = destination_window;
+    xcb_out.x_offset = x_offset;
+    xcb_out.y_offset = y_offset;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_shape_offset (xcb_connection_t *c,
+                  xcb_shape_kind_t  destination_kind,
+                  xcb_window_t      destination_window,
+                  int16_t           x_offset,
+                  int16_t           y_offset)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shape_id,
+        .opcode = XCB_SHAPE_OFFSET,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_shape_offset_request_t xcb_out;
+
+    xcb_out.destination_kind = destination_kind;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.destination_window = destination_window;
+    xcb_out.x_offset = x_offset;
+    xcb_out.y_offset = y_offset;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_shape_query_extents_cookie_t
+xcb_shape_query_extents (xcb_connection_t *c,
+                         xcb_window_t      destination_window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shape_id,
+        .opcode = XCB_SHAPE_QUERY_EXTENTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_shape_query_extents_cookie_t xcb_ret;
+    xcb_shape_query_extents_request_t xcb_out;
+
+    xcb_out.destination_window = destination_window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_shape_query_extents_cookie_t
+xcb_shape_query_extents_unchecked (xcb_connection_t *c,
+                                   xcb_window_t      destination_window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shape_id,
+        .opcode = XCB_SHAPE_QUERY_EXTENTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_shape_query_extents_cookie_t xcb_ret;
+    xcb_shape_query_extents_request_t xcb_out;
+
+    xcb_out.destination_window = destination_window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_shape_query_extents_reply_t *
+xcb_shape_query_extents_reply (xcb_connection_t                  *c,
+                               xcb_shape_query_extents_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_shape_query_extents_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_shape_select_input_checked (xcb_connection_t *c,
+                                xcb_window_t      destination_window,
+                                uint8_t           enable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shape_id,
+        .opcode = XCB_SHAPE_SELECT_INPUT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_shape_select_input_request_t xcb_out;
+
+    xcb_out.destination_window = destination_window;
+    xcb_out.enable = enable;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_shape_select_input (xcb_connection_t *c,
+                        xcb_window_t      destination_window,
+                        uint8_t           enable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shape_id,
+        .opcode = XCB_SHAPE_SELECT_INPUT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_shape_select_input_request_t xcb_out;
+
+    xcb_out.destination_window = destination_window;
+    xcb_out.enable = enable;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_shape_input_selected_cookie_t
+xcb_shape_input_selected (xcb_connection_t *c,
+                          xcb_window_t      destination_window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shape_id,
+        .opcode = XCB_SHAPE_INPUT_SELECTED,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_shape_input_selected_cookie_t xcb_ret;
+    xcb_shape_input_selected_request_t xcb_out;
+
+    xcb_out.destination_window = destination_window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_shape_input_selected_cookie_t
+xcb_shape_input_selected_unchecked (xcb_connection_t *c,
+                                    xcb_window_t      destination_window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shape_id,
+        .opcode = XCB_SHAPE_INPUT_SELECTED,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_shape_input_selected_cookie_t xcb_ret;
+    xcb_shape_input_selected_request_t xcb_out;
+
+    xcb_out.destination_window = destination_window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_shape_input_selected_reply_t *
+xcb_shape_input_selected_reply (xcb_connection_t                   *c,
+                                xcb_shape_input_selected_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e)
+{
+    return (xcb_shape_input_selected_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_shape_get_rectangles_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_shape_get_rectangles_reply_t *_aux = (xcb_shape_get_rectangles_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_shape_get_rectangles_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* rectangles */
+    xcb_block_len += _aux->rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_rectangle_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_shape_get_rectangles_cookie_t
+xcb_shape_get_rectangles (xcb_connection_t *c,
+                          xcb_window_t      window,
+                          xcb_shape_kind_t  source_kind)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shape_id,
+        .opcode = XCB_SHAPE_GET_RECTANGLES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_shape_get_rectangles_cookie_t xcb_ret;
+    xcb_shape_get_rectangles_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.source_kind = source_kind;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_shape_get_rectangles_cookie_t
+xcb_shape_get_rectangles_unchecked (xcb_connection_t *c,
+                                    xcb_window_t      window,
+                                    xcb_shape_kind_t  source_kind)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shape_id,
+        .opcode = XCB_SHAPE_GET_RECTANGLES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_shape_get_rectangles_cookie_t xcb_ret;
+    xcb_shape_get_rectangles_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.source_kind = source_kind;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_rectangle_t *
+xcb_shape_get_rectangles_rectangles (const xcb_shape_get_rectangles_reply_t *R)
+{
+    return (xcb_rectangle_t *) (R + 1);
+}
+
+int
+xcb_shape_get_rectangles_rectangles_length (const xcb_shape_get_rectangles_reply_t *R)
+{
+    return R->rectangles_len;
+}
+
+xcb_rectangle_iterator_t
+xcb_shape_get_rectangles_rectangles_iterator (const xcb_shape_get_rectangles_reply_t *R)
+{
+    xcb_rectangle_iterator_t i;
+    i.data = (xcb_rectangle_t *) (R + 1);
+    i.rem = R->rectangles_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_shape_get_rectangles_reply_t *
+xcb_shape_get_rectangles_reply (xcb_connection_t                   *c,
+                                xcb_shape_get_rectangles_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e)
+{
+    return (xcb_shape_get_rectangles_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
diff --git a/depends/libxcb/src/shm.c b/depends/libxcb/src/shm.c
new file mode 100644
index 0000000..f51c9e5
--- /dev/null
+++ b/depends/libxcb/src/shm.c
@@ -0,0 +1,633 @@
+/*
+ * This file generated automatically from shm.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "shm.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xproto.h"
+
+xcb_extension_t xcb_shm_id = { "MIT-SHM", 0 };
+
+void
+xcb_shm_seg_next (xcb_shm_seg_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_shm_seg_t);
+}
+
+xcb_generic_iterator_t
+xcb_shm_seg_end (xcb_shm_seg_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+xcb_shm_query_version_cookie_t
+xcb_shm_query_version (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shm_id,
+        .opcode = XCB_SHM_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_shm_query_version_cookie_t xcb_ret;
+    xcb_shm_query_version_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_shm_query_version_cookie_t
+xcb_shm_query_version_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shm_id,
+        .opcode = XCB_SHM_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_shm_query_version_cookie_t xcb_ret;
+    xcb_shm_query_version_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_shm_query_version_reply_t *
+xcb_shm_query_version_reply (xcb_connection_t                *c,
+                             xcb_shm_query_version_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_shm_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_shm_attach_checked (xcb_connection_t *c,
+                        xcb_shm_seg_t     shmseg,
+                        uint32_t          shmid,
+                        uint8_t           read_only)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shm_id,
+        .opcode = XCB_SHM_ATTACH,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_shm_attach_request_t xcb_out;
+
+    xcb_out.shmseg = shmseg;
+    xcb_out.shmid = shmid;
+    xcb_out.read_only = read_only;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_shm_attach (xcb_connection_t *c,
+                xcb_shm_seg_t     shmseg,
+                uint32_t          shmid,
+                uint8_t           read_only)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shm_id,
+        .opcode = XCB_SHM_ATTACH,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_shm_attach_request_t xcb_out;
+
+    xcb_out.shmseg = shmseg;
+    xcb_out.shmid = shmid;
+    xcb_out.read_only = read_only;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_shm_detach_checked (xcb_connection_t *c,
+                        xcb_shm_seg_t     shmseg)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shm_id,
+        .opcode = XCB_SHM_DETACH,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_shm_detach_request_t xcb_out;
+
+    xcb_out.shmseg = shmseg;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_shm_detach (xcb_connection_t *c,
+                xcb_shm_seg_t     shmseg)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shm_id,
+        .opcode = XCB_SHM_DETACH,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_shm_detach_request_t xcb_out;
+
+    xcb_out.shmseg = shmseg;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_shm_put_image_checked (xcb_connection_t *c,
+                           xcb_drawable_t    drawable,
+                           xcb_gcontext_t    gc,
+                           uint16_t          total_width,
+                           uint16_t          total_height,
+                           uint16_t          src_x,
+                           uint16_t          src_y,
+                           uint16_t          src_width,
+                           uint16_t          src_height,
+                           int16_t           dst_x,
+                           int16_t           dst_y,
+                           uint8_t           depth,
+                           uint8_t           format,
+                           uint8_t           send_event,
+                           xcb_shm_seg_t     shmseg,
+                           uint32_t          offset)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shm_id,
+        .opcode = XCB_SHM_PUT_IMAGE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_shm_put_image_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.total_width = total_width;
+    xcb_out.total_height = total_height;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+    xcb_out.src_width = src_width;
+    xcb_out.src_height = src_height;
+    xcb_out.dst_x = dst_x;
+    xcb_out.dst_y = dst_y;
+    xcb_out.depth = depth;
+    xcb_out.format = format;
+    xcb_out.send_event = send_event;
+    xcb_out.pad0 = 0;
+    xcb_out.shmseg = shmseg;
+    xcb_out.offset = offset;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_shm_put_image (xcb_connection_t *c,
+                   xcb_drawable_t    drawable,
+                   xcb_gcontext_t    gc,
+                   uint16_t          total_width,
+                   uint16_t          total_height,
+                   uint16_t          src_x,
+                   uint16_t          src_y,
+                   uint16_t          src_width,
+                   uint16_t          src_height,
+                   int16_t           dst_x,
+                   int16_t           dst_y,
+                   uint8_t           depth,
+                   uint8_t           format,
+                   uint8_t           send_event,
+                   xcb_shm_seg_t     shmseg,
+                   uint32_t          offset)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shm_id,
+        .opcode = XCB_SHM_PUT_IMAGE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_shm_put_image_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.total_width = total_width;
+    xcb_out.total_height = total_height;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+    xcb_out.src_width = src_width;
+    xcb_out.src_height = src_height;
+    xcb_out.dst_x = dst_x;
+    xcb_out.dst_y = dst_y;
+    xcb_out.depth = depth;
+    xcb_out.format = format;
+    xcb_out.send_event = send_event;
+    xcb_out.pad0 = 0;
+    xcb_out.shmseg = shmseg;
+    xcb_out.offset = offset;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_shm_get_image_cookie_t
+xcb_shm_get_image (xcb_connection_t *c,
+                   xcb_drawable_t    drawable,
+                   int16_t           x,
+                   int16_t           y,
+                   uint16_t          width,
+                   uint16_t          height,
+                   uint32_t          plane_mask,
+                   uint8_t           format,
+                   xcb_shm_seg_t     shmseg,
+                   uint32_t          offset)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shm_id,
+        .opcode = XCB_SHM_GET_IMAGE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_shm_get_image_cookie_t xcb_ret;
+    xcb_shm_get_image_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.x = x;
+    xcb_out.y = y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.plane_mask = plane_mask;
+    xcb_out.format = format;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.shmseg = shmseg;
+    xcb_out.offset = offset;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_shm_get_image_cookie_t
+xcb_shm_get_image_unchecked (xcb_connection_t *c,
+                             xcb_drawable_t    drawable,
+                             int16_t           x,
+                             int16_t           y,
+                             uint16_t          width,
+                             uint16_t          height,
+                             uint32_t          plane_mask,
+                             uint8_t           format,
+                             xcb_shm_seg_t     shmseg,
+                             uint32_t          offset)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shm_id,
+        .opcode = XCB_SHM_GET_IMAGE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_shm_get_image_cookie_t xcb_ret;
+    xcb_shm_get_image_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.x = x;
+    xcb_out.y = y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.plane_mask = plane_mask;
+    xcb_out.format = format;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.shmseg = shmseg;
+    xcb_out.offset = offset;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_shm_get_image_reply_t *
+xcb_shm_get_image_reply (xcb_connection_t            *c,
+                         xcb_shm_get_image_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e)
+{
+    return (xcb_shm_get_image_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_shm_create_pixmap_checked (xcb_connection_t *c,
+                               xcb_pixmap_t      pid,
+                               xcb_drawable_t    drawable,
+                               uint16_t          width,
+                               uint16_t          height,
+                               uint8_t           depth,
+                               xcb_shm_seg_t     shmseg,
+                               uint32_t          offset)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shm_id,
+        .opcode = XCB_SHM_CREATE_PIXMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_shm_create_pixmap_request_t xcb_out;
+
+    xcb_out.pid = pid;
+    xcb_out.drawable = drawable;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.depth = depth;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.shmseg = shmseg;
+    xcb_out.offset = offset;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_shm_create_pixmap (xcb_connection_t *c,
+                       xcb_pixmap_t      pid,
+                       xcb_drawable_t    drawable,
+                       uint16_t          width,
+                       uint16_t          height,
+                       uint8_t           depth,
+                       xcb_shm_seg_t     shmseg,
+                       uint32_t          offset)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shm_id,
+        .opcode = XCB_SHM_CREATE_PIXMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_shm_create_pixmap_request_t xcb_out;
+
+    xcb_out.pid = pid;
+    xcb_out.drawable = drawable;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.depth = depth;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.shmseg = shmseg;
+    xcb_out.offset = offset;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_shm_attach_fd_checked (xcb_connection_t *c,
+                           xcb_shm_seg_t     shmseg,
+                           int32_t           shm_fd,
+                           uint8_t           read_only)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shm_id,
+        .opcode = XCB_SHM_ATTACH_FD,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_shm_attach_fd_request_t xcb_out;
+    int fds[1];
+    int fd_index = 0;
+
+    xcb_out.shmseg = shmseg;
+    xcb_out.read_only = read_only;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    fds[fd_index++] = shm_fd;
+    xcb_ret.sequence = xcb_send_request_with_fds(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req, 1, fds);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_shm_attach_fd (xcb_connection_t *c,
+                   xcb_shm_seg_t     shmseg,
+                   int32_t           shm_fd,
+                   uint8_t           read_only)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shm_id,
+        .opcode = XCB_SHM_ATTACH_FD,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_shm_attach_fd_request_t xcb_out;
+    int fds[1];
+    int fd_index = 0;
+
+    xcb_out.shmseg = shmseg;
+    xcb_out.read_only = read_only;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    fds[fd_index++] = shm_fd;
+    xcb_ret.sequence = xcb_send_request_with_fds(c, 0, xcb_parts + 2, &xcb_req, 1, fds);
+    return xcb_ret;
+}
+
+xcb_shm_create_segment_cookie_t
+xcb_shm_create_segment (xcb_connection_t *c,
+                        xcb_shm_seg_t     shmseg,
+                        uint32_t          size,
+                        uint8_t           read_only)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shm_id,
+        .opcode = XCB_SHM_CREATE_SEGMENT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_shm_create_segment_cookie_t xcb_ret;
+    xcb_shm_create_segment_request_t xcb_out;
+
+    xcb_out.shmseg = shmseg;
+    xcb_out.size = size;
+    xcb_out.read_only = read_only;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED|XCB_REQUEST_REPLY_FDS, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_shm_create_segment_cookie_t
+xcb_shm_create_segment_unchecked (xcb_connection_t *c,
+                                  xcb_shm_seg_t     shmseg,
+                                  uint32_t          size,
+                                  uint8_t           read_only)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_shm_id,
+        .opcode = XCB_SHM_CREATE_SEGMENT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_shm_create_segment_cookie_t xcb_ret;
+    xcb_shm_create_segment_request_t xcb_out;
+
+    xcb_out.shmseg = shmseg;
+    xcb_out.size = size;
+    xcb_out.read_only = read_only;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_REPLY_FDS, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_shm_create_segment_reply_t *
+xcb_shm_create_segment_reply (xcb_connection_t                 *c,
+                              xcb_shm_create_segment_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_shm_create_segment_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int *
+xcb_shm_create_segment_reply_fds (xcb_connection_t                *c  /**< */,
+                                  xcb_shm_create_segment_reply_t  *reply)
+{
+    return xcb_get_reply_fds(c, reply, sizeof(xcb_shm_create_segment_reply_t) + 4 * reply->length);
+}
+
diff --git a/depends/libxcb/src/sync.c b/depends/libxcb/src/sync.c
new file mode 100644
index 0000000..c19e051
--- /dev/null
+++ b/depends/libxcb/src/sync.c
@@ -0,0 +1,2087 @@
+/*
+ * This file generated automatically from sync.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "sync.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xproto.h"
+
+xcb_extension_t xcb_sync_id = { "SYNC", 0 };
+
+void
+xcb_sync_alarm_next (xcb_sync_alarm_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_sync_alarm_t);
+}
+
+xcb_generic_iterator_t
+xcb_sync_alarm_end (xcb_sync_alarm_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_sync_counter_next (xcb_sync_counter_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_sync_counter_t);
+}
+
+xcb_generic_iterator_t
+xcb_sync_counter_end (xcb_sync_counter_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_sync_fence_next (xcb_sync_fence_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_sync_fence_t);
+}
+
+xcb_generic_iterator_t
+xcb_sync_fence_end (xcb_sync_fence_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_sync_int64_next (xcb_sync_int64_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_sync_int64_t);
+}
+
+xcb_generic_iterator_t
+xcb_sync_int64_end (xcb_sync_int64_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_sync_systemcounter_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_sync_systemcounter_t *_aux = (xcb_sync_systemcounter_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_sync_systemcounter_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->name_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+char *
+xcb_sync_systemcounter_name (const xcb_sync_systemcounter_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_sync_systemcounter_name_length (const xcb_sync_systemcounter_t *R)
+{
+    return R->name_len;
+}
+
+xcb_generic_iterator_t
+xcb_sync_systemcounter_name_end (const xcb_sync_systemcounter_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->name_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_sync_systemcounter_next (xcb_sync_systemcounter_iterator_t *i)
+{
+    xcb_sync_systemcounter_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_sync_systemcounter_t *)(((char *)R) + xcb_sync_systemcounter_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_sync_systemcounter_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_sync_systemcounter_end (xcb_sync_systemcounter_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_sync_systemcounter_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+void
+xcb_sync_trigger_next (xcb_sync_trigger_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_sync_trigger_t);
+}
+
+xcb_generic_iterator_t
+xcb_sync_trigger_end (xcb_sync_trigger_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_sync_waitcondition_next (xcb_sync_waitcondition_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_sync_waitcondition_t);
+}
+
+xcb_generic_iterator_t
+xcb_sync_waitcondition_end (xcb_sync_waitcondition_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+xcb_sync_initialize_cookie_t
+xcb_sync_initialize (xcb_connection_t *c,
+                     uint8_t           desired_major_version,
+                     uint8_t           desired_minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_INITIALIZE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_sync_initialize_cookie_t xcb_ret;
+    xcb_sync_initialize_request_t xcb_out;
+
+    xcb_out.desired_major_version = desired_major_version;
+    xcb_out.desired_minor_version = desired_minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_sync_initialize_cookie_t
+xcb_sync_initialize_unchecked (xcb_connection_t *c,
+                               uint8_t           desired_major_version,
+                               uint8_t           desired_minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_INITIALIZE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_sync_initialize_cookie_t xcb_ret;
+    xcb_sync_initialize_request_t xcb_out;
+
+    xcb_out.desired_major_version = desired_major_version;
+    xcb_out.desired_minor_version = desired_minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_sync_initialize_reply_t *
+xcb_sync_initialize_reply (xcb_connection_t              *c,
+                           xcb_sync_initialize_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e)
+{
+    return (xcb_sync_initialize_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_sync_list_system_counters_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_sync_list_system_counters_reply_t *_aux = (xcb_sync_list_system_counters_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_sync_list_system_counters_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* counters */
+    for(i=0; i<_aux->counters_len; i++) {
+        xcb_tmp_len = xcb_sync_systemcounter_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_sync_systemcounter_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_sync_list_system_counters_cookie_t
+xcb_sync_list_system_counters (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_LIST_SYSTEM_COUNTERS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_sync_list_system_counters_cookie_t xcb_ret;
+    xcb_sync_list_system_counters_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_sync_list_system_counters_cookie_t
+xcb_sync_list_system_counters_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_LIST_SYSTEM_COUNTERS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_sync_list_system_counters_cookie_t xcb_ret;
+    xcb_sync_list_system_counters_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_sync_list_system_counters_counters_length (const xcb_sync_list_system_counters_reply_t *R)
+{
+    return R->counters_len;
+}
+
+xcb_sync_systemcounter_iterator_t
+xcb_sync_list_system_counters_counters_iterator (const xcb_sync_list_system_counters_reply_t *R)
+{
+    xcb_sync_systemcounter_iterator_t i;
+    i.data = (xcb_sync_systemcounter_t *) (R + 1);
+    i.rem = R->counters_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_sync_list_system_counters_reply_t *
+xcb_sync_list_system_counters_reply (xcb_connection_t                        *c,
+                                     xcb_sync_list_system_counters_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e)
+{
+    return (xcb_sync_list_system_counters_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_sync_create_counter_checked (xcb_connection_t   *c,
+                                 xcb_sync_counter_t  id,
+                                 xcb_sync_int64_t    initial_value)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_CREATE_COUNTER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_create_counter_request_t xcb_out;
+
+    xcb_out.id = id;
+    xcb_out.initial_value = initial_value;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_create_counter (xcb_connection_t   *c,
+                         xcb_sync_counter_t  id,
+                         xcb_sync_int64_t    initial_value)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_CREATE_COUNTER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_create_counter_request_t xcb_out;
+
+    xcb_out.id = id;
+    xcb_out.initial_value = initial_value;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_destroy_counter_checked (xcb_connection_t   *c,
+                                  xcb_sync_counter_t  counter)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_DESTROY_COUNTER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_destroy_counter_request_t xcb_out;
+
+    xcb_out.counter = counter;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_destroy_counter (xcb_connection_t   *c,
+                          xcb_sync_counter_t  counter)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_DESTROY_COUNTER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_destroy_counter_request_t xcb_out;
+
+    xcb_out.counter = counter;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_sync_query_counter_cookie_t
+xcb_sync_query_counter (xcb_connection_t   *c,
+                        xcb_sync_counter_t  counter)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_QUERY_COUNTER,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_sync_query_counter_cookie_t xcb_ret;
+    xcb_sync_query_counter_request_t xcb_out;
+
+    xcb_out.counter = counter;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_sync_query_counter_cookie_t
+xcb_sync_query_counter_unchecked (xcb_connection_t   *c,
+                                  xcb_sync_counter_t  counter)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_QUERY_COUNTER,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_sync_query_counter_cookie_t xcb_ret;
+    xcb_sync_query_counter_request_t xcb_out;
+
+    xcb_out.counter = counter;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_sync_query_counter_reply_t *
+xcb_sync_query_counter_reply (xcb_connection_t                 *c,
+                              xcb_sync_query_counter_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_sync_query_counter_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_sync_await_sizeof (const void  *_buffer,
+                       uint32_t     wait_list_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_sync_await_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* wait_list */
+    xcb_block_len += wait_list_len * sizeof(xcb_sync_waitcondition_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_sync_waitcondition_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_sync_await_checked (xcb_connection_t               *c,
+                        uint32_t                        wait_list_len,
+                        const xcb_sync_waitcondition_t *wait_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_AWAIT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_await_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_sync_waitcondition_t wait_list */
+    xcb_parts[4].iov_base = (char *) wait_list;
+    xcb_parts[4].iov_len = wait_list_len * sizeof(xcb_sync_waitcondition_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_await (xcb_connection_t               *c,
+                uint32_t                        wait_list_len,
+                const xcb_sync_waitcondition_t *wait_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_AWAIT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_await_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_sync_waitcondition_t wait_list */
+    xcb_parts[4].iov_base = (char *) wait_list;
+    xcb_parts[4].iov_len = wait_list_len * sizeof(xcb_sync_waitcondition_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_sync_waitcondition_t *
+xcb_sync_await_wait_list (const xcb_sync_await_request_t *R)
+{
+    return (xcb_sync_waitcondition_t *) (R + 1);
+}
+
+int
+xcb_sync_await_wait_list_length (const xcb_sync_await_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_sync_await_request_t))/sizeof(xcb_sync_waitcondition_t));
+}
+
+xcb_sync_waitcondition_iterator_t
+xcb_sync_await_wait_list_iterator (const xcb_sync_await_request_t *R)
+{
+    xcb_sync_waitcondition_iterator_t i;
+    i.data = (xcb_sync_waitcondition_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_sync_await_request_t))/sizeof(xcb_sync_waitcondition_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_sync_change_counter_checked (xcb_connection_t   *c,
+                                 xcb_sync_counter_t  counter,
+                                 xcb_sync_int64_t    amount)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_CHANGE_COUNTER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_change_counter_request_t xcb_out;
+
+    xcb_out.counter = counter;
+    xcb_out.amount = amount;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_change_counter (xcb_connection_t   *c,
+                         xcb_sync_counter_t  counter,
+                         xcb_sync_int64_t    amount)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_CHANGE_COUNTER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_change_counter_request_t xcb_out;
+
+    xcb_out.counter = counter;
+    xcb_out.amount = amount;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_set_counter_checked (xcb_connection_t   *c,
+                              xcb_sync_counter_t  counter,
+                              xcb_sync_int64_t    value)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_SET_COUNTER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_set_counter_request_t xcb_out;
+
+    xcb_out.counter = counter;
+    xcb_out.value = value;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_set_counter (xcb_connection_t   *c,
+                      xcb_sync_counter_t  counter,
+                      xcb_sync_int64_t    value)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_SET_COUNTER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_set_counter_request_t xcb_out;
+
+    xcb_out.counter = counter;
+    xcb_out.value = value;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_sync_create_alarm_value_list_serialize (void                                     **_buffer,
+                                            uint32_t                                   value_mask,
+                                            const xcb_sync_create_alarm_value_list_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[7];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(value_mask & XCB_SYNC_CA_COUNTER) {
+        /* xcb_sync_create_alarm_value_list_t.counter */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->counter;
+        xcb_block_len += sizeof(xcb_sync_counter_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_counter_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_sync_counter_t);
+    }
+    if(value_mask & XCB_SYNC_CA_VALUE_TYPE) {
+        /* xcb_sync_create_alarm_value_list_t.valueType */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valueType;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_SYNC_CA_VALUE) {
+        /* xcb_sync_create_alarm_value_list_t.value */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->value;
+        xcb_block_len += sizeof(xcb_sync_int64_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_int64_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_sync_int64_t);
+    }
+    if(value_mask & XCB_SYNC_CA_TEST_TYPE) {
+        /* xcb_sync_create_alarm_value_list_t.testType */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->testType;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_SYNC_CA_DELTA) {
+        /* xcb_sync_create_alarm_value_list_t.delta */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->delta;
+        xcb_block_len += sizeof(xcb_sync_int64_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_int64_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_sync_int64_t);
+    }
+    if(value_mask & XCB_SYNC_CA_EVENTS) {
+        /* xcb_sync_create_alarm_value_list_t.events */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->events;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_sync_create_alarm_value_list_unpack (const void                          *_buffer,
+                                         uint32_t                             value_mask,
+                                         xcb_sync_create_alarm_value_list_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if(value_mask & XCB_SYNC_CA_COUNTER) {
+        /* xcb_sync_create_alarm_value_list_t.counter */
+        _aux->counter = *(xcb_sync_counter_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_sync_counter_t);
+        xcb_tmp += sizeof(xcb_sync_counter_t);
+        xcb_align_to = ALIGNOF(xcb_sync_counter_t);
+    }
+    if(value_mask & XCB_SYNC_CA_VALUE_TYPE) {
+        /* xcb_sync_create_alarm_value_list_t.valueType */
+        _aux->valueType = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_SYNC_CA_VALUE) {
+        /* xcb_sync_create_alarm_value_list_t.value */
+        _aux->value = *(xcb_sync_int64_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_sync_int64_t);
+        xcb_tmp += sizeof(xcb_sync_int64_t);
+        xcb_align_to = ALIGNOF(xcb_sync_int64_t);
+    }
+    if(value_mask & XCB_SYNC_CA_TEST_TYPE) {
+        /* xcb_sync_create_alarm_value_list_t.testType */
+        _aux->testType = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_SYNC_CA_DELTA) {
+        /* xcb_sync_create_alarm_value_list_t.delta */
+        _aux->delta = *(xcb_sync_int64_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_sync_int64_t);
+        xcb_tmp += sizeof(xcb_sync_int64_t);
+        xcb_align_to = ALIGNOF(xcb_sync_int64_t);
+    }
+    if(value_mask & XCB_SYNC_CA_EVENTS) {
+        /* xcb_sync_create_alarm_value_list_t.events */
+        _aux->events = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_sync_create_alarm_value_list_sizeof (const void  *_buffer,
+                                         uint32_t     value_mask)
+{
+    xcb_sync_create_alarm_value_list_t _aux;
+    return xcb_sync_create_alarm_value_list_unpack(_buffer, value_mask, &_aux);
+}
+
+int
+xcb_sync_create_alarm_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_sync_create_alarm_request_t *_aux = (xcb_sync_create_alarm_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_sync_create_alarm_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* value_list */
+    xcb_block_len += xcb_sync_create_alarm_value_list_sizeof(xcb_tmp, _aux->value_mask);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_sync_create_alarm_checked (xcb_connection_t *c,
+                               xcb_sync_alarm_t  id,
+                               uint32_t          value_mask,
+                               const void       *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_CREATE_ALARM,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_create_alarm_request_t xcb_out;
+
+    xcb_out.id = id;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_sync_create_alarm_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_sync_create_alarm_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_create_alarm (xcb_connection_t *c,
+                       xcb_sync_alarm_t  id,
+                       uint32_t          value_mask,
+                       const void       *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_CREATE_ALARM,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_create_alarm_request_t xcb_out;
+
+    xcb_out.id = id;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_sync_create_alarm_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_sync_create_alarm_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_create_alarm_aux_checked (xcb_connection_t                         *c,
+                                   xcb_sync_alarm_t                          id,
+                                   uint32_t                                  value_mask,
+                                   const xcb_sync_create_alarm_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_CREATE_ALARM,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_create_alarm_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.id = id;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_sync_create_alarm_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_sync_create_alarm_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_create_alarm_aux (xcb_connection_t                         *c,
+                           xcb_sync_alarm_t                          id,
+                           uint32_t                                  value_mask,
+                           const xcb_sync_create_alarm_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_CREATE_ALARM,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_create_alarm_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.id = id;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_sync_create_alarm_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_sync_create_alarm_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+void *
+xcb_sync_create_alarm_value_list (const xcb_sync_create_alarm_request_t *R)
+{
+    return (void *) (R + 1);
+}
+
+int
+xcb_sync_change_alarm_value_list_serialize (void                                     **_buffer,
+                                            uint32_t                                   value_mask,
+                                            const xcb_sync_change_alarm_value_list_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[7];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(value_mask & XCB_SYNC_CA_COUNTER) {
+        /* xcb_sync_change_alarm_value_list_t.counter */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->counter;
+        xcb_block_len += sizeof(xcb_sync_counter_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_counter_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_sync_counter_t);
+    }
+    if(value_mask & XCB_SYNC_CA_VALUE_TYPE) {
+        /* xcb_sync_change_alarm_value_list_t.valueType */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valueType;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_SYNC_CA_VALUE) {
+        /* xcb_sync_change_alarm_value_list_t.value */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->value;
+        xcb_block_len += sizeof(xcb_sync_int64_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_int64_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_sync_int64_t);
+    }
+    if(value_mask & XCB_SYNC_CA_TEST_TYPE) {
+        /* xcb_sync_change_alarm_value_list_t.testType */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->testType;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_SYNC_CA_DELTA) {
+        /* xcb_sync_change_alarm_value_list_t.delta */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->delta;
+        xcb_block_len += sizeof(xcb_sync_int64_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_int64_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_sync_int64_t);
+    }
+    if(value_mask & XCB_SYNC_CA_EVENTS) {
+        /* xcb_sync_change_alarm_value_list_t.events */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->events;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_sync_change_alarm_value_list_unpack (const void                          *_buffer,
+                                         uint32_t                             value_mask,
+                                         xcb_sync_change_alarm_value_list_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if(value_mask & XCB_SYNC_CA_COUNTER) {
+        /* xcb_sync_change_alarm_value_list_t.counter */
+        _aux->counter = *(xcb_sync_counter_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_sync_counter_t);
+        xcb_tmp += sizeof(xcb_sync_counter_t);
+        xcb_align_to = ALIGNOF(xcb_sync_counter_t);
+    }
+    if(value_mask & XCB_SYNC_CA_VALUE_TYPE) {
+        /* xcb_sync_change_alarm_value_list_t.valueType */
+        _aux->valueType = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_SYNC_CA_VALUE) {
+        /* xcb_sync_change_alarm_value_list_t.value */
+        _aux->value = *(xcb_sync_int64_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_sync_int64_t);
+        xcb_tmp += sizeof(xcb_sync_int64_t);
+        xcb_align_to = ALIGNOF(xcb_sync_int64_t);
+    }
+    if(value_mask & XCB_SYNC_CA_TEST_TYPE) {
+        /* xcb_sync_change_alarm_value_list_t.testType */
+        _aux->testType = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_SYNC_CA_DELTA) {
+        /* xcb_sync_change_alarm_value_list_t.delta */
+        _aux->delta = *(xcb_sync_int64_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_sync_int64_t);
+        xcb_tmp += sizeof(xcb_sync_int64_t);
+        xcb_align_to = ALIGNOF(xcb_sync_int64_t);
+    }
+    if(value_mask & XCB_SYNC_CA_EVENTS) {
+        /* xcb_sync_change_alarm_value_list_t.events */
+        _aux->events = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_sync_change_alarm_value_list_sizeof (const void  *_buffer,
+                                         uint32_t     value_mask)
+{
+    xcb_sync_change_alarm_value_list_t _aux;
+    return xcb_sync_change_alarm_value_list_unpack(_buffer, value_mask, &_aux);
+}
+
+int
+xcb_sync_change_alarm_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_sync_change_alarm_request_t *_aux = (xcb_sync_change_alarm_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_sync_change_alarm_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* value_list */
+    xcb_block_len += xcb_sync_change_alarm_value_list_sizeof(xcb_tmp, _aux->value_mask);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_sync_change_alarm_checked (xcb_connection_t *c,
+                               xcb_sync_alarm_t  id,
+                               uint32_t          value_mask,
+                               const void       *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_CHANGE_ALARM,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_change_alarm_request_t xcb_out;
+
+    xcb_out.id = id;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_sync_change_alarm_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_sync_change_alarm_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_change_alarm (xcb_connection_t *c,
+                       xcb_sync_alarm_t  id,
+                       uint32_t          value_mask,
+                       const void       *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_CHANGE_ALARM,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_change_alarm_request_t xcb_out;
+
+    xcb_out.id = id;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_sync_change_alarm_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_sync_change_alarm_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_change_alarm_aux_checked (xcb_connection_t                         *c,
+                                   xcb_sync_alarm_t                          id,
+                                   uint32_t                                  value_mask,
+                                   const xcb_sync_change_alarm_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_CHANGE_ALARM,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_change_alarm_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.id = id;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_sync_change_alarm_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_sync_change_alarm_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_change_alarm_aux (xcb_connection_t                         *c,
+                           xcb_sync_alarm_t                          id,
+                           uint32_t                                  value_mask,
+                           const xcb_sync_change_alarm_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_CHANGE_ALARM,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_change_alarm_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.id = id;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_sync_change_alarm_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_sync_change_alarm_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+void *
+xcb_sync_change_alarm_value_list (const xcb_sync_change_alarm_request_t *R)
+{
+    return (void *) (R + 1);
+}
+
+xcb_void_cookie_t
+xcb_sync_destroy_alarm_checked (xcb_connection_t *c,
+                                xcb_sync_alarm_t  alarm)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_DESTROY_ALARM,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_destroy_alarm_request_t xcb_out;
+
+    xcb_out.alarm = alarm;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_destroy_alarm (xcb_connection_t *c,
+                        xcb_sync_alarm_t  alarm)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_DESTROY_ALARM,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_destroy_alarm_request_t xcb_out;
+
+    xcb_out.alarm = alarm;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_sync_query_alarm_cookie_t
+xcb_sync_query_alarm (xcb_connection_t *c,
+                      xcb_sync_alarm_t  alarm)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_QUERY_ALARM,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_sync_query_alarm_cookie_t xcb_ret;
+    xcb_sync_query_alarm_request_t xcb_out;
+
+    xcb_out.alarm = alarm;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_sync_query_alarm_cookie_t
+xcb_sync_query_alarm_unchecked (xcb_connection_t *c,
+                                xcb_sync_alarm_t  alarm)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_QUERY_ALARM,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_sync_query_alarm_cookie_t xcb_ret;
+    xcb_sync_query_alarm_request_t xcb_out;
+
+    xcb_out.alarm = alarm;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_sync_query_alarm_reply_t *
+xcb_sync_query_alarm_reply (xcb_connection_t               *c,
+                            xcb_sync_query_alarm_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e)
+{
+    return (xcb_sync_query_alarm_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_sync_set_priority_checked (xcb_connection_t *c,
+                               uint32_t          id,
+                               int32_t           priority)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_SET_PRIORITY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_set_priority_request_t xcb_out;
+
+    xcb_out.id = id;
+    xcb_out.priority = priority;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_set_priority (xcb_connection_t *c,
+                       uint32_t          id,
+                       int32_t           priority)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_SET_PRIORITY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_set_priority_request_t xcb_out;
+
+    xcb_out.id = id;
+    xcb_out.priority = priority;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_sync_get_priority_cookie_t
+xcb_sync_get_priority (xcb_connection_t *c,
+                       uint32_t          id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_GET_PRIORITY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_sync_get_priority_cookie_t xcb_ret;
+    xcb_sync_get_priority_request_t xcb_out;
+
+    xcb_out.id = id;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_sync_get_priority_cookie_t
+xcb_sync_get_priority_unchecked (xcb_connection_t *c,
+                                 uint32_t          id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_GET_PRIORITY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_sync_get_priority_cookie_t xcb_ret;
+    xcb_sync_get_priority_request_t xcb_out;
+
+    xcb_out.id = id;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_sync_get_priority_reply_t *
+xcb_sync_get_priority_reply (xcb_connection_t                *c,
+                             xcb_sync_get_priority_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_sync_get_priority_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_sync_create_fence_checked (xcb_connection_t *c,
+                               xcb_drawable_t    drawable,
+                               xcb_sync_fence_t  fence,
+                               uint8_t           initially_triggered)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_CREATE_FENCE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_create_fence_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.fence = fence;
+    xcb_out.initially_triggered = initially_triggered;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_create_fence (xcb_connection_t *c,
+                       xcb_drawable_t    drawable,
+                       xcb_sync_fence_t  fence,
+                       uint8_t           initially_triggered)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_CREATE_FENCE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_create_fence_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.fence = fence;
+    xcb_out.initially_triggered = initially_triggered;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_trigger_fence_checked (xcb_connection_t *c,
+                                xcb_sync_fence_t  fence)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_TRIGGER_FENCE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_trigger_fence_request_t xcb_out;
+
+    xcb_out.fence = fence;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_trigger_fence (xcb_connection_t *c,
+                        xcb_sync_fence_t  fence)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_TRIGGER_FENCE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_trigger_fence_request_t xcb_out;
+
+    xcb_out.fence = fence;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_reset_fence_checked (xcb_connection_t *c,
+                              xcb_sync_fence_t  fence)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_RESET_FENCE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_reset_fence_request_t xcb_out;
+
+    xcb_out.fence = fence;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_reset_fence (xcb_connection_t *c,
+                      xcb_sync_fence_t  fence)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_RESET_FENCE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_reset_fence_request_t xcb_out;
+
+    xcb_out.fence = fence;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_destroy_fence_checked (xcb_connection_t *c,
+                                xcb_sync_fence_t  fence)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_DESTROY_FENCE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_destroy_fence_request_t xcb_out;
+
+    xcb_out.fence = fence;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_destroy_fence (xcb_connection_t *c,
+                        xcb_sync_fence_t  fence)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_DESTROY_FENCE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_destroy_fence_request_t xcb_out;
+
+    xcb_out.fence = fence;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_sync_query_fence_cookie_t
+xcb_sync_query_fence (xcb_connection_t *c,
+                      xcb_sync_fence_t  fence)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_QUERY_FENCE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_sync_query_fence_cookie_t xcb_ret;
+    xcb_sync_query_fence_request_t xcb_out;
+
+    xcb_out.fence = fence;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_sync_query_fence_cookie_t
+xcb_sync_query_fence_unchecked (xcb_connection_t *c,
+                                xcb_sync_fence_t  fence)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_QUERY_FENCE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_sync_query_fence_cookie_t xcb_ret;
+    xcb_sync_query_fence_request_t xcb_out;
+
+    xcb_out.fence = fence;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_sync_query_fence_reply_t *
+xcb_sync_query_fence_reply (xcb_connection_t               *c,
+                            xcb_sync_query_fence_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e)
+{
+    return (xcb_sync_query_fence_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_sync_await_fence_sizeof (const void  *_buffer,
+                             uint32_t     fence_list_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_sync_await_fence_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* fence_list */
+    xcb_block_len += fence_list_len * sizeof(xcb_sync_fence_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_sync_fence_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_sync_await_fence_checked (xcb_connection_t       *c,
+                              uint32_t                fence_list_len,
+                              const xcb_sync_fence_t *fence_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_AWAIT_FENCE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_await_fence_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_sync_fence_t fence_list */
+    xcb_parts[4].iov_base = (char *) fence_list;
+    xcb_parts[4].iov_len = fence_list_len * sizeof(xcb_sync_fence_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_sync_await_fence (xcb_connection_t       *c,
+                      uint32_t                fence_list_len,
+                      const xcb_sync_fence_t *fence_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_sync_id,
+        .opcode = XCB_SYNC_AWAIT_FENCE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_sync_await_fence_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_sync_fence_t fence_list */
+    xcb_parts[4].iov_base = (char *) fence_list;
+    xcb_parts[4].iov_len = fence_list_len * sizeof(xcb_sync_fence_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_sync_fence_t *
+xcb_sync_await_fence_fence_list (const xcb_sync_await_fence_request_t *R)
+{
+    return (xcb_sync_fence_t *) (R + 1);
+}
+
+int
+xcb_sync_await_fence_fence_list_length (const xcb_sync_await_fence_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_sync_await_fence_request_t))/sizeof(xcb_sync_fence_t));
+}
+
+xcb_generic_iterator_t
+xcb_sync_await_fence_fence_list_end (const xcb_sync_await_fence_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_sync_fence_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_sync_await_fence_request_t))/sizeof(xcb_sync_fence_t)));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
diff --git a/depends/libxcb/src/xc_misc.c b/depends/libxcb/src/xc_misc.c
new file mode 100644
index 0000000..2ce38b6
--- /dev/null
+++ b/depends/libxcb/src/xc_misc.c
@@ -0,0 +1,252 @@
+/*
+ * This file generated automatically from xc_misc.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "xc_misc.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+
+xcb_extension_t xcb_xc_misc_id = { "XC-MISC", 0 };
+
+xcb_xc_misc_get_version_cookie_t
+xcb_xc_misc_get_version (xcb_connection_t *c,
+                         uint16_t          client_major_version,
+                         uint16_t          client_minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xc_misc_id,
+        .opcode = XCB_XC_MISC_GET_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xc_misc_get_version_cookie_t xcb_ret;
+    xcb_xc_misc_get_version_request_t xcb_out;
+
+    xcb_out.client_major_version = client_major_version;
+    xcb_out.client_minor_version = client_minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xc_misc_get_version_cookie_t
+xcb_xc_misc_get_version_unchecked (xcb_connection_t *c,
+                                   uint16_t          client_major_version,
+                                   uint16_t          client_minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xc_misc_id,
+        .opcode = XCB_XC_MISC_GET_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xc_misc_get_version_cookie_t xcb_ret;
+    xcb_xc_misc_get_version_request_t xcb_out;
+
+    xcb_out.client_major_version = client_major_version;
+    xcb_out.client_minor_version = client_minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xc_misc_get_version_reply_t *
+xcb_xc_misc_get_version_reply (xcb_connection_t                  *c,
+                               xcb_xc_misc_get_version_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_xc_misc_get_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_xc_misc_get_xid_range_cookie_t
+xcb_xc_misc_get_xid_range (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xc_misc_id,
+        .opcode = XCB_XC_MISC_GET_XID_RANGE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xc_misc_get_xid_range_cookie_t xcb_ret;
+    xcb_xc_misc_get_xid_range_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xc_misc_get_xid_range_cookie_t
+xcb_xc_misc_get_xid_range_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xc_misc_id,
+        .opcode = XCB_XC_MISC_GET_XID_RANGE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xc_misc_get_xid_range_cookie_t xcb_ret;
+    xcb_xc_misc_get_xid_range_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xc_misc_get_xid_range_reply_t *
+xcb_xc_misc_get_xid_range_reply (xcb_connection_t                    *c,
+                                 xcb_xc_misc_get_xid_range_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e)
+{
+    return (xcb_xc_misc_get_xid_range_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xc_misc_get_xid_list_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xc_misc_get_xid_list_reply_t *_aux = (xcb_xc_misc_get_xid_list_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xc_misc_get_xid_list_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* ids */
+    xcb_block_len += _aux->ids_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xc_misc_get_xid_list_cookie_t
+xcb_xc_misc_get_xid_list (xcb_connection_t *c,
+                          uint32_t          count)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xc_misc_id,
+        .opcode = XCB_XC_MISC_GET_XID_LIST,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xc_misc_get_xid_list_cookie_t xcb_ret;
+    xcb_xc_misc_get_xid_list_request_t xcb_out;
+
+    xcb_out.count = count;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xc_misc_get_xid_list_cookie_t
+xcb_xc_misc_get_xid_list_unchecked (xcb_connection_t *c,
+                                    uint32_t          count)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xc_misc_id,
+        .opcode = XCB_XC_MISC_GET_XID_LIST,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xc_misc_get_xid_list_cookie_t xcb_ret;
+    xcb_xc_misc_get_xid_list_request_t xcb_out;
+
+    xcb_out.count = count;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_xc_misc_get_xid_list_ids (const xcb_xc_misc_get_xid_list_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_xc_misc_get_xid_list_ids_length (const xcb_xc_misc_get_xid_list_reply_t *R)
+{
+    return R->ids_len;
+}
+
+xcb_generic_iterator_t
+xcb_xc_misc_get_xid_list_ids_end (const xcb_xc_misc_get_xid_list_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->ids_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xc_misc_get_xid_list_reply_t *
+xcb_xc_misc_get_xid_list_reply (xcb_connection_t                   *c,
+                                xcb_xc_misc_get_xid_list_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e)
+{
+    return (xcb_xc_misc_get_xid_list_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
diff --git a/depends/libxcb/src/xcb_auth.c b/depends/libxcb/src/xcb_auth.c
new file mode 100644
index 0000000..8ebe9a4
--- /dev/null
+++ b/depends/libxcb/src/xcb_auth.c
@@ -0,0 +1,388 @@
+/* Copyright (C) 2001-2004 Bart Massey and Jamey Sharp.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the names of the authors or their
+ * institutions shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the authors.
+ */
+
+/* Authorization systems for the X protocol. */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <assert.h>
+#include <X11/Xauth.h>
+#include <stdlib.h>
+#include <time.h>
+
+#ifdef __INTERIX
+/* _don't_ ask. interix has INADDR_LOOPBACK in here. */
+#include <rpc/types.h>
+#endif
+
+#ifdef _WIN32
+#ifdef HASXDMAUTH
+/* We must include the wrapped windows.h before any system header which includes
+   it unwrapped, to avoid conflicts with types defined in X headers */
+#include <X11/Xwindows.h>
+#endif
+#include "xcb_windefs.h"
+#else
+#include <sys/param.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/un.h>
+#endif /* _WIN32 */
+
+#include "xcb.h"
+#include "xcbint.h"
+
+#ifdef HASXDMAUTH
+#include <X11/Xdmcp.h>
+#endif
+
+enum auth_protos {
+#ifdef HASXDMAUTH
+    AUTH_XA1,
+#endif
+    AUTH_MC1,
+    N_AUTH_PROTOS
+};
+
+#define AUTH_PROTO_XDM_AUTHORIZATION "XDM-AUTHORIZATION-1"
+#define AUTH_PROTO_MIT_MAGIC_COOKIE "MIT-MAGIC-COOKIE-1"
+
+static char *authnames[N_AUTH_PROTOS] = {
+#ifdef HASXDMAUTH
+    AUTH_PROTO_XDM_AUTHORIZATION,
+#endif
+    AUTH_PROTO_MIT_MAGIC_COOKIE,
+};
+
+static int authnameslen[N_AUTH_PROTOS] = {
+#ifdef HASXDMAUTH
+    sizeof(AUTH_PROTO_XDM_AUTHORIZATION) - 1,
+#endif
+    sizeof(AUTH_PROTO_MIT_MAGIC_COOKIE) - 1,
+};
+
+static size_t memdup(char **dst, void *src, size_t len)
+{
+    if(len)
+        *dst = malloc(len);
+    else
+        *dst = 0;
+    if(!*dst)
+        return 0;
+    memcpy(*dst, src, len);
+    return len;
+}
+
+static int authname_match(enum auth_protos kind, char *name, size_t namelen)
+{
+    if(authnameslen[kind] != namelen)
+        return 0;
+    if(memcmp(authnames[kind], name, namelen))
+        return 0;
+    return 1;
+}
+
+#define SIN6_ADDR(s) (&((struct sockaddr_in6 *)s)->sin6_addr)
+
+static Xauth *get_authptr(struct sockaddr *sockname, int display)
+{
+    char *addr = 0;
+    int addrlen = 0;
+    unsigned short family;
+    char hostnamebuf[256];   /* big enough for max hostname */
+    char dispbuf[40];   /* big enough to hold more than 2^64 base 10 */
+    int dispbuflen;
+
+    family = FamilyLocal; /* 256 */
+    switch(sockname->sa_family)
+    {
+#ifdef AF_INET6
+    case AF_INET6:
+        addr = (char *) SIN6_ADDR(sockname);
+        addrlen = sizeof(*SIN6_ADDR(sockname));
+        if(!IN6_IS_ADDR_V4MAPPED(SIN6_ADDR(sockname)))
+        {
+            if(!IN6_IS_ADDR_LOOPBACK(SIN6_ADDR(sockname)))
+                family = XCB_FAMILY_INTERNET_6;
+            break;
+        }
+        addr += 12;
+        /* if v4-mapped, fall through. */
+        XCB_ALLOW_FALLTHRU
+#endif
+    case AF_INET:
+        if(!addr)
+            addr = (char *) &((struct sockaddr_in *)sockname)->sin_addr;
+        addrlen = sizeof(((struct sockaddr_in *)sockname)->sin_addr);
+        if(*(in_addr_t *) addr != htonl(INADDR_LOOPBACK))
+            family = XCB_FAMILY_INTERNET;
+        break;
+    case AF_UNIX:
+        break;
+    default:
+        return 0;   /* cannot authenticate this family */
+    }
+
+    dispbuflen = snprintf(dispbuf, sizeof(dispbuf), "%d", display);
+    if(dispbuflen < 0)
+        return 0;
+    /* snprintf may have truncate our text */
+    dispbuflen = MIN(dispbuflen, sizeof(dispbuf) - 1);
+
+    if (family == FamilyLocal) {
+        if (gethostname(hostnamebuf, sizeof(hostnamebuf)) == -1)
+            return 0;   /* do not know own hostname */
+        addr = hostnamebuf;
+        addrlen = strlen(addr);
+    }
+
+    return XauGetBestAuthByAddr (family,
+                                 (unsigned short) addrlen, addr,
+                                 (unsigned short) dispbuflen, dispbuf,
+                                 N_AUTH_PROTOS, authnames, authnameslen);
+}
+
+#ifdef HASXDMAUTH
+static int next_nonce(void)
+{
+    static int nonce = 0;
+    static pthread_mutex_t nonce_mutex = PTHREAD_MUTEX_INITIALIZER;
+    int ret;
+    pthread_mutex_lock(&nonce_mutex);
+    ret = nonce++;
+    pthread_mutex_unlock(&nonce_mutex);
+    return ret;
+}
+
+static void do_append(char *buf, int *idxp, void *val, size_t valsize) {
+    memcpy(buf + *idxp, val, valsize);
+    *idxp += valsize;
+}
+#endif
+
+static int compute_auth(xcb_auth_info_t *info, Xauth *authptr, struct sockaddr *sockname)
+{
+    if (authname_match(AUTH_MC1, authptr->name, authptr->name_length)) {
+        info->datalen = memdup(&info->data, authptr->data, authptr->data_length);
+        if(!info->datalen)
+            return 0;
+        return 1;
+    }
+#ifdef HASXDMAUTH
+#define APPEND(buf,idx,val) do_append((buf),&(idx),&(val),sizeof(val))
+    if (authname_match(AUTH_XA1, authptr->name, authptr->name_length)) {
+        int j;
+
+        info->data = malloc(192 / 8);
+        if(!info->data)
+            return 0;
+
+        for (j = 0; j < 8; j++)
+            info->data[j] = authptr->data[j];
+        switch(sockname->sa_family) {
+        case AF_INET:
+            /*block*/ {
+            struct sockaddr_in *si = (struct sockaddr_in *) sockname;
+            APPEND(info->data, j, si->sin_addr.s_addr);
+            APPEND(info->data, j, si->sin_port);
+        }
+        break;
+#ifdef AF_INET6
+        case AF_INET6:
+            /*block*/ {
+            struct sockaddr_in6 *si6 = (struct sockaddr_in6 *) sockname;
+            if(IN6_IS_ADDR_V4MAPPED(SIN6_ADDR(sockname)))
+            {
+                do_append(info->data, &j, &si6->sin6_addr.s6_addr[12], 4);
+                APPEND(info->data, j, si6->sin6_port);
+            }
+            else
+            {
+                /* XDM-AUTHORIZATION-1 does not handle IPv6 correctly.  Do the
+                   same thing Xlib does: use all zeroes for the 4-byte address
+                   and 2-byte port number. */
+                uint32_t fakeaddr = 0;
+                uint16_t fakeport = 0;
+                APPEND(info->data, j, fakeaddr);
+                APPEND(info->data, j, fakeport);
+            }
+        }
+        break;
+#endif
+        case AF_UNIX:
+            /*block*/ {
+            uint32_t fakeaddr = htonl(0xffffffff - next_nonce());
+            uint16_t fakeport = htons(getpid());
+            APPEND(info->data, j, fakeaddr);
+            APPEND(info->data, j, fakeport);
+        }
+        break;
+        default:
+            free(info->data);
+            return 0;   /* do not know how to build this */
+        }
+        {
+            uint32_t now = htonl(time(0));
+            APPEND(info->data, j, now);
+        }
+        assert(j <= 192 / 8);
+        while (j < 192 / 8)
+            info->data[j++] = 0;
+        info->datalen = j;
+        XdmcpWrap ((unsigned char *) info->data, (unsigned char *) authptr->data + 8, (unsigned char *) info->data, info->datalen);
+        return 1;
+    }
+#undef APPEND
+#endif
+
+    return 0;   /* Unknown authorization type */
+}
+
+/* `sockaddr_un.sun_path' typical size usually ranges between 92 and 108 */
+#define INITIAL_SOCKNAME_SLACK 108
+
+/* Return a dynamically allocated socket address structure according
+   to the value returned by either getpeername() or getsockname()
+   (according to POSIX, applications should not assume a particular
+   length for `sockaddr_un.sun_path') */
+#ifdef _WIN32
+static struct sockaddr *get_peer_sock_name(int(_stdcall *socket_func)(SOCKET,
+    struct sockaddr *,
+    socklen_t *),
+    int fd)
+#else
+static struct sockaddr *get_peer_sock_name(int (*socket_func)(int,
+                                                              struct sockaddr *,
+                                                              socklen_t *),
+                                           int fd)
+#endif
+{
+    socklen_t socknamelen = sizeof(struct sockaddr) + INITIAL_SOCKNAME_SLACK;
+    socklen_t actual_socknamelen = socknamelen;
+    struct sockaddr *sockname = malloc(socknamelen);
+
+    if (sockname == NULL)
+        return NULL;
+
+    /* Both getpeername() and getsockname() truncates sockname if
+       there is not enough space and set the required length in
+       actual_socknamelen */
+    if (socket_func(fd, sockname, &actual_socknamelen) == -1)
+        goto sock_or_realloc_error;
+
+    if (actual_socknamelen > socknamelen)
+    {
+        struct sockaddr *new_sockname = NULL;
+        socknamelen = actual_socknamelen;
+
+        if ((new_sockname = realloc(sockname, actual_socknamelen)) == NULL)
+            goto sock_or_realloc_error;
+
+        sockname = new_sockname;
+
+        if (socket_func(fd, sockname, &actual_socknamelen) == -1 ||
+            actual_socknamelen > socknamelen)
+            goto sock_or_realloc_error;
+    }
+
+    return sockname;
+
+ sock_or_realloc_error:
+    free(sockname);
+    return NULL;
+}
+
+int _xcb_get_auth_info(int fd, xcb_auth_info_t *info, int display)
+{
+    /* code adapted from Xlib/ConnDis.c, xtrans/Xtranssocket.c,
+       xtrans/Xtransutils.c */
+    struct sockaddr *sockname = NULL;
+    int gotsockname = 0;
+    Xauth *authptr = 0;
+    int ret = 1;
+
+    /* Some systems like hpux or Hurd do not expose peer names
+     * for UNIX Domain Sockets, but this is irrelevant,
+     * since compute_auth() ignores the peer name in this
+     * case anyway.*/
+    if ((sockname = get_peer_sock_name(getpeername, fd)) == NULL)
+    {
+        if ((sockname = get_peer_sock_name(getsockname, fd)) == NULL)
+            return 0;   /* can only authenticate sockets */
+        if (sockname->sa_family != AF_UNIX)
+        {
+            free(sockname);
+            return 0;   /* except for AF_UNIX, sockets should have peernames */
+        }
+        gotsockname = 1;
+    }
+
+    authptr = get_authptr(sockname, display);
+    if (authptr == 0)
+    {
+        free(sockname);
+        return 0;   /* cannot find good auth data */
+    }
+
+    info->namelen = memdup(&info->name, authptr->name, authptr->name_length);
+    if (!info->namelen)
+        goto no_auth;   /* out of memory */
+
+    if (!gotsockname)
+    {
+        free(sockname);
+
+        if ((sockname = get_peer_sock_name(getsockname, fd)) == NULL)
+        {
+            free(info->name);
+            goto no_auth;   /* can only authenticate sockets */
+        }
+    }
+
+    ret = compute_auth(info, authptr, sockname);
+    if(!ret)
+    {
+        free(info->name);
+        goto no_auth;   /* cannot build auth record */
+    }
+
+    free(sockname);
+    sockname = NULL;
+
+    XauDisposeAuth(authptr);
+    return ret;
+
+ no_auth:
+    free(sockname);
+
+    info->name = 0;
+    info->namelen = 0;
+    XauDisposeAuth(authptr);
+    return 0;
+}
diff --git a/depends/libxcb/src/xcb_conn.c b/depends/libxcb/src/xcb_conn.c
new file mode 100644
index 0000000..3084c18
--- /dev/null
+++ b/depends/libxcb/src/xcb_conn.c
@@ -0,0 +1,586 @@
+/* Copyright (C) 2001-2004 Bart Massey and Jamey Sharp.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the names of the authors or their
+ * institutions shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the authors.
+ */
+
+/* Connection management: the core of XCB. */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <limits.h>
+
+#include "xcb.h"
+#include "xcbint.h"
+#if USE_POLL
+#include <poll.h>
+#elif !defined _WIN32
+#include <sys/select.h>
+#endif
+
+#ifdef _WIN32
+#include "xcb_windefs.h"
+#include <io.h>
+#else
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#endif /* _WIN32 */
+
+/* SHUT_RDWR is fairly recent and is not available on all platforms */
+#if !defined(SHUT_RDWR)
+#define SHUT_RDWR 2
+#endif
+
+typedef struct {
+    uint8_t  status;
+    uint8_t  pad0[5];
+    uint16_t length;
+} xcb_setup_generic_t;
+
+static const xcb_setup_t xcb_error_setup = {
+    0,     /* status: failed (but we wouldn't have a xcb_setup_t in this case) */
+    0,     /* pad0 */
+    0, 0,  /* protocol version, should be 11.0, but isn't */
+    0,     /* length, invalid value */
+    0,     /* release_number */
+    0, 0,  /* resource_id_{base,mask} */
+    0,     /* motion_buffer_size */
+    0,     /* vendor_len */
+    0,     /* maximum_request_length */
+    0,     /* roots_len */
+    0,     /* pixmap_formats_len */
+    0,     /* image_byte_order */
+    0,     /* bitmap_format_bit_order */
+    0,     /* bitmap_format_scanline_unit */
+    0,     /* bitmap_format_scanline_pad */
+    0, 0,  /* {min,max}_keycode */
+    { 0, 0, 0, 0 } /* pad1 */
+};
+
+/* Keep this list in sync with is_static_error_conn()! */
+static const int xcb_con_error = XCB_CONN_ERROR;
+static const int xcb_con_closed_mem_er = XCB_CONN_CLOSED_MEM_INSUFFICIENT;
+static const int xcb_con_closed_parse_er = XCB_CONN_CLOSED_PARSE_ERR;
+static const int xcb_con_closed_screen_er = XCB_CONN_CLOSED_INVALID_SCREEN;
+
+static int is_static_error_conn(xcb_connection_t *c)
+{
+    return c == (xcb_connection_t *) &xcb_con_error ||
+           c == (xcb_connection_t *) &xcb_con_closed_mem_er ||
+           c == (xcb_connection_t *) &xcb_con_closed_parse_er ||
+           c == (xcb_connection_t *) &xcb_con_closed_screen_er;
+}
+
+static int set_fd_flags(const int fd)
+{
+/* Win32 doesn't have file descriptors and the fcntl function. This block sets the socket in non-blocking mode */
+
+#ifdef _WIN32
+   u_long iMode = 1; /* non-zero puts it in non-blocking mode, 0 in blocking mode */
+   int ret = 0;
+
+   ret = ioctlsocket(fd, FIONBIO, &iMode);
+   if(ret != 0)
+       return 0;
+   return 1;
+#else
+    int flags = fcntl(fd, F_GETFL, 0);
+    if(flags == -1)
+        return 0;
+    flags |= O_NONBLOCK;
+    if(fcntl(fd, F_SETFL, flags) == -1)
+        return 0;
+    if(fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
+        return 0;
+    return 1;
+#endif /* _WIN32 */
+}
+
+static int write_setup(xcb_connection_t *c, xcb_auth_info_t *auth_info)
+{
+    static const char pad[3];
+    xcb_setup_request_t out;
+    struct iovec parts[6];
+    int count = 0;
+    static const uint32_t endian = 0x01020304;
+    int ret;
+
+    memset(&out, 0, sizeof(out));
+
+    /* B = 0x42 = MSB first, l = 0x6c = LSB first */
+    if(htonl(endian) == endian)
+        out.byte_order = 0x42;
+    else
+        out.byte_order = 0x6c;
+    out.protocol_major_version = X_PROTOCOL;
+    out.protocol_minor_version = X_PROTOCOL_REVISION;
+    out.authorization_protocol_name_len = 0;
+    out.authorization_protocol_data_len = 0;
+    parts[count].iov_len = sizeof(xcb_setup_request_t);
+    parts[count++].iov_base = &out;
+    parts[count].iov_len = XCB_PAD(sizeof(xcb_setup_request_t));
+    parts[count++].iov_base = (char *) pad;
+
+    if(auth_info)
+    {
+        parts[count].iov_len = out.authorization_protocol_name_len = auth_info->namelen;
+        parts[count++].iov_base = auth_info->name;
+        parts[count].iov_len = XCB_PAD(out.authorization_protocol_name_len);
+        parts[count++].iov_base = (char *) pad;
+        parts[count].iov_len = out.authorization_protocol_data_len = auth_info->datalen;
+        parts[count++].iov_base = auth_info->data;
+        parts[count].iov_len = XCB_PAD(out.authorization_protocol_data_len);
+        parts[count++].iov_base = (char *) pad;
+    }
+    assert(count <= (int) (sizeof(parts) / sizeof(*parts)));
+
+    pthread_mutex_lock(&c->iolock);
+    ret = _xcb_out_send(c, parts, count);
+    pthread_mutex_unlock(&c->iolock);
+    return ret;
+}
+
+static int read_setup(xcb_connection_t *c)
+{
+    const char newline = '\n';
+
+    /* Read the server response */
+    c->setup = malloc(sizeof(xcb_setup_generic_t));
+    if(!c->setup)
+        return 0;
+
+    if(_xcb_in_read_block(c, c->setup, sizeof(xcb_setup_generic_t)) != sizeof(xcb_setup_generic_t))
+        return 0;
+
+    {
+        void *tmp = realloc(c->setup, c->setup->length * 4 + sizeof(xcb_setup_generic_t));
+        if(!tmp)
+            return 0;
+        c->setup = tmp;
+    }
+
+    if(_xcb_in_read_block(c, (char *) c->setup + sizeof(xcb_setup_generic_t), c->setup->length * 4) <= 0)
+        return 0;
+
+    /* 0 = failed, 2 = authenticate, 1 = success */
+    switch(c->setup->status)
+    {
+    case 0: /* failed */
+        {
+            xcb_setup_failed_t *setup = (xcb_setup_failed_t *) c->setup;
+            write(STDERR_FILENO, xcb_setup_failed_reason(setup), xcb_setup_failed_reason_length(setup));
+            write(STDERR_FILENO, &newline, 1);
+            return 0;
+        }
+
+    case 2: /* authenticate */
+        {
+            xcb_setup_authenticate_t *setup = (xcb_setup_authenticate_t *) c->setup;
+            write(STDERR_FILENO, xcb_setup_authenticate_reason(setup), xcb_setup_authenticate_reason_length(setup));
+            write(STDERR_FILENO, &newline, 1);
+            return 0;
+        }
+    }
+
+    return 1;
+}
+
+/* precondition: there must be something for us to write. */
+static int write_vec(xcb_connection_t *c, struct iovec **vector, int *count)
+{
+#ifndef _WIN32
+    int n;
+#endif
+
+    assert(!c->out.queue_len);
+
+#ifdef _WIN32
+    /* Could use the WSASend win32 function for scatter/gather i/o but setting up the WSABUF struct from
+       an iovec would require more work and I'm not sure of the benefit....works for now */
+    while (*count)
+    {
+        struct iovec *vec = *vector;
+        if (vec->iov_len)
+        {
+            int ret = send(c->fd, vec->iov_base, vec->iov_len, 0);
+            if (ret == SOCKET_ERROR)
+            {
+                int err = WSAGetLastError();
+                if (err == WSAEWOULDBLOCK)
+                {
+                    return 1;
+                }
+            }
+            if (ret <= 0)
+            {
+                _xcb_conn_shutdown(c, XCB_CONN_ERROR);
+                return 0;
+            }
+            c->out.total_written += ret;
+            vec->iov_len -= ret;
+            vec->iov_base = (char *)vec->iov_base + ret;
+        }
+        if (vec->iov_len == 0) {
+            (*vector)++;
+            (*count)--;
+        }
+    }
+
+    if (!*count)
+        *vector = 0;
+
+#else
+    n = *count;
+    if (n > IOV_MAX)
+        n = IOV_MAX;
+
+#if HAVE_SENDMSG
+    if (c->out.out_fd.nfd) {
+        union {
+            struct cmsghdr cmsghdr;
+            char buf[CMSG_SPACE(XCB_MAX_PASS_FD * sizeof(int))];
+        } cmsgbuf;
+        struct msghdr msg = {
+            .msg_name = NULL,
+            .msg_namelen = 0,
+            .msg_iov = *vector,
+            .msg_iovlen = n,
+            .msg_control = cmsgbuf.buf,
+            .msg_controllen = CMSG_LEN(c->out.out_fd.nfd * sizeof (int)),
+        };
+        int i;
+        struct cmsghdr *hdr = CMSG_FIRSTHDR(&msg);
+
+        hdr->cmsg_len = msg.msg_controllen;
+        hdr->cmsg_level = SOL_SOCKET;
+        hdr->cmsg_type = SCM_RIGHTS;
+        memcpy(CMSG_DATA(hdr), c->out.out_fd.fd, c->out.out_fd.nfd * sizeof (int));
+
+        n = sendmsg(c->fd, &msg, 0);
+        if(n < 0 && errno == EAGAIN)
+            return 1;
+        for (i = 0; i < c->out.out_fd.nfd; i++)
+            close(c->out.out_fd.fd[i]);
+        c->out.out_fd.nfd = 0;
+    } else
+#endif
+    {
+        n = writev(c->fd, *vector, n);
+        if(n < 0 && errno == EAGAIN)
+            return 1;
+    }
+
+    if(n <= 0)
+    {
+        _xcb_conn_shutdown(c, XCB_CONN_ERROR);
+        return 0;
+    }
+
+    c->out.total_written += n;
+    for(; *count; --*count, ++*vector)
+    {
+        int cur = (*vector)->iov_len;
+        if(cur > n)
+            cur = n;
+        (*vector)->iov_len -= cur;
+        (*vector)->iov_base = (char *) (*vector)->iov_base + cur;
+        n -= cur;
+        if((*vector)->iov_len)
+            break;
+    }
+    if(!*count)
+        *vector = 0;
+    assert(n == 0);
+
+#endif /* _WIN32 */
+
+    return 1;
+}
+
+/* Public interface */
+
+const xcb_setup_t *xcb_get_setup(xcb_connection_t *c)
+{
+    if(is_static_error_conn(c))
+        return &xcb_error_setup;
+    /* doesn't need locking because it's never written to. */
+    return c->setup;
+}
+
+int xcb_get_file_descriptor(xcb_connection_t *c)
+{
+    if(is_static_error_conn(c))
+        return -1;
+    /* doesn't need locking because it's never written to. */
+    return c->fd;
+}
+
+int xcb_connection_has_error(xcb_connection_t *c)
+{
+    /* doesn't need locking because it's read and written atomically. */
+    return c->has_error;
+}
+
+xcb_connection_t *xcb_connect_to_fd(int fd, xcb_auth_info_t *auth_info)
+{
+    xcb_connection_t* c;
+
+#ifndef _WIN32
+#ifndef USE_POLL
+    if(fd >= FD_SETSIZE) /* would overflow in FD_SET */
+    {
+        close(fd);
+        return _xcb_conn_ret_error(XCB_CONN_ERROR);
+    }
+#endif
+#endif /* !_WIN32*/
+
+    c = calloc(1, sizeof(xcb_connection_t));
+    if(!c) {
+#ifdef _WIN32
+        closesocket(fd);
+#else
+        close(fd);
+#endif
+        return _xcb_conn_ret_error(XCB_CONN_CLOSED_MEM_INSUFFICIENT) ;
+    }
+
+    c->fd = fd;
+
+    if(!(
+        set_fd_flags(fd) &&
+        pthread_mutex_init(&c->iolock, 0) == 0 &&
+        _xcb_in_init(&c->in) &&
+        _xcb_out_init(&c->out) &&
+        write_setup(c, auth_info) &&
+        read_setup(c) &&
+        _xcb_ext_init(c) &&
+        _xcb_xid_init(c)
+        ))
+    {
+        xcb_disconnect(c);
+        return _xcb_conn_ret_error(XCB_CONN_ERROR);
+    }
+
+    return c;
+}
+
+void xcb_disconnect(xcb_connection_t *c)
+{
+    if(c == NULL || is_static_error_conn(c))
+        return;
+
+    free(c->setup);
+
+    /* disallow further sends and receives */
+    shutdown(c->fd, SHUT_RDWR);
+#ifdef _WIN32
+    closesocket(c->fd);
+#else
+    close(c->fd);
+#endif
+
+    pthread_mutex_destroy(&c->iolock);
+    _xcb_in_destroy(&c->in);
+    _xcb_out_destroy(&c->out);
+
+    _xcb_ext_destroy(c);
+    _xcb_xid_destroy(c);
+
+    free(c);
+
+#ifdef _WIN32
+    WSACleanup();
+#endif
+}
+
+/* Private interface */
+
+void _xcb_conn_shutdown(xcb_connection_t *c, int err)
+{
+    c->has_error = err;
+}
+
+/* Return connection error state.
+ * To make thread-safe, I need a seperate static
+ * variable for every possible error.
+ * has_error is the first field in xcb_connection_t, so just
+ * return a casted int here; checking has_error (and only
+ * has_error) will be safe.
+ */
+xcb_connection_t *_xcb_conn_ret_error(int err)
+{
+
+    switch(err)
+    {
+        case XCB_CONN_CLOSED_MEM_INSUFFICIENT:
+        {
+            return (xcb_connection_t *) &xcb_con_closed_mem_er;
+        }
+        case XCB_CONN_CLOSED_PARSE_ERR:
+        {
+            return (xcb_connection_t *) &xcb_con_closed_parse_er;
+        }
+        case XCB_CONN_CLOSED_INVALID_SCREEN:
+        {
+            return (xcb_connection_t *) &xcb_con_closed_screen_er;
+        }
+        case XCB_CONN_ERROR:
+        default:
+        {
+            return (xcb_connection_t *) &xcb_con_error;
+        }
+    }
+}
+
+int _xcb_conn_wait(xcb_connection_t *c, pthread_cond_t *cond, struct iovec **vector, int *count)
+{
+    int ret;
+#if USE_POLL
+    struct pollfd fd;
+#else
+    fd_set rfds, wfds;
+#endif
+
+    /* If the thing I should be doing is already being done, wait for it. */
+    if(count ? c->out.writing : c->in.reading)
+    {
+        pthread_cond_wait(cond, &c->iolock);
+        return 1;
+    }
+
+#if USE_POLL
+    memset(&fd, 0, sizeof(fd));
+    fd.fd = c->fd;
+    fd.events = POLLIN;
+#else
+    FD_ZERO(&rfds);
+    FD_SET(c->fd, &rfds);
+#endif
+    ++c->in.reading;
+
+#if USE_POLL
+    if(count)
+    {
+        fd.events |= POLLOUT;
+        ++c->out.writing;
+    }
+#else
+    FD_ZERO(&wfds);
+    if(count)
+    {
+        FD_SET(c->fd, &wfds);
+        ++c->out.writing;
+    }
+#endif
+
+    pthread_mutex_unlock(&c->iolock);
+    do {
+#if USE_POLL
+        ret = poll(&fd, 1, -1);
+        /* If poll() returns an event we didn't expect, such as POLLNVAL, treat
+         * it as if it failed. */
+        if(ret >= 0 && (fd.revents & ~fd.events))
+        {
+            ret = -1;
+            break;
+        }
+#else
+        ret = select(c->fd + 1, &rfds, &wfds, 0, 0);
+#endif
+    } while (ret == -1 && errno == EINTR);
+    if(ret < 0)
+    {
+        _xcb_conn_shutdown(c, XCB_CONN_ERROR);
+        ret = 0;
+    }
+    pthread_mutex_lock(&c->iolock);
+
+    if(ret)
+    {
+        /* The code allows two threads to call select()/poll() at the same time.
+         * First thread just wants to read, a second thread wants to write, too.
+         * We have to make sure that we don't steal the reading thread's reply
+         * and let it get stuck in select()/poll().
+         * So a thread may read if either:
+         * - There is no other thread that wants to read (the above situation
+         *   did not occur).
+         * - It is the reading thread (above situation occurred).
+         */
+        int may_read = c->in.reading == 1 || !count;
+#if USE_POLL
+        if(may_read && (fd.revents & POLLIN) != 0)
+#else
+        if(may_read && FD_ISSET(c->fd, &rfds))
+#endif
+            ret = ret && _xcb_in_read(c);
+
+#if USE_POLL
+        if((fd.revents & POLLOUT) != 0)
+#else
+        if(FD_ISSET(c->fd, &wfds))
+#endif
+            ret = ret && write_vec(c, vector, count);
+    }
+
+    if(count)
+        --c->out.writing;
+    --c->in.reading;
+
+    return ret;
+}
+
+uint64_t xcb_total_read(xcb_connection_t *c)
+{
+    uint64_t n;
+
+    if (xcb_connection_has_error(c))
+        return 0;
+
+    pthread_mutex_lock(&c->iolock);
+    n = c->in.total_read;
+    pthread_mutex_unlock(&c->iolock);
+    return n;
+}
+
+uint64_t xcb_total_written(xcb_connection_t *c)
+{
+    uint64_t n;
+
+    if (xcb_connection_has_error(c))
+        return 0;
+
+    pthread_mutex_lock(&c->iolock);
+    n = c->out.total_written;
+    pthread_mutex_unlock(&c->iolock);
+
+    return n;
+}
diff --git a/depends/libxcb/src/xcb_ext.c b/depends/libxcb/src/xcb_ext.c
new file mode 100644
index 0000000..831f283
--- /dev/null
+++ b/depends/libxcb/src/xcb_ext.c
@@ -0,0 +1,131 @@
+/* Copyright (C) 2001-2004 Bart Massey and Jamey Sharp.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the names of the authors or their
+ * institutions shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the authors.
+ */
+
+/* A cache for QueryExtension results. */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "xcb.h"
+#include "xcbext.h"
+#include "xcbint.h"
+
+typedef struct lazyreply {
+    enum lazy_reply_tag tag;
+    union {
+        xcb_query_extension_cookie_t cookie;
+        xcb_query_extension_reply_t *reply;
+    } value;
+} lazyreply;
+
+static lazyreply *get_index(xcb_connection_t *c, int idx)
+{
+    if(idx > c->ext.extensions_size)
+    {
+        int new_size = idx << 1;
+        lazyreply *new_extensions = realloc(c->ext.extensions, sizeof(lazyreply) * new_size);
+        if(!new_extensions)
+            return 0;
+        memset(new_extensions + c->ext.extensions_size, 0, sizeof(lazyreply) * (new_size - c->ext.extensions_size));
+        c->ext.extensions = new_extensions;
+        c->ext.extensions_size = new_size;
+    }
+    return c->ext.extensions + idx - 1;
+}
+
+static lazyreply *get_lazyreply(xcb_connection_t *c, xcb_extension_t *ext)
+{
+    static pthread_mutex_t global_lock = PTHREAD_MUTEX_INITIALIZER;
+    static int next_global_id;
+
+    lazyreply *data;
+
+    pthread_mutex_lock(&global_lock);
+    if(!ext->global_id)
+        ext->global_id = ++next_global_id;
+    pthread_mutex_unlock(&global_lock);
+
+    data = get_index(c, ext->global_id);
+    if(data && data->tag == LAZY_NONE)
+    {
+        /* cache miss: query the server */
+        data->tag = LAZY_COOKIE;
+        data->value.cookie = xcb_query_extension(c, strlen(ext->name), ext->name);
+    }
+    return data;
+}
+
+/* Public interface */
+
+/* Do not free the returned xcb_query_extension_reply_t - on return, it's aliased
+ * from the cache. */
+const xcb_query_extension_reply_t *xcb_get_extension_data(xcb_connection_t *c, xcb_extension_t *ext)
+{
+    lazyreply *data;
+    if(c->has_error)
+        return 0;
+
+    pthread_mutex_lock(&c->ext.lock);
+    data = get_lazyreply(c, ext);
+    if(data && data->tag == LAZY_COOKIE)
+    {
+        data->tag = LAZY_FORCED;
+        data->value.reply = xcb_query_extension_reply(c, data->value.cookie, 0);
+    }
+    pthread_mutex_unlock(&c->ext.lock);
+
+    return data ? data->value.reply : 0;
+}
+
+void xcb_prefetch_extension_data(xcb_connection_t *c, xcb_extension_t *ext)
+{
+    if(c->has_error)
+        return;
+    pthread_mutex_lock(&c->ext.lock);
+    get_lazyreply(c, ext);
+    pthread_mutex_unlock(&c->ext.lock);
+}
+
+/* Private interface */
+
+int _xcb_ext_init(xcb_connection_t *c)
+{
+    if(pthread_mutex_init(&c->ext.lock, 0))
+        return 0;
+    return 1;
+}
+
+void _xcb_ext_destroy(xcb_connection_t *c)
+{
+    pthread_mutex_destroy(&c->ext.lock);
+    while(c->ext.extensions_size-- > 0)
+        if(c->ext.extensions[c->ext.extensions_size].tag == LAZY_FORCED)
+            free(c->ext.extensions[c->ext.extensions_size].value.reply);
+    free(c->ext.extensions);
+}
diff --git a/depends/libxcb/src/xcb_in.c b/depends/libxcb/src/xcb_in.c
new file mode 100644
index 0000000..c9a264d
--- /dev/null
+++ b/depends/libxcb/src/xcb_in.c
@@ -0,0 +1,1096 @@
+/* Copyright (C) 2001-2004 Bart Massey and Jamey Sharp.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the names of the authors or their
+ * institutions shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the authors.
+ */
+
+/* Stuff that reads stuff from the server. */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+
+#if USE_POLL
+#include <poll.h>
+#endif
+#ifndef _WIN32
+#include <unistd.h>
+#include <sys/select.h>
+#include <sys/socket.h>
+#endif
+
+#ifdef _WIN32
+#include "xcb_windefs.h"
+#endif /* _WIN32 */
+
+#include "xcb.h"
+#include "xcbext.h"
+#include "xcbint.h"
+
+#define XCB_ERROR 0
+#define XCB_REPLY 1
+#define XCB_XGE_EVENT 35
+
+struct event_list {
+    xcb_generic_event_t *event;
+    struct event_list *next;
+};
+
+struct xcb_special_event {
+
+    struct xcb_special_event *next;
+
+    /* Match XGE events for the specific extension and event ID (the
+     * first 32 bit word after evtype)
+     */
+    uint8_t     extension;
+    uint32_t    eid;
+    uint32_t    *stamp;
+
+    struct event_list   *events;
+    struct event_list   **events_tail;
+
+    pthread_cond_t special_event_cond;
+};
+
+struct reply_list {
+    void *reply;
+    struct reply_list *next;
+};
+
+typedef struct pending_reply {
+    uint64_t first_request;
+    uint64_t last_request;
+    enum workarounds workaround;
+    int flags;
+    struct pending_reply *next;
+} pending_reply;
+
+typedef struct reader_list {
+    uint64_t request;
+    pthread_cond_t *data;
+    struct reader_list *next;
+} reader_list;
+
+typedef struct special_list {
+    xcb_special_event_t *se;
+    struct special_list *next;
+} special_list;
+
+static void remove_finished_readers(reader_list **prev_reader, uint64_t completed)
+{
+    while(*prev_reader && XCB_SEQUENCE_COMPARE((*prev_reader)->request, <=, completed))
+    {
+        /* If you don't have what you're looking for now, you never
+         * will. Wake up and leave me alone. */
+        pthread_cond_signal((*prev_reader)->data);
+        *prev_reader = (*prev_reader)->next;
+    }
+}
+
+#if HAVE_SENDMSG
+static int read_fds(xcb_connection_t *c, int *fds, int nfd)
+{
+    int *ifds = &c->in.in_fd.fd[c->in.in_fd.ifd];
+    int infd = c->in.in_fd.nfd - c->in.in_fd.ifd;
+
+    if (nfd > infd)
+        return 0;
+    memcpy(fds, ifds, nfd * sizeof (int));
+    c->in.in_fd.ifd += nfd;
+    return 1;
+}
+#endif
+
+typedef struct xcb_ge_special_event_t {
+    uint8_t  response_type; /**<  */
+    uint8_t  extension; /**<  */
+    uint16_t sequence; /**<  */
+    uint32_t length; /**<  */
+    uint16_t evtype; /**<  */
+    uint8_t  pad0[2]; /**< */
+    uint32_t eid; /**< */
+    uint8_t  pad1[16]; /**<  */
+} xcb_ge_special_event_t;
+
+static int event_special(xcb_connection_t *c,
+                         struct event_list *event)
+{
+    struct xcb_special_event *special_event;
+    struct xcb_ge_special_event_t *ges = (void *) event->event;
+
+    /* Special events are always XGE events */
+    if ((ges->response_type & 0x7f) != XCB_XGE_EVENT)
+        return 0;
+
+    for (special_event = c->in.special_events;
+         special_event;
+         special_event = special_event->next)
+    {
+        if (ges->extension == special_event->extension &&
+            ges->eid == special_event->eid)
+        {
+            *special_event->events_tail = event;
+            special_event->events_tail = &event->next;
+            if (special_event->stamp)
+                ++(*special_event->stamp);
+            pthread_cond_signal(&special_event->special_event_cond);
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+static int read_packet(xcb_connection_t *c)
+{
+    xcb_generic_reply_t genrep;
+    uint64_t length = 32;
+    uint64_t eventlength = 0; /* length after first 32 bytes for GenericEvents */
+    int nfd = 0;         /* Number of file descriptors attached to the reply */
+    uint64_t bufsize;
+    void *buf;
+    pending_reply *pend = 0;
+    struct event_list *event;
+
+    /* Wait for there to be enough data for us to read a whole packet */
+    if(c->in.queue_len < length)
+        return 0;
+
+    /* Get the response type, length, and sequence number. */
+    memcpy(&genrep, c->in.queue, sizeof(genrep));
+
+    /* Compute 32-bit sequence number of this packet. */
+    if((genrep.response_type & 0x7f) != XCB_KEYMAP_NOTIFY)
+    {
+        uint64_t lastread = c->in.request_read;
+        c->in.request_read = (lastread & UINT64_C(0xffffffffffff0000)) | genrep.sequence;
+        if(XCB_SEQUENCE_COMPARE(c->in.request_read, <, lastread))
+            c->in.request_read += 0x10000;
+        if(XCB_SEQUENCE_COMPARE(c->in.request_read, >, c->in.request_expected))
+            c->in.request_expected = c->in.request_read;
+
+        if(c->in.request_read != lastread)
+        {
+            if(c->in.current_reply)
+            {
+                _xcb_map_put(c->in.replies, lastread, c->in.current_reply);
+                c->in.current_reply = 0;
+                c->in.current_reply_tail = &c->in.current_reply;
+            }
+            c->in.request_completed = c->in.request_read - 1;
+        }
+
+        while(c->in.pending_replies &&
+              c->in.pending_replies->workaround != WORKAROUND_EXTERNAL_SOCKET_OWNER &&
+              XCB_SEQUENCE_COMPARE (c->in.pending_replies->last_request, <=, c->in.request_completed))
+        {
+            pending_reply *oldpend = c->in.pending_replies;
+            c->in.pending_replies = oldpend->next;
+            if(!oldpend->next)
+                c->in.pending_replies_tail = &c->in.pending_replies;
+            free(oldpend);
+        }
+
+        if(genrep.response_type == XCB_ERROR)
+            c->in.request_completed = c->in.request_read;
+
+        remove_finished_readers(&c->in.readers, c->in.request_completed);
+    }
+
+    if(genrep.response_type == XCB_ERROR || genrep.response_type == XCB_REPLY)
+    {
+        pend = c->in.pending_replies;
+        if(pend &&
+           !(XCB_SEQUENCE_COMPARE(pend->first_request, <=, c->in.request_read) &&
+             (pend->workaround == WORKAROUND_EXTERNAL_SOCKET_OWNER ||
+              XCB_SEQUENCE_COMPARE(c->in.request_read, <=, pend->last_request))))
+            pend = 0;
+    }
+
+    /* For reply packets, check that the entire packet is available. */
+    if(genrep.response_type == XCB_REPLY)
+    {
+        if(pend && pend->workaround == WORKAROUND_GLX_GET_FB_CONFIGS_BUG)
+        {
+            uint32_t *p = (uint32_t *) c->in.queue;
+            uint64_t new_length = ((uint64_t)p[2]) * ((uint64_t)p[3]);
+            if(new_length >= (UINT32_MAX / UINT32_C(16)))
+            {
+                _xcb_conn_shutdown(c, XCB_CONN_CLOSED_MEM_INSUFFICIENT);
+                return 0;
+            }
+            genrep.length = (uint32_t)(new_length * UINT64_C(2));
+        }
+        length += genrep.length * UINT64_C(4);
+
+        /* XXX a bit of a hack -- we "know" that all FD replys place
+         * the number of fds in the pad0 byte */
+        if (pend && pend->flags & XCB_REQUEST_REPLY_FDS)
+            nfd = genrep.pad0;
+    }
+
+    /* XGE events may have sizes > 32 */
+    if ((genrep.response_type & 0x7f) == XCB_XGE_EVENT)
+        eventlength = genrep.length * UINT64_C(4);
+
+    bufsize = length + eventlength + nfd * sizeof(int)  +
+        (genrep.response_type == XCB_REPLY ? 0 : sizeof(uint32_t));
+    if (bufsize < INT32_MAX)
+        buf = malloc((size_t) bufsize);
+    else
+        buf = NULL;
+    if(!buf)
+    {
+        _xcb_conn_shutdown(c, XCB_CONN_CLOSED_MEM_INSUFFICIENT);
+        return 0;
+    }
+
+    if(_xcb_in_read_block(c, buf, length) <= 0)
+    {
+        free(buf);
+        return 0;
+    }
+
+    /* pull in XGE event data if available, append after event struct */
+    if (eventlength)
+    {
+        if(_xcb_in_read_block(c, &((xcb_generic_event_t*)buf)[1], eventlength) <= 0)
+        {
+            free(buf);
+            return 0;
+        }
+    }
+
+#if HAVE_SENDMSG
+    if (nfd)
+    {
+        if (!read_fds(c, (int *) &((char *) buf)[length], nfd))
+        {
+            free(buf);
+            return 0;
+        }
+    }
+#endif
+
+    if(pend && (pend->flags & XCB_REQUEST_DISCARD_REPLY))
+    {
+        free(buf);
+        return 1;
+    }
+
+    if(genrep.response_type != XCB_REPLY)
+        ((xcb_generic_event_t *) buf)->full_sequence = c->in.request_read;
+
+    /* reply, or checked error */
+    if( genrep.response_type == XCB_REPLY ||
+       (genrep.response_type == XCB_ERROR && pend && (pend->flags & XCB_REQUEST_CHECKED)))
+    {
+        struct reply_list *cur = malloc(sizeof(struct reply_list));
+        if(!cur)
+        {
+            _xcb_conn_shutdown(c, XCB_CONN_CLOSED_MEM_INSUFFICIENT);
+            free(buf);
+            return 0;
+        }
+        cur->reply = buf;
+        cur->next = 0;
+        *c->in.current_reply_tail = cur;
+        c->in.current_reply_tail = &cur->next;
+        if(c->in.readers && c->in.readers->request == c->in.request_read)
+            pthread_cond_signal(c->in.readers->data);
+        return 1;
+    }
+
+    /* event, or unchecked error */
+    event = malloc(sizeof(struct event_list));
+    if(!event)
+    {
+        _xcb_conn_shutdown(c, XCB_CONN_CLOSED_MEM_INSUFFICIENT);
+        free(buf);
+        return 0;
+    }
+    event->event = buf;
+    event->next = 0;
+
+    if (!event_special(c, event)) {
+        *c->in.events_tail = event;
+        c->in.events_tail = &event->next;
+        pthread_cond_signal(&c->in.event_cond);
+    }
+    return 1; /* I have something for you... */
+}
+
+static xcb_generic_event_t *get_event(xcb_connection_t *c)
+{
+    struct event_list *cur = c->in.events;
+    xcb_generic_event_t *ret;
+    if(!c->in.events)
+        return 0;
+    ret = cur->event;
+    c->in.events = cur->next;
+    if(!cur->next)
+        c->in.events_tail = &c->in.events;
+    free(cur);
+    return ret;
+}
+
+static void free_reply_list(struct reply_list *head)
+{
+    while(head)
+    {
+        struct reply_list *cur = head;
+        head = cur->next;
+        free(cur->reply);
+        free(cur);
+    }
+}
+
+static int read_block(const int fd, void *buf, const intptr_t len)
+{
+    int done = 0;
+    while(done < len)
+    {
+        int ret = recv(fd, ((char *) buf) + done, len - done, 0);
+        if(ret > 0)
+            done += ret;
+#ifndef _WIN32
+        if(ret < 0 && errno == EAGAIN)
+#else
+        if(ret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK)
+#endif /* !_Win32 */
+        {
+#if USE_POLL
+            struct pollfd pfd;
+            pfd.fd = fd;
+            pfd.events = POLLIN;
+            pfd.revents = 0;
+            do {
+                ret = poll(&pfd, 1, -1);
+            } while (ret == -1 && errno == EINTR);
+#else
+            fd_set fds;
+            FD_ZERO(&fds);
+            FD_SET(fd, &fds);
+
+            /* Initializing errno here makes sure that for Win32 this loop will execute only once */
+            errno = 0;
+            do {
+                ret = select(fd + 1, &fds, 0, 0, 0);
+            } while (ret == -1 && errno == EINTR);
+#endif /* USE_POLL */
+        }
+        if(ret <= 0)
+            return ret;
+    }
+    return len;
+}
+
+static int poll_for_reply(xcb_connection_t *c, uint64_t request, void **reply, xcb_generic_error_t **error)
+{
+    struct reply_list *head;
+
+    /* If an error occurred when issuing the request, fail immediately. */
+    if(!request)
+        head = 0;
+    /* We've read requests past the one we want, so if it has replies we have
+     * them all and they're in the replies map. */
+    else if(XCB_SEQUENCE_COMPARE(request, <, c->in.request_read))
+    {
+        head = _xcb_map_remove(c->in.replies, request);
+        if(head && head->next)
+            _xcb_map_put(c->in.replies, request, head->next);
+    }
+    /* We're currently processing the responses to the request we want, and we
+     * have a reply ready to return. So just return it without blocking. */
+    else if(request == c->in.request_read && c->in.current_reply)
+    {
+        head = c->in.current_reply;
+        c->in.current_reply = head->next;
+        if(!head->next)
+            c->in.current_reply_tail = &c->in.current_reply;
+    }
+    /* We know this request can't have any more replies, and we've already
+     * established it doesn't have a reply now. Don't bother blocking. */
+    else if(request == c->in.request_completed)
+        head = 0;
+    /* We may have more replies on the way for this request: block until we're
+     * sure. */
+    else
+        return 0;
+
+    if(error)
+        *error = 0;
+    *reply = 0;
+
+    if(head)
+    {
+        if(((xcb_generic_reply_t *) head->reply)->response_type == XCB_ERROR)
+        {
+            if(error)
+                *error = head->reply;
+            else
+                free(head->reply);
+        }
+        else
+            *reply = head->reply;
+
+        free(head);
+    }
+
+    return 1;
+}
+
+static void insert_reader(reader_list **prev_reader, reader_list *reader, uint64_t request, pthread_cond_t *cond)
+{
+    while(*prev_reader && XCB_SEQUENCE_COMPARE((*prev_reader)->request, <=, request))
+        prev_reader = &(*prev_reader)->next;
+    reader->request = request;
+    reader->data = cond;
+    reader->next = *prev_reader;
+    *prev_reader = reader;
+}
+
+static void remove_reader(reader_list **prev_reader, reader_list *reader)
+{
+    while(*prev_reader && XCB_SEQUENCE_COMPARE((*prev_reader)->request, <=, reader->request))
+        if(*prev_reader == reader)
+        {
+            *prev_reader = (*prev_reader)->next;
+            break;
+        }
+}
+
+static void insert_special(special_list **prev_special, special_list *special, xcb_special_event_t *se)
+{
+    special->se = se;
+    special->next = *prev_special;
+    *prev_special = special;
+}
+
+static void remove_special(special_list **prev_special, special_list *special)
+{
+    while(*prev_special)
+    {
+        if(*prev_special == special)
+        {
+            *prev_special = (*prev_special)->next;
+            break;
+        }
+        prev_special = &(*prev_special)->next;
+    }
+}
+
+static void *wait_for_reply(xcb_connection_t *c, uint64_t request, xcb_generic_error_t **e)
+{
+    void *ret = 0;
+
+    /* If this request has not been written yet, write it. */
+    if(c->out.return_socket || _xcb_out_flush_to(c, request))
+    {
+        pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+        reader_list reader;
+
+        insert_reader(&c->in.readers, &reader, request, &cond);
+
+        while(!poll_for_reply(c, request, &ret, e))
+            if(!_xcb_conn_wait(c, &cond, 0, 0))
+                break;
+
+        remove_reader(&c->in.readers, &reader);
+        pthread_cond_destroy(&cond);
+    }
+
+    _xcb_in_wake_up_next_reader(c);
+    return ret;
+}
+
+static uint64_t widen(xcb_connection_t *c, unsigned int request)
+{
+    uint64_t widened_request = (c->out.request & UINT64_C(0xffffffff00000000)) | request;
+    if(widened_request > c->out.request)
+        widened_request -= UINT64_C(1) << 32;
+    return widened_request;
+}
+
+/* Public interface */
+
+void *xcb_wait_for_reply(xcb_connection_t *c, unsigned int request, xcb_generic_error_t **e)
+{
+    void *ret;
+    if(e)
+        *e = 0;
+    if(c->has_error)
+        return 0;
+
+    pthread_mutex_lock(&c->iolock);
+    ret = wait_for_reply(c, widen(c, request), e);
+    pthread_mutex_unlock(&c->iolock);
+    return ret;
+}
+
+void *xcb_wait_for_reply64(xcb_connection_t *c, uint64_t request, xcb_generic_error_t **e)
+{
+    void *ret;
+    if(e)
+        *e = 0;
+    if(c->has_error)
+        return 0;
+
+    pthread_mutex_lock(&c->iolock);
+    ret = wait_for_reply(c, request, e);
+    pthread_mutex_unlock(&c->iolock);
+    return ret;
+}
+
+int *xcb_get_reply_fds(xcb_connection_t *c, void *reply, size_t reply_size)
+{
+    return (int *) (&((char *) reply)[reply_size]);
+}
+
+static void insert_pending_discard(xcb_connection_t *c, pending_reply **prev_next, uint64_t seq)
+{
+    pending_reply *pend;
+    pend = malloc(sizeof(*pend));
+    if(!pend)
+    {
+        _xcb_conn_shutdown(c, XCB_CONN_CLOSED_MEM_INSUFFICIENT);
+        return;
+    }
+
+    pend->first_request = seq;
+    pend->last_request = seq;
+    pend->workaround = 0;
+    pend->flags = XCB_REQUEST_DISCARD_REPLY;
+    pend->next = *prev_next;
+    *prev_next = pend;
+
+    if(!pend->next)
+        c->in.pending_replies_tail = &pend->next;
+}
+
+static void discard_reply(xcb_connection_t *c, uint64_t request)
+{
+    void *reply;
+    pending_reply **prev_pend;
+
+    /* Free any replies or errors that we've already read. Stop if
+     * xcb_wait_for_reply would block or we've run out of replies. */
+    while(poll_for_reply(c, request, &reply, 0) && reply)
+        free(reply);
+
+    /* If we've proven there are no more responses coming, we're done. */
+    if(XCB_SEQUENCE_COMPARE(request, <=, c->in.request_completed))
+        return;
+
+    /* Walk the list of pending requests. Mark the first match for deletion. */
+    for(prev_pend = &c->in.pending_replies; *prev_pend; prev_pend = &(*prev_pend)->next)
+    {
+        if(XCB_SEQUENCE_COMPARE((*prev_pend)->first_request, >, request))
+            break;
+
+        if((*prev_pend)->first_request == request)
+        {
+            /* Pending reply found. Mark for discard: */
+            (*prev_pend)->flags |= XCB_REQUEST_DISCARD_REPLY;
+            return;
+        }
+    }
+
+    /* Pending reply not found (likely due to _unchecked request). Create one: */
+    insert_pending_discard(c, prev_pend, request);
+}
+
+void xcb_discard_reply(xcb_connection_t *c, unsigned int sequence)
+{
+    if(c->has_error)
+        return;
+
+    /* If an error occurred when issuing the request, fail immediately. */
+    if(!sequence)
+        return;
+
+    pthread_mutex_lock(&c->iolock);
+    discard_reply(c, widen(c, sequence));
+    pthread_mutex_unlock(&c->iolock);
+}
+
+void xcb_discard_reply64(xcb_connection_t *c, uint64_t sequence)
+{
+    if(c->has_error)
+        return;
+
+    /* If an error occurred when issuing the request, fail immediately. */
+    if(!sequence)
+        return;
+
+    pthread_mutex_lock(&c->iolock);
+    discard_reply(c, sequence);
+    pthread_mutex_unlock(&c->iolock);
+}
+
+int xcb_poll_for_reply(xcb_connection_t *c, unsigned int request, void **reply, xcb_generic_error_t **error)
+{
+    int ret;
+    if(c->has_error)
+    {
+        *reply = 0;
+        if(error)
+            *error = 0;
+        return 1; /* would not block */
+    }
+    assert(reply != 0);
+    pthread_mutex_lock(&c->iolock);
+    ret = poll_for_reply(c, widen(c, request), reply, error);
+    if(!ret && c->in.reading == 0 && _xcb_in_read(c)) /* _xcb_in_read shuts down the connection on error */
+        ret = poll_for_reply(c, widen(c, request), reply, error);
+    pthread_mutex_unlock(&c->iolock);
+    return ret;
+}
+
+int xcb_poll_for_reply64(xcb_connection_t *c, uint64_t request, void **reply, xcb_generic_error_t **error)
+{
+    int ret;
+    if(c->has_error)
+    {
+        *reply = 0;
+        if(error)
+            *error = 0;
+        return 1; /* would not block */
+    }
+    assert(reply != 0);
+    pthread_mutex_lock(&c->iolock);
+    ret = poll_for_reply(c, request, reply, error);
+    if(!ret && c->in.reading == 0 && _xcb_in_read(c)) /* _xcb_in_read shuts down the connection on error */
+        ret = poll_for_reply(c, request, reply, error);
+    pthread_mutex_unlock(&c->iolock);
+    return ret;
+}
+
+xcb_generic_event_t *xcb_wait_for_event(xcb_connection_t *c)
+{
+    xcb_generic_event_t *ret;
+    if(c->has_error)
+        return 0;
+    pthread_mutex_lock(&c->iolock);
+    /* get_event returns 0 on empty list. */
+    while(!(ret = get_event(c)))
+        if(!_xcb_conn_wait(c, &c->in.event_cond, 0, 0))
+            break;
+
+    _xcb_in_wake_up_next_reader(c);
+    pthread_mutex_unlock(&c->iolock);
+    return ret;
+}
+
+static xcb_generic_event_t *poll_for_next_event(xcb_connection_t *c, int queued)
+{
+    xcb_generic_event_t *ret = 0;
+    if(!c->has_error)
+    {
+        pthread_mutex_lock(&c->iolock);
+        /* FIXME: follow X meets Z architecture changes. */
+        ret = get_event(c);
+        if(!ret && !queued && c->in.reading == 0 && _xcb_in_read(c)) /* _xcb_in_read shuts down the connection on error */
+            ret = get_event(c);
+        pthread_mutex_unlock(&c->iolock);
+    }
+    return ret;
+}
+
+xcb_generic_event_t *xcb_poll_for_event(xcb_connection_t *c)
+{
+    return poll_for_next_event(c, 0);
+}
+
+xcb_generic_event_t *xcb_poll_for_queued_event(xcb_connection_t *c)
+{
+    return poll_for_next_event(c, 1);
+}
+
+xcb_generic_error_t *xcb_request_check(xcb_connection_t *c, xcb_void_cookie_t cookie)
+{
+    uint64_t request;
+    xcb_generic_error_t *ret = 0;
+    void *reply;
+    if(c->has_error)
+        return 0;
+    pthread_mutex_lock(&c->iolock);
+    request = widen(c, cookie.sequence);
+    if (XCB_SEQUENCE_COMPARE(request, >, c->in.request_completed))
+    {
+        if(XCB_SEQUENCE_COMPARE(request, >=, c->in.request_expected))
+        {
+            _xcb_out_send_sync(c);
+        }
+        if (XCB_SEQUENCE_COMPARE(request, >=, c->out.request_expected_written))
+        {
+            _xcb_out_flush_to(c, c->out.request);
+        }
+    }
+    reply = wait_for_reply(c, request, &ret);
+    assert(!reply);
+    pthread_mutex_unlock(&c->iolock);
+    return ret;
+}
+
+static xcb_generic_event_t *get_special_event(xcb_connection_t *c,
+                                              xcb_special_event_t *se)
+{
+    xcb_generic_event_t *event = NULL;
+    struct event_list *events;
+
+    if ((events = se->events) != NULL) {
+        event = events->event;
+        if (!(se->events = events->next))
+            se->events_tail = &se->events;
+        free (events);
+    }
+    return event;
+}
+
+xcb_generic_event_t *xcb_poll_for_special_event(xcb_connection_t *c,
+                                                xcb_special_event_t *se)
+{
+    xcb_generic_event_t *event;
+
+    if(c->has_error)
+        return 0;
+    pthread_mutex_lock(&c->iolock);
+    event = get_special_event(c, se);
+    if(!event && c->in.reading == 0 && _xcb_in_read(c)) /* _xcb_in_read shuts down the connection on error */
+        event = get_special_event(c, se);
+    pthread_mutex_unlock(&c->iolock);
+    return event;
+}
+
+xcb_generic_event_t *xcb_wait_for_special_event(xcb_connection_t *c,
+                                                xcb_special_event_t *se)
+{
+    special_list special;
+    xcb_generic_event_t *event;
+
+    if(c->has_error)
+        return 0;
+    pthread_mutex_lock(&c->iolock);
+
+    insert_special(&c->in.special_waiters, &special, se);
+
+    /* get_special_event returns 0 on empty list. */
+    while(!(event = get_special_event(c, se)))
+        if(!_xcb_conn_wait(c, &se->special_event_cond, 0, 0))
+            break;
+
+    remove_special(&c->in.special_waiters, &special);
+
+    _xcb_in_wake_up_next_reader(c);
+    pthread_mutex_unlock(&c->iolock);
+    return event;
+}
+
+xcb_special_event_t *
+xcb_register_for_special_xge(xcb_connection_t *c,
+                             xcb_extension_t *ext,
+                             uint32_t eid,
+                             uint32_t *stamp)
+{
+    xcb_special_event_t *se;
+    const xcb_query_extension_reply_t   *ext_reply;
+
+    if(c->has_error)
+        return NULL;
+    ext_reply = xcb_get_extension_data(c, ext);
+    if (!ext_reply)
+        return NULL;
+    pthread_mutex_lock(&c->iolock);
+    for (se = c->in.special_events; se; se = se->next) {
+        if (se->extension == ext_reply->major_opcode &&
+            se->eid == eid) {
+            pthread_mutex_unlock(&c->iolock);
+            return NULL;
+        }
+    }
+    se = calloc(1, sizeof(xcb_special_event_t));
+    if (!se) {
+        pthread_mutex_unlock(&c->iolock);
+        return NULL;
+    }
+
+    se->extension = ext_reply->major_opcode;
+    se->eid = eid;
+
+    se->events = NULL;
+    se->events_tail = &se->events;
+    se->stamp = stamp;
+
+    pthread_cond_init(&se->special_event_cond, 0);
+
+    se->next = c->in.special_events;
+    c->in.special_events = se;
+    pthread_mutex_unlock(&c->iolock);
+    return se;
+}
+
+void
+xcb_unregister_for_special_event(xcb_connection_t *c,
+                                 xcb_special_event_t *se)
+{
+    xcb_special_event_t *s, **prev;
+    struct event_list   *events, *next;
+
+    if (!se)
+        return;
+
+    if (c->has_error)
+        return;
+
+    pthread_mutex_lock(&c->iolock);
+
+    for (prev = &c->in.special_events; (s = *prev) != NULL; prev = &(s->next)) {
+        if (s == se) {
+            *prev = se->next;
+            for (events = se->events; events; events = next) {
+                next = events->next;
+                free (events->event);
+                free (events);
+            }
+            pthread_cond_destroy(&se->special_event_cond);
+            free (se);
+            break;
+        }
+    }
+    pthread_mutex_unlock(&c->iolock);
+}
+
+/* Private interface */
+
+int _xcb_in_init(_xcb_in *in)
+{
+    if(pthread_cond_init(&in->event_cond, 0))
+        return 0;
+    in->reading = 0;
+
+    in->queue_len = 0;
+
+    in->request_read = 0;
+    in->request_completed = 0;
+
+    in->replies = _xcb_map_new();
+    if(!in->replies)
+        return 0;
+
+    in->current_reply_tail = &in->current_reply;
+    in->events_tail = &in->events;
+    in->pending_replies_tail = &in->pending_replies;
+
+    return 1;
+}
+
+void _xcb_in_destroy(_xcb_in *in)
+{
+    pthread_cond_destroy(&in->event_cond);
+    free_reply_list(in->current_reply);
+    _xcb_map_delete(in->replies, (void (*)(void *)) free_reply_list);
+    while(in->events)
+    {
+        struct event_list *e = in->events;
+        in->events = e->next;
+        free(e->event);
+        free(e);
+    }
+    while(in->pending_replies)
+    {
+        pending_reply *pend = in->pending_replies;
+        in->pending_replies = pend->next;
+        free(pend);
+    }
+}
+
+void _xcb_in_wake_up_next_reader(xcb_connection_t *c)
+{
+    int pthreadret;
+    if(c->in.readers)
+        pthreadret = pthread_cond_signal(c->in.readers->data);
+    else if(c->in.special_waiters)
+        pthreadret = pthread_cond_signal(&c->in.special_waiters->se->special_event_cond);
+    else
+        pthreadret = pthread_cond_signal(&c->in.event_cond);
+    assert(pthreadret == 0);
+}
+
+int _xcb_in_expect_reply(xcb_connection_t *c, uint64_t request, enum workarounds workaround, int flags)
+{
+    pending_reply *pend = malloc(sizeof(pending_reply));
+    assert(workaround != WORKAROUND_NONE || flags != 0);
+    if(!pend)
+    {
+        _xcb_conn_shutdown(c, XCB_CONN_CLOSED_MEM_INSUFFICIENT);
+        return 0;
+    }
+    pend->first_request = pend->last_request = request;
+    pend->workaround = workaround;
+    pend->flags = flags;
+    pend->next = 0;
+    *c->in.pending_replies_tail = pend;
+    c->in.pending_replies_tail = &pend->next;
+    return 1;
+}
+
+void _xcb_in_replies_done(xcb_connection_t *c)
+{
+    struct pending_reply *pend;
+    if (c->in.pending_replies_tail != &c->in.pending_replies)
+    {
+        pend = container_of(c->in.pending_replies_tail, struct pending_reply, next);
+        if(pend->workaround == WORKAROUND_EXTERNAL_SOCKET_OWNER)
+        {
+            if (XCB_SEQUENCE_COMPARE(pend->first_request, <=, c->out.request)) {
+                pend->last_request = c->out.request;
+                pend->workaround = WORKAROUND_NONE;
+            } else {
+                /* The socket was taken, but no requests were actually sent
+                 * so just discard the pending_reply that was created.
+                 */
+                struct pending_reply **prev_next = &c->in.pending_replies;
+                while (*prev_next != pend)
+                    prev_next = &(*prev_next)->next;
+                *prev_next = NULL;
+                c->in.pending_replies_tail = prev_next;
+                free(pend);
+            }
+        }
+    }
+}
+
+int _xcb_in_read(xcb_connection_t *c)
+{
+    int n;
+
+#if HAVE_SENDMSG
+    struct iovec    iov = {
+        .iov_base = c->in.queue + c->in.queue_len,
+        .iov_len = sizeof(c->in.queue) - c->in.queue_len,
+    };
+    union {
+        struct cmsghdr cmsghdr;
+        char buf[CMSG_SPACE(XCB_MAX_PASS_FD * sizeof(int))];
+    } cmsgbuf;
+    struct msghdr msg = {
+        .msg_name = NULL,
+        .msg_namelen = 0,
+        .msg_iov = &iov,
+        .msg_iovlen = 1,
+        .msg_control = cmsgbuf.buf,
+        .msg_controllen = CMSG_SPACE(sizeof(int) * (XCB_MAX_PASS_FD - c->in.in_fd.nfd)),
+    };
+    n = recvmsg(c->fd, &msg, 0);
+
+    /* Check for truncation errors. Only MSG_CTRUNC is
+     * probably possible here, which would indicate that
+     * the sender tried to transmit more than XCB_MAX_PASS_FD
+     * file descriptors.
+     */
+    if (msg.msg_flags & (MSG_TRUNC|MSG_CTRUNC)) {
+        _xcb_conn_shutdown(c, XCB_CONN_CLOSED_FDPASSING_FAILED);
+        return 0;
+    }
+#else
+    n = recv(c->fd, c->in.queue + c->in.queue_len, sizeof(c->in.queue) - c->in.queue_len, 0);
+#endif
+    if(n > 0) {
+#if HAVE_SENDMSG
+        struct cmsghdr *hdr;
+
+        if (msg.msg_controllen >= sizeof (struct cmsghdr)) {
+            for (hdr = CMSG_FIRSTHDR(&msg); hdr; hdr = CMSG_NXTHDR(&msg, hdr)) {
+                if (hdr->cmsg_level == SOL_SOCKET && hdr->cmsg_type == SCM_RIGHTS) {
+                    int nfd = (hdr->cmsg_len - CMSG_LEN(0)) / sizeof (int);
+                    memcpy(&c->in.in_fd.fd[c->in.in_fd.nfd], CMSG_DATA(hdr), nfd * sizeof (int));
+                    c->in.in_fd.nfd += nfd;
+                }
+            }
+        }
+#endif
+        c->in.total_read += n;
+        c->in.queue_len += n;
+    }
+    while(read_packet(c))
+        /* empty */;
+#if HAVE_SENDMSG
+    if (c->in.in_fd.nfd) {
+        c->in.in_fd.nfd -= c->in.in_fd.ifd;
+        memmove(&c->in.in_fd.fd[0],
+                &c->in.in_fd.fd[c->in.in_fd.ifd],
+                c->in.in_fd.nfd * sizeof (int));
+        c->in.in_fd.ifd = 0;
+
+        /* If we have any left-over file descriptors after emptying
+         * the input buffer, then the server sent some that we weren't
+         * expecting.  Close them and mark the connection as broken;
+         */
+        if (c->in.queue_len == 0 && c->in.in_fd.nfd != 0) {
+            int i;
+            for (i = 0; i < c->in.in_fd.nfd; i++)
+                close(c->in.in_fd.fd[i]);
+            _xcb_conn_shutdown(c, XCB_CONN_CLOSED_FDPASSING_FAILED);
+            return 0;
+        }
+    }
+#endif
+#ifndef _WIN32
+    if((n > 0) || (n < 0 && (errno == EAGAIN || errno == EINTR)))
+#else
+    if((n > 0) || (n < 0 && WSAGetLastError() == WSAEWOULDBLOCK))
+#endif /* !_WIN32 */
+        return 1;
+    _xcb_conn_shutdown(c, XCB_CONN_ERROR);
+    return 0;
+}
+
+int _xcb_in_read_block(xcb_connection_t *c, void *buf, int len)
+{
+    int done = c->in.queue_len;
+    if(len < done)
+        done = len;
+
+    memcpy(buf, c->in.queue, done);
+    c->in.queue_len -= done;
+    memmove(c->in.queue, c->in.queue + done, c->in.queue_len);
+
+    if(len > done)
+    {
+        int ret = read_block(c->fd, (char *) buf + done, len - done);
+        if(ret <= 0)
+        {
+            _xcb_conn_shutdown(c, XCB_CONN_ERROR);
+            return ret;
+        }
+    }
+
+    return len;
+}
diff --git a/depends/libxcb/src/xcb_list.c b/depends/libxcb/src/xcb_list.c
new file mode 100644
index 0000000..bdd2d43
--- /dev/null
+++ b/depends/libxcb/src/xcb_list.c
@@ -0,0 +1,105 @@
+/* Copyright (C) 2001-2004 Bart Massey and Jamey Sharp.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the names of the authors or their
+ * institutions shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the authors.
+ */
+
+/* A generic implementation of a list of void-pointers. */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h>
+
+#include "xcb.h"
+#include "xcbint.h"
+
+typedef struct node {
+    struct node *next;
+    uint64_t key;
+    void *data;
+} node;
+
+struct _xcb_map {
+    node *head;
+    node **tail;
+};
+
+/* Private interface */
+
+_xcb_map *_xcb_map_new(void)
+{
+    _xcb_map *list;
+    list = malloc(sizeof(_xcb_map));
+    if(!list)
+        return 0;
+    list->head = 0;
+    list->tail = &list->head;
+    return list;
+}
+
+void _xcb_map_delete(_xcb_map *list, xcb_list_free_func_t do_free)
+{
+    if(!list)
+        return;
+    while(list->head)
+    {
+        node *cur = list->head;
+        if(do_free)
+            do_free(cur->data);
+        list->head = cur->next;
+        free(cur);
+    }
+    free(list);
+}
+
+int _xcb_map_put(_xcb_map *list, uint64_t key, void *data)
+{
+    node *cur = malloc(sizeof(node));
+    if(!cur)
+        return 0;
+    cur->key = key;
+    cur->data = data;
+    cur->next = 0;
+    *list->tail = cur;
+    list->tail = &cur->next;
+    return 1;
+}
+
+void *_xcb_map_remove(_xcb_map *list, uint64_t key)
+{
+    node **cur;
+    for(cur = &list->head; *cur; cur = &(*cur)->next)
+        if((*cur)->key == key)
+        {
+            node *tmp = *cur;
+            void *ret = (*cur)->data;
+            *cur = (*cur)->next;
+            if(!*cur)
+                list->tail = cur;
+
+            free(tmp);
+            return ret;
+        }
+    return 0;
+}
diff --git a/depends/libxcb/src/xcb_out.c b/depends/libxcb/src/xcb_out.c
new file mode 100644
index 0000000..a4fe823
--- /dev/null
+++ b/depends/libxcb/src/xcb_out.c
@@ -0,0 +1,501 @@
+/* Copyright (C) 2001-2004 Bart Massey and Jamey Sharp.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the names of the authors or their
+ * institutions shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the authors.
+ */
+
+/* Stuff that sends stuff to the server. */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <assert.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+#include <string.h>
+
+#include "xcb.h"
+#include "xcbext.h"
+#include "xcbint.h"
+#include "bigreq.h"
+
+static inline void send_request(xcb_connection_t *c, int isvoid, enum workarounds workaround, int flags, struct iovec *vector, int count)
+{
+    if(c->has_error)
+        return;
+
+    ++c->out.request;
+    if(!isvoid)
+        c->in.request_expected = c->out.request;
+    if(workaround != WORKAROUND_NONE || flags != 0)
+        _xcb_in_expect_reply(c, c->out.request, workaround, flags);
+
+    while(count && c->out.queue_len + vector[0].iov_len <= sizeof(c->out.queue))
+    {
+        memcpy(c->out.queue + c->out.queue_len, vector[0].iov_base, vector[0].iov_len);
+        c->out.queue_len += vector[0].iov_len;
+        vector[0].iov_base = (char *) vector[0].iov_base + vector[0].iov_len;
+        vector[0].iov_len = 0;
+        ++vector, --count;
+    }
+    if(!count)
+        return;
+
+    --vector, ++count;
+    vector[0].iov_base = c->out.queue;
+    vector[0].iov_len = c->out.queue_len;
+    c->out.queue_len = 0;
+    _xcb_out_send(c, vector, count);
+}
+
+static void send_sync(xcb_connection_t *c)
+{
+    static const union {
+        struct {
+            uint8_t major;
+            uint8_t pad;
+            uint16_t len;
+        } fields;
+        uint32_t packet;
+    } sync_req = { { /* GetInputFocus */ 43, 0, 1 } };
+    struct iovec vector[2];
+    vector[1].iov_base = (char *) &sync_req;
+    vector[1].iov_len = sizeof(sync_req);
+    send_request(c, 0, WORKAROUND_NONE, XCB_REQUEST_DISCARD_REPLY, vector + 1, 1);
+}
+
+static void get_socket_back(xcb_connection_t *c)
+{
+    while(c->out.return_socket && c->out.socket_moving)
+        pthread_cond_wait(&c->out.socket_cond, &c->iolock);
+    if(!c->out.return_socket)
+        return;
+
+    c->out.socket_moving = 1;
+    pthread_mutex_unlock(&c->iolock);
+    c->out.return_socket(c->out.socket_closure);
+    pthread_mutex_lock(&c->iolock);
+    c->out.socket_moving = 0;
+
+    pthread_cond_broadcast(&c->out.socket_cond);
+    c->out.return_socket = 0;
+    c->out.socket_closure = 0;
+    _xcb_in_replies_done(c);
+}
+
+static void prepare_socket_request(xcb_connection_t *c)
+{
+    /* We're about to append data to out.queue, so we need to
+     * atomically test for an external socket owner *and* some other
+     * thread currently writing.
+     *
+     * If we have an external socket owner, we have to get the socket back
+     * before we can use it again.
+     *
+     * If some other thread is writing to the socket, we assume it's
+     * writing from out.queue, and so we can't stick data there.
+     *
+     * We satisfy this condition by first calling get_socket_back
+     * (which may drop the lock, but will return when XCB owns the
+     * socket again) and then checking for another writing thread and
+     * escaping the loop if we're ready to go.
+     */
+    for (;;) {
+        if(c->has_error)
+            return;
+        get_socket_back(c);
+        if (!c->out.writing)
+            break;
+        pthread_cond_wait(&c->out.cond, &c->iolock);
+    }
+}
+
+/* Public interface */
+
+void xcb_prefetch_maximum_request_length(xcb_connection_t *c)
+{
+    if(c->has_error)
+        return;
+    pthread_mutex_lock(&c->out.reqlenlock);
+    if(c->out.maximum_request_length_tag == LAZY_NONE)
+    {
+        const xcb_query_extension_reply_t *ext;
+        ext = xcb_get_extension_data(c, &xcb_big_requests_id);
+        if(ext && ext->present)
+        {
+            c->out.maximum_request_length_tag = LAZY_COOKIE;
+            c->out.maximum_request_length.cookie = xcb_big_requests_enable(c);
+        }
+        else
+        {
+            c->out.maximum_request_length_tag = LAZY_FORCED;
+            c->out.maximum_request_length.value = c->setup->maximum_request_length;
+        }
+    }
+    pthread_mutex_unlock(&c->out.reqlenlock);
+}
+
+uint32_t xcb_get_maximum_request_length(xcb_connection_t *c)
+{
+    if(c->has_error)
+        return 0;
+    xcb_prefetch_maximum_request_length(c);
+    pthread_mutex_lock(&c->out.reqlenlock);
+    if(c->out.maximum_request_length_tag == LAZY_COOKIE)
+    {
+        xcb_big_requests_enable_reply_t *r = xcb_big_requests_enable_reply(c, c->out.maximum_request_length.cookie, 0);
+        c->out.maximum_request_length_tag = LAZY_FORCED;
+        if(r)
+        {
+            c->out.maximum_request_length.value = r->maximum_request_length;
+            free(r);
+        }
+        else
+            c->out.maximum_request_length.value = c->setup->maximum_request_length;
+    }
+    pthread_mutex_unlock(&c->out.reqlenlock);
+    return c->out.maximum_request_length.value;
+}
+
+static void close_fds(int *fds, unsigned int num_fds)
+{
+    for (unsigned int index = 0; index < num_fds; index++)
+        close(fds[index]);
+}
+
+static void send_fds(xcb_connection_t *c, int *fds, unsigned int num_fds)
+{
+#if HAVE_SENDMSG
+    /* Calling _xcb_out_flush_to() can drop the iolock and wait on a condition
+     * variable if another thread is currently writing (c->out.writing > 0).
+     * This call waits for writers to be done and thus _xcb_out_flush_to() will
+     * do the work itself (in which case we are a writer and
+     * prepare_socket_request() will wait for us to be done if another threads
+     * tries to send fds, too). Thanks to this, we can atomically write out FDs.
+     */
+    prepare_socket_request(c);
+
+    while (num_fds > 0) {
+        while (c->out.out_fd.nfd == XCB_MAX_PASS_FD && !c->has_error) {
+            /* XXX: if c->out.writing > 0, this releases the iolock and
+             * potentially allows other threads to interfere with their own fds.
+             */
+            _xcb_out_flush_to(c, c->out.request);
+
+            if (c->out.out_fd.nfd == XCB_MAX_PASS_FD) {
+                /* We need some request to send FDs with */
+                _xcb_out_send_sync(c);
+            }
+        }
+        if (c->has_error)
+            break;
+
+        c->out.out_fd.fd[c->out.out_fd.nfd++] = fds[0];
+        fds++;
+        num_fds--;
+    }
+#endif
+    close_fds(fds, num_fds);
+}
+
+uint64_t xcb_send_request_with_fds64(xcb_connection_t *c, int flags, struct iovec *vector,
+                const xcb_protocol_request_t *req, unsigned int num_fds, int *fds)
+{
+    uint64_t request;
+    uint32_t prefix[2];
+    int veclen = req->count;
+    enum workarounds workaround = WORKAROUND_NONE;
+
+    if(c->has_error) {
+        close_fds(fds, num_fds);
+        return 0;
+    }
+
+    assert(c != 0);
+    assert(vector != 0);
+    assert(req->count > 0);
+
+    if(!(flags & XCB_REQUEST_RAW))
+    {
+        static const char pad[3];
+        unsigned int i;
+        uint16_t shortlen = 0;
+        size_t longlen = 0;
+        assert(vector[0].iov_len >= 4);
+        /* set the major opcode, and the minor opcode for extensions */
+        if(req->ext)
+        {
+            const xcb_query_extension_reply_t *extension = xcb_get_extension_data(c, req->ext);
+            if(!(extension && extension->present))
+            {
+                close_fds(fds, num_fds);
+                _xcb_conn_shutdown(c, XCB_CONN_CLOSED_EXT_NOTSUPPORTED);
+                return 0;
+            }
+            ((uint8_t *) vector[0].iov_base)[0] = extension->major_opcode;
+            ((uint8_t *) vector[0].iov_base)[1] = req->opcode;
+        }
+        else
+            ((uint8_t *) vector[0].iov_base)[0] = req->opcode;
+
+        /* put together the length field, possibly using BIGREQUESTS */
+        for(i = 0; i < req->count; ++i)
+        {
+            longlen += vector[i].iov_len;
+            if(!vector[i].iov_base)
+            {
+                vector[i].iov_base = (char *) pad;
+                assert(vector[i].iov_len <= sizeof(pad));
+            }
+        }
+        assert((longlen & 3) == 0);
+        longlen >>= 2;
+
+        if(longlen <= c->setup->maximum_request_length)
+        {
+            /* we don't need BIGREQUESTS. */
+            shortlen = longlen;
+            longlen = 0;
+        }
+        else if(longlen > xcb_get_maximum_request_length(c))
+        {
+            close_fds(fds, num_fds);
+            _xcb_conn_shutdown(c, XCB_CONN_CLOSED_REQ_LEN_EXCEED);
+            return 0; /* server can't take this; maybe need BIGREQUESTS? */
+        }
+
+        /* set the length field. */
+        ((uint16_t *) vector[0].iov_base)[1] = shortlen;
+        if(!shortlen)
+        {
+            prefix[0] = ((uint32_t *) vector[0].iov_base)[0];
+            prefix[1] = ++longlen;
+            vector[0].iov_base = (uint32_t *) vector[0].iov_base + 1;
+            vector[0].iov_len -= sizeof(uint32_t);
+            --vector, ++veclen;
+            vector[0].iov_base = prefix;
+            vector[0].iov_len = sizeof(prefix);
+        }
+    }
+    flags &= ~XCB_REQUEST_RAW;
+
+    /* do we need to work around the X server bug described in glx.xml? */
+    /* XXX: GetFBConfigs won't use BIG-REQUESTS in any sane
+     * configuration, but that should be handled here anyway. */
+    if(req->ext && !req->isvoid && !strcmp(req->ext->name, "GLX") &&
+            ((req->opcode == 17 && ((uint32_t *) vector[0].iov_base)[1] == 0x10004) ||
+             req->opcode == 21))
+        workaround = WORKAROUND_GLX_GET_FB_CONFIGS_BUG;
+
+    /* get a sequence number and arrange for delivery. */
+    pthread_mutex_lock(&c->iolock);
+
+    /* send FDs before establishing a good request number, because this might
+     * call send_sync(), too
+     */
+    send_fds(c, fds, num_fds);
+
+    prepare_socket_request(c);
+
+    /* send GetInputFocus (sync_req) when 64k-2 requests have been sent without
+     * a reply.
+     * Also send sync_req (could use NoOp) at 32-bit wrap to avoid having
+     * applications see sequence 0 as that is used to indicate
+     * an error in sending the request
+     */
+
+    while ((req->isvoid && c->out.request == c->in.request_expected + (1 << 16) - 2) ||
+           (unsigned int) (c->out.request + 1) == 0)
+    {
+        send_sync(c);
+        prepare_socket_request(c);
+    }
+
+    send_request(c, req->isvoid, workaround, flags, vector, veclen);
+    request = c->has_error ? 0 : c->out.request;
+    pthread_mutex_unlock(&c->iolock);
+    return request;
+}
+
+/* request number are actually uint64_t internally but keep API compat with unsigned int */
+unsigned int xcb_send_request_with_fds(xcb_connection_t *c, int flags, struct iovec *vector,
+        const xcb_protocol_request_t *req, unsigned int num_fds, int *fds)
+{
+    return xcb_send_request_with_fds64(c, flags, vector, req, num_fds, fds);
+}
+
+uint64_t xcb_send_request64(xcb_connection_t *c, int flags, struct iovec *vector, const xcb_protocol_request_t *req)
+{
+    return xcb_send_request_with_fds64(c, flags, vector, req, 0, NULL);
+}
+
+/* request number are actually uint64_t internally but keep API compat with unsigned int */
+unsigned int xcb_send_request(xcb_connection_t *c, int flags, struct iovec *vector, const xcb_protocol_request_t *req)
+{
+    return xcb_send_request64(c, flags, vector, req);
+}
+
+void
+xcb_send_fd(xcb_connection_t *c, int fd)
+{
+    int fds[1] = { fd };
+
+    if (c->has_error) {
+        close(fd);
+        return;
+    }
+    pthread_mutex_lock(&c->iolock);
+    send_fds(c, &fds[0], 1);
+    pthread_mutex_unlock(&c->iolock);
+}
+
+int xcb_take_socket(xcb_connection_t *c, void (*return_socket)(void *closure), void *closure, int flags, uint64_t *sent)
+{
+    int ret;
+    if(c->has_error)
+        return 0;
+    pthread_mutex_lock(&c->iolock);
+    get_socket_back(c);
+
+    /* _xcb_out_flush may drop the iolock allowing other threads to
+     * write requests, so keep flushing until we're done
+     */
+    do
+        ret = _xcb_out_flush_to(c, c->out.request);
+    while (ret && c->out.request != c->out.request_written);
+    if(ret)
+    {
+        c->out.return_socket = return_socket;
+        c->out.socket_closure = closure;
+        if(flags) {
+            /* c->out.request + 1 will be the first request sent by the external
+             * socket owner. If the socket is returned before this request is sent
+             * it will be detected in _xcb_in_replies_done and this pending_reply
+             * will be discarded.
+             */
+            _xcb_in_expect_reply(c, c->out.request + 1, WORKAROUND_EXTERNAL_SOCKET_OWNER, flags);
+        }
+        assert(c->out.request == c->out.request_written);
+        *sent = c->out.request;
+    }
+    pthread_mutex_unlock(&c->iolock);
+    return ret;
+}
+
+int xcb_writev(xcb_connection_t *c, struct iovec *vector, int count, uint64_t requests)
+{
+    int ret;
+    if(c->has_error)
+        return 0;
+    pthread_mutex_lock(&c->iolock);
+    c->out.request += requests;
+    ret = _xcb_out_send(c, vector, count);
+    pthread_mutex_unlock(&c->iolock);
+    return ret;
+}
+
+int xcb_flush(xcb_connection_t *c)
+{
+    int ret;
+    if(c->has_error)
+        return 0;
+    pthread_mutex_lock(&c->iolock);
+    ret = _xcb_out_flush_to(c, c->out.request);
+    pthread_mutex_unlock(&c->iolock);
+    return ret;
+}
+
+/* Private interface */
+
+int _xcb_out_init(_xcb_out *out)
+{
+    if(pthread_cond_init(&out->socket_cond, 0))
+        return 0;
+    out->return_socket = 0;
+    out->socket_closure = 0;
+    out->socket_moving = 0;
+
+    if(pthread_cond_init(&out->cond, 0))
+        return 0;
+    out->writing = 0;
+
+    out->queue_len = 0;
+
+    out->request = 0;
+    out->request_written = 0;
+    out->request_expected_written = 0;
+
+    if(pthread_mutex_init(&out->reqlenlock, 0))
+        return 0;
+    out->maximum_request_length_tag = LAZY_NONE;
+
+    return 1;
+}
+
+void _xcb_out_destroy(_xcb_out *out)
+{
+    pthread_mutex_destroy(&out->reqlenlock);
+    pthread_cond_destroy(&out->cond);
+    pthread_cond_destroy(&out->socket_cond);
+}
+
+int _xcb_out_send(xcb_connection_t *c, struct iovec *vector, int count)
+{
+    int ret = 1;
+    while(ret && count)
+        ret = _xcb_conn_wait(c, &c->out.cond, &vector, &count);
+    c->out.request_written = c->out.request;
+    c->out.request_expected_written = c->in.request_expected;
+    pthread_cond_broadcast(&c->out.cond);
+    _xcb_in_wake_up_next_reader(c);
+    return ret;
+}
+
+void _xcb_out_send_sync(xcb_connection_t *c)
+{
+    prepare_socket_request(c);
+    send_sync(c);
+}
+
+int _xcb_out_flush_to(xcb_connection_t *c, uint64_t request)
+{
+    assert(XCB_SEQUENCE_COMPARE(request, <=, c->out.request));
+    if(XCB_SEQUENCE_COMPARE(c->out.request_written, >=, request))
+        return 1;
+    if(c->out.queue_len)
+    {
+        struct iovec vec;
+        vec.iov_base = c->out.queue;
+        vec.iov_len = c->out.queue_len;
+        c->out.queue_len = 0;
+        return _xcb_out_send(c, &vec, 1);
+    }
+    while(c->out.writing)
+        pthread_cond_wait(&c->out.cond, &c->iolock);
+    assert(XCB_SEQUENCE_COMPARE(c->out.request_written, >=, request));
+    return 1;
+}
diff --git a/depends/libxcb/src/xcb_util.c b/depends/libxcb/src/xcb_util.c
new file mode 100644
index 0000000..0296ce0
--- /dev/null
+++ b/depends/libxcb/src/xcb_util.c
@@ -0,0 +1,557 @@
+/* Copyright (C) 2001-2004 Bart Massey and Jamey Sharp.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the names of the authors or their
+ * institutions shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the authors.
+ */
+
+/* Utility functions implementable using only public APIs. */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <assert.h>
+#include <sys/types.h>
+#include <limits.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+
+#ifdef _WIN32
+#include "xcb_windefs.h"
+#else
+#include <unistd.h>
+#include <arpa/inet.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <fcntl.h>
+#include <netdb.h>
+#endif /* _WIN32 */
+
+#include "xcb.h"
+#include "xcbext.h"
+#include "xcbint.h"
+
+#if defined(HAVE_TSOL_LABEL_H) && defined(HAVE_IS_SYSTEM_LABELED)
+# include <tsol/label.h>
+# include <sys/stat.h>
+#endif
+
+#ifdef HAVE_LAUNCHD
+#include <sys/stat.h>
+#endif
+
+int xcb_popcount(uint32_t mask)
+{
+    uint32_t y;
+    y = (mask >> 1) & 033333333333;
+    y = mask - y - ((y >> 1) & 033333333333);
+    return ((y + (y >> 3)) & 030707070707) % 077;
+}
+
+int xcb_sumof(uint8_t *list, int len)
+{
+  int i, s = 0;
+  for(i=0; i<len; i++) {
+    s += *list;
+    list++;
+  }
+  return s;
+}
+
+#ifdef HAVE_LAUNCHD
+/* Return true and parse if name matches <path to socket>[.<screen>]
+ * Upon success:
+ *     host = <path to socket>
+ *     protocol = "unix"
+ *     display = 0
+ *     screen = <screen>
+ */
+static int _xcb_parse_display_path_to_socket(const char *name, char **host, char **protocol,
+                                             int *displayp, int *screenp)
+{
+    struct stat sbuf;
+    char path[PATH_MAX];
+    int _screen = 0;
+
+    strlcpy(path, name, sizeof(path));
+    if (0 != stat(path, &sbuf)) {
+        char *dot = strrchr(path, '.');
+        if (!dot)
+            return 0;
+        *dot = '\0';
+
+        if (0 != stat(path, &sbuf))
+            return 0;
+
+        _screen = atoi(dot + 1);
+    }
+
+    if (host) {
+        *host = strdup(path);
+        if (!*host)
+            return 0;
+    }
+
+    if (protocol) {
+        *protocol = strdup("unix");
+        if (!*protocol) {
+            if (host)
+                free(*host);
+            return 0;
+        }
+    }
+
+    if (displayp)
+        *displayp = 0;
+
+    if (screenp)
+        *screenp = _screen;
+
+    return 1;
+}
+#endif
+
+static int _xcb_parse_display(const char *name, char **host, char **protocol,
+                      int *displayp, int *screenp)
+{
+    int len, display, screen;
+    char *slash, *colon, *dot, *end;
+
+    if(!name || !*name)
+        name = getenv("DISPLAY");
+    if(!name)
+        return 0;
+
+#ifdef HAVE_LAUNCHD
+    /* First check for <path to socket>[.<screen>] */
+    if (_xcb_parse_display_path_to_socket(name, host, protocol, displayp, screenp))
+        return 1;
+#endif
+
+    slash = strrchr(name, '/');
+
+    if (slash) {
+        len = slash - name;
+        if (protocol) {
+            *protocol = malloc(len + 1);
+            if(!*protocol)
+                return 0;
+            memcpy(*protocol, name, len);
+            (*protocol)[len] = '\0';
+        }
+        name = slash + 1;
+    } else
+        if (protocol)
+            *protocol = NULL;
+
+    colon = strrchr(name, ':');
+    if(!colon)
+        goto error_out;
+    len = colon - name;
+    ++colon;
+    display = strtoul(colon, &dot, 10);
+    if(dot == colon)
+        goto error_out;
+    if(*dot == '\0')
+        screen = 0;
+    else
+    {
+        if(*dot != '.')
+            goto error_out;
+        ++dot;
+        screen = strtoul(dot, &end, 10);
+        if(end == dot || *end != '\0')
+            goto error_out;
+    }
+    /* At this point, the display string is fully parsed and valid, but
+     * the caller's memory is untouched. */
+
+    *host = malloc(len + 1);
+    if(!*host)
+        goto error_out;
+    memcpy(*host, name, len);
+    (*host)[len] = '\0';
+    *displayp = display;
+    if(screenp)
+        *screenp = screen;
+    return 1;
+
+error_out:
+    if (protocol) {
+        free(*protocol);
+        *protocol = NULL;
+    }
+
+    return 0;
+}
+
+int xcb_parse_display(const char *name, char **host, int *displayp,
+                             int *screenp)
+{
+    return _xcb_parse_display(name, host, NULL, displayp, screenp);
+}
+
+static int _xcb_open_tcp(const char *host, char *protocol, const unsigned short port);
+#ifndef _WIN32
+static int _xcb_open_unix(char *protocol, const char *file);
+#endif /* !WIN32 */
+#ifdef HAVE_ABSTRACT_SOCKETS
+static int _xcb_open_abstract(char *protocol, const char *file, size_t filelen);
+#endif
+
+static int _xcb_open(const char *host, char *protocol, const int display)
+{
+    int fd;
+#ifdef __hpux
+    static const char unix_base[] = "/usr/spool/sockets/X11/";
+#else
+    static const char unix_base[] = "/tmp/.X11-unix/X";
+#endif
+    const char *base = unix_base;
+    size_t filelen;
+    char *file = NULL;
+    int actual_filelen;
+
+    /* If protocol or host is "unix", fall through to Unix socket code below */
+    if ((!protocol || (strcmp("unix",protocol) != 0)) &&
+        (*host != '\0') && (strcmp("unix",host) != 0))
+    {
+        /* display specifies TCP */
+        unsigned short port = X_TCP_PORT + display;
+        return _xcb_open_tcp(host, protocol, port);
+    }
+
+#ifndef _WIN32
+#if defined(HAVE_TSOL_LABEL_H) && defined(HAVE_IS_SYSTEM_LABELED)
+    /* Check special path for Unix sockets under Solaris Trusted Extensions */
+    if (is_system_labeled())
+    {
+        struct stat sbuf;
+        const char *tsol_base = "/var/tsol/doors/.X11-unix/X";
+        char tsol_socket[PATH_MAX];
+
+        snprintf(tsol_socket, sizeof(tsol_socket), "%s%d", tsol_base, display);
+
+        if (stat(tsol_socket, &sbuf) == 0)
+            base = tsol_base;
+    }
+#endif
+
+#ifdef HAVE_LAUNCHD
+    struct stat sbuf;
+    if (0 == stat(host, &sbuf)) {
+        file = strdup(host);
+        if(file == NULL)
+            return -1;
+        filelen = actual_filelen = strlen(file);
+    } else
+#endif
+    {
+        filelen = strlen(base) + 1 + sizeof(display) * 3 + 1;
+        file = malloc(filelen);
+        if(file == NULL)
+            return -1;
+
+        /* display specifies Unix socket */
+        actual_filelen = snprintf(file, filelen, "%s%d", base, display);
+    }
+
+    if(actual_filelen < 0)
+    {
+        free(file);
+        return -1;
+    }
+    /* snprintf may truncate the file */
+    filelen = MIN(actual_filelen, filelen - 1);
+#ifdef HAVE_ABSTRACT_SOCKETS
+    fd = _xcb_open_abstract(protocol, file, filelen);
+    if (fd >= 0 || (errno != ENOENT && errno != ECONNREFUSED))
+    {
+        free(file);
+        return fd;
+    }
+
+#endif
+    fd = _xcb_open_unix(protocol, file);
+    free(file);
+
+    if (fd < 0 && !protocol && *host == '\0') {
+            unsigned short port = X_TCP_PORT + display;
+            fd = _xcb_open_tcp(host, protocol, port);
+    }
+
+    return fd;
+#endif /* !_WIN32 */
+    return -1; /* if control reaches here then something has gone wrong */
+}
+
+static int _xcb_socket(int family, int type, int proto)
+{
+    int fd;
+
+#ifdef SOCK_CLOEXEC
+    fd = socket(family, type | SOCK_CLOEXEC, proto);
+    if (fd == -1 && errno == EINVAL)
+#endif
+    {
+        fd = socket(family, type, proto);
+#ifndef _WIN32
+        if (fd >= 0)
+            fcntl(fd, F_SETFD, FD_CLOEXEC);
+#endif
+    }
+    return fd;
+}
+
+
+static int _xcb_do_connect(int fd, const struct sockaddr* addr, int addrlen) {
+    int on = 1;
+
+    if(fd < 0)
+        return -1;
+
+    setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on));
+    setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on));
+
+    return connect(fd, addr, addrlen);
+}
+
+static int _xcb_open_tcp(const char *host, char *protocol, const unsigned short port)
+{
+    int fd = -1;
+#if HAVE_GETADDRINFO
+    struct addrinfo hints;
+    char service[6]; /* "65535" with the trailing '\0' */
+    struct addrinfo *results, *addr;
+    char *bracket;
+#endif
+
+    if (protocol && strcmp("tcp",protocol) && strcmp("inet",protocol)
+#ifdef AF_INET6
+                 && strcmp("inet6",protocol)
+#endif
+        )
+        return -1;
+
+    if (*host == '\0')
+        host = "localhost";
+
+#if HAVE_GETADDRINFO
+    memset(&hints, 0, sizeof(hints));
+#ifdef AI_NUMERICSERV
+    hints.ai_flags |= AI_NUMERICSERV;
+#endif
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+
+#ifdef AF_INET6
+    /* Allow IPv6 addresses enclosed in brackets. */
+    if(host[0] == '[' && (bracket = strrchr(host, ']')) && bracket[1] == '\0')
+    {
+        *bracket = '\0';
+        ++host;
+        hints.ai_flags |= AI_NUMERICHOST;
+        hints.ai_family = AF_INET6;
+    }
+#endif
+
+    snprintf(service, sizeof(service), "%hu", port);
+    if(getaddrinfo(host, service, &hints, &results))
+        /* FIXME: use gai_strerror, and fill in error connection */
+        return -1;
+
+    for(addr = results; addr; addr = addr->ai_next)
+    {
+        fd = _xcb_socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
+        if (_xcb_do_connect(fd, addr->ai_addr, addr->ai_addrlen) >= 0)
+            break;
+        close(fd);
+        fd = -1;
+    }
+    freeaddrinfo(results);
+    return fd;
+#else
+    {
+        struct hostent* _h;
+        struct sockaddr_in _s;
+        struct in_addr ** _c;
+
+        if((_h = gethostbyname(host)) == NULL)
+            return -1;
+
+        _c = (struct in_addr**)_h->h_addr_list;
+        fd = -1;
+
+        while(*_c) {
+            _s.sin_family = AF_INET;
+            _s.sin_port = htons(port);
+            _s.sin_addr = *(*_c);
+
+            fd = _xcb_socket(_s.sin_family, SOCK_STREAM, 0);
+            if(_xcb_do_connect(fd, (struct sockaddr*)&_s, sizeof(_s)) >= 0)
+                break;
+
+#ifdef _WIN32
+            closesocket(fd);
+#else
+            close(fd);
+#endif
+            fd = -1;
+            ++_c;
+        }
+
+        return fd;
+    }
+#endif
+}
+
+#ifndef _WIN32
+static int _xcb_open_unix(char *protocol, const char *file)
+{
+    int fd;
+    struct sockaddr_un addr;
+    socklen_t len = sizeof(int);
+    int val;
+
+    if (protocol && strcmp("unix",protocol))
+        return -1;
+
+    strcpy(addr.sun_path, file);
+    addr.sun_family = AF_UNIX;
+#ifdef HAVE_SOCKADDR_SUN_LEN
+    addr.sun_len = SUN_LEN(&addr);
+#endif
+    fd = _xcb_socket(AF_UNIX, SOCK_STREAM, 0);
+    if(fd == -1)
+        return -1;
+    if(getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &val, &len) == 0 && val < 64 * 1024)
+    {
+        val = 64 * 1024;
+        setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &val, sizeof(int));
+    }
+    if(connect(fd, (struct sockaddr *) &addr, sizeof(addr)) == -1) {
+        close(fd);
+        return -1;
+    }
+    return fd;
+}
+#endif /* !_WIN32 */
+
+#ifdef HAVE_ABSTRACT_SOCKETS
+static int _xcb_open_abstract(char *protocol, const char *file, size_t filelen)
+{
+    int fd;
+    struct sockaddr_un addr = {0};
+    socklen_t namelen;
+
+    if (protocol && strcmp("unix",protocol))
+        return -1;
+
+    strcpy(addr.sun_path + 1, file);
+    addr.sun_family = AF_UNIX;
+    namelen = offsetof(struct sockaddr_un, sun_path) + 1 + filelen;
+#ifdef HAVE_SOCKADDR_SUN_LEN
+    addr.sun_len = 1 + filelen;
+#endif
+    fd = _xcb_socket(AF_UNIX, SOCK_STREAM, 0);
+    if (fd == -1)
+        return -1;
+    if (connect(fd, (struct sockaddr *) &addr, namelen) == -1) {
+        close(fd);
+        return -1;
+    }
+    return fd;
+}
+#endif
+
+xcb_connection_t *xcb_connect(const char *displayname, int *screenp)
+{
+    return xcb_connect_to_display_with_auth_info(displayname, NULL, screenp);
+}
+
+xcb_connection_t *xcb_connect_to_display_with_auth_info(const char *displayname, xcb_auth_info_t *auth, int *screenp)
+{
+    int fd, display = 0;
+    char *host = NULL;
+    char *protocol = NULL;
+    xcb_auth_info_t ourauth;
+    xcb_connection_t *c;
+
+    int parsed = _xcb_parse_display(displayname, &host, &protocol, &display, screenp);
+
+    if(!parsed) {
+        c = _xcb_conn_ret_error(XCB_CONN_CLOSED_PARSE_ERR);
+        goto out;
+    }
+
+#ifdef _WIN32
+    WSADATA wsaData;
+    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
+        c = _xcb_conn_ret_error(XCB_CONN_ERROR);
+        goto out;
+    }
+#endif
+
+    fd = _xcb_open(host, protocol, display);
+
+    if(fd == -1) {
+        c = _xcb_conn_ret_error(XCB_CONN_ERROR);
+#ifdef _WIN32
+        WSACleanup();
+#endif
+        goto out;
+    }
+
+    if(auth) {
+        c = xcb_connect_to_fd(fd, auth);
+        goto out;
+    }
+
+    if(_xcb_get_auth_info(fd, &ourauth, display))
+    {
+        c = xcb_connect_to_fd(fd, &ourauth);
+        free(ourauth.name);
+        free(ourauth.data);
+    }
+    else
+        c = xcb_connect_to_fd(fd, 0);
+
+    if(c->has_error)
+        goto out;
+
+    /* Make sure requested screen number is in bounds for this server */
+    if((screenp != NULL) && (*screenp >= (int) c->setup->roots_len)) {
+        xcb_disconnect(c);
+        c = _xcb_conn_ret_error(XCB_CONN_CLOSED_INVALID_SCREEN);
+        goto out;
+    }
+
+out:
+    free(host);
+    free(protocol);
+    return c;
+}
diff --git a/depends/libxcb/src/xcb_xid.c b/depends/libxcb/src/xcb_xid.c
new file mode 100644
index 0000000..ebe41a1
--- /dev/null
+++ b/depends/libxcb/src/xcb_xid.c
@@ -0,0 +1,101 @@
+/* Copyright (C) 2001-2008 Bart Massey and Jamey Sharp.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * 
+ * Except as contained in this notice, the names of the authors or their
+ * institutions shall not be used in advertising or otherwise to promote the
+ * sale, use or other dealings in this Software without prior written
+ * authorization from the authors.
+ */
+
+/* XID allocators. */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <assert.h>
+#include <stdlib.h>
+#include "xcb.h"
+#include "xcbext.h"
+#include "xcbint.h"
+#include "xc_misc.h"
+
+/* Public interface */
+
+uint32_t xcb_generate_id(xcb_connection_t *c)
+{
+    uint32_t ret;
+    if(c->has_error)
+        return -1;
+    pthread_mutex_lock(&c->xid.lock);
+    if(c->xid.last >= c->xid.max - c->xid.inc + 1)
+    {
+        xcb_xc_misc_get_xid_range_reply_t *range;
+        assert(c->xid.last == c->xid.max);
+        if (c->xid.last == 0) {
+            /* finish setting up initial range */
+            c->xid.max = c->setup->resource_id_mask;
+        } else {
+            /* check for extension */
+            const xcb_query_extension_reply_t *xc_misc_reply =
+              xcb_get_extension_data(c, &xcb_xc_misc_id);
+            if (!xc_misc_reply || !xc_misc_reply->present) {
+                pthread_mutex_unlock(&c->xid.lock);
+                return -1;
+            }
+            /* get new range */
+            range = xcb_xc_misc_get_xid_range_reply(c,
+                      xcb_xc_misc_get_xid_range(c), 0);
+            /* XXX The latter disjunct is what the server returns
+               when it is out of XIDs.  Sweet. */
+            if(!range || (range->start_id == 0 && range->count == 1))
+            {
+                pthread_mutex_unlock(&c->xid.lock);
+                return -1;
+            }
+            assert(range->count > 0 && range->start_id > 0);
+            c->xid.last = range->start_id;
+            c->xid.max = range->start_id + (range->count - 1) * c->xid.inc;
+            free(range);
+        }
+    } else {
+        c->xid.last += c->xid.inc;
+    }
+    ret = c->xid.last | c->xid.base;
+    pthread_mutex_unlock(&c->xid.lock);
+    return ret;
+}
+
+/* Private interface */
+
+int _xcb_xid_init(xcb_connection_t *c)
+{
+    if(pthread_mutex_init(&c->xid.lock, 0))
+        return 0;
+    c->xid.last = 0;
+    c->xid.max = 0;
+    c->xid.base = c->setup->resource_id_base;
+    c->xid.inc = c->setup->resource_id_mask & -(c->setup->resource_id_mask);
+    return 1;
+}
+
+void _xcb_xid_destroy(xcb_connection_t *c)
+{
+    pthread_mutex_destroy(&c->xid.lock);
+}
diff --git a/depends/libxcb/src/xevie.c b/depends/libxcb/src/xevie.c
new file mode 100644
index 0000000..0adbf03
--- /dev/null
+++ b/depends/libxcb/src/xevie.c
@@ -0,0 +1,347 @@
+/*
+ * This file generated automatically from xevie.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "xevie.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+
+xcb_extension_t xcb_xevie_id = { "XEVIE", 0 };
+
+xcb_xevie_query_version_cookie_t
+xcb_xevie_query_version (xcb_connection_t *c,
+                         uint16_t          client_major_version,
+                         uint16_t          client_minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xevie_id,
+        .opcode = XCB_XEVIE_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xevie_query_version_cookie_t xcb_ret;
+    xcb_xevie_query_version_request_t xcb_out;
+
+    xcb_out.client_major_version = client_major_version;
+    xcb_out.client_minor_version = client_minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xevie_query_version_cookie_t
+xcb_xevie_query_version_unchecked (xcb_connection_t *c,
+                                   uint16_t          client_major_version,
+                                   uint16_t          client_minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xevie_id,
+        .opcode = XCB_XEVIE_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xevie_query_version_cookie_t xcb_ret;
+    xcb_xevie_query_version_request_t xcb_out;
+
+    xcb_out.client_major_version = client_major_version;
+    xcb_out.client_minor_version = client_minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xevie_query_version_reply_t *
+xcb_xevie_query_version_reply (xcb_connection_t                  *c,
+                               xcb_xevie_query_version_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_xevie_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_xevie_start_cookie_t
+xcb_xevie_start (xcb_connection_t *c,
+                 uint32_t          screen)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xevie_id,
+        .opcode = XCB_XEVIE_START,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xevie_start_cookie_t xcb_ret;
+    xcb_xevie_start_request_t xcb_out;
+
+    xcb_out.screen = screen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xevie_start_cookie_t
+xcb_xevie_start_unchecked (xcb_connection_t *c,
+                           uint32_t          screen)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xevie_id,
+        .opcode = XCB_XEVIE_START,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xevie_start_cookie_t xcb_ret;
+    xcb_xevie_start_request_t xcb_out;
+
+    xcb_out.screen = screen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xevie_start_reply_t *
+xcb_xevie_start_reply (xcb_connection_t          *c,
+                       xcb_xevie_start_cookie_t   cookie  /**< */,
+                       xcb_generic_error_t      **e)
+{
+    return (xcb_xevie_start_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_xevie_end_cookie_t
+xcb_xevie_end (xcb_connection_t *c,
+               uint32_t          cmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xevie_id,
+        .opcode = XCB_XEVIE_END,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xevie_end_cookie_t xcb_ret;
+    xcb_xevie_end_request_t xcb_out;
+
+    xcb_out.cmap = cmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xevie_end_cookie_t
+xcb_xevie_end_unchecked (xcb_connection_t *c,
+                         uint32_t          cmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xevie_id,
+        .opcode = XCB_XEVIE_END,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xevie_end_cookie_t xcb_ret;
+    xcb_xevie_end_request_t xcb_out;
+
+    xcb_out.cmap = cmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xevie_end_reply_t *
+xcb_xevie_end_reply (xcb_connection_t        *c,
+                     xcb_xevie_end_cookie_t   cookie  /**< */,
+                     xcb_generic_error_t    **e)
+{
+    return (xcb_xevie_end_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+void
+xcb_xevie_event_next (xcb_xevie_event_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xevie_event_t);
+}
+
+xcb_generic_iterator_t
+xcb_xevie_event_end (xcb_xevie_event_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+xcb_xevie_send_cookie_t
+xcb_xevie_send (xcb_connection_t  *c,
+                xcb_xevie_event_t  event,
+                uint32_t           data_type)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xevie_id,
+        .opcode = XCB_XEVIE_SEND,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xevie_send_cookie_t xcb_ret;
+    xcb_xevie_send_request_t xcb_out;
+
+    xcb_out.event = event;
+    xcb_out.data_type = data_type;
+    memset(xcb_out.pad0, 0, 64);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xevie_send_cookie_t
+xcb_xevie_send_unchecked (xcb_connection_t  *c,
+                          xcb_xevie_event_t  event,
+                          uint32_t           data_type)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xevie_id,
+        .opcode = XCB_XEVIE_SEND,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xevie_send_cookie_t xcb_ret;
+    xcb_xevie_send_request_t xcb_out;
+
+    xcb_out.event = event;
+    xcb_out.data_type = data_type;
+    memset(xcb_out.pad0, 0, 64);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xevie_send_reply_t *
+xcb_xevie_send_reply (xcb_connection_t         *c,
+                      xcb_xevie_send_cookie_t   cookie  /**< */,
+                      xcb_generic_error_t     **e)
+{
+    return (xcb_xevie_send_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_xevie_select_input_cookie_t
+xcb_xevie_select_input (xcb_connection_t *c,
+                        uint32_t          event_mask)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xevie_id,
+        .opcode = XCB_XEVIE_SELECT_INPUT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xevie_select_input_cookie_t xcb_ret;
+    xcb_xevie_select_input_request_t xcb_out;
+
+    xcb_out.event_mask = event_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xevie_select_input_cookie_t
+xcb_xevie_select_input_unchecked (xcb_connection_t *c,
+                                  uint32_t          event_mask)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xevie_id,
+        .opcode = XCB_XEVIE_SELECT_INPUT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xevie_select_input_cookie_t xcb_ret;
+    xcb_xevie_select_input_request_t xcb_out;
+
+    xcb_out.event_mask = event_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xevie_select_input_reply_t *
+xcb_xevie_select_input_reply (xcb_connection_t                 *c,
+                              xcb_xevie_select_input_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_xevie_select_input_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
diff --git a/depends/libxcb/src/xf86dri.c b/depends/libxcb/src/xf86dri.c
new file mode 100644
index 0000000..7d48d44
--- /dev/null
+++ b/depends/libxcb/src/xf86dri.c
@@ -0,0 +1,1005 @@
+/*
+ * This file generated automatically from xf86dri.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "xf86dri.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+
+xcb_extension_t xcb_xf86dri_id = { "XFree86-DRI", 0 };
+
+void
+xcb_xf86dri_drm_clip_rect_next (xcb_xf86dri_drm_clip_rect_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xf86dri_drm_clip_rect_t);
+}
+
+xcb_generic_iterator_t
+xcb_xf86dri_drm_clip_rect_end (xcb_xf86dri_drm_clip_rect_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+xcb_xf86dri_query_version_cookie_t
+xcb_xf86dri_query_version (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xf86dri_query_version_cookie_t xcb_ret;
+    xcb_xf86dri_query_version_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xf86dri_query_version_cookie_t
+xcb_xf86dri_query_version_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xf86dri_query_version_cookie_t xcb_ret;
+    xcb_xf86dri_query_version_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xf86dri_query_version_reply_t *
+xcb_xf86dri_query_version_reply (xcb_connection_t                    *c,
+                                 xcb_xf86dri_query_version_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e)
+{
+    return (xcb_xf86dri_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_xf86dri_query_direct_rendering_capable_cookie_t
+xcb_xf86dri_query_direct_rendering_capable (xcb_connection_t *c,
+                                            uint32_t          screen)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_QUERY_DIRECT_RENDERING_CAPABLE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xf86dri_query_direct_rendering_capable_cookie_t xcb_ret;
+    xcb_xf86dri_query_direct_rendering_capable_request_t xcb_out;
+
+    xcb_out.screen = screen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xf86dri_query_direct_rendering_capable_cookie_t
+xcb_xf86dri_query_direct_rendering_capable_unchecked (xcb_connection_t *c,
+                                                      uint32_t          screen)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_QUERY_DIRECT_RENDERING_CAPABLE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xf86dri_query_direct_rendering_capable_cookie_t xcb_ret;
+    xcb_xf86dri_query_direct_rendering_capable_request_t xcb_out;
+
+    xcb_out.screen = screen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xf86dri_query_direct_rendering_capable_reply_t *
+xcb_xf86dri_query_direct_rendering_capable_reply (xcb_connection_t                                     *c,
+                                                  xcb_xf86dri_query_direct_rendering_capable_cookie_t   cookie  /**< */,
+                                                  xcb_generic_error_t                                 **e)
+{
+    return (xcb_xf86dri_query_direct_rendering_capable_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xf86dri_open_connection_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xf86dri_open_connection_reply_t *_aux = (xcb_xf86dri_open_connection_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xf86dri_open_connection_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* bus_id */
+    xcb_block_len += _aux->bus_id_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xf86dri_open_connection_cookie_t
+xcb_xf86dri_open_connection (xcb_connection_t *c,
+                             uint32_t          screen)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_OPEN_CONNECTION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xf86dri_open_connection_cookie_t xcb_ret;
+    xcb_xf86dri_open_connection_request_t xcb_out;
+
+    xcb_out.screen = screen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xf86dri_open_connection_cookie_t
+xcb_xf86dri_open_connection_unchecked (xcb_connection_t *c,
+                                       uint32_t          screen)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_OPEN_CONNECTION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xf86dri_open_connection_cookie_t xcb_ret;
+    xcb_xf86dri_open_connection_request_t xcb_out;
+
+    xcb_out.screen = screen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_xf86dri_open_connection_bus_id (const xcb_xf86dri_open_connection_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_xf86dri_open_connection_bus_id_length (const xcb_xf86dri_open_connection_reply_t *R)
+{
+    return R->bus_id_len;
+}
+
+xcb_generic_iterator_t
+xcb_xf86dri_open_connection_bus_id_end (const xcb_xf86dri_open_connection_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->bus_id_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xf86dri_open_connection_reply_t *
+xcb_xf86dri_open_connection_reply (xcb_connection_t                      *c,
+                                   xcb_xf86dri_open_connection_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e)
+{
+    return (xcb_xf86dri_open_connection_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_xf86dri_close_connection_checked (xcb_connection_t *c,
+                                      uint32_t          screen)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_CLOSE_CONNECTION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xf86dri_close_connection_request_t xcb_out;
+
+    xcb_out.screen = screen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xf86dri_close_connection (xcb_connection_t *c,
+                              uint32_t          screen)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_CLOSE_CONNECTION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xf86dri_close_connection_request_t xcb_out;
+
+    xcb_out.screen = screen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_xf86dri_get_client_driver_name_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xf86dri_get_client_driver_name_reply_t *_aux = (xcb_xf86dri_get_client_driver_name_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xf86dri_get_client_driver_name_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* client_driver_name */
+    xcb_block_len += _aux->client_driver_name_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xf86dri_get_client_driver_name_cookie_t
+xcb_xf86dri_get_client_driver_name (xcb_connection_t *c,
+                                    uint32_t          screen)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_GET_CLIENT_DRIVER_NAME,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xf86dri_get_client_driver_name_cookie_t xcb_ret;
+    xcb_xf86dri_get_client_driver_name_request_t xcb_out;
+
+    xcb_out.screen = screen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xf86dri_get_client_driver_name_cookie_t
+xcb_xf86dri_get_client_driver_name_unchecked (xcb_connection_t *c,
+                                              uint32_t          screen)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_GET_CLIENT_DRIVER_NAME,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xf86dri_get_client_driver_name_cookie_t xcb_ret;
+    xcb_xf86dri_get_client_driver_name_request_t xcb_out;
+
+    xcb_out.screen = screen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_xf86dri_get_client_driver_name_client_driver_name (const xcb_xf86dri_get_client_driver_name_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_xf86dri_get_client_driver_name_client_driver_name_length (const xcb_xf86dri_get_client_driver_name_reply_t *R)
+{
+    return R->client_driver_name_len;
+}
+
+xcb_generic_iterator_t
+xcb_xf86dri_get_client_driver_name_client_driver_name_end (const xcb_xf86dri_get_client_driver_name_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->client_driver_name_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xf86dri_get_client_driver_name_reply_t *
+xcb_xf86dri_get_client_driver_name_reply (xcb_connection_t                             *c,
+                                          xcb_xf86dri_get_client_driver_name_cookie_t   cookie  /**< */,
+                                          xcb_generic_error_t                         **e)
+{
+    return (xcb_xf86dri_get_client_driver_name_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_xf86dri_create_context_cookie_t
+xcb_xf86dri_create_context (xcb_connection_t *c,
+                            uint32_t          screen,
+                            uint32_t          visual,
+                            uint32_t          context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_CREATE_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xf86dri_create_context_cookie_t xcb_ret;
+    xcb_xf86dri_create_context_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.visual = visual;
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xf86dri_create_context_cookie_t
+xcb_xf86dri_create_context_unchecked (xcb_connection_t *c,
+                                      uint32_t          screen,
+                                      uint32_t          visual,
+                                      uint32_t          context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_CREATE_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xf86dri_create_context_cookie_t xcb_ret;
+    xcb_xf86dri_create_context_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.visual = visual;
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xf86dri_create_context_reply_t *
+xcb_xf86dri_create_context_reply (xcb_connection_t                     *c,
+                                  xcb_xf86dri_create_context_cookie_t   cookie  /**< */,
+                                  xcb_generic_error_t                 **e)
+{
+    return (xcb_xf86dri_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_xf86dri_destroy_context_checked (xcb_connection_t *c,
+                                     uint32_t          screen,
+                                     uint32_t          context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_DESTROY_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xf86dri_destroy_context_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xf86dri_destroy_context (xcb_connection_t *c,
+                             uint32_t          screen,
+                             uint32_t          context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_DESTROY_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xf86dri_destroy_context_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xf86dri_create_drawable_cookie_t
+xcb_xf86dri_create_drawable (xcb_connection_t *c,
+                             uint32_t          screen,
+                             uint32_t          drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_CREATE_DRAWABLE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xf86dri_create_drawable_cookie_t xcb_ret;
+    xcb_xf86dri_create_drawable_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xf86dri_create_drawable_cookie_t
+xcb_xf86dri_create_drawable_unchecked (xcb_connection_t *c,
+                                       uint32_t          screen,
+                                       uint32_t          drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_CREATE_DRAWABLE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xf86dri_create_drawable_cookie_t xcb_ret;
+    xcb_xf86dri_create_drawable_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xf86dri_create_drawable_reply_t *
+xcb_xf86dri_create_drawable_reply (xcb_connection_t                      *c,
+                                   xcb_xf86dri_create_drawable_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e)
+{
+    return (xcb_xf86dri_create_drawable_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_xf86dri_destroy_drawable_checked (xcb_connection_t *c,
+                                      uint32_t          screen,
+                                      uint32_t          drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_DESTROY_DRAWABLE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xf86dri_destroy_drawable_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xf86dri_destroy_drawable (xcb_connection_t *c,
+                              uint32_t          screen,
+                              uint32_t          drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_DESTROY_DRAWABLE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xf86dri_destroy_drawable_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_xf86dri_get_drawable_info_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xf86dri_get_drawable_info_reply_t *_aux = (xcb_xf86dri_get_drawable_info_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xf86dri_get_drawable_info_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* clip_rects */
+    xcb_block_len += _aux->num_clip_rects * sizeof(xcb_xf86dri_drm_clip_rect_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xf86dri_drm_clip_rect_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* back_clip_rects */
+    xcb_block_len += _aux->num_back_clip_rects * sizeof(xcb_xf86dri_drm_clip_rect_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xf86dri_drm_clip_rect_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xf86dri_get_drawable_info_cookie_t
+xcb_xf86dri_get_drawable_info (xcb_connection_t *c,
+                               uint32_t          screen,
+                               uint32_t          drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_GET_DRAWABLE_INFO,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xf86dri_get_drawable_info_cookie_t xcb_ret;
+    xcb_xf86dri_get_drawable_info_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xf86dri_get_drawable_info_cookie_t
+xcb_xf86dri_get_drawable_info_unchecked (xcb_connection_t *c,
+                                         uint32_t          screen,
+                                         uint32_t          drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_GET_DRAWABLE_INFO,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xf86dri_get_drawable_info_cookie_t xcb_ret;
+    xcb_xf86dri_get_drawable_info_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xf86dri_drm_clip_rect_t *
+xcb_xf86dri_get_drawable_info_clip_rects (const xcb_xf86dri_get_drawable_info_reply_t *R)
+{
+    return (xcb_xf86dri_drm_clip_rect_t *) (R + 1);
+}
+
+int
+xcb_xf86dri_get_drawable_info_clip_rects_length (const xcb_xf86dri_get_drawable_info_reply_t *R)
+{
+    return R->num_clip_rects;
+}
+
+xcb_xf86dri_drm_clip_rect_iterator_t
+xcb_xf86dri_get_drawable_info_clip_rects_iterator (const xcb_xf86dri_get_drawable_info_reply_t *R)
+{
+    xcb_xf86dri_drm_clip_rect_iterator_t i;
+    i.data = (xcb_xf86dri_drm_clip_rect_t *) (R + 1);
+    i.rem = R->num_clip_rects;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xf86dri_drm_clip_rect_t *
+xcb_xf86dri_get_drawable_info_back_clip_rects (const xcb_xf86dri_get_drawable_info_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_xf86dri_drm_clip_rect_end(xcb_xf86dri_get_drawable_info_clip_rects_iterator(R));
+    return (xcb_xf86dri_drm_clip_rect_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xf86dri_drm_clip_rect_t, prev.index) + 0);
+}
+
+int
+xcb_xf86dri_get_drawable_info_back_clip_rects_length (const xcb_xf86dri_get_drawable_info_reply_t *R)
+{
+    return R->num_back_clip_rects;
+}
+
+xcb_xf86dri_drm_clip_rect_iterator_t
+xcb_xf86dri_get_drawable_info_back_clip_rects_iterator (const xcb_xf86dri_get_drawable_info_reply_t *R)
+{
+    xcb_xf86dri_drm_clip_rect_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_xf86dri_drm_clip_rect_end(xcb_xf86dri_get_drawable_info_clip_rects_iterator(R));
+    i.data = (xcb_xf86dri_drm_clip_rect_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xf86dri_drm_clip_rect_t, prev.index));
+    i.rem = R->num_back_clip_rects;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xf86dri_get_drawable_info_reply_t *
+xcb_xf86dri_get_drawable_info_reply (xcb_connection_t                        *c,
+                                     xcb_xf86dri_get_drawable_info_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e)
+{
+    return (xcb_xf86dri_get_drawable_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xf86dri_get_device_info_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xf86dri_get_device_info_reply_t *_aux = (xcb_xf86dri_get_device_info_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xf86dri_get_device_info_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* device_private */
+    xcb_block_len += _aux->device_private_size * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xf86dri_get_device_info_cookie_t
+xcb_xf86dri_get_device_info (xcb_connection_t *c,
+                             uint32_t          screen)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_GET_DEVICE_INFO,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xf86dri_get_device_info_cookie_t xcb_ret;
+    xcb_xf86dri_get_device_info_request_t xcb_out;
+
+    xcb_out.screen = screen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xf86dri_get_device_info_cookie_t
+xcb_xf86dri_get_device_info_unchecked (xcb_connection_t *c,
+                                       uint32_t          screen)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_GET_DEVICE_INFO,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xf86dri_get_device_info_cookie_t xcb_ret;
+    xcb_xf86dri_get_device_info_request_t xcb_out;
+
+    xcb_out.screen = screen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_xf86dri_get_device_info_device_private (const xcb_xf86dri_get_device_info_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_xf86dri_get_device_info_device_private_length (const xcb_xf86dri_get_device_info_reply_t *R)
+{
+    return R->device_private_size;
+}
+
+xcb_generic_iterator_t
+xcb_xf86dri_get_device_info_device_private_end (const xcb_xf86dri_get_device_info_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->device_private_size);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xf86dri_get_device_info_reply_t *
+xcb_xf86dri_get_device_info_reply (xcb_connection_t                      *c,
+                                   xcb_xf86dri_get_device_info_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e)
+{
+    return (xcb_xf86dri_get_device_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_xf86dri_auth_connection_cookie_t
+xcb_xf86dri_auth_connection (xcb_connection_t *c,
+                             uint32_t          screen,
+                             uint32_t          magic)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_AUTH_CONNECTION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xf86dri_auth_connection_cookie_t xcb_ret;
+    xcb_xf86dri_auth_connection_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.magic = magic;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xf86dri_auth_connection_cookie_t
+xcb_xf86dri_auth_connection_unchecked (xcb_connection_t *c,
+                                       uint32_t          screen,
+                                       uint32_t          magic)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xf86dri_id,
+        .opcode = XCB_XF86DRI_AUTH_CONNECTION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xf86dri_auth_connection_cookie_t xcb_ret;
+    xcb_xf86dri_auth_connection_request_t xcb_out;
+
+    xcb_out.screen = screen;
+    xcb_out.magic = magic;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xf86dri_auth_connection_reply_t *
+xcb_xf86dri_auth_connection_reply (xcb_connection_t                      *c,
+                                   xcb_xf86dri_auth_connection_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e)
+{
+    return (xcb_xf86dri_auth_connection_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
diff --git a/depends/libxcb/src/xfixes.c b/depends/libxcb/src/xfixes.c
new file mode 100644
index 0000000..87b198d
--- /dev/null
+++ b/depends/libxcb/src/xfixes.c
@@ -0,0 +1,2699 @@
+/*
+ * This file generated automatically from xfixes.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "xfixes.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xproto.h"
+#include "render.h"
+#include "shape.h"
+
+xcb_extension_t xcb_xfixes_id = { "XFIXES", 0 };
+
+xcb_xfixes_query_version_cookie_t
+xcb_xfixes_query_version (xcb_connection_t *c,
+                          uint32_t          client_major_version,
+                          uint32_t          client_minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xfixes_query_version_cookie_t xcb_ret;
+    xcb_xfixes_query_version_request_t xcb_out;
+
+    xcb_out.client_major_version = client_major_version;
+    xcb_out.client_minor_version = client_minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xfixes_query_version_cookie_t
+xcb_xfixes_query_version_unchecked (xcb_connection_t *c,
+                                    uint32_t          client_major_version,
+                                    uint32_t          client_minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xfixes_query_version_cookie_t xcb_ret;
+    xcb_xfixes_query_version_request_t xcb_out;
+
+    xcb_out.client_major_version = client_major_version;
+    xcb_out.client_minor_version = client_minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xfixes_query_version_reply_t *
+xcb_xfixes_query_version_reply (xcb_connection_t                   *c,
+                                xcb_xfixes_query_version_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e)
+{
+    return (xcb_xfixes_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_xfixes_change_save_set_checked (xcb_connection_t *c,
+                                    uint8_t           mode,
+                                    uint8_t           target,
+                                    uint8_t           map,
+                                    xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_CHANGE_SAVE_SET,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_change_save_set_request_t xcb_out;
+
+    xcb_out.mode = mode;
+    xcb_out.target = target;
+    xcb_out.map = map;
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_change_save_set (xcb_connection_t *c,
+                            uint8_t           mode,
+                            uint8_t           target,
+                            uint8_t           map,
+                            xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_CHANGE_SAVE_SET,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_change_save_set_request_t xcb_out;
+
+    xcb_out.mode = mode;
+    xcb_out.target = target;
+    xcb_out.map = map;
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_select_selection_input_checked (xcb_connection_t *c,
+                                           xcb_window_t      window,
+                                           xcb_atom_t        selection,
+                                           uint32_t          event_mask)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_SELECT_SELECTION_INPUT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_select_selection_input_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.selection = selection;
+    xcb_out.event_mask = event_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_select_selection_input (xcb_connection_t *c,
+                                   xcb_window_t      window,
+                                   xcb_atom_t        selection,
+                                   uint32_t          event_mask)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_SELECT_SELECTION_INPUT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_select_selection_input_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.selection = selection;
+    xcb_out.event_mask = event_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_select_cursor_input_checked (xcb_connection_t *c,
+                                        xcb_window_t      window,
+                                        uint32_t          event_mask)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_SELECT_CURSOR_INPUT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_select_cursor_input_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.event_mask = event_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_select_cursor_input (xcb_connection_t *c,
+                                xcb_window_t      window,
+                                uint32_t          event_mask)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_SELECT_CURSOR_INPUT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_select_cursor_input_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.event_mask = event_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_xfixes_get_cursor_image_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xfixes_get_cursor_image_reply_t *_aux = (xcb_xfixes_get_cursor_image_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xfixes_get_cursor_image_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* cursor_image */
+    xcb_block_len += (_aux->width * _aux->height) * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xfixes_get_cursor_image_cookie_t
+xcb_xfixes_get_cursor_image (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_GET_CURSOR_IMAGE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xfixes_get_cursor_image_cookie_t xcb_ret;
+    xcb_xfixes_get_cursor_image_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xfixes_get_cursor_image_cookie_t
+xcb_xfixes_get_cursor_image_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_GET_CURSOR_IMAGE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xfixes_get_cursor_image_cookie_t xcb_ret;
+    xcb_xfixes_get_cursor_image_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_xfixes_get_cursor_image_cursor_image (const xcb_xfixes_get_cursor_image_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_xfixes_get_cursor_image_cursor_image_length (const xcb_xfixes_get_cursor_image_reply_t *R)
+{
+    return (R->width * R->height);
+}
+
+xcb_generic_iterator_t
+xcb_xfixes_get_cursor_image_cursor_image_end (const xcb_xfixes_get_cursor_image_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + ((R->width * R->height));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xfixes_get_cursor_image_reply_t *
+xcb_xfixes_get_cursor_image_reply (xcb_connection_t                      *c,
+                                   xcb_xfixes_get_cursor_image_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e)
+{
+    return (xcb_xfixes_get_cursor_image_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+void
+xcb_xfixes_region_next (xcb_xfixes_region_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xfixes_region_t);
+}
+
+xcb_generic_iterator_t
+xcb_xfixes_region_end (xcb_xfixes_region_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_xfixes_create_region_sizeof (const void  *_buffer,
+                                 uint32_t     rectangles_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xfixes_create_region_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* rectangles */
+    xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_rectangle_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_create_region_checked (xcb_connection_t      *c,
+                                  xcb_xfixes_region_t    region,
+                                  uint32_t               rectangles_len,
+                                  const xcb_rectangle_t *rectangles)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_CREATE_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_create_region_request_t xcb_out;
+
+    xcb_out.region = region;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_rectangle_t rectangles */
+    xcb_parts[4].iov_base = (char *) rectangles;
+    xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_create_region (xcb_connection_t      *c,
+                          xcb_xfixes_region_t    region,
+                          uint32_t               rectangles_len,
+                          const xcb_rectangle_t *rectangles)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_CREATE_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_create_region_request_t xcb_out;
+
+    xcb_out.region = region;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_rectangle_t rectangles */
+    xcb_parts[4].iov_base = (char *) rectangles;
+    xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_rectangle_t *
+xcb_xfixes_create_region_rectangles (const xcb_xfixes_create_region_request_t *R)
+{
+    return (xcb_rectangle_t *) (R + 1);
+}
+
+int
+xcb_xfixes_create_region_rectangles_length (const xcb_xfixes_create_region_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_xfixes_create_region_request_t))/sizeof(xcb_rectangle_t));
+}
+
+xcb_rectangle_iterator_t
+xcb_xfixes_create_region_rectangles_iterator (const xcb_xfixes_create_region_request_t *R)
+{
+    xcb_rectangle_iterator_t i;
+    i.data = (xcb_rectangle_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_xfixes_create_region_request_t))/sizeof(xcb_rectangle_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_create_region_from_bitmap_checked (xcb_connection_t    *c,
+                                              xcb_xfixes_region_t  region,
+                                              xcb_pixmap_t         bitmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_CREATE_REGION_FROM_BITMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_create_region_from_bitmap_request_t xcb_out;
+
+    xcb_out.region = region;
+    xcb_out.bitmap = bitmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_create_region_from_bitmap (xcb_connection_t    *c,
+                                      xcb_xfixes_region_t  region,
+                                      xcb_pixmap_t         bitmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_CREATE_REGION_FROM_BITMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_create_region_from_bitmap_request_t xcb_out;
+
+    xcb_out.region = region;
+    xcb_out.bitmap = bitmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_create_region_from_window_checked (xcb_connection_t    *c,
+                                              xcb_xfixes_region_t  region,
+                                              xcb_window_t         window,
+                                              xcb_shape_kind_t     kind)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_CREATE_REGION_FROM_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_create_region_from_window_request_t xcb_out;
+
+    xcb_out.region = region;
+    xcb_out.window = window;
+    xcb_out.kind = kind;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_create_region_from_window (xcb_connection_t    *c,
+                                      xcb_xfixes_region_t  region,
+                                      xcb_window_t         window,
+                                      xcb_shape_kind_t     kind)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_CREATE_REGION_FROM_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_create_region_from_window_request_t xcb_out;
+
+    xcb_out.region = region;
+    xcb_out.window = window;
+    xcb_out.kind = kind;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_create_region_from_gc_checked (xcb_connection_t    *c,
+                                          xcb_xfixes_region_t  region,
+                                          xcb_gcontext_t       gc)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_CREATE_REGION_FROM_GC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_create_region_from_gc_request_t xcb_out;
+
+    xcb_out.region = region;
+    xcb_out.gc = gc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_create_region_from_gc (xcb_connection_t    *c,
+                                  xcb_xfixes_region_t  region,
+                                  xcb_gcontext_t       gc)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_CREATE_REGION_FROM_GC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_create_region_from_gc_request_t xcb_out;
+
+    xcb_out.region = region;
+    xcb_out.gc = gc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_create_region_from_picture_checked (xcb_connection_t     *c,
+                                               xcb_xfixes_region_t   region,
+                                               xcb_render_picture_t  picture)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_CREATE_REGION_FROM_PICTURE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_create_region_from_picture_request_t xcb_out;
+
+    xcb_out.region = region;
+    xcb_out.picture = picture;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_create_region_from_picture (xcb_connection_t     *c,
+                                       xcb_xfixes_region_t   region,
+                                       xcb_render_picture_t  picture)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_CREATE_REGION_FROM_PICTURE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_create_region_from_picture_request_t xcb_out;
+
+    xcb_out.region = region;
+    xcb_out.picture = picture;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_destroy_region_checked (xcb_connection_t    *c,
+                                   xcb_xfixes_region_t  region)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_DESTROY_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_destroy_region_request_t xcb_out;
+
+    xcb_out.region = region;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_destroy_region (xcb_connection_t    *c,
+                           xcb_xfixes_region_t  region)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_DESTROY_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_destroy_region_request_t xcb_out;
+
+    xcb_out.region = region;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_xfixes_set_region_sizeof (const void  *_buffer,
+                              uint32_t     rectangles_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xfixes_set_region_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* rectangles */
+    xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_rectangle_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_set_region_checked (xcb_connection_t      *c,
+                               xcb_xfixes_region_t    region,
+                               uint32_t               rectangles_len,
+                               const xcb_rectangle_t *rectangles)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_SET_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_set_region_request_t xcb_out;
+
+    xcb_out.region = region;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_rectangle_t rectangles */
+    xcb_parts[4].iov_base = (char *) rectangles;
+    xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_set_region (xcb_connection_t      *c,
+                       xcb_xfixes_region_t    region,
+                       uint32_t               rectangles_len,
+                       const xcb_rectangle_t *rectangles)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_SET_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_set_region_request_t xcb_out;
+
+    xcb_out.region = region;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_rectangle_t rectangles */
+    xcb_parts[4].iov_base = (char *) rectangles;
+    xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_rectangle_t *
+xcb_xfixes_set_region_rectangles (const xcb_xfixes_set_region_request_t *R)
+{
+    return (xcb_rectangle_t *) (R + 1);
+}
+
+int
+xcb_xfixes_set_region_rectangles_length (const xcb_xfixes_set_region_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_xfixes_set_region_request_t))/sizeof(xcb_rectangle_t));
+}
+
+xcb_rectangle_iterator_t
+xcb_xfixes_set_region_rectangles_iterator (const xcb_xfixes_set_region_request_t *R)
+{
+    xcb_rectangle_iterator_t i;
+    i.data = (xcb_rectangle_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_xfixes_set_region_request_t))/sizeof(xcb_rectangle_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_copy_region_checked (xcb_connection_t    *c,
+                                xcb_xfixes_region_t  source,
+                                xcb_xfixes_region_t  destination)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_COPY_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_copy_region_request_t xcb_out;
+
+    xcb_out.source = source;
+    xcb_out.destination = destination;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_copy_region (xcb_connection_t    *c,
+                        xcb_xfixes_region_t  source,
+                        xcb_xfixes_region_t  destination)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_COPY_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_copy_region_request_t xcb_out;
+
+    xcb_out.source = source;
+    xcb_out.destination = destination;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_union_region_checked (xcb_connection_t    *c,
+                                 xcb_xfixes_region_t  source1,
+                                 xcb_xfixes_region_t  source2,
+                                 xcb_xfixes_region_t  destination)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_UNION_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_union_region_request_t xcb_out;
+
+    xcb_out.source1 = source1;
+    xcb_out.source2 = source2;
+    xcb_out.destination = destination;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_union_region (xcb_connection_t    *c,
+                         xcb_xfixes_region_t  source1,
+                         xcb_xfixes_region_t  source2,
+                         xcb_xfixes_region_t  destination)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_UNION_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_union_region_request_t xcb_out;
+
+    xcb_out.source1 = source1;
+    xcb_out.source2 = source2;
+    xcb_out.destination = destination;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_intersect_region_checked (xcb_connection_t    *c,
+                                     xcb_xfixes_region_t  source1,
+                                     xcb_xfixes_region_t  source2,
+                                     xcb_xfixes_region_t  destination)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_INTERSECT_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_intersect_region_request_t xcb_out;
+
+    xcb_out.source1 = source1;
+    xcb_out.source2 = source2;
+    xcb_out.destination = destination;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_intersect_region (xcb_connection_t    *c,
+                             xcb_xfixes_region_t  source1,
+                             xcb_xfixes_region_t  source2,
+                             xcb_xfixes_region_t  destination)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_INTERSECT_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_intersect_region_request_t xcb_out;
+
+    xcb_out.source1 = source1;
+    xcb_out.source2 = source2;
+    xcb_out.destination = destination;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_subtract_region_checked (xcb_connection_t    *c,
+                                    xcb_xfixes_region_t  source1,
+                                    xcb_xfixes_region_t  source2,
+                                    xcb_xfixes_region_t  destination)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_SUBTRACT_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_subtract_region_request_t xcb_out;
+
+    xcb_out.source1 = source1;
+    xcb_out.source2 = source2;
+    xcb_out.destination = destination;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_subtract_region (xcb_connection_t    *c,
+                            xcb_xfixes_region_t  source1,
+                            xcb_xfixes_region_t  source2,
+                            xcb_xfixes_region_t  destination)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_SUBTRACT_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_subtract_region_request_t xcb_out;
+
+    xcb_out.source1 = source1;
+    xcb_out.source2 = source2;
+    xcb_out.destination = destination;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_invert_region_checked (xcb_connection_t    *c,
+                                  xcb_xfixes_region_t  source,
+                                  xcb_rectangle_t      bounds,
+                                  xcb_xfixes_region_t  destination)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_INVERT_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_invert_region_request_t xcb_out;
+
+    xcb_out.source = source;
+    xcb_out.bounds = bounds;
+    xcb_out.destination = destination;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_invert_region (xcb_connection_t    *c,
+                          xcb_xfixes_region_t  source,
+                          xcb_rectangle_t      bounds,
+                          xcb_xfixes_region_t  destination)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_INVERT_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_invert_region_request_t xcb_out;
+
+    xcb_out.source = source;
+    xcb_out.bounds = bounds;
+    xcb_out.destination = destination;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_translate_region_checked (xcb_connection_t    *c,
+                                     xcb_xfixes_region_t  region,
+                                     int16_t              dx,
+                                     int16_t              dy)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_TRANSLATE_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_translate_region_request_t xcb_out;
+
+    xcb_out.region = region;
+    xcb_out.dx = dx;
+    xcb_out.dy = dy;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_translate_region (xcb_connection_t    *c,
+                             xcb_xfixes_region_t  region,
+                             int16_t              dx,
+                             int16_t              dy)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_TRANSLATE_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_translate_region_request_t xcb_out;
+
+    xcb_out.region = region;
+    xcb_out.dx = dx;
+    xcb_out.dy = dy;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_region_extents_checked (xcb_connection_t    *c,
+                                   xcb_xfixes_region_t  source,
+                                   xcb_xfixes_region_t  destination)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_REGION_EXTENTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_region_extents_request_t xcb_out;
+
+    xcb_out.source = source;
+    xcb_out.destination = destination;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_region_extents (xcb_connection_t    *c,
+                           xcb_xfixes_region_t  source,
+                           xcb_xfixes_region_t  destination)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_REGION_EXTENTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_region_extents_request_t xcb_out;
+
+    xcb_out.source = source;
+    xcb_out.destination = destination;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_xfixes_fetch_region_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xfixes_fetch_region_reply_t *_aux = (xcb_xfixes_fetch_region_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xfixes_fetch_region_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* rectangles */
+    xcb_block_len += (_aux->length / 2) * sizeof(xcb_rectangle_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_rectangle_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xfixes_fetch_region_cookie_t
+xcb_xfixes_fetch_region (xcb_connection_t    *c,
+                         xcb_xfixes_region_t  region)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_FETCH_REGION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xfixes_fetch_region_cookie_t xcb_ret;
+    xcb_xfixes_fetch_region_request_t xcb_out;
+
+    xcb_out.region = region;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xfixes_fetch_region_cookie_t
+xcb_xfixes_fetch_region_unchecked (xcb_connection_t    *c,
+                                   xcb_xfixes_region_t  region)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_FETCH_REGION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xfixes_fetch_region_cookie_t xcb_ret;
+    xcb_xfixes_fetch_region_request_t xcb_out;
+
+    xcb_out.region = region;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_rectangle_t *
+xcb_xfixes_fetch_region_rectangles (const xcb_xfixes_fetch_region_reply_t *R)
+{
+    return (xcb_rectangle_t *) (R + 1);
+}
+
+int
+xcb_xfixes_fetch_region_rectangles_length (const xcb_xfixes_fetch_region_reply_t *R)
+{
+    return (R->length / 2);
+}
+
+xcb_rectangle_iterator_t
+xcb_xfixes_fetch_region_rectangles_iterator (const xcb_xfixes_fetch_region_reply_t *R)
+{
+    xcb_rectangle_iterator_t i;
+    i.data = (xcb_rectangle_t *) (R + 1);
+    i.rem = (R->length / 2);
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xfixes_fetch_region_reply_t *
+xcb_xfixes_fetch_region_reply (xcb_connection_t                  *c,
+                               xcb_xfixes_fetch_region_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_xfixes_fetch_region_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_xfixes_set_gc_clip_region_checked (xcb_connection_t    *c,
+                                       xcb_gcontext_t       gc,
+                                       xcb_xfixes_region_t  region,
+                                       int16_t              x_origin,
+                                       int16_t              y_origin)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_SET_GC_CLIP_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_set_gc_clip_region_request_t xcb_out;
+
+    xcb_out.gc = gc;
+    xcb_out.region = region;
+    xcb_out.x_origin = x_origin;
+    xcb_out.y_origin = y_origin;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_set_gc_clip_region (xcb_connection_t    *c,
+                               xcb_gcontext_t       gc,
+                               xcb_xfixes_region_t  region,
+                               int16_t              x_origin,
+                               int16_t              y_origin)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_SET_GC_CLIP_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_set_gc_clip_region_request_t xcb_out;
+
+    xcb_out.gc = gc;
+    xcb_out.region = region;
+    xcb_out.x_origin = x_origin;
+    xcb_out.y_origin = y_origin;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_set_window_shape_region_checked (xcb_connection_t    *c,
+                                            xcb_window_t         dest,
+                                            xcb_shape_kind_t     dest_kind,
+                                            int16_t              x_offset,
+                                            int16_t              y_offset,
+                                            xcb_xfixes_region_t  region)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_SET_WINDOW_SHAPE_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_set_window_shape_region_request_t xcb_out;
+
+    xcb_out.dest = dest;
+    xcb_out.dest_kind = dest_kind;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.x_offset = x_offset;
+    xcb_out.y_offset = y_offset;
+    xcb_out.region = region;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_set_window_shape_region (xcb_connection_t    *c,
+                                    xcb_window_t         dest,
+                                    xcb_shape_kind_t     dest_kind,
+                                    int16_t              x_offset,
+                                    int16_t              y_offset,
+                                    xcb_xfixes_region_t  region)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_SET_WINDOW_SHAPE_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_set_window_shape_region_request_t xcb_out;
+
+    xcb_out.dest = dest;
+    xcb_out.dest_kind = dest_kind;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.x_offset = x_offset;
+    xcb_out.y_offset = y_offset;
+    xcb_out.region = region;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_set_picture_clip_region_checked (xcb_connection_t     *c,
+                                            xcb_render_picture_t  picture,
+                                            xcb_xfixes_region_t   region,
+                                            int16_t               x_origin,
+                                            int16_t               y_origin)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_SET_PICTURE_CLIP_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_set_picture_clip_region_request_t xcb_out;
+
+    xcb_out.picture = picture;
+    xcb_out.region = region;
+    xcb_out.x_origin = x_origin;
+    xcb_out.y_origin = y_origin;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_set_picture_clip_region (xcb_connection_t     *c,
+                                    xcb_render_picture_t  picture,
+                                    xcb_xfixes_region_t   region,
+                                    int16_t               x_origin,
+                                    int16_t               y_origin)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_SET_PICTURE_CLIP_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_set_picture_clip_region_request_t xcb_out;
+
+    xcb_out.picture = picture;
+    xcb_out.region = region;
+    xcb_out.x_origin = x_origin;
+    xcb_out.y_origin = y_origin;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_xfixes_set_cursor_name_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xfixes_set_cursor_name_request_t *_aux = (xcb_xfixes_set_cursor_name_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xfixes_set_cursor_name_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->nbytes * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_set_cursor_name_checked (xcb_connection_t *c,
+                                    xcb_cursor_t      cursor,
+                                    uint16_t          nbytes,
+                                    const char       *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_SET_CURSOR_NAME,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_set_cursor_name_request_t xcb_out;
+
+    xcb_out.cursor = cursor;
+    xcb_out.nbytes = nbytes;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = nbytes * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_set_cursor_name (xcb_connection_t *c,
+                            xcb_cursor_t      cursor,
+                            uint16_t          nbytes,
+                            const char       *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_SET_CURSOR_NAME,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_set_cursor_name_request_t xcb_out;
+
+    xcb_out.cursor = cursor;
+    xcb_out.nbytes = nbytes;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = nbytes * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_xfixes_set_cursor_name_name (const xcb_xfixes_set_cursor_name_request_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_xfixes_set_cursor_name_name_length (const xcb_xfixes_set_cursor_name_request_t *R)
+{
+    return R->nbytes;
+}
+
+xcb_generic_iterator_t
+xcb_xfixes_set_cursor_name_name_end (const xcb_xfixes_set_cursor_name_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->nbytes);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_xfixes_get_cursor_name_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xfixes_get_cursor_name_reply_t *_aux = (xcb_xfixes_get_cursor_name_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xfixes_get_cursor_name_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->nbytes * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xfixes_get_cursor_name_cookie_t
+xcb_xfixes_get_cursor_name (xcb_connection_t *c,
+                            xcb_cursor_t      cursor)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_GET_CURSOR_NAME,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xfixes_get_cursor_name_cookie_t xcb_ret;
+    xcb_xfixes_get_cursor_name_request_t xcb_out;
+
+    xcb_out.cursor = cursor;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xfixes_get_cursor_name_cookie_t
+xcb_xfixes_get_cursor_name_unchecked (xcb_connection_t *c,
+                                      xcb_cursor_t      cursor)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_GET_CURSOR_NAME,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xfixes_get_cursor_name_cookie_t xcb_ret;
+    xcb_xfixes_get_cursor_name_request_t xcb_out;
+
+    xcb_out.cursor = cursor;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_xfixes_get_cursor_name_name (const xcb_xfixes_get_cursor_name_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_xfixes_get_cursor_name_name_length (const xcb_xfixes_get_cursor_name_reply_t *R)
+{
+    return R->nbytes;
+}
+
+xcb_generic_iterator_t
+xcb_xfixes_get_cursor_name_name_end (const xcb_xfixes_get_cursor_name_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->nbytes);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xfixes_get_cursor_name_reply_t *
+xcb_xfixes_get_cursor_name_reply (xcb_connection_t                     *c,
+                                  xcb_xfixes_get_cursor_name_cookie_t   cookie  /**< */,
+                                  xcb_generic_error_t                 **e)
+{
+    return (xcb_xfixes_get_cursor_name_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xfixes_get_cursor_image_and_name_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xfixes_get_cursor_image_and_name_reply_t *_aux = (xcb_xfixes_get_cursor_image_and_name_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xfixes_get_cursor_image_and_name_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* cursor_image */
+    xcb_block_len += (_aux->width * _aux->height) * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->nbytes * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xfixes_get_cursor_image_and_name_cookie_t
+xcb_xfixes_get_cursor_image_and_name (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_GET_CURSOR_IMAGE_AND_NAME,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xfixes_get_cursor_image_and_name_cookie_t xcb_ret;
+    xcb_xfixes_get_cursor_image_and_name_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xfixes_get_cursor_image_and_name_cookie_t
+xcb_xfixes_get_cursor_image_and_name_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_GET_CURSOR_IMAGE_AND_NAME,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xfixes_get_cursor_image_and_name_cookie_t xcb_ret;
+    xcb_xfixes_get_cursor_image_and_name_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_xfixes_get_cursor_image_and_name_cursor_image (const xcb_xfixes_get_cursor_image_and_name_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_xfixes_get_cursor_image_and_name_cursor_image_length (const xcb_xfixes_get_cursor_image_and_name_reply_t *R)
+{
+    return (R->width * R->height);
+}
+
+xcb_generic_iterator_t
+xcb_xfixes_get_cursor_image_and_name_cursor_image_end (const xcb_xfixes_get_cursor_image_and_name_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + ((R->width * R->height));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+char *
+xcb_xfixes_get_cursor_image_and_name_name (const xcb_xfixes_get_cursor_image_and_name_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_xfixes_get_cursor_image_and_name_cursor_image_end(R);
+    return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0);
+}
+
+int
+xcb_xfixes_get_cursor_image_and_name_name_length (const xcb_xfixes_get_cursor_image_and_name_reply_t *R)
+{
+    return R->nbytes;
+}
+
+xcb_generic_iterator_t
+xcb_xfixes_get_cursor_image_and_name_name_end (const xcb_xfixes_get_cursor_image_and_name_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_xfixes_get_cursor_image_and_name_cursor_image_end(R);
+    i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->nbytes);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xfixes_get_cursor_image_and_name_reply_t *
+xcb_xfixes_get_cursor_image_and_name_reply (xcb_connection_t                               *c,
+                                            xcb_xfixes_get_cursor_image_and_name_cookie_t   cookie  /**< */,
+                                            xcb_generic_error_t                           **e)
+{
+    return (xcb_xfixes_get_cursor_image_and_name_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_xfixes_change_cursor_checked (xcb_connection_t *c,
+                                  xcb_cursor_t      source,
+                                  xcb_cursor_t      destination)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_CHANGE_CURSOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_change_cursor_request_t xcb_out;
+
+    xcb_out.source = source;
+    xcb_out.destination = destination;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_change_cursor (xcb_connection_t *c,
+                          xcb_cursor_t      source,
+                          xcb_cursor_t      destination)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_CHANGE_CURSOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_change_cursor_request_t xcb_out;
+
+    xcb_out.source = source;
+    xcb_out.destination = destination;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_xfixes_change_cursor_by_name_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xfixes_change_cursor_by_name_request_t *_aux = (xcb_xfixes_change_cursor_by_name_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xfixes_change_cursor_by_name_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->nbytes * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_change_cursor_by_name_checked (xcb_connection_t *c,
+                                          xcb_cursor_t      src,
+                                          uint16_t          nbytes,
+                                          const char       *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_CHANGE_CURSOR_BY_NAME,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_change_cursor_by_name_request_t xcb_out;
+
+    xcb_out.src = src;
+    xcb_out.nbytes = nbytes;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = nbytes * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_change_cursor_by_name (xcb_connection_t *c,
+                                  xcb_cursor_t      src,
+                                  uint16_t          nbytes,
+                                  const char       *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_CHANGE_CURSOR_BY_NAME,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_change_cursor_by_name_request_t xcb_out;
+
+    xcb_out.src = src;
+    xcb_out.nbytes = nbytes;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = nbytes * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_xfixes_change_cursor_by_name_name (const xcb_xfixes_change_cursor_by_name_request_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_xfixes_change_cursor_by_name_name_length (const xcb_xfixes_change_cursor_by_name_request_t *R)
+{
+    return R->nbytes;
+}
+
+xcb_generic_iterator_t
+xcb_xfixes_change_cursor_by_name_name_end (const xcb_xfixes_change_cursor_by_name_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->nbytes);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_expand_region_checked (xcb_connection_t    *c,
+                                  xcb_xfixes_region_t  source,
+                                  xcb_xfixes_region_t  destination,
+                                  uint16_t             left,
+                                  uint16_t             right,
+                                  uint16_t             top,
+                                  uint16_t             bottom)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_EXPAND_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_expand_region_request_t xcb_out;
+
+    xcb_out.source = source;
+    xcb_out.destination = destination;
+    xcb_out.left = left;
+    xcb_out.right = right;
+    xcb_out.top = top;
+    xcb_out.bottom = bottom;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_expand_region (xcb_connection_t    *c,
+                          xcb_xfixes_region_t  source,
+                          xcb_xfixes_region_t  destination,
+                          uint16_t             left,
+                          uint16_t             right,
+                          uint16_t             top,
+                          uint16_t             bottom)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_EXPAND_REGION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_expand_region_request_t xcb_out;
+
+    xcb_out.source = source;
+    xcb_out.destination = destination;
+    xcb_out.left = left;
+    xcb_out.right = right;
+    xcb_out.top = top;
+    xcb_out.bottom = bottom;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_hide_cursor_checked (xcb_connection_t *c,
+                                xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_HIDE_CURSOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_hide_cursor_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_hide_cursor (xcb_connection_t *c,
+                        xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_HIDE_CURSOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_hide_cursor_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_show_cursor_checked (xcb_connection_t *c,
+                                xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_SHOW_CURSOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_show_cursor_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_show_cursor (xcb_connection_t *c,
+                        xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_SHOW_CURSOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_show_cursor_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+void
+xcb_xfixes_barrier_next (xcb_xfixes_barrier_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xfixes_barrier_t);
+}
+
+xcb_generic_iterator_t
+xcb_xfixes_barrier_end (xcb_xfixes_barrier_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_xfixes_create_pointer_barrier_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xfixes_create_pointer_barrier_request_t *_aux = (xcb_xfixes_create_pointer_barrier_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xfixes_create_pointer_barrier_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* devices */
+    xcb_block_len += _aux->num_devices * sizeof(uint16_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint16_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_create_pointer_barrier_checked (xcb_connection_t     *c,
+                                           xcb_xfixes_barrier_t  barrier,
+                                           xcb_window_t          window,
+                                           uint16_t              x1,
+                                           uint16_t              y1,
+                                           uint16_t              x2,
+                                           uint16_t              y2,
+                                           uint32_t              directions,
+                                           uint16_t              num_devices,
+                                           const uint16_t       *devices)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_CREATE_POINTER_BARRIER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_create_pointer_barrier_request_t xcb_out;
+
+    xcb_out.barrier = barrier;
+    xcb_out.window = window;
+    xcb_out.x1 = x1;
+    xcb_out.y1 = y1;
+    xcb_out.x2 = x2;
+    xcb_out.y2 = y2;
+    xcb_out.directions = directions;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.num_devices = num_devices;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint16_t devices */
+    xcb_parts[4].iov_base = (char *) devices;
+    xcb_parts[4].iov_len = num_devices * sizeof(uint16_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_create_pointer_barrier (xcb_connection_t     *c,
+                                   xcb_xfixes_barrier_t  barrier,
+                                   xcb_window_t          window,
+                                   uint16_t              x1,
+                                   uint16_t              y1,
+                                   uint16_t              x2,
+                                   uint16_t              y2,
+                                   uint32_t              directions,
+                                   uint16_t              num_devices,
+                                   const uint16_t       *devices)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_CREATE_POINTER_BARRIER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_create_pointer_barrier_request_t xcb_out;
+
+    xcb_out.barrier = barrier;
+    xcb_out.window = window;
+    xcb_out.x1 = x1;
+    xcb_out.y1 = y1;
+    xcb_out.x2 = x2;
+    xcb_out.y2 = y2;
+    xcb_out.directions = directions;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.num_devices = num_devices;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint16_t devices */
+    xcb_parts[4].iov_base = (char *) devices;
+    xcb_parts[4].iov_len = num_devices * sizeof(uint16_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint16_t *
+xcb_xfixes_create_pointer_barrier_devices (const xcb_xfixes_create_pointer_barrier_request_t *R)
+{
+    return (uint16_t *) (R + 1);
+}
+
+int
+xcb_xfixes_create_pointer_barrier_devices_length (const xcb_xfixes_create_pointer_barrier_request_t *R)
+{
+    return R->num_devices;
+}
+
+xcb_generic_iterator_t
+xcb_xfixes_create_pointer_barrier_devices_end (const xcb_xfixes_create_pointer_barrier_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint16_t *) (R + 1)) + (R->num_devices);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_delete_pointer_barrier_checked (xcb_connection_t     *c,
+                                           xcb_xfixes_barrier_t  barrier)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_DELETE_POINTER_BARRIER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_delete_pointer_barrier_request_t xcb_out;
+
+    xcb_out.barrier = barrier;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_delete_pointer_barrier (xcb_connection_t     *c,
+                                   xcb_xfixes_barrier_t  barrier)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_DELETE_POINTER_BARRIER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_delete_pointer_barrier_request_t xcb_out;
+
+    xcb_out.barrier = barrier;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_set_client_disconnect_mode_checked (xcb_connection_t *c,
+                                               uint32_t          disconnect_mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_SET_CLIENT_DISCONNECT_MODE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_set_client_disconnect_mode_request_t xcb_out;
+
+    xcb_out.disconnect_mode = disconnect_mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xfixes_set_client_disconnect_mode (xcb_connection_t *c,
+                                       uint32_t          disconnect_mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_SET_CLIENT_DISCONNECT_MODE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xfixes_set_client_disconnect_mode_request_t xcb_out;
+
+    xcb_out.disconnect_mode = disconnect_mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xfixes_get_client_disconnect_mode_cookie_t
+xcb_xfixes_get_client_disconnect_mode (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_GET_CLIENT_DISCONNECT_MODE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xfixes_get_client_disconnect_mode_cookie_t xcb_ret;
+    xcb_xfixes_get_client_disconnect_mode_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xfixes_get_client_disconnect_mode_cookie_t
+xcb_xfixes_get_client_disconnect_mode_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xfixes_id,
+        .opcode = XCB_XFIXES_GET_CLIENT_DISCONNECT_MODE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xfixes_get_client_disconnect_mode_cookie_t xcb_ret;
+    xcb_xfixes_get_client_disconnect_mode_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xfixes_get_client_disconnect_mode_reply_t *
+xcb_xfixes_get_client_disconnect_mode_reply (xcb_connection_t                                *c,
+                                             xcb_xfixes_get_client_disconnect_mode_cookie_t   cookie  /**< */,
+                                             xcb_generic_error_t                            **e)
+{
+    return (xcb_xfixes_get_client_disconnect_mode_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
diff --git a/depends/libxcb/src/xinerama.c b/depends/libxcb/src/xinerama.c
new file mode 100644
index 0000000..2f23676
--- /dev/null
+++ b/depends/libxcb/src/xinerama.c
@@ -0,0 +1,451 @@
+/*
+ * This file generated automatically from xinerama.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "xinerama.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xproto.h"
+
+xcb_extension_t xcb_xinerama_id = { "XINERAMA", 0 };
+
+void
+xcb_xinerama_screen_info_next (xcb_xinerama_screen_info_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xinerama_screen_info_t);
+}
+
+xcb_generic_iterator_t
+xcb_xinerama_screen_info_end (xcb_xinerama_screen_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+xcb_xinerama_query_version_cookie_t
+xcb_xinerama_query_version (xcb_connection_t *c,
+                            uint8_t           major,
+                            uint8_t           minor)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xinerama_id,
+        .opcode = XCB_XINERAMA_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xinerama_query_version_cookie_t xcb_ret;
+    xcb_xinerama_query_version_request_t xcb_out;
+
+    xcb_out.major = major;
+    xcb_out.minor = minor;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xinerama_query_version_cookie_t
+xcb_xinerama_query_version_unchecked (xcb_connection_t *c,
+                                      uint8_t           major,
+                                      uint8_t           minor)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xinerama_id,
+        .opcode = XCB_XINERAMA_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xinerama_query_version_cookie_t xcb_ret;
+    xcb_xinerama_query_version_request_t xcb_out;
+
+    xcb_out.major = major;
+    xcb_out.minor = minor;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xinerama_query_version_reply_t *
+xcb_xinerama_query_version_reply (xcb_connection_t                     *c,
+                                  xcb_xinerama_query_version_cookie_t   cookie  /**< */,
+                                  xcb_generic_error_t                 **e)
+{
+    return (xcb_xinerama_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_xinerama_get_state_cookie_t
+xcb_xinerama_get_state (xcb_connection_t *c,
+                        xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xinerama_id,
+        .opcode = XCB_XINERAMA_GET_STATE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xinerama_get_state_cookie_t xcb_ret;
+    xcb_xinerama_get_state_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xinerama_get_state_cookie_t
+xcb_xinerama_get_state_unchecked (xcb_connection_t *c,
+                                  xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xinerama_id,
+        .opcode = XCB_XINERAMA_GET_STATE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xinerama_get_state_cookie_t xcb_ret;
+    xcb_xinerama_get_state_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xinerama_get_state_reply_t *
+xcb_xinerama_get_state_reply (xcb_connection_t                 *c,
+                              xcb_xinerama_get_state_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_xinerama_get_state_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_xinerama_get_screen_count_cookie_t
+xcb_xinerama_get_screen_count (xcb_connection_t *c,
+                               xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xinerama_id,
+        .opcode = XCB_XINERAMA_GET_SCREEN_COUNT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xinerama_get_screen_count_cookie_t xcb_ret;
+    xcb_xinerama_get_screen_count_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xinerama_get_screen_count_cookie_t
+xcb_xinerama_get_screen_count_unchecked (xcb_connection_t *c,
+                                         xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xinerama_id,
+        .opcode = XCB_XINERAMA_GET_SCREEN_COUNT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xinerama_get_screen_count_cookie_t xcb_ret;
+    xcb_xinerama_get_screen_count_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xinerama_get_screen_count_reply_t *
+xcb_xinerama_get_screen_count_reply (xcb_connection_t                        *c,
+                                     xcb_xinerama_get_screen_count_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e)
+{
+    return (xcb_xinerama_get_screen_count_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_xinerama_get_screen_size_cookie_t
+xcb_xinerama_get_screen_size (xcb_connection_t *c,
+                              xcb_window_t      window,
+                              uint32_t          screen)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xinerama_id,
+        .opcode = XCB_XINERAMA_GET_SCREEN_SIZE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xinerama_get_screen_size_cookie_t xcb_ret;
+    xcb_xinerama_get_screen_size_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.screen = screen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xinerama_get_screen_size_cookie_t
+xcb_xinerama_get_screen_size_unchecked (xcb_connection_t *c,
+                                        xcb_window_t      window,
+                                        uint32_t          screen)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xinerama_id,
+        .opcode = XCB_XINERAMA_GET_SCREEN_SIZE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xinerama_get_screen_size_cookie_t xcb_ret;
+    xcb_xinerama_get_screen_size_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.screen = screen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xinerama_get_screen_size_reply_t *
+xcb_xinerama_get_screen_size_reply (xcb_connection_t                       *c,
+                                    xcb_xinerama_get_screen_size_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e)
+{
+    return (xcb_xinerama_get_screen_size_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_xinerama_is_active_cookie_t
+xcb_xinerama_is_active (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xinerama_id,
+        .opcode = XCB_XINERAMA_IS_ACTIVE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xinerama_is_active_cookie_t xcb_ret;
+    xcb_xinerama_is_active_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xinerama_is_active_cookie_t
+xcb_xinerama_is_active_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xinerama_id,
+        .opcode = XCB_XINERAMA_IS_ACTIVE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xinerama_is_active_cookie_t xcb_ret;
+    xcb_xinerama_is_active_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xinerama_is_active_reply_t *
+xcb_xinerama_is_active_reply (xcb_connection_t                 *c,
+                              xcb_xinerama_is_active_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_xinerama_is_active_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xinerama_query_screens_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xinerama_query_screens_reply_t *_aux = (xcb_xinerama_query_screens_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xinerama_query_screens_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* screen_info */
+    xcb_block_len += _aux->number * sizeof(xcb_xinerama_screen_info_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xinerama_screen_info_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xinerama_query_screens_cookie_t
+xcb_xinerama_query_screens (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xinerama_id,
+        .opcode = XCB_XINERAMA_QUERY_SCREENS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xinerama_query_screens_cookie_t xcb_ret;
+    xcb_xinerama_query_screens_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xinerama_query_screens_cookie_t
+xcb_xinerama_query_screens_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xinerama_id,
+        .opcode = XCB_XINERAMA_QUERY_SCREENS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xinerama_query_screens_cookie_t xcb_ret;
+    xcb_xinerama_query_screens_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xinerama_screen_info_t *
+xcb_xinerama_query_screens_screen_info (const xcb_xinerama_query_screens_reply_t *R)
+{
+    return (xcb_xinerama_screen_info_t *) (R + 1);
+}
+
+int
+xcb_xinerama_query_screens_screen_info_length (const xcb_xinerama_query_screens_reply_t *R)
+{
+    return R->number;
+}
+
+xcb_xinerama_screen_info_iterator_t
+xcb_xinerama_query_screens_screen_info_iterator (const xcb_xinerama_query_screens_reply_t *R)
+{
+    xcb_xinerama_screen_info_iterator_t i;
+    i.data = (xcb_xinerama_screen_info_t *) (R + 1);
+    i.rem = R->number;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xinerama_query_screens_reply_t *
+xcb_xinerama_query_screens_reply (xcb_connection_t                     *c,
+                                  xcb_xinerama_query_screens_cookie_t   cookie  /**< */,
+                                  xcb_generic_error_t                 **e)
+{
+    return (xcb_xinerama_query_screens_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
diff --git a/depends/libxcb/src/xinput.c b/depends/libxcb/src/xinput.c
new file mode 100644
index 0000000..38fc6c4
--- /dev/null
+++ b/depends/libxcb/src/xinput.c
@@ -0,0 +1,14513 @@
+/*
+ * This file generated automatically from xinput.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "xinput.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xfixes.h"
+
+xcb_extension_t xcb_input_id = { "XInputExtension", 0 };
+
+void
+xcb_input_event_class_next (xcb_input_event_class_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_event_class_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_event_class_end (xcb_input_event_class_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_key_code_next (xcb_input_key_code_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_key_code_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_key_code_end (xcb_input_key_code_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_device_id_next (xcb_input_device_id_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_device_id_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_device_id_end (xcb_input_device_id_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_fp1616_next (xcb_input_fp1616_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_fp1616_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_fp1616_end (xcb_input_fp1616_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_fp3232_next (xcb_input_fp3232_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_fp3232_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_fp3232_end (xcb_input_fp3232_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_input_get_extension_version_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_get_extension_version_request_t *_aux = (xcb_input_get_extension_version_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_get_extension_version_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->name_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_get_extension_version_cookie_t
+xcb_input_get_extension_version (xcb_connection_t *c,
+                                 uint16_t          name_len,
+                                 const char       *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_EXTENSION_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_input_get_extension_version_cookie_t xcb_ret;
+    xcb_input_get_extension_version_request_t xcb_out;
+
+    xcb_out.name_len = name_len;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = name_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_get_extension_version_cookie_t
+xcb_input_get_extension_version_unchecked (xcb_connection_t *c,
+                                           uint16_t          name_len,
+                                           const char       *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_EXTENSION_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_input_get_extension_version_cookie_t xcb_ret;
+    xcb_input_get_extension_version_request_t xcb_out;
+
+    xcb_out.name_len = name_len;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = name_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_get_extension_version_reply_t *
+xcb_input_get_extension_version_reply (xcb_connection_t                          *c,
+                                       xcb_input_get_extension_version_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e)
+{
+    return (xcb_input_get_extension_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+void
+xcb_input_device_info_next (xcb_input_device_info_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_device_info_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_device_info_end (xcb_input_device_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_key_info_next (xcb_input_key_info_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_key_info_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_key_info_end (xcb_input_key_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_button_info_next (xcb_input_button_info_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_button_info_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_button_info_end (xcb_input_button_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_axis_info_next (xcb_input_axis_info_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_axis_info_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_axis_info_end (xcb_input_axis_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_input_valuator_info_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_valuator_info_t *_aux = (xcb_input_valuator_info_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_valuator_info_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* axes */
+    xcb_block_len += _aux->axes_len * sizeof(xcb_input_axis_info_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_axis_info_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_axis_info_t *
+xcb_input_valuator_info_axes (const xcb_input_valuator_info_t *R)
+{
+    return (xcb_input_axis_info_t *) (R + 1);
+}
+
+int
+xcb_input_valuator_info_axes_length (const xcb_input_valuator_info_t *R)
+{
+    return R->axes_len;
+}
+
+xcb_input_axis_info_iterator_t
+xcb_input_valuator_info_axes_iterator (const xcb_input_valuator_info_t *R)
+{
+    xcb_input_axis_info_iterator_t i;
+    i.data = (xcb_input_axis_info_t *) (R + 1);
+    i.rem = R->axes_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_input_valuator_info_next (xcb_input_valuator_info_iterator_t *i)
+{
+    xcb_input_valuator_info_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_valuator_info_t *)(((char *)R) + xcb_input_valuator_info_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_valuator_info_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_valuator_info_end (xcb_input_valuator_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_valuator_info_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+xcb_input_axis_info_t *
+xcb_input_input_info_info_valuator_axes (const xcb_input_input_info_info_t *S)
+{
+    return S->valuator.axes;
+}
+
+int
+xcb_input_input_info_info_valuator_axes_length (const xcb_input_input_info_t *R,
+                                                const xcb_input_input_info_info_t *S)
+{
+    return S->valuator.axes_len;
+}
+
+xcb_input_axis_info_iterator_t
+xcb_input_input_info_info_valuator_axes_iterator (const xcb_input_input_info_t *R,
+                                                  const xcb_input_input_info_info_t *S)
+{
+    xcb_input_axis_info_iterator_t i;
+    i.data = S->valuator.axes;
+    i.rem = S->valuator.axes_len;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_input_input_info_info_serialize (void                              **_buffer,
+                                     uint8_t                             class_id,
+                                     const xcb_input_input_info_info_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 2;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[11];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(class_id == XCB_INPUT_INPUT_CLASS_KEY) {
+        /* xcb_input_input_info_info_t.key.min_keycode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key.min_keycode;
+        xcb_block_len += sizeof(xcb_input_key_code_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_key_code_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_input_key_code_t);
+        /* xcb_input_input_info_info_t.key.max_keycode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key.max_keycode;
+        xcb_block_len += sizeof(xcb_input_key_code_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_key_code_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_input_key_code_t);
+        /* xcb_input_input_info_info_t.key.num_keys */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key.num_keys;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_input_info_info_t.key.pad0 */
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_block_len += sizeof(uint8_t)*2;
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if(class_id == XCB_INPUT_INPUT_CLASS_BUTTON) {
+        /* xcb_input_input_info_info_t.button.num_buttons */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->button.num_buttons;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+    }
+    if(class_id == XCB_INPUT_INPUT_CLASS_VALUATOR) {
+        /* xcb_input_input_info_info_t.valuator.axes_len */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.axes_len;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_input_info_info_t.valuator.mode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.mode;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_input_info_info_t.valuator.motion_size */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.motion_size;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* axes */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->valuator.axes;
+        xcb_block_len += _aux->valuator.axes_len * sizeof(xcb_input_axis_info_t);
+        xcb_parts[xcb_parts_idx].iov_len = _aux->valuator.axes_len * sizeof(xcb_input_axis_info_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_input_axis_info_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_input_info_info_unpack (const void                   *_buffer,
+                                  uint8_t                       class_id,
+                                  xcb_input_input_info_info_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 2;
+
+
+    if(class_id == XCB_INPUT_INPUT_CLASS_KEY) {
+        /* xcb_input_input_info_info_t.key.min_keycode */
+        _aux->key.min_keycode = *(xcb_input_key_code_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_input_key_code_t);
+        xcb_tmp += sizeof(xcb_input_key_code_t);
+        xcb_align_to = ALIGNOF(xcb_input_key_code_t);
+        /* xcb_input_input_info_info_t.key.max_keycode */
+        _aux->key.max_keycode = *(xcb_input_key_code_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_input_key_code_t);
+        xcb_tmp += sizeof(xcb_input_key_code_t);
+        xcb_align_to = ALIGNOF(xcb_input_key_code_t);
+        /* xcb_input_input_info_info_t.key.num_keys */
+        _aux->key.num_keys = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_input_info_info_t.key.pad0 */
+        _aux->key.pad0[0] = *(uint8_t *)xcb_tmp;
+        _aux->key.pad0[1] = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t) * 2;
+        xcb_tmp += sizeof(uint8_t) * 2;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if(class_id == XCB_INPUT_INPUT_CLASS_BUTTON) {
+        /* xcb_input_input_info_info_t.button.num_buttons */
+        _aux->button.num_buttons = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+    }
+    if(class_id == XCB_INPUT_INPUT_CLASS_VALUATOR) {
+        /* xcb_input_input_info_info_t.valuator.axes_len */
+        _aux->valuator.axes_len = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_input_info_info_t.valuator.mode */
+        _aux->valuator.mode = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_input_info_info_t.valuator.motion_size */
+        _aux->valuator.motion_size = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* axes */
+        _aux->valuator.axes = (xcb_input_axis_info_t *)xcb_tmp;
+        xcb_block_len += _aux->valuator.axes_len * sizeof(xcb_input_axis_info_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_input_axis_info_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_input_info_info_sizeof (const void  *_buffer,
+                                  uint8_t      class_id)
+{
+    xcb_input_input_info_info_t _aux;
+    return xcb_input_input_info_info_unpack(_buffer, class_id, &_aux);
+}
+
+int
+xcb_input_input_info_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_input_info_t *_aux = (xcb_input_input_info_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_input_info_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* info */
+    xcb_block_len += xcb_input_input_info_info_sizeof(xcb_tmp, _aux->class_id);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+void *
+xcb_input_input_info_info (const xcb_input_input_info_t *R)
+{
+    return (void *) (R + 1);
+}
+
+void
+xcb_input_input_info_next (xcb_input_input_info_iterator_t *i)
+{
+    xcb_input_input_info_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_input_info_t *)(((char *)R) + xcb_input_input_info_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_input_info_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_input_info_end (xcb_input_input_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_input_info_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_input_device_name_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_device_name_t *_aux = (xcb_input_device_name_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_device_name_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* string */
+    xcb_block_len += _aux->len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+char *
+xcb_input_device_name_string (const xcb_input_device_name_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_input_device_name_string_length (const xcb_input_device_name_t *R)
+{
+    return R->len;
+}
+
+xcb_generic_iterator_t
+xcb_input_device_name_string_end (const xcb_input_device_name_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_input_device_name_next (xcb_input_device_name_iterator_t *i)
+{
+    xcb_input_device_name_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_device_name_t *)(((char *)R) + xcb_input_device_name_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_device_name_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_device_name_end (xcb_input_device_name_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_device_name_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_input_list_input_devices_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_list_input_devices_reply_t *_aux = (xcb_input_list_input_devices_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    int xcb_pre_tmp_1; /* sumof length */
+    int xcb_pre_tmp_2; /* sumof loop counter */
+    int64_t xcb_pre_tmp_3; /* sumof sum */
+    const xcb_input_device_info_t* xcb_pre_tmp_4; /* sumof list ptr */
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_input_list_input_devices_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* devices */
+    xcb_block_len += _aux->devices_len * sizeof(xcb_input_device_info_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_device_info_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* infos */
+    /* sumof start */
+    xcb_pre_tmp_1 = _aux->devices_len;
+    xcb_pre_tmp_3 = 0;
+    xcb_pre_tmp_4 = xcb_input_list_input_devices_devices(_aux);
+    for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
+        xcb_pre_tmp_3 += xcb_pre_tmp_4->num_class_info;
+        xcb_pre_tmp_4++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_3 */
+    for(i=0; i<xcb_pre_tmp_3; i++) {
+        xcb_tmp_len = xcb_input_input_info_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_input_input_info_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* names */
+    for(i=0; i<_aux->devices_len; i++) {
+        xcb_tmp_len = xcb_str_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_str_t);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_list_input_devices_cookie_t
+xcb_input_list_input_devices (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_LIST_INPUT_DEVICES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_list_input_devices_cookie_t xcb_ret;
+    xcb_input_list_input_devices_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_list_input_devices_cookie_t
+xcb_input_list_input_devices_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_LIST_INPUT_DEVICES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_list_input_devices_cookie_t xcb_ret;
+    xcb_input_list_input_devices_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_device_info_t *
+xcb_input_list_input_devices_devices (const xcb_input_list_input_devices_reply_t *R)
+{
+    return (xcb_input_device_info_t *) (R + 1);
+}
+
+int
+xcb_input_list_input_devices_devices_length (const xcb_input_list_input_devices_reply_t *R)
+{
+    return R->devices_len;
+}
+
+xcb_input_device_info_iterator_t
+xcb_input_list_input_devices_devices_iterator (const xcb_input_list_input_devices_reply_t *R)
+{
+    xcb_input_device_info_iterator_t i;
+    i.data = (xcb_input_device_info_t *) (R + 1);
+    i.rem = R->devices_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_input_list_input_devices_infos_length (const xcb_input_list_input_devices_reply_t *R)
+{
+    int xcb_pre_tmp_5; /* sumof length */
+    int xcb_pre_tmp_6; /* sumof loop counter */
+    int64_t xcb_pre_tmp_7; /* sumof sum */
+    const xcb_input_device_info_t* xcb_pre_tmp_8; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_5 = R->devices_len;
+    xcb_pre_tmp_7 = 0;
+    xcb_pre_tmp_8 = xcb_input_list_input_devices_devices(R);
+    for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) {
+        xcb_pre_tmp_7 += xcb_pre_tmp_8->num_class_info;
+        xcb_pre_tmp_8++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_7 */
+    return xcb_pre_tmp_7;
+}
+
+xcb_input_input_info_iterator_t
+xcb_input_list_input_devices_infos_iterator (const xcb_input_list_input_devices_reply_t *R)
+{
+    xcb_input_input_info_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_input_device_info_end(xcb_input_list_input_devices_devices_iterator(R));
+    int xcb_pre_tmp_9; /* sumof length */
+    int xcb_pre_tmp_10; /* sumof loop counter */
+    int64_t xcb_pre_tmp_11; /* sumof sum */
+    const xcb_input_device_info_t* xcb_pre_tmp_12; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_9 = R->devices_len;
+    xcb_pre_tmp_11 = 0;
+    xcb_pre_tmp_12 = xcb_input_list_input_devices_devices(R);
+    for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) {
+        xcb_pre_tmp_11 += xcb_pre_tmp_12->num_class_info;
+        xcb_pre_tmp_12++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_11 */
+    i.data = (xcb_input_input_info_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_input_info_t, prev.index));
+    i.rem = xcb_pre_tmp_11;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_input_list_input_devices_names_length (const xcb_input_list_input_devices_reply_t *R)
+{
+    return R->devices_len;
+}
+
+xcb_str_iterator_t
+xcb_input_list_input_devices_names_iterator (const xcb_input_list_input_devices_reply_t *R)
+{
+    xcb_str_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_input_input_info_end(xcb_input_list_input_devices_infos_iterator(R));
+    i.data = (xcb_str_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_str_t, prev.index));
+    i.rem = R->devices_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_list_input_devices_reply_t *
+xcb_input_list_input_devices_reply (xcb_connection_t                       *c,
+                                    xcb_input_list_input_devices_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e)
+{
+    return (xcb_input_list_input_devices_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+void
+xcb_input_event_type_base_next (xcb_input_event_type_base_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_event_type_base_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_event_type_base_end (xcb_input_event_type_base_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_input_class_info_next (xcb_input_input_class_info_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_input_class_info_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_input_class_info_end (xcb_input_input_class_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_input_open_device_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_open_device_reply_t *_aux = (xcb_input_open_device_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_open_device_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* class_info */
+    xcb_block_len += _aux->num_classes * sizeof(xcb_input_input_class_info_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_input_class_info_t);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_open_device_cookie_t
+xcb_input_open_device (xcb_connection_t *c,
+                       uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_OPEN_DEVICE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_open_device_cookie_t xcb_ret;
+    xcb_input_open_device_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_open_device_cookie_t
+xcb_input_open_device_unchecked (xcb_connection_t *c,
+                                 uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_OPEN_DEVICE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_open_device_cookie_t xcb_ret;
+    xcb_input_open_device_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_input_class_info_t *
+xcb_input_open_device_class_info (const xcb_input_open_device_reply_t *R)
+{
+    return (xcb_input_input_class_info_t *) (R + 1);
+}
+
+int
+xcb_input_open_device_class_info_length (const xcb_input_open_device_reply_t *R)
+{
+    return R->num_classes;
+}
+
+xcb_input_input_class_info_iterator_t
+xcb_input_open_device_class_info_iterator (const xcb_input_open_device_reply_t *R)
+{
+    xcb_input_input_class_info_iterator_t i;
+    i.data = (xcb_input_input_class_info_t *) (R + 1);
+    i.rem = R->num_classes;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_open_device_reply_t *
+xcb_input_open_device_reply (xcb_connection_t                *c,
+                             xcb_input_open_device_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_input_open_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_input_close_device_checked (xcb_connection_t *c,
+                                uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_CLOSE_DEVICE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_close_device_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_close_device (xcb_connection_t *c,
+                        uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_CLOSE_DEVICE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_close_device_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_set_device_mode_cookie_t
+xcb_input_set_device_mode (xcb_connection_t *c,
+                           uint8_t           device_id,
+                           uint8_t           mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_SET_DEVICE_MODE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_set_device_mode_cookie_t xcb_ret;
+    xcb_input_set_device_mode_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    xcb_out.mode = mode;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_set_device_mode_cookie_t
+xcb_input_set_device_mode_unchecked (xcb_connection_t *c,
+                                     uint8_t           device_id,
+                                     uint8_t           mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_SET_DEVICE_MODE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_set_device_mode_cookie_t xcb_ret;
+    xcb_input_set_device_mode_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    xcb_out.mode = mode;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_set_device_mode_reply_t *
+xcb_input_set_device_mode_reply (xcb_connection_t                    *c,
+                                 xcb_input_set_device_mode_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e)
+{
+    return (xcb_input_set_device_mode_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_input_select_extension_event_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_select_extension_event_request_t *_aux = (xcb_input_select_extension_event_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_select_extension_event_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* classes */
+    xcb_block_len += _aux->num_classes * sizeof(xcb_input_event_class_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_event_class_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_input_select_extension_event_checked (xcb_connection_t              *c,
+                                          xcb_window_t                   window,
+                                          uint16_t                       num_classes,
+                                          const xcb_input_event_class_t *classes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_SELECT_EXTENSION_EVENT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_select_extension_event_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.num_classes = num_classes;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_event_class_t classes */
+    xcb_parts[4].iov_base = (char *) classes;
+    xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_select_extension_event (xcb_connection_t              *c,
+                                  xcb_window_t                   window,
+                                  uint16_t                       num_classes,
+                                  const xcb_input_event_class_t *classes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_SELECT_EXTENSION_EVENT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_select_extension_event_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.num_classes = num_classes;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_event_class_t classes */
+    xcb_parts[4].iov_base = (char *) classes;
+    xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_event_class_t *
+xcb_input_select_extension_event_classes (const xcb_input_select_extension_event_request_t *R)
+{
+    return (xcb_input_event_class_t *) (R + 1);
+}
+
+int
+xcb_input_select_extension_event_classes_length (const xcb_input_select_extension_event_request_t *R)
+{
+    return R->num_classes;
+}
+
+xcb_generic_iterator_t
+xcb_input_select_extension_event_classes_end (const xcb_input_select_extension_event_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_input_get_selected_extension_events_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_get_selected_extension_events_reply_t *_aux = (xcb_input_get_selected_extension_events_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_get_selected_extension_events_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* this_classes */
+    xcb_block_len += _aux->num_this_classes * sizeof(xcb_input_event_class_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_event_class_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* all_classes */
+    xcb_block_len += _aux->num_all_classes * sizeof(xcb_input_event_class_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_event_class_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_get_selected_extension_events_cookie_t
+xcb_input_get_selected_extension_events (xcb_connection_t *c,
+                                         xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_SELECTED_EXTENSION_EVENTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_get_selected_extension_events_cookie_t xcb_ret;
+    xcb_input_get_selected_extension_events_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_get_selected_extension_events_cookie_t
+xcb_input_get_selected_extension_events_unchecked (xcb_connection_t *c,
+                                                   xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_SELECTED_EXTENSION_EVENTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_get_selected_extension_events_cookie_t xcb_ret;
+    xcb_input_get_selected_extension_events_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_event_class_t *
+xcb_input_get_selected_extension_events_this_classes (const xcb_input_get_selected_extension_events_reply_t *R)
+{
+    return (xcb_input_event_class_t *) (R + 1);
+}
+
+int
+xcb_input_get_selected_extension_events_this_classes_length (const xcb_input_get_selected_extension_events_reply_t *R)
+{
+    return R->num_this_classes;
+}
+
+xcb_generic_iterator_t
+xcb_input_get_selected_extension_events_this_classes_end (const xcb_input_get_selected_extension_events_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_this_classes);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_event_class_t *
+xcb_input_get_selected_extension_events_all_classes (const xcb_input_get_selected_extension_events_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_input_get_selected_extension_events_this_classes_end(R);
+    return (xcb_input_event_class_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_event_class_t, prev.index) + 0);
+}
+
+int
+xcb_input_get_selected_extension_events_all_classes_length (const xcb_input_get_selected_extension_events_reply_t *R)
+{
+    return R->num_all_classes;
+}
+
+xcb_generic_iterator_t
+xcb_input_get_selected_extension_events_all_classes_end (const xcb_input_get_selected_extension_events_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_input_get_selected_extension_events_this_classes_end(R);
+    i.data = ((xcb_input_event_class_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_input_event_class_t, prev.index))) + (R->num_all_classes);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_get_selected_extension_events_reply_t *
+xcb_input_get_selected_extension_events_reply (xcb_connection_t                                  *c,
+                                               xcb_input_get_selected_extension_events_cookie_t   cookie  /**< */,
+                                               xcb_generic_error_t                              **e)
+{
+    return (xcb_input_get_selected_extension_events_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_input_change_device_dont_propagate_list_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_change_device_dont_propagate_list_request_t *_aux = (xcb_input_change_device_dont_propagate_list_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_change_device_dont_propagate_list_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* classes */
+    xcb_block_len += _aux->num_classes * sizeof(xcb_input_event_class_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_event_class_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_input_change_device_dont_propagate_list_checked (xcb_connection_t              *c,
+                                                     xcb_window_t                   window,
+                                                     uint16_t                       num_classes,
+                                                     uint8_t                        mode,
+                                                     const xcb_input_event_class_t *classes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_CHANGE_DEVICE_DONT_PROPAGATE_LIST,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_change_device_dont_propagate_list_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.num_classes = num_classes;
+    xcb_out.mode = mode;
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_event_class_t classes */
+    xcb_parts[4].iov_base = (char *) classes;
+    xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_change_device_dont_propagate_list (xcb_connection_t              *c,
+                                             xcb_window_t                   window,
+                                             uint16_t                       num_classes,
+                                             uint8_t                        mode,
+                                             const xcb_input_event_class_t *classes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_CHANGE_DEVICE_DONT_PROPAGATE_LIST,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_change_device_dont_propagate_list_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.num_classes = num_classes;
+    xcb_out.mode = mode;
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_event_class_t classes */
+    xcb_parts[4].iov_base = (char *) classes;
+    xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_event_class_t *
+xcb_input_change_device_dont_propagate_list_classes (const xcb_input_change_device_dont_propagate_list_request_t *R)
+{
+    return (xcb_input_event_class_t *) (R + 1);
+}
+
+int
+xcb_input_change_device_dont_propagate_list_classes_length (const xcb_input_change_device_dont_propagate_list_request_t *R)
+{
+    return R->num_classes;
+}
+
+xcb_generic_iterator_t
+xcb_input_change_device_dont_propagate_list_classes_end (const xcb_input_change_device_dont_propagate_list_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_input_get_device_dont_propagate_list_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_get_device_dont_propagate_list_reply_t *_aux = (xcb_input_get_device_dont_propagate_list_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_get_device_dont_propagate_list_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* classes */
+    xcb_block_len += _aux->num_classes * sizeof(xcb_input_event_class_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_event_class_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_get_device_dont_propagate_list_cookie_t
+xcb_input_get_device_dont_propagate_list (xcb_connection_t *c,
+                                          xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_DEVICE_DONT_PROPAGATE_LIST,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_get_device_dont_propagate_list_cookie_t xcb_ret;
+    xcb_input_get_device_dont_propagate_list_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_get_device_dont_propagate_list_cookie_t
+xcb_input_get_device_dont_propagate_list_unchecked (xcb_connection_t *c,
+                                                    xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_DEVICE_DONT_PROPAGATE_LIST,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_get_device_dont_propagate_list_cookie_t xcb_ret;
+    xcb_input_get_device_dont_propagate_list_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_event_class_t *
+xcb_input_get_device_dont_propagate_list_classes (const xcb_input_get_device_dont_propagate_list_reply_t *R)
+{
+    return (xcb_input_event_class_t *) (R + 1);
+}
+
+int
+xcb_input_get_device_dont_propagate_list_classes_length (const xcb_input_get_device_dont_propagate_list_reply_t *R)
+{
+    return R->num_classes;
+}
+
+xcb_generic_iterator_t
+xcb_input_get_device_dont_propagate_list_classes_end (const xcb_input_get_device_dont_propagate_list_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_get_device_dont_propagate_list_reply_t *
+xcb_input_get_device_dont_propagate_list_reply (xcb_connection_t                                   *c,
+                                                xcb_input_get_device_dont_propagate_list_cookie_t   cookie  /**< */,
+                                                xcb_generic_error_t                               **e)
+{
+    return (xcb_input_get_device_dont_propagate_list_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_input_device_time_coord_sizeof (const void  *_buffer,
+                                    uint8_t      num_axes)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_device_time_coord_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* axisvalues */
+    xcb_block_len += num_axes * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+int32_t *
+xcb_input_device_time_coord_axisvalues (const xcb_input_device_time_coord_t *R)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_input_device_time_coord_axisvalues_length (const xcb_input_device_time_coord_t *R,
+                                               uint8_t num_axes)
+{
+    return num_axes;
+}
+
+xcb_generic_iterator_t
+xcb_input_device_time_coord_axisvalues_end (const xcb_input_device_time_coord_t *R,
+                                            uint8_t num_axes)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + (num_axes);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_input_device_time_coord_next (xcb_input_device_time_coord_iterator_t *i)
+{
+    xcb_input_device_time_coord_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_device_time_coord_t *)(((char *)R) + xcb_input_device_time_coord_sizeof(R, i->num_axes));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_device_time_coord_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_device_time_coord_end (xcb_input_device_time_coord_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_device_time_coord_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_input_get_device_motion_events_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_get_device_motion_events_reply_t *_aux = (xcb_input_get_device_motion_events_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_input_get_device_motion_events_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* events */
+    for(i=0; i<_aux->num_events; i++) {
+        xcb_tmp_len = xcb_input_device_time_coord_sizeof(xcb_tmp, _aux->num_axes);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_input_device_time_coord_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_get_device_motion_events_cookie_t
+xcb_input_get_device_motion_events (xcb_connection_t *c,
+                                    xcb_timestamp_t   start,
+                                    xcb_timestamp_t   stop,
+                                    uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_DEVICE_MOTION_EVENTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_get_device_motion_events_cookie_t xcb_ret;
+    xcb_input_get_device_motion_events_request_t xcb_out;
+
+    xcb_out.start = start;
+    xcb_out.stop = stop;
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_get_device_motion_events_cookie_t
+xcb_input_get_device_motion_events_unchecked (xcb_connection_t *c,
+                                              xcb_timestamp_t   start,
+                                              xcb_timestamp_t   stop,
+                                              uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_DEVICE_MOTION_EVENTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_get_device_motion_events_cookie_t xcb_ret;
+    xcb_input_get_device_motion_events_request_t xcb_out;
+
+    xcb_out.start = start;
+    xcb_out.stop = stop;
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_input_get_device_motion_events_events_length (const xcb_input_get_device_motion_events_reply_t *R)
+{
+    return R->num_events;
+}
+
+xcb_input_device_time_coord_iterator_t
+xcb_input_get_device_motion_events_events_iterator (const xcb_input_get_device_motion_events_reply_t *R)
+{
+    xcb_input_device_time_coord_iterator_t i;
+    i.data = (xcb_input_device_time_coord_t *) (R + 1);
+    i.rem = R->num_events;
+    i.index = (char *) i.data - (char *) R;
+    i.num_axes = R->num_axes;
+    return i;
+}
+
+xcb_input_get_device_motion_events_reply_t *
+xcb_input_get_device_motion_events_reply (xcb_connection_t                             *c,
+                                          xcb_input_get_device_motion_events_cookie_t   cookie  /**< */,
+                                          xcb_generic_error_t                         **e)
+{
+    return (xcb_input_get_device_motion_events_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_input_change_keyboard_device_cookie_t
+xcb_input_change_keyboard_device (xcb_connection_t *c,
+                                  uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_CHANGE_KEYBOARD_DEVICE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_change_keyboard_device_cookie_t xcb_ret;
+    xcb_input_change_keyboard_device_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_change_keyboard_device_cookie_t
+xcb_input_change_keyboard_device_unchecked (xcb_connection_t *c,
+                                            uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_CHANGE_KEYBOARD_DEVICE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_change_keyboard_device_cookie_t xcb_ret;
+    xcb_input_change_keyboard_device_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_change_keyboard_device_reply_t *
+xcb_input_change_keyboard_device_reply (xcb_connection_t                           *c,
+                                        xcb_input_change_keyboard_device_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e)
+{
+    return (xcb_input_change_keyboard_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_input_change_pointer_device_cookie_t
+xcb_input_change_pointer_device (xcb_connection_t *c,
+                                 uint8_t           x_axis,
+                                 uint8_t           y_axis,
+                                 uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_CHANGE_POINTER_DEVICE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_change_pointer_device_cookie_t xcb_ret;
+    xcb_input_change_pointer_device_request_t xcb_out;
+
+    xcb_out.x_axis = x_axis;
+    xcb_out.y_axis = y_axis;
+    xcb_out.device_id = device_id;
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_change_pointer_device_cookie_t
+xcb_input_change_pointer_device_unchecked (xcb_connection_t *c,
+                                           uint8_t           x_axis,
+                                           uint8_t           y_axis,
+                                           uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_CHANGE_POINTER_DEVICE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_change_pointer_device_cookie_t xcb_ret;
+    xcb_input_change_pointer_device_request_t xcb_out;
+
+    xcb_out.x_axis = x_axis;
+    xcb_out.y_axis = y_axis;
+    xcb_out.device_id = device_id;
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_change_pointer_device_reply_t *
+xcb_input_change_pointer_device_reply (xcb_connection_t                          *c,
+                                       xcb_input_change_pointer_device_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e)
+{
+    return (xcb_input_change_pointer_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_input_grab_device_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_grab_device_request_t *_aux = (xcb_input_grab_device_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_grab_device_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* classes */
+    xcb_block_len += _aux->num_classes * sizeof(xcb_input_event_class_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_event_class_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_grab_device_cookie_t
+xcb_input_grab_device (xcb_connection_t              *c,
+                       xcb_window_t                   grab_window,
+                       xcb_timestamp_t                time,
+                       uint16_t                       num_classes,
+                       uint8_t                        this_device_mode,
+                       uint8_t                        other_device_mode,
+                       uint8_t                        owner_events,
+                       uint8_t                        device_id,
+                       const xcb_input_event_class_t *classes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GRAB_DEVICE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_input_grab_device_cookie_t xcb_ret;
+    xcb_input_grab_device_request_t xcb_out;
+
+    xcb_out.grab_window = grab_window;
+    xcb_out.time = time;
+    xcb_out.num_classes = num_classes;
+    xcb_out.this_device_mode = this_device_mode;
+    xcb_out.other_device_mode = other_device_mode;
+    xcb_out.owner_events = owner_events;
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_event_class_t classes */
+    xcb_parts[4].iov_base = (char *) classes;
+    xcb_parts[4].iov_len = num_classes * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_grab_device_cookie_t
+xcb_input_grab_device_unchecked (xcb_connection_t              *c,
+                                 xcb_window_t                   grab_window,
+                                 xcb_timestamp_t                time,
+                                 uint16_t                       num_classes,
+                                 uint8_t                        this_device_mode,
+                                 uint8_t                        other_device_mode,
+                                 uint8_t                        owner_events,
+                                 uint8_t                        device_id,
+                                 const xcb_input_event_class_t *classes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GRAB_DEVICE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_input_grab_device_cookie_t xcb_ret;
+    xcb_input_grab_device_request_t xcb_out;
+
+    xcb_out.grab_window = grab_window;
+    xcb_out.time = time;
+    xcb_out.num_classes = num_classes;
+    xcb_out.this_device_mode = this_device_mode;
+    xcb_out.other_device_mode = other_device_mode;
+    xcb_out.owner_events = owner_events;
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_event_class_t classes */
+    xcb_parts[4].iov_base = (char *) classes;
+    xcb_parts[4].iov_len = num_classes * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_grab_device_reply_t *
+xcb_input_grab_device_reply (xcb_connection_t                *c,
+                             xcb_input_grab_device_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_input_grab_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_input_ungrab_device_checked (xcb_connection_t *c,
+                                 xcb_timestamp_t   time,
+                                 uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_UNGRAB_DEVICE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_ungrab_device_request_t xcb_out;
+
+    xcb_out.time = time;
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_ungrab_device (xcb_connection_t *c,
+                         xcb_timestamp_t   time,
+                         uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_UNGRAB_DEVICE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_ungrab_device_request_t xcb_out;
+
+    xcb_out.time = time;
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_input_grab_device_key_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_grab_device_key_request_t *_aux = (xcb_input_grab_device_key_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_grab_device_key_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* classes */
+    xcb_block_len += _aux->num_classes * sizeof(xcb_input_event_class_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_event_class_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_input_grab_device_key_checked (xcb_connection_t              *c,
+                                   xcb_window_t                   grab_window,
+                                   uint16_t                       num_classes,
+                                   uint16_t                       modifiers,
+                                   uint8_t                        modifier_device,
+                                   uint8_t                        grabbed_device,
+                                   uint8_t                        key,
+                                   uint8_t                        this_device_mode,
+                                   uint8_t                        other_device_mode,
+                                   uint8_t                        owner_events,
+                                   const xcb_input_event_class_t *classes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GRAB_DEVICE_KEY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_grab_device_key_request_t xcb_out;
+
+    xcb_out.grab_window = grab_window;
+    xcb_out.num_classes = num_classes;
+    xcb_out.modifiers = modifiers;
+    xcb_out.modifier_device = modifier_device;
+    xcb_out.grabbed_device = grabbed_device;
+    xcb_out.key = key;
+    xcb_out.this_device_mode = this_device_mode;
+    xcb_out.other_device_mode = other_device_mode;
+    xcb_out.owner_events = owner_events;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_event_class_t classes */
+    xcb_parts[4].iov_base = (char *) classes;
+    xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_grab_device_key (xcb_connection_t              *c,
+                           xcb_window_t                   grab_window,
+                           uint16_t                       num_classes,
+                           uint16_t                       modifiers,
+                           uint8_t                        modifier_device,
+                           uint8_t                        grabbed_device,
+                           uint8_t                        key,
+                           uint8_t                        this_device_mode,
+                           uint8_t                        other_device_mode,
+                           uint8_t                        owner_events,
+                           const xcb_input_event_class_t *classes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GRAB_DEVICE_KEY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_grab_device_key_request_t xcb_out;
+
+    xcb_out.grab_window = grab_window;
+    xcb_out.num_classes = num_classes;
+    xcb_out.modifiers = modifiers;
+    xcb_out.modifier_device = modifier_device;
+    xcb_out.grabbed_device = grabbed_device;
+    xcb_out.key = key;
+    xcb_out.this_device_mode = this_device_mode;
+    xcb_out.other_device_mode = other_device_mode;
+    xcb_out.owner_events = owner_events;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_event_class_t classes */
+    xcb_parts[4].iov_base = (char *) classes;
+    xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_event_class_t *
+xcb_input_grab_device_key_classes (const xcb_input_grab_device_key_request_t *R)
+{
+    return (xcb_input_event_class_t *) (R + 1);
+}
+
+int
+xcb_input_grab_device_key_classes_length (const xcb_input_grab_device_key_request_t *R)
+{
+    return R->num_classes;
+}
+
+xcb_generic_iterator_t
+xcb_input_grab_device_key_classes_end (const xcb_input_grab_device_key_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_input_ungrab_device_key_checked (xcb_connection_t *c,
+                                     xcb_window_t      grabWindow,
+                                     uint16_t          modifiers,
+                                     uint8_t           modifier_device,
+                                     uint8_t           key,
+                                     uint8_t           grabbed_device)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_UNGRAB_DEVICE_KEY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_ungrab_device_key_request_t xcb_out;
+
+    xcb_out.grabWindow = grabWindow;
+    xcb_out.modifiers = modifiers;
+    xcb_out.modifier_device = modifier_device;
+    xcb_out.key = key;
+    xcb_out.grabbed_device = grabbed_device;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_ungrab_device_key (xcb_connection_t *c,
+                             xcb_window_t      grabWindow,
+                             uint16_t          modifiers,
+                             uint8_t           modifier_device,
+                             uint8_t           key,
+                             uint8_t           grabbed_device)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_UNGRAB_DEVICE_KEY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_ungrab_device_key_request_t xcb_out;
+
+    xcb_out.grabWindow = grabWindow;
+    xcb_out.modifiers = modifiers;
+    xcb_out.modifier_device = modifier_device;
+    xcb_out.key = key;
+    xcb_out.grabbed_device = grabbed_device;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_input_grab_device_button_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_grab_device_button_request_t *_aux = (xcb_input_grab_device_button_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_grab_device_button_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* classes */
+    xcb_block_len += _aux->num_classes * sizeof(xcb_input_event_class_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_event_class_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_input_grab_device_button_checked (xcb_connection_t              *c,
+                                      xcb_window_t                   grab_window,
+                                      uint8_t                        grabbed_device,
+                                      uint8_t                        modifier_device,
+                                      uint16_t                       num_classes,
+                                      uint16_t                       modifiers,
+                                      uint8_t                        this_device_mode,
+                                      uint8_t                        other_device_mode,
+                                      uint8_t                        button,
+                                      uint8_t                        owner_events,
+                                      const xcb_input_event_class_t *classes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GRAB_DEVICE_BUTTON,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_grab_device_button_request_t xcb_out;
+
+    xcb_out.grab_window = grab_window;
+    xcb_out.grabbed_device = grabbed_device;
+    xcb_out.modifier_device = modifier_device;
+    xcb_out.num_classes = num_classes;
+    xcb_out.modifiers = modifiers;
+    xcb_out.this_device_mode = this_device_mode;
+    xcb_out.other_device_mode = other_device_mode;
+    xcb_out.button = button;
+    xcb_out.owner_events = owner_events;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_event_class_t classes */
+    xcb_parts[4].iov_base = (char *) classes;
+    xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_grab_device_button (xcb_connection_t              *c,
+                              xcb_window_t                   grab_window,
+                              uint8_t                        grabbed_device,
+                              uint8_t                        modifier_device,
+                              uint16_t                       num_classes,
+                              uint16_t                       modifiers,
+                              uint8_t                        this_device_mode,
+                              uint8_t                        other_device_mode,
+                              uint8_t                        button,
+                              uint8_t                        owner_events,
+                              const xcb_input_event_class_t *classes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GRAB_DEVICE_BUTTON,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_grab_device_button_request_t xcb_out;
+
+    xcb_out.grab_window = grab_window;
+    xcb_out.grabbed_device = grabbed_device;
+    xcb_out.modifier_device = modifier_device;
+    xcb_out.num_classes = num_classes;
+    xcb_out.modifiers = modifiers;
+    xcb_out.this_device_mode = this_device_mode;
+    xcb_out.other_device_mode = other_device_mode;
+    xcb_out.button = button;
+    xcb_out.owner_events = owner_events;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_event_class_t classes */
+    xcb_parts[4].iov_base = (char *) classes;
+    xcb_parts[4].iov_len = num_classes * sizeof(xcb_input_event_class_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_event_class_t *
+xcb_input_grab_device_button_classes (const xcb_input_grab_device_button_request_t *R)
+{
+    return (xcb_input_event_class_t *) (R + 1);
+}
+
+int
+xcb_input_grab_device_button_classes_length (const xcb_input_grab_device_button_request_t *R)
+{
+    return R->num_classes;
+}
+
+xcb_generic_iterator_t
+xcb_input_grab_device_button_classes_end (const xcb_input_grab_device_button_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_input_event_class_t *) (R + 1)) + (R->num_classes);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_input_ungrab_device_button_checked (xcb_connection_t *c,
+                                        xcb_window_t      grab_window,
+                                        uint16_t          modifiers,
+                                        uint8_t           modifier_device,
+                                        uint8_t           button,
+                                        uint8_t           grabbed_device)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_UNGRAB_DEVICE_BUTTON,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_ungrab_device_button_request_t xcb_out;
+
+    xcb_out.grab_window = grab_window;
+    xcb_out.modifiers = modifiers;
+    xcb_out.modifier_device = modifier_device;
+    xcb_out.button = button;
+    xcb_out.grabbed_device = grabbed_device;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_ungrab_device_button (xcb_connection_t *c,
+                                xcb_window_t      grab_window,
+                                uint16_t          modifiers,
+                                uint8_t           modifier_device,
+                                uint8_t           button,
+                                uint8_t           grabbed_device)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_UNGRAB_DEVICE_BUTTON,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_ungrab_device_button_request_t xcb_out;
+
+    xcb_out.grab_window = grab_window;
+    xcb_out.modifiers = modifiers;
+    xcb_out.modifier_device = modifier_device;
+    xcb_out.button = button;
+    xcb_out.grabbed_device = grabbed_device;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_allow_device_events_checked (xcb_connection_t *c,
+                                       xcb_timestamp_t   time,
+                                       uint8_t           mode,
+                                       uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_ALLOW_DEVICE_EVENTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_allow_device_events_request_t xcb_out;
+
+    xcb_out.time = time;
+    xcb_out.mode = mode;
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_allow_device_events (xcb_connection_t *c,
+                               xcb_timestamp_t   time,
+                               uint8_t           mode,
+                               uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_ALLOW_DEVICE_EVENTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_allow_device_events_request_t xcb_out;
+
+    xcb_out.time = time;
+    xcb_out.mode = mode;
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_get_device_focus_cookie_t
+xcb_input_get_device_focus (xcb_connection_t *c,
+                            uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_DEVICE_FOCUS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_get_device_focus_cookie_t xcb_ret;
+    xcb_input_get_device_focus_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_get_device_focus_cookie_t
+xcb_input_get_device_focus_unchecked (xcb_connection_t *c,
+                                      uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_DEVICE_FOCUS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_get_device_focus_cookie_t xcb_ret;
+    xcb_input_get_device_focus_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_get_device_focus_reply_t *
+xcb_input_get_device_focus_reply (xcb_connection_t                     *c,
+                                  xcb_input_get_device_focus_cookie_t   cookie  /**< */,
+                                  xcb_generic_error_t                 **e)
+{
+    return (xcb_input_get_device_focus_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_input_set_device_focus_checked (xcb_connection_t *c,
+                                    xcb_window_t      focus,
+                                    xcb_timestamp_t   time,
+                                    uint8_t           revert_to,
+                                    uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_SET_DEVICE_FOCUS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_set_device_focus_request_t xcb_out;
+
+    xcb_out.focus = focus;
+    xcb_out.time = time;
+    xcb_out.revert_to = revert_to;
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_set_device_focus (xcb_connection_t *c,
+                            xcb_window_t      focus,
+                            xcb_timestamp_t   time,
+                            uint8_t           revert_to,
+                            uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_SET_DEVICE_FOCUS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_set_device_focus_request_t xcb_out;
+
+    xcb_out.focus = focus;
+    xcb_out.time = time;
+    xcb_out.revert_to = revert_to;
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+void
+xcb_input_kbd_feedback_state_next (xcb_input_kbd_feedback_state_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_kbd_feedback_state_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_kbd_feedback_state_end (xcb_input_kbd_feedback_state_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_ptr_feedback_state_next (xcb_input_ptr_feedback_state_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_ptr_feedback_state_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_ptr_feedback_state_end (xcb_input_ptr_feedback_state_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_integer_feedback_state_next (xcb_input_integer_feedback_state_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_integer_feedback_state_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_integer_feedback_state_end (xcb_input_integer_feedback_state_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_input_string_feedback_state_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_string_feedback_state_t *_aux = (xcb_input_string_feedback_state_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_string_feedback_state_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* keysyms */
+    xcb_block_len += _aux->num_keysyms * sizeof(xcb_keysym_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_keysym_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_keysym_t *
+xcb_input_string_feedback_state_keysyms (const xcb_input_string_feedback_state_t *R)
+{
+    return (xcb_keysym_t *) (R + 1);
+}
+
+int
+xcb_input_string_feedback_state_keysyms_length (const xcb_input_string_feedback_state_t *R)
+{
+    return R->num_keysyms;
+}
+
+xcb_generic_iterator_t
+xcb_input_string_feedback_state_keysyms_end (const xcb_input_string_feedback_state_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_keysym_t *) (R + 1)) + (R->num_keysyms);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_input_string_feedback_state_next (xcb_input_string_feedback_state_iterator_t *i)
+{
+    xcb_input_string_feedback_state_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_string_feedback_state_t *)(((char *)R) + xcb_input_string_feedback_state_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_string_feedback_state_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_string_feedback_state_end (xcb_input_string_feedback_state_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_string_feedback_state_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+void
+xcb_input_bell_feedback_state_next (xcb_input_bell_feedback_state_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_bell_feedback_state_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_bell_feedback_state_end (xcb_input_bell_feedback_state_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_led_feedback_state_next (xcb_input_led_feedback_state_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_led_feedback_state_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_led_feedback_state_end (xcb_input_led_feedback_state_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+xcb_keysym_t *
+xcb_input_feedback_state_data_string_keysyms (const xcb_input_feedback_state_data_t *S)
+{
+    return S->string.keysyms;
+}
+
+int
+xcb_input_feedback_state_data_string_keysyms_length (const xcb_input_feedback_state_t *R,
+                                                     const xcb_input_feedback_state_data_t *S)
+{
+    return S->string.num_keysyms;
+}
+
+xcb_generic_iterator_t
+xcb_input_feedback_state_data_string_keysyms_end (const xcb_input_feedback_state_t *R,
+                                                  const xcb_input_feedback_state_data_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->string.keysyms + S->string.num_keysyms;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_input_feedback_state_data_serialize (void                                  **_buffer,
+                                         uint8_t                                 class_id,
+                                         const xcb_input_feedback_state_data_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[27];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_KEYBOARD) {
+        /* xcb_input_feedback_state_data_t.keyboard.pitch */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.pitch;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_feedback_state_data_t.keyboard.duration */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.duration;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_feedback_state_data_t.keyboard.led_mask */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.led_mask;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_feedback_state_data_t.keyboard.led_values */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.led_values;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_feedback_state_data_t.keyboard.global_auto_repeat */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.global_auto_repeat;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_state_data_t.keyboard.click */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.click;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_state_data_t.keyboard.percent */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.percent;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_state_data_t.keyboard.pad0 */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_state_data_t.keyboard.auto_repeats */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyboard.auto_repeats;
+        xcb_block_len += 32;
+        xcb_parts[xcb_parts_idx].iov_len = 32;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_POINTER) {
+        /* xcb_input_feedback_state_data_t.pointer.pad1 */
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_block_len += sizeof(uint8_t)*2;
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_state_data_t.pointer.accel_num */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.accel_num;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_feedback_state_data_t.pointer.accel_denom */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.accel_denom;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_feedback_state_data_t.pointer.threshold */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.threshold;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+    }
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_STRING) {
+        /* xcb_input_feedback_state_data_t.string.max_symbols */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->string.max_symbols;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_feedback_state_data_t.string.num_keysyms */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->string.num_keysyms;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* keysyms */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->string.keysyms;
+        xcb_block_len += _aux->string.num_keysyms * sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = _aux->string.num_keysyms * sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_keysym_t);
+    }
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_INTEGER) {
+        /* xcb_input_feedback_state_data_t.integer.resolution */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->integer.resolution;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_feedback_state_data_t.integer.min_value */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->integer.min_value;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_feedback_state_data_t.integer.max_value */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->integer.max_value;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_LED) {
+        /* xcb_input_feedback_state_data_t.led.led_mask */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led.led_mask;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_feedback_state_data_t.led.led_values */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led.led_values;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_BELL) {
+        /* xcb_input_feedback_state_data_t.bell.percent */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.percent;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_state_data_t.bell.pad2 */
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_block_len += sizeof(uint8_t)*3;
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_state_data_t.bell.pitch */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.pitch;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_feedback_state_data_t.bell.duration */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.duration;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_feedback_state_data_unpack (const void                       *_buffer,
+                                      uint8_t                           class_id,
+                                      xcb_input_feedback_state_data_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_KEYBOARD) {
+        /* xcb_input_feedback_state_data_t.keyboard.pitch */
+        _aux->keyboard.pitch = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_feedback_state_data_t.keyboard.duration */
+        _aux->keyboard.duration = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_feedback_state_data_t.keyboard.led_mask */
+        _aux->keyboard.led_mask = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_feedback_state_data_t.keyboard.led_values */
+        _aux->keyboard.led_values = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_feedback_state_data_t.keyboard.global_auto_repeat */
+        _aux->keyboard.global_auto_repeat = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_state_data_t.keyboard.click */
+        _aux->keyboard.click = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_state_data_t.keyboard.percent */
+        _aux->keyboard.percent = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_state_data_t.keyboard.pad0 */
+        _aux->keyboard.pad0 = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_state_data_t.keyboard.auto_repeats */
+        memcpy(_aux->keyboard.auto_repeats, xcb_tmp, sizeof(uint8_t) * 32);
+        xcb_block_len += sizeof(uint8_t) * 32;
+        xcb_tmp += sizeof(uint8_t) * 32;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_POINTER) {
+        /* xcb_input_feedback_state_data_t.pointer.pad1 */
+        _aux->pointer.pad1[0] = *(uint8_t *)xcb_tmp;
+        _aux->pointer.pad1[1] = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t) * 2;
+        xcb_tmp += sizeof(uint8_t) * 2;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_state_data_t.pointer.accel_num */
+        _aux->pointer.accel_num = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_feedback_state_data_t.pointer.accel_denom */
+        _aux->pointer.accel_denom = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_feedback_state_data_t.pointer.threshold */
+        _aux->pointer.threshold = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+    }
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_STRING) {
+        /* xcb_input_feedback_state_data_t.string.max_symbols */
+        _aux->string.max_symbols = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_feedback_state_data_t.string.num_keysyms */
+        _aux->string.num_keysyms = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* keysyms */
+        _aux->string.keysyms = (xcb_keysym_t *)xcb_tmp;
+        xcb_block_len += _aux->string.num_keysyms * sizeof(uint32_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_keysym_t);
+    }
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_INTEGER) {
+        /* xcb_input_feedback_state_data_t.integer.resolution */
+        _aux->integer.resolution = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_feedback_state_data_t.integer.min_value */
+        _aux->integer.min_value = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_feedback_state_data_t.integer.max_value */
+        _aux->integer.max_value = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_LED) {
+        /* xcb_input_feedback_state_data_t.led.led_mask */
+        _aux->led.led_mask = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_feedback_state_data_t.led.led_values */
+        _aux->led.led_values = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_BELL) {
+        /* xcb_input_feedback_state_data_t.bell.percent */
+        _aux->bell.percent = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_state_data_t.bell.pad2 */
+        _aux->bell.pad2[0] = *(uint8_t *)xcb_tmp;
+        _aux->bell.pad2[1] = *(uint8_t *)xcb_tmp;
+        _aux->bell.pad2[2] = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t) * 3;
+        xcb_tmp += sizeof(uint8_t) * 3;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_state_data_t.bell.pitch */
+        _aux->bell.pitch = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_feedback_state_data_t.bell.duration */
+        _aux->bell.duration = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_feedback_state_data_sizeof (const void  *_buffer,
+                                      uint8_t      class_id)
+{
+    xcb_input_feedback_state_data_t _aux;
+    return xcb_input_feedback_state_data_unpack(_buffer, class_id, &_aux);
+}
+
+int
+xcb_input_feedback_state_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_feedback_state_t *_aux = (xcb_input_feedback_state_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_feedback_state_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += xcb_input_feedback_state_data_sizeof(xcb_tmp, _aux->class_id);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+void *
+xcb_input_feedback_state_data (const xcb_input_feedback_state_t *R)
+{
+    return (void *) (R + 1);
+}
+
+void
+xcb_input_feedback_state_next (xcb_input_feedback_state_iterator_t *i)
+{
+    xcb_input_feedback_state_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_feedback_state_t *)(((char *)R) + xcb_input_feedback_state_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_feedback_state_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_feedback_state_end (xcb_input_feedback_state_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_feedback_state_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_input_get_feedback_control_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_get_feedback_control_reply_t *_aux = (xcb_input_get_feedback_control_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_input_get_feedback_control_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* feedbacks */
+    for(i=0; i<_aux->num_feedbacks; i++) {
+        xcb_tmp_len = xcb_input_feedback_state_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_input_feedback_state_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_get_feedback_control_cookie_t
+xcb_input_get_feedback_control (xcb_connection_t *c,
+                                uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_FEEDBACK_CONTROL,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_get_feedback_control_cookie_t xcb_ret;
+    xcb_input_get_feedback_control_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_get_feedback_control_cookie_t
+xcb_input_get_feedback_control_unchecked (xcb_connection_t *c,
+                                          uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_FEEDBACK_CONTROL,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_get_feedback_control_cookie_t xcb_ret;
+    xcb_input_get_feedback_control_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_input_get_feedback_control_feedbacks_length (const xcb_input_get_feedback_control_reply_t *R)
+{
+    return R->num_feedbacks;
+}
+
+xcb_input_feedback_state_iterator_t
+xcb_input_get_feedback_control_feedbacks_iterator (const xcb_input_get_feedback_control_reply_t *R)
+{
+    xcb_input_feedback_state_iterator_t i;
+    i.data = (xcb_input_feedback_state_t *) (R + 1);
+    i.rem = R->num_feedbacks;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_get_feedback_control_reply_t *
+xcb_input_get_feedback_control_reply (xcb_connection_t                         *c,
+                                      xcb_input_get_feedback_control_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e)
+{
+    return (xcb_input_get_feedback_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+void
+xcb_input_kbd_feedback_ctl_next (xcb_input_kbd_feedback_ctl_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_kbd_feedback_ctl_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_kbd_feedback_ctl_end (xcb_input_kbd_feedback_ctl_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_ptr_feedback_ctl_next (xcb_input_ptr_feedback_ctl_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_ptr_feedback_ctl_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_ptr_feedback_ctl_end (xcb_input_ptr_feedback_ctl_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_integer_feedback_ctl_next (xcb_input_integer_feedback_ctl_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_integer_feedback_ctl_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_integer_feedback_ctl_end (xcb_input_integer_feedback_ctl_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_input_string_feedback_ctl_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_string_feedback_ctl_t *_aux = (xcb_input_string_feedback_ctl_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_string_feedback_ctl_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* keysyms */
+    xcb_block_len += _aux->num_keysyms * sizeof(xcb_keysym_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_keysym_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_keysym_t *
+xcb_input_string_feedback_ctl_keysyms (const xcb_input_string_feedback_ctl_t *R)
+{
+    return (xcb_keysym_t *) (R + 1);
+}
+
+int
+xcb_input_string_feedback_ctl_keysyms_length (const xcb_input_string_feedback_ctl_t *R)
+{
+    return R->num_keysyms;
+}
+
+xcb_generic_iterator_t
+xcb_input_string_feedback_ctl_keysyms_end (const xcb_input_string_feedback_ctl_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_keysym_t *) (R + 1)) + (R->num_keysyms);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_input_string_feedback_ctl_next (xcb_input_string_feedback_ctl_iterator_t *i)
+{
+    xcb_input_string_feedback_ctl_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_string_feedback_ctl_t *)(((char *)R) + xcb_input_string_feedback_ctl_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_string_feedback_ctl_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_string_feedback_ctl_end (xcb_input_string_feedback_ctl_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_string_feedback_ctl_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+void
+xcb_input_bell_feedback_ctl_next (xcb_input_bell_feedback_ctl_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_bell_feedback_ctl_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_bell_feedback_ctl_end (xcb_input_bell_feedback_ctl_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_led_feedback_ctl_next (xcb_input_led_feedback_ctl_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_led_feedback_ctl_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_led_feedback_ctl_end (xcb_input_led_feedback_ctl_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+xcb_keysym_t *
+xcb_input_feedback_ctl_data_string_keysyms (const xcb_input_feedback_ctl_data_t *S)
+{
+    return S->string.keysyms;
+}
+
+int
+xcb_input_feedback_ctl_data_string_keysyms_length (const xcb_input_feedback_ctl_t *R,
+                                                   const xcb_input_feedback_ctl_data_t *S)
+{
+    return S->string.num_keysyms;
+}
+
+xcb_generic_iterator_t
+xcb_input_feedback_ctl_data_string_keysyms_end (const xcb_input_feedback_ctl_t *R,
+                                                const xcb_input_feedback_ctl_data_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->string.keysyms + S->string.num_keysyms;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_input_feedback_ctl_data_serialize (void                                **_buffer,
+                                       uint8_t                               class_id,
+                                       const xcb_input_feedback_ctl_data_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[24];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_KEYBOARD) {
+        /* xcb_input_feedback_ctl_data_t.keyboard.key */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.key;
+        xcb_block_len += sizeof(xcb_input_key_code_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_key_code_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_input_key_code_t);
+        /* xcb_input_feedback_ctl_data_t.keyboard.auto_repeat_mode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.auto_repeat_mode;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_ctl_data_t.keyboard.key_click_percent */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.key_click_percent;
+        xcb_block_len += sizeof(int8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int8_t);
+        /* xcb_input_feedback_ctl_data_t.keyboard.bell_percent */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.bell_percent;
+        xcb_block_len += sizeof(int8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int8_t);
+        /* xcb_input_feedback_ctl_data_t.keyboard.bell_pitch */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.bell_pitch;
+        xcb_block_len += sizeof(int16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int16_t);
+        /* xcb_input_feedback_ctl_data_t.keyboard.bell_duration */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.bell_duration;
+        xcb_block_len += sizeof(int16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int16_t);
+        /* xcb_input_feedback_ctl_data_t.keyboard.led_mask */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.led_mask;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_feedback_ctl_data_t.keyboard.led_values */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keyboard.led_values;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_POINTER) {
+        /* xcb_input_feedback_ctl_data_t.pointer.pad0 */
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_block_len += sizeof(uint8_t)*2;
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_ctl_data_t.pointer.num */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.num;
+        xcb_block_len += sizeof(int16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int16_t);
+        /* xcb_input_feedback_ctl_data_t.pointer.denom */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.denom;
+        xcb_block_len += sizeof(int16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int16_t);
+        /* xcb_input_feedback_ctl_data_t.pointer.threshold */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->pointer.threshold;
+        xcb_block_len += sizeof(int16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int16_t);
+    }
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_STRING) {
+        /* xcb_input_feedback_ctl_data_t.string.pad1 */
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_block_len += sizeof(uint8_t)*2;
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_ctl_data_t.string.num_keysyms */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->string.num_keysyms;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* keysyms */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->string.keysyms;
+        xcb_block_len += _aux->string.num_keysyms * sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = _aux->string.num_keysyms * sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_keysym_t);
+    }
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_INTEGER) {
+        /* xcb_input_feedback_ctl_data_t.integer.int_to_display */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->integer.int_to_display;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_LED) {
+        /* xcb_input_feedback_ctl_data_t.led.led_mask */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led.led_mask;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_feedback_ctl_data_t.led.led_values */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led.led_values;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_BELL) {
+        /* xcb_input_feedback_ctl_data_t.bell.percent */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.percent;
+        xcb_block_len += sizeof(int8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int8_t);
+        /* xcb_input_feedback_ctl_data_t.bell.pad2 */
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_block_len += sizeof(uint8_t)*3;
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_ctl_data_t.bell.pitch */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.pitch;
+        xcb_block_len += sizeof(int16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int16_t);
+        /* xcb_input_feedback_ctl_data_t.bell.duration */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell.duration;
+        xcb_block_len += sizeof(int16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int16_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_feedback_ctl_data_unpack (const void                     *_buffer,
+                                    uint8_t                         class_id,
+                                    xcb_input_feedback_ctl_data_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_KEYBOARD) {
+        /* xcb_input_feedback_ctl_data_t.keyboard.key */
+        _aux->keyboard.key = *(xcb_input_key_code_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_input_key_code_t);
+        xcb_tmp += sizeof(xcb_input_key_code_t);
+        xcb_align_to = ALIGNOF(xcb_input_key_code_t);
+        /* xcb_input_feedback_ctl_data_t.keyboard.auto_repeat_mode */
+        _aux->keyboard.auto_repeat_mode = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_ctl_data_t.keyboard.key_click_percent */
+        _aux->keyboard.key_click_percent = *(int8_t *)xcb_tmp;
+        xcb_block_len += sizeof(int8_t);
+        xcb_tmp += sizeof(int8_t);
+        xcb_align_to = ALIGNOF(int8_t);
+        /* xcb_input_feedback_ctl_data_t.keyboard.bell_percent */
+        _aux->keyboard.bell_percent = *(int8_t *)xcb_tmp;
+        xcb_block_len += sizeof(int8_t);
+        xcb_tmp += sizeof(int8_t);
+        xcb_align_to = ALIGNOF(int8_t);
+        /* xcb_input_feedback_ctl_data_t.keyboard.bell_pitch */
+        _aux->keyboard.bell_pitch = *(int16_t *)xcb_tmp;
+        xcb_block_len += sizeof(int16_t);
+        xcb_tmp += sizeof(int16_t);
+        xcb_align_to = ALIGNOF(int16_t);
+        /* xcb_input_feedback_ctl_data_t.keyboard.bell_duration */
+        _aux->keyboard.bell_duration = *(int16_t *)xcb_tmp;
+        xcb_block_len += sizeof(int16_t);
+        xcb_tmp += sizeof(int16_t);
+        xcb_align_to = ALIGNOF(int16_t);
+        /* xcb_input_feedback_ctl_data_t.keyboard.led_mask */
+        _aux->keyboard.led_mask = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_feedback_ctl_data_t.keyboard.led_values */
+        _aux->keyboard.led_values = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_POINTER) {
+        /* xcb_input_feedback_ctl_data_t.pointer.pad0 */
+        _aux->pointer.pad0[0] = *(uint8_t *)xcb_tmp;
+        _aux->pointer.pad0[1] = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t) * 2;
+        xcb_tmp += sizeof(uint8_t) * 2;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_ctl_data_t.pointer.num */
+        _aux->pointer.num = *(int16_t *)xcb_tmp;
+        xcb_block_len += sizeof(int16_t);
+        xcb_tmp += sizeof(int16_t);
+        xcb_align_to = ALIGNOF(int16_t);
+        /* xcb_input_feedback_ctl_data_t.pointer.denom */
+        _aux->pointer.denom = *(int16_t *)xcb_tmp;
+        xcb_block_len += sizeof(int16_t);
+        xcb_tmp += sizeof(int16_t);
+        xcb_align_to = ALIGNOF(int16_t);
+        /* xcb_input_feedback_ctl_data_t.pointer.threshold */
+        _aux->pointer.threshold = *(int16_t *)xcb_tmp;
+        xcb_block_len += sizeof(int16_t);
+        xcb_tmp += sizeof(int16_t);
+        xcb_align_to = ALIGNOF(int16_t);
+    }
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_STRING) {
+        /* xcb_input_feedback_ctl_data_t.string.pad1 */
+        _aux->string.pad1[0] = *(uint8_t *)xcb_tmp;
+        _aux->string.pad1[1] = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t) * 2;
+        xcb_tmp += sizeof(uint8_t) * 2;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_ctl_data_t.string.num_keysyms */
+        _aux->string.num_keysyms = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* keysyms */
+        _aux->string.keysyms = (xcb_keysym_t *)xcb_tmp;
+        xcb_block_len += _aux->string.num_keysyms * sizeof(uint32_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_keysym_t);
+    }
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_INTEGER) {
+        /* xcb_input_feedback_ctl_data_t.integer.int_to_display */
+        _aux->integer.int_to_display = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_LED) {
+        /* xcb_input_feedback_ctl_data_t.led.led_mask */
+        _aux->led.led_mask = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_feedback_ctl_data_t.led.led_values */
+        _aux->led.led_values = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(class_id == XCB_INPUT_FEEDBACK_CLASS_BELL) {
+        /* xcb_input_feedback_ctl_data_t.bell.percent */
+        _aux->bell.percent = *(int8_t *)xcb_tmp;
+        xcb_block_len += sizeof(int8_t);
+        xcb_tmp += sizeof(int8_t);
+        xcb_align_to = ALIGNOF(int8_t);
+        /* xcb_input_feedback_ctl_data_t.bell.pad2 */
+        _aux->bell.pad2[0] = *(uint8_t *)xcb_tmp;
+        _aux->bell.pad2[1] = *(uint8_t *)xcb_tmp;
+        _aux->bell.pad2[2] = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t) * 3;
+        xcb_tmp += sizeof(uint8_t) * 3;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_feedback_ctl_data_t.bell.pitch */
+        _aux->bell.pitch = *(int16_t *)xcb_tmp;
+        xcb_block_len += sizeof(int16_t);
+        xcb_tmp += sizeof(int16_t);
+        xcb_align_to = ALIGNOF(int16_t);
+        /* xcb_input_feedback_ctl_data_t.bell.duration */
+        _aux->bell.duration = *(int16_t *)xcb_tmp;
+        xcb_block_len += sizeof(int16_t);
+        xcb_tmp += sizeof(int16_t);
+        xcb_align_to = ALIGNOF(int16_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_feedback_ctl_data_sizeof (const void  *_buffer,
+                                    uint8_t      class_id)
+{
+    xcb_input_feedback_ctl_data_t _aux;
+    return xcb_input_feedback_ctl_data_unpack(_buffer, class_id, &_aux);
+}
+
+int
+xcb_input_feedback_ctl_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_feedback_ctl_t *_aux = (xcb_input_feedback_ctl_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_feedback_ctl_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += xcb_input_feedback_ctl_data_sizeof(xcb_tmp, _aux->class_id);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+void *
+xcb_input_feedback_ctl_data (const xcb_input_feedback_ctl_t *R)
+{
+    return (void *) (R + 1);
+}
+
+void
+xcb_input_feedback_ctl_next (xcb_input_feedback_ctl_iterator_t *i)
+{
+    xcb_input_feedback_ctl_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_feedback_ctl_t *)(((char *)R) + xcb_input_feedback_ctl_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_feedback_ctl_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_feedback_ctl_end (xcb_input_feedback_ctl_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_feedback_ctl_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_input_change_feedback_control_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_change_feedback_control_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* feedback */
+    xcb_block_len += xcb_input_feedback_ctl_sizeof(xcb_tmp);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_feedback_ctl_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_input_change_feedback_control_checked (xcb_connection_t         *c,
+                                           uint32_t                  mask,
+                                           uint8_t                   device_id,
+                                           uint8_t                   feedback_id,
+                                           xcb_input_feedback_ctl_t *feedback)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_CHANGE_FEEDBACK_CONTROL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_change_feedback_control_request_t xcb_out;
+
+    xcb_out.mask = mask;
+    xcb_out.device_id = device_id;
+    xcb_out.feedback_id = feedback_id;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_feedback_ctl_t feedback */
+    xcb_parts[4].iov_base = (char *) feedback;
+    xcb_parts[4].iov_len =
+      xcb_input_feedback_ctl_sizeof (feedback);
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_change_feedback_control (xcb_connection_t         *c,
+                                   uint32_t                  mask,
+                                   uint8_t                   device_id,
+                                   uint8_t                   feedback_id,
+                                   xcb_input_feedback_ctl_t *feedback)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_CHANGE_FEEDBACK_CONTROL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_change_feedback_control_request_t xcb_out;
+
+    xcb_out.mask = mask;
+    xcb_out.device_id = device_id;
+    xcb_out.feedback_id = feedback_id;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_feedback_ctl_t feedback */
+    xcb_parts[4].iov_base = (char *) feedback;
+    xcb_parts[4].iov_len =
+      xcb_input_feedback_ctl_sizeof (feedback);
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_feedback_ctl_t *
+xcb_input_change_feedback_control_feedback (const xcb_input_change_feedback_control_request_t *R)
+{
+    return (xcb_input_feedback_ctl_t *) (R + 1);
+}
+
+int
+xcb_input_get_device_key_mapping_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_get_device_key_mapping_reply_t *_aux = (xcb_input_get_device_key_mapping_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_get_device_key_mapping_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* keysyms */
+    xcb_block_len += _aux->length * sizeof(xcb_keysym_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_keysym_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_get_device_key_mapping_cookie_t
+xcb_input_get_device_key_mapping (xcb_connection_t     *c,
+                                  uint8_t               device_id,
+                                  xcb_input_key_code_t  first_keycode,
+                                  uint8_t               count)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_DEVICE_KEY_MAPPING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_get_device_key_mapping_cookie_t xcb_ret;
+    xcb_input_get_device_key_mapping_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    xcb_out.first_keycode = first_keycode;
+    xcb_out.count = count;
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_get_device_key_mapping_cookie_t
+xcb_input_get_device_key_mapping_unchecked (xcb_connection_t     *c,
+                                            uint8_t               device_id,
+                                            xcb_input_key_code_t  first_keycode,
+                                            uint8_t               count)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_DEVICE_KEY_MAPPING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_get_device_key_mapping_cookie_t xcb_ret;
+    xcb_input_get_device_key_mapping_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    xcb_out.first_keycode = first_keycode;
+    xcb_out.count = count;
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_keysym_t *
+xcb_input_get_device_key_mapping_keysyms (const xcb_input_get_device_key_mapping_reply_t *R)
+{
+    return (xcb_keysym_t *) (R + 1);
+}
+
+int
+xcb_input_get_device_key_mapping_keysyms_length (const xcb_input_get_device_key_mapping_reply_t *R)
+{
+    return R->length;
+}
+
+xcb_generic_iterator_t
+xcb_input_get_device_key_mapping_keysyms_end (const xcb_input_get_device_key_mapping_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_keysym_t *) (R + 1)) + (R->length);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_get_device_key_mapping_reply_t *
+xcb_input_get_device_key_mapping_reply (xcb_connection_t                           *c,
+                                        xcb_input_get_device_key_mapping_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e)
+{
+    return (xcb_input_get_device_key_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_input_change_device_key_mapping_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_change_device_key_mapping_request_t *_aux = (xcb_input_change_device_key_mapping_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_change_device_key_mapping_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* keysyms */
+    xcb_block_len += (_aux->keycode_count * _aux->keysyms_per_keycode) * sizeof(xcb_keysym_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_keysym_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_input_change_device_key_mapping_checked (xcb_connection_t     *c,
+                                             uint8_t               device_id,
+                                             xcb_input_key_code_t  first_keycode,
+                                             uint8_t               keysyms_per_keycode,
+                                             uint8_t               keycode_count,
+                                             const xcb_keysym_t   *keysyms)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_CHANGE_DEVICE_KEY_MAPPING,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_change_device_key_mapping_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    xcb_out.first_keycode = first_keycode;
+    xcb_out.keysyms_per_keycode = keysyms_per_keycode;
+    xcb_out.keycode_count = keycode_count;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_keysym_t keysyms */
+    xcb_parts[4].iov_base = (char *) keysyms;
+    xcb_parts[4].iov_len = (keycode_count * keysyms_per_keycode) * sizeof(xcb_keysym_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_change_device_key_mapping (xcb_connection_t     *c,
+                                     uint8_t               device_id,
+                                     xcb_input_key_code_t  first_keycode,
+                                     uint8_t               keysyms_per_keycode,
+                                     uint8_t               keycode_count,
+                                     const xcb_keysym_t   *keysyms)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_CHANGE_DEVICE_KEY_MAPPING,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_change_device_key_mapping_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    xcb_out.first_keycode = first_keycode;
+    xcb_out.keysyms_per_keycode = keysyms_per_keycode;
+    xcb_out.keycode_count = keycode_count;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_keysym_t keysyms */
+    xcb_parts[4].iov_base = (char *) keysyms;
+    xcb_parts[4].iov_len = (keycode_count * keysyms_per_keycode) * sizeof(xcb_keysym_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_keysym_t *
+xcb_input_change_device_key_mapping_keysyms (const xcb_input_change_device_key_mapping_request_t *R)
+{
+    return (xcb_keysym_t *) (R + 1);
+}
+
+int
+xcb_input_change_device_key_mapping_keysyms_length (const xcb_input_change_device_key_mapping_request_t *R)
+{
+    return (R->keycode_count * R->keysyms_per_keycode);
+}
+
+xcb_generic_iterator_t
+xcb_input_change_device_key_mapping_keysyms_end (const xcb_input_change_device_key_mapping_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_keysym_t *) (R + 1)) + ((R->keycode_count * R->keysyms_per_keycode));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_input_get_device_modifier_mapping_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_get_device_modifier_mapping_reply_t *_aux = (xcb_input_get_device_modifier_mapping_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_get_device_modifier_mapping_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* keymaps */
+    xcb_block_len += (_aux->keycodes_per_modifier * 8) * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_get_device_modifier_mapping_cookie_t
+xcb_input_get_device_modifier_mapping (xcb_connection_t *c,
+                                       uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_DEVICE_MODIFIER_MAPPING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_get_device_modifier_mapping_cookie_t xcb_ret;
+    xcb_input_get_device_modifier_mapping_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_get_device_modifier_mapping_cookie_t
+xcb_input_get_device_modifier_mapping_unchecked (xcb_connection_t *c,
+                                                 uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_DEVICE_MODIFIER_MAPPING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_get_device_modifier_mapping_cookie_t xcb_ret;
+    xcb_input_get_device_modifier_mapping_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_input_get_device_modifier_mapping_keymaps (const xcb_input_get_device_modifier_mapping_reply_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_input_get_device_modifier_mapping_keymaps_length (const xcb_input_get_device_modifier_mapping_reply_t *R)
+{
+    return (R->keycodes_per_modifier * 8);
+}
+
+xcb_generic_iterator_t
+xcb_input_get_device_modifier_mapping_keymaps_end (const xcb_input_get_device_modifier_mapping_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((R->keycodes_per_modifier * 8));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_get_device_modifier_mapping_reply_t *
+xcb_input_get_device_modifier_mapping_reply (xcb_connection_t                                *c,
+                                             xcb_input_get_device_modifier_mapping_cookie_t   cookie  /**< */,
+                                             xcb_generic_error_t                            **e)
+{
+    return (xcb_input_get_device_modifier_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_input_set_device_modifier_mapping_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_set_device_modifier_mapping_request_t *_aux = (xcb_input_set_device_modifier_mapping_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_set_device_modifier_mapping_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* keymaps */
+    xcb_block_len += (_aux->keycodes_per_modifier * 8) * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_set_device_modifier_mapping_cookie_t
+xcb_input_set_device_modifier_mapping (xcb_connection_t *c,
+                                       uint8_t           device_id,
+                                       uint8_t           keycodes_per_modifier,
+                                       const uint8_t    *keymaps)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_SET_DEVICE_MODIFIER_MAPPING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_input_set_device_modifier_mapping_cookie_t xcb_ret;
+    xcb_input_set_device_modifier_mapping_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    xcb_out.keycodes_per_modifier = keycodes_per_modifier;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t keymaps */
+    xcb_parts[4].iov_base = (char *) keymaps;
+    xcb_parts[4].iov_len = (keycodes_per_modifier * 8) * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_set_device_modifier_mapping_cookie_t
+xcb_input_set_device_modifier_mapping_unchecked (xcb_connection_t *c,
+                                                 uint8_t           device_id,
+                                                 uint8_t           keycodes_per_modifier,
+                                                 const uint8_t    *keymaps)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_SET_DEVICE_MODIFIER_MAPPING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_input_set_device_modifier_mapping_cookie_t xcb_ret;
+    xcb_input_set_device_modifier_mapping_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    xcb_out.keycodes_per_modifier = keycodes_per_modifier;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t keymaps */
+    xcb_parts[4].iov_base = (char *) keymaps;
+    xcb_parts[4].iov_len = (keycodes_per_modifier * 8) * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_set_device_modifier_mapping_reply_t *
+xcb_input_set_device_modifier_mapping_reply (xcb_connection_t                                *c,
+                                             xcb_input_set_device_modifier_mapping_cookie_t   cookie  /**< */,
+                                             xcb_generic_error_t                            **e)
+{
+    return (xcb_input_set_device_modifier_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_input_get_device_button_mapping_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_get_device_button_mapping_reply_t *_aux = (xcb_input_get_device_button_mapping_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_get_device_button_mapping_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* map */
+    xcb_block_len += _aux->map_size * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_get_device_button_mapping_cookie_t
+xcb_input_get_device_button_mapping (xcb_connection_t *c,
+                                     uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_DEVICE_BUTTON_MAPPING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_get_device_button_mapping_cookie_t xcb_ret;
+    xcb_input_get_device_button_mapping_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_get_device_button_mapping_cookie_t
+xcb_input_get_device_button_mapping_unchecked (xcb_connection_t *c,
+                                               uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_DEVICE_BUTTON_MAPPING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_get_device_button_mapping_cookie_t xcb_ret;
+    xcb_input_get_device_button_mapping_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_input_get_device_button_mapping_map (const xcb_input_get_device_button_mapping_reply_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_input_get_device_button_mapping_map_length (const xcb_input_get_device_button_mapping_reply_t *R)
+{
+    return R->map_size;
+}
+
+xcb_generic_iterator_t
+xcb_input_get_device_button_mapping_map_end (const xcb_input_get_device_button_mapping_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + (R->map_size);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_get_device_button_mapping_reply_t *
+xcb_input_get_device_button_mapping_reply (xcb_connection_t                              *c,
+                                           xcb_input_get_device_button_mapping_cookie_t   cookie  /**< */,
+                                           xcb_generic_error_t                          **e)
+{
+    return (xcb_input_get_device_button_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_input_set_device_button_mapping_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_set_device_button_mapping_request_t *_aux = (xcb_input_set_device_button_mapping_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_set_device_button_mapping_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* map */
+    xcb_block_len += _aux->map_size * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_set_device_button_mapping_cookie_t
+xcb_input_set_device_button_mapping (xcb_connection_t *c,
+                                     uint8_t           device_id,
+                                     uint8_t           map_size,
+                                     const uint8_t    *map)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_SET_DEVICE_BUTTON_MAPPING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_input_set_device_button_mapping_cookie_t xcb_ret;
+    xcb_input_set_device_button_mapping_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    xcb_out.map_size = map_size;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t map */
+    xcb_parts[4].iov_base = (char *) map;
+    xcb_parts[4].iov_len = map_size * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_set_device_button_mapping_cookie_t
+xcb_input_set_device_button_mapping_unchecked (xcb_connection_t *c,
+                                               uint8_t           device_id,
+                                               uint8_t           map_size,
+                                               const uint8_t    *map)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_SET_DEVICE_BUTTON_MAPPING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_input_set_device_button_mapping_cookie_t xcb_ret;
+    xcb_input_set_device_button_mapping_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    xcb_out.map_size = map_size;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t map */
+    xcb_parts[4].iov_base = (char *) map;
+    xcb_parts[4].iov_len = map_size * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_set_device_button_mapping_reply_t *
+xcb_input_set_device_button_mapping_reply (xcb_connection_t                              *c,
+                                           xcb_input_set_device_button_mapping_cookie_t   cookie  /**< */,
+                                           xcb_generic_error_t                          **e)
+{
+    return (xcb_input_set_device_button_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+void
+xcb_input_key_state_next (xcb_input_key_state_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_key_state_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_key_state_end (xcb_input_key_state_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_button_state_next (xcb_input_button_state_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_button_state_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_button_state_end (xcb_input_button_state_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_input_valuator_state_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_valuator_state_t *_aux = (xcb_input_valuator_state_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_valuator_state_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* valuators */
+    xcb_block_len += _aux->num_valuators * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+int32_t *
+xcb_input_valuator_state_valuators (const xcb_input_valuator_state_t *R)
+{
+    return (int32_t *) (R + 1);
+}
+
+int
+xcb_input_valuator_state_valuators_length (const xcb_input_valuator_state_t *R)
+{
+    return R->num_valuators;
+}
+
+xcb_generic_iterator_t
+xcb_input_valuator_state_valuators_end (const xcb_input_valuator_state_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((int32_t *) (R + 1)) + (R->num_valuators);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_input_valuator_state_next (xcb_input_valuator_state_iterator_t *i)
+{
+    xcb_input_valuator_state_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_valuator_state_t *)(((char *)R) + xcb_input_valuator_state_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_valuator_state_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_valuator_state_end (xcb_input_valuator_state_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_valuator_state_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int32_t *
+xcb_input_input_state_data_valuator_valuators (const xcb_input_input_state_data_t *S)
+{
+    return S->valuator.valuators;
+}
+
+int
+xcb_input_input_state_data_valuator_valuators_length (const xcb_input_input_state_t *R,
+                                                      const xcb_input_input_state_data_t *S)
+{
+    return S->valuator.num_valuators;
+}
+
+xcb_generic_iterator_t
+xcb_input_input_state_data_valuator_valuators_end (const xcb_input_input_state_t *R,
+                                                   const xcb_input_input_state_data_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->valuator.valuators + S->valuator.num_valuators;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_input_input_state_data_serialize (void                               **_buffer,
+                                      uint8_t                              class_id,
+                                      const xcb_input_input_state_data_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 2;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[11];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(class_id == XCB_INPUT_INPUT_CLASS_KEY) {
+        /* xcb_input_input_state_data_t.key.num_keys */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key.num_keys;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_input_state_data_t.key.pad0 */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_input_state_data_t.key.keys */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->key.keys;
+        xcb_block_len += 32;
+        xcb_parts[xcb_parts_idx].iov_len = 32;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if(class_id == XCB_INPUT_INPUT_CLASS_BUTTON) {
+        /* xcb_input_input_state_data_t.button.num_buttons */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->button.num_buttons;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_input_state_data_t.button.pad1 */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_input_state_data_t.button.buttons */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->button.buttons;
+        xcb_block_len += 32;
+        xcb_parts[xcb_parts_idx].iov_len = 32;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if(class_id == XCB_INPUT_INPUT_CLASS_VALUATOR) {
+        /* xcb_input_input_state_data_t.valuator.num_valuators */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.num_valuators;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_input_state_data_t.valuator.mode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.mode;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* valuators */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->valuator.valuators;
+        xcb_block_len += _aux->valuator.num_valuators * sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = _aux->valuator.num_valuators * sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_input_state_data_unpack (const void                    *_buffer,
+                                   uint8_t                        class_id,
+                                   xcb_input_input_state_data_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 2;
+
+
+    if(class_id == XCB_INPUT_INPUT_CLASS_KEY) {
+        /* xcb_input_input_state_data_t.key.num_keys */
+        _aux->key.num_keys = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_input_state_data_t.key.pad0 */
+        _aux->key.pad0 = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_input_state_data_t.key.keys */
+        memcpy(_aux->key.keys, xcb_tmp, sizeof(uint8_t) * 32);
+        xcb_block_len += sizeof(uint8_t) * 32;
+        xcb_tmp += sizeof(uint8_t) * 32;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if(class_id == XCB_INPUT_INPUT_CLASS_BUTTON) {
+        /* xcb_input_input_state_data_t.button.num_buttons */
+        _aux->button.num_buttons = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_input_state_data_t.button.pad1 */
+        _aux->button.pad1 = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_input_state_data_t.button.buttons */
+        memcpy(_aux->button.buttons, xcb_tmp, sizeof(uint8_t) * 32);
+        xcb_block_len += sizeof(uint8_t) * 32;
+        xcb_tmp += sizeof(uint8_t) * 32;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if(class_id == XCB_INPUT_INPUT_CLASS_VALUATOR) {
+        /* xcb_input_input_state_data_t.valuator.num_valuators */
+        _aux->valuator.num_valuators = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_input_state_data_t.valuator.mode */
+        _aux->valuator.mode = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* valuators */
+        _aux->valuator.valuators = (int32_t *)xcb_tmp;
+        xcb_block_len += _aux->valuator.num_valuators * sizeof(int32_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_input_state_data_sizeof (const void  *_buffer,
+                                   uint8_t      class_id)
+{
+    xcb_input_input_state_data_t _aux;
+    return xcb_input_input_state_data_unpack(_buffer, class_id, &_aux);
+}
+
+int
+xcb_input_input_state_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_input_state_t *_aux = (xcb_input_input_state_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_input_state_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += xcb_input_input_state_data_sizeof(xcb_tmp, _aux->class_id);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+void *
+xcb_input_input_state_data (const xcb_input_input_state_t *R)
+{
+    return (void *) (R + 1);
+}
+
+void
+xcb_input_input_state_next (xcb_input_input_state_iterator_t *i)
+{
+    xcb_input_input_state_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_input_state_t *)(((char *)R) + xcb_input_input_state_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_input_state_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_input_state_end (xcb_input_input_state_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_input_state_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_input_query_device_state_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_query_device_state_reply_t *_aux = (xcb_input_query_device_state_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_input_query_device_state_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* classes */
+    for(i=0; i<_aux->num_classes; i++) {
+        xcb_tmp_len = xcb_input_input_state_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_input_input_state_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_query_device_state_cookie_t
+xcb_input_query_device_state (xcb_connection_t *c,
+                              uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_QUERY_DEVICE_STATE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_query_device_state_cookie_t xcb_ret;
+    xcb_input_query_device_state_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_query_device_state_cookie_t
+xcb_input_query_device_state_unchecked (xcb_connection_t *c,
+                                        uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_QUERY_DEVICE_STATE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_query_device_state_cookie_t xcb_ret;
+    xcb_input_query_device_state_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_input_query_device_state_classes_length (const xcb_input_query_device_state_reply_t *R)
+{
+    return R->num_classes;
+}
+
+xcb_input_input_state_iterator_t
+xcb_input_query_device_state_classes_iterator (const xcb_input_query_device_state_reply_t *R)
+{
+    xcb_input_input_state_iterator_t i;
+    i.data = (xcb_input_input_state_t *) (R + 1);
+    i.rem = R->num_classes;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_query_device_state_reply_t *
+xcb_input_query_device_state_reply (xcb_connection_t                       *c,
+                                    xcb_input_query_device_state_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e)
+{
+    return (xcb_input_query_device_state_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_input_device_bell_checked (xcb_connection_t *c,
+                               uint8_t           device_id,
+                               uint8_t           feedback_id,
+                               uint8_t           feedback_class,
+                               int8_t            percent)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_DEVICE_BELL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_device_bell_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    xcb_out.feedback_id = feedback_id;
+    xcb_out.feedback_class = feedback_class;
+    xcb_out.percent = percent;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_device_bell (xcb_connection_t *c,
+                       uint8_t           device_id,
+                       uint8_t           feedback_id,
+                       uint8_t           feedback_class,
+                       int8_t            percent)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_DEVICE_BELL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_device_bell_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    xcb_out.feedback_id = feedback_id;
+    xcb_out.feedback_class = feedback_class;
+    xcb_out.percent = percent;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_input_set_device_valuators_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_set_device_valuators_request_t *_aux = (xcb_input_set_device_valuators_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_set_device_valuators_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* valuators */
+    xcb_block_len += _aux->num_valuators * sizeof(int32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(int32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_set_device_valuators_cookie_t
+xcb_input_set_device_valuators (xcb_connection_t *c,
+                                uint8_t           device_id,
+                                uint8_t           first_valuator,
+                                uint8_t           num_valuators,
+                                const int32_t    *valuators)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_SET_DEVICE_VALUATORS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_input_set_device_valuators_cookie_t xcb_ret;
+    xcb_input_set_device_valuators_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    xcb_out.first_valuator = first_valuator;
+    xcb_out.num_valuators = num_valuators;
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* int32_t valuators */
+    xcb_parts[4].iov_base = (char *) valuators;
+    xcb_parts[4].iov_len = num_valuators * sizeof(int32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_set_device_valuators_cookie_t
+xcb_input_set_device_valuators_unchecked (xcb_connection_t *c,
+                                          uint8_t           device_id,
+                                          uint8_t           first_valuator,
+                                          uint8_t           num_valuators,
+                                          const int32_t    *valuators)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_SET_DEVICE_VALUATORS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_input_set_device_valuators_cookie_t xcb_ret;
+    xcb_input_set_device_valuators_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    xcb_out.first_valuator = first_valuator;
+    xcb_out.num_valuators = num_valuators;
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* int32_t valuators */
+    xcb_parts[4].iov_base = (char *) valuators;
+    xcb_parts[4].iov_len = num_valuators * sizeof(int32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_set_device_valuators_reply_t *
+xcb_input_set_device_valuators_reply (xcb_connection_t                         *c,
+                                      xcb_input_set_device_valuators_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e)
+{
+    return (xcb_input_set_device_valuators_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_input_device_resolution_state_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_device_resolution_state_t *_aux = (xcb_input_device_resolution_state_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_device_resolution_state_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* resolution_values */
+    xcb_block_len += _aux->num_valuators * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* resolution_min */
+    xcb_block_len += _aux->num_valuators * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* resolution_max */
+    xcb_block_len += _aux->num_valuators * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+uint32_t *
+xcb_input_device_resolution_state_resolution_values (const xcb_input_device_resolution_state_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_input_device_resolution_state_resolution_values_length (const xcb_input_device_resolution_state_t *R)
+{
+    return R->num_valuators;
+}
+
+xcb_generic_iterator_t
+xcb_input_device_resolution_state_resolution_values_end (const xcb_input_device_resolution_state_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->num_valuators);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint32_t *
+xcb_input_device_resolution_state_resolution_min (const xcb_input_device_resolution_state_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_input_device_resolution_state_resolution_values_end(R);
+    return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0);
+}
+
+int
+xcb_input_device_resolution_state_resolution_min_length (const xcb_input_device_resolution_state_t *R)
+{
+    return R->num_valuators;
+}
+
+xcb_generic_iterator_t
+xcb_input_device_resolution_state_resolution_min_end (const xcb_input_device_resolution_state_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_input_device_resolution_state_resolution_values_end(R);
+    i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->num_valuators);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint32_t *
+xcb_input_device_resolution_state_resolution_max (const xcb_input_device_resolution_state_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_input_device_resolution_state_resolution_min_end(R);
+    return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0);
+}
+
+int
+xcb_input_device_resolution_state_resolution_max_length (const xcb_input_device_resolution_state_t *R)
+{
+    return R->num_valuators;
+}
+
+xcb_generic_iterator_t
+xcb_input_device_resolution_state_resolution_max_end (const xcb_input_device_resolution_state_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_input_device_resolution_state_resolution_min_end(R);
+    i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->num_valuators);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_input_device_resolution_state_next (xcb_input_device_resolution_state_iterator_t *i)
+{
+    xcb_input_device_resolution_state_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_device_resolution_state_t *)(((char *)R) + xcb_input_device_resolution_state_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_device_resolution_state_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_device_resolution_state_end (xcb_input_device_resolution_state_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_device_resolution_state_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+void
+xcb_input_device_abs_calib_state_next (xcb_input_device_abs_calib_state_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_device_abs_calib_state_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_device_abs_calib_state_end (xcb_input_device_abs_calib_state_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_device_abs_area_state_next (xcb_input_device_abs_area_state_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_device_abs_area_state_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_device_abs_area_state_end (xcb_input_device_abs_area_state_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_device_core_state_next (xcb_input_device_core_state_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_device_core_state_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_device_core_state_end (xcb_input_device_core_state_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_device_enable_state_next (xcb_input_device_enable_state_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_device_enable_state_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_device_enable_state_end (xcb_input_device_enable_state_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+uint32_t *
+xcb_input_device_state_data_resolution_resolution_values (const xcb_input_device_state_data_t *S)
+{
+    return S->resolution.resolution_values;
+}
+
+int
+xcb_input_device_state_data_resolution_resolution_values_length (const xcb_input_device_state_t *R,
+                                                                 const xcb_input_device_state_data_t *S)
+{
+    return S->resolution.num_valuators;
+}
+
+xcb_generic_iterator_t
+xcb_input_device_state_data_resolution_resolution_values_end (const xcb_input_device_state_t *R,
+                                                              const xcb_input_device_state_data_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->resolution.resolution_values + S->resolution.num_valuators;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+uint32_t *
+xcb_input_device_state_data_resolution_resolution_min (const xcb_input_device_state_data_t *S)
+{
+    return S->resolution.resolution_min;
+}
+
+int
+xcb_input_device_state_data_resolution_resolution_min_length (const xcb_input_device_state_t *R,
+                                                              const xcb_input_device_state_data_t *S)
+{
+    return S->resolution.num_valuators;
+}
+
+xcb_generic_iterator_t
+xcb_input_device_state_data_resolution_resolution_min_end (const xcb_input_device_state_t *R,
+                                                           const xcb_input_device_state_data_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->resolution.resolution_min + S->resolution.num_valuators;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+uint32_t *
+xcb_input_device_state_data_resolution_resolution_max (const xcb_input_device_state_data_t *S)
+{
+    return S->resolution.resolution_max;
+}
+
+int
+xcb_input_device_state_data_resolution_resolution_max_length (const xcb_input_device_state_t *R,
+                                                              const xcb_input_device_state_data_t *S)
+{
+    return S->resolution.num_valuators;
+}
+
+xcb_generic_iterator_t
+xcb_input_device_state_data_resolution_resolution_max_end (const xcb_input_device_state_t *R,
+                                                           const xcb_input_device_state_data_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->resolution.resolution_max + S->resolution.num_valuators;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_input_device_state_data_serialize (void                                **_buffer,
+                                       uint16_t                              control_id,
+                                       const xcb_input_device_state_data_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[27];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(control_id == XCB_INPUT_DEVICE_CONTROL_RESOLUTION) {
+        /* xcb_input_device_state_data_t.resolution.num_valuators */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->resolution.num_valuators;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* resolution_values */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->resolution.resolution_values;
+        xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = _aux->resolution.num_valuators * sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* resolution_min */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->resolution.resolution_min;
+        xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = _aux->resolution.num_valuators * sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* resolution_max */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->resolution.resolution_max;
+        xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = _aux->resolution.num_valuators * sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_CALIB) {
+        /* xcb_input_device_state_data_t.abs_calib.min_x */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.min_x;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_state_data_t.abs_calib.max_x */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.max_x;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_state_data_t.abs_calib.min_y */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.min_y;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_state_data_t.abs_calib.max_y */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.max_y;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_state_data_t.abs_calib.flip_x */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.flip_x;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_state_data_t.abs_calib.flip_y */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.flip_y;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_state_data_t.abs_calib.rotation */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.rotation;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_state_data_t.abs_calib.button_threshold */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.button_threshold;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(control_id == XCB_INPUT_DEVICE_CONTROL_CORE) {
+        /* xcb_input_device_state_data_t.core.status */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->core.status;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_state_data_t.core.iscore */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->core.iscore;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_state_data_t.core.pad0 */
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_block_len += sizeof(uint8_t)*2;
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if(control_id == XCB_INPUT_DEVICE_CONTROL_ENABLE) {
+        /* xcb_input_device_state_data_t.enable.enable */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->enable.enable;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_state_data_t.enable.pad1 */
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_block_len += sizeof(uint8_t)*3;
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_AREA) {
+        /* xcb_input_device_state_data_t.abs_area.offset_x */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.offset_x;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_state_data_t.abs_area.offset_y */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.offset_y;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_state_data_t.abs_area.width */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.width;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_state_data_t.abs_area.height */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.height;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_state_data_t.abs_area.screen */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.screen;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_state_data_t.abs_area.following */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.following;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_device_state_data_unpack (const void                     *_buffer,
+                                    uint16_t                        control_id,
+                                    xcb_input_device_state_data_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if(control_id == XCB_INPUT_DEVICE_CONTROL_RESOLUTION) {
+        /* xcb_input_device_state_data_t.resolution.num_valuators */
+        _aux->resolution.num_valuators = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* resolution_values */
+        _aux->resolution.resolution_values = (uint32_t *)xcb_tmp;
+        xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* resolution_min */
+        _aux->resolution.resolution_min = (uint32_t *)xcb_tmp;
+        xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* resolution_max */
+        _aux->resolution.resolution_max = (uint32_t *)xcb_tmp;
+        xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_CALIB) {
+        /* xcb_input_device_state_data_t.abs_calib.min_x */
+        _aux->abs_calib.min_x = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_state_data_t.abs_calib.max_x */
+        _aux->abs_calib.max_x = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_state_data_t.abs_calib.min_y */
+        _aux->abs_calib.min_y = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_state_data_t.abs_calib.max_y */
+        _aux->abs_calib.max_y = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_state_data_t.abs_calib.flip_x */
+        _aux->abs_calib.flip_x = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_state_data_t.abs_calib.flip_y */
+        _aux->abs_calib.flip_y = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_state_data_t.abs_calib.rotation */
+        _aux->abs_calib.rotation = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_state_data_t.abs_calib.button_threshold */
+        _aux->abs_calib.button_threshold = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(control_id == XCB_INPUT_DEVICE_CONTROL_CORE) {
+        /* xcb_input_device_state_data_t.core.status */
+        _aux->core.status = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_state_data_t.core.iscore */
+        _aux->core.iscore = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_state_data_t.core.pad0 */
+        _aux->core.pad0[0] = *(uint8_t *)xcb_tmp;
+        _aux->core.pad0[1] = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t) * 2;
+        xcb_tmp += sizeof(uint8_t) * 2;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if(control_id == XCB_INPUT_DEVICE_CONTROL_ENABLE) {
+        /* xcb_input_device_state_data_t.enable.enable */
+        _aux->enable.enable = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_state_data_t.enable.pad1 */
+        _aux->enable.pad1[0] = *(uint8_t *)xcb_tmp;
+        _aux->enable.pad1[1] = *(uint8_t *)xcb_tmp;
+        _aux->enable.pad1[2] = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t) * 3;
+        xcb_tmp += sizeof(uint8_t) * 3;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_AREA) {
+        /* xcb_input_device_state_data_t.abs_area.offset_x */
+        _aux->abs_area.offset_x = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_state_data_t.abs_area.offset_y */
+        _aux->abs_area.offset_y = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_state_data_t.abs_area.width */
+        _aux->abs_area.width = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_state_data_t.abs_area.height */
+        _aux->abs_area.height = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_state_data_t.abs_area.screen */
+        _aux->abs_area.screen = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_state_data_t.abs_area.following */
+        _aux->abs_area.following = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_device_state_data_sizeof (const void  *_buffer,
+                                    uint16_t     control_id)
+{
+    xcb_input_device_state_data_t _aux;
+    return xcb_input_device_state_data_unpack(_buffer, control_id, &_aux);
+}
+
+int
+xcb_input_device_state_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_device_state_t *_aux = (xcb_input_device_state_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_device_state_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += xcb_input_device_state_data_sizeof(xcb_tmp, _aux->control_id);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+void *
+xcb_input_device_state_data (const xcb_input_device_state_t *R)
+{
+    return (void *) (R + 1);
+}
+
+void
+xcb_input_device_state_next (xcb_input_device_state_iterator_t *i)
+{
+    xcb_input_device_state_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_device_state_t *)(((char *)R) + xcb_input_device_state_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_device_state_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_device_state_end (xcb_input_device_state_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_device_state_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_input_get_device_control_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_get_device_control_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* control */
+    xcb_block_len += xcb_input_device_state_sizeof(xcb_tmp);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_device_state_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_get_device_control_cookie_t
+xcb_input_get_device_control (xcb_connection_t *c,
+                              uint16_t          control_id,
+                              uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_DEVICE_CONTROL,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_get_device_control_cookie_t xcb_ret;
+    xcb_input_get_device_control_request_t xcb_out;
+
+    xcb_out.control_id = control_id;
+    xcb_out.device_id = device_id;
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_get_device_control_cookie_t
+xcb_input_get_device_control_unchecked (xcb_connection_t *c,
+                                        uint16_t          control_id,
+                                        uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_DEVICE_CONTROL,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_get_device_control_cookie_t xcb_ret;
+    xcb_input_get_device_control_request_t xcb_out;
+
+    xcb_out.control_id = control_id;
+    xcb_out.device_id = device_id;
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_device_state_t *
+xcb_input_get_device_control_control (const xcb_input_get_device_control_reply_t *R)
+{
+    return (xcb_input_device_state_t *) (R + 1);
+}
+
+xcb_input_get_device_control_reply_t *
+xcb_input_get_device_control_reply (xcb_connection_t                       *c,
+                                    xcb_input_get_device_control_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e)
+{
+    return (xcb_input_get_device_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_input_device_resolution_ctl_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_device_resolution_ctl_t *_aux = (xcb_input_device_resolution_ctl_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_device_resolution_ctl_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* resolution_values */
+    xcb_block_len += _aux->num_valuators * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+uint32_t *
+xcb_input_device_resolution_ctl_resolution_values (const xcb_input_device_resolution_ctl_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_input_device_resolution_ctl_resolution_values_length (const xcb_input_device_resolution_ctl_t *R)
+{
+    return R->num_valuators;
+}
+
+xcb_generic_iterator_t
+xcb_input_device_resolution_ctl_resolution_values_end (const xcb_input_device_resolution_ctl_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->num_valuators);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_input_device_resolution_ctl_next (xcb_input_device_resolution_ctl_iterator_t *i)
+{
+    xcb_input_device_resolution_ctl_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_device_resolution_ctl_t *)(((char *)R) + xcb_input_device_resolution_ctl_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_device_resolution_ctl_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_device_resolution_ctl_end (xcb_input_device_resolution_ctl_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_device_resolution_ctl_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+void
+xcb_input_device_abs_calib_ctl_next (xcb_input_device_abs_calib_ctl_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_device_abs_calib_ctl_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_device_abs_calib_ctl_end (xcb_input_device_abs_calib_ctl_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_device_abs_area_ctrl_next (xcb_input_device_abs_area_ctrl_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_device_abs_area_ctrl_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_device_abs_area_ctrl_end (xcb_input_device_abs_area_ctrl_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_device_core_ctrl_next (xcb_input_device_core_ctrl_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_device_core_ctrl_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_device_core_ctrl_end (xcb_input_device_core_ctrl_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_device_enable_ctrl_next (xcb_input_device_enable_ctrl_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_device_enable_ctrl_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_device_enable_ctrl_end (xcb_input_device_enable_ctrl_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+uint32_t *
+xcb_input_device_ctl_data_resolution_resolution_values (const xcb_input_device_ctl_data_t *S)
+{
+    return S->resolution.resolution_values;
+}
+
+int
+xcb_input_device_ctl_data_resolution_resolution_values_length (const xcb_input_device_ctl_t *R,
+                                                               const xcb_input_device_ctl_data_t *S)
+{
+    return S->resolution.num_valuators;
+}
+
+xcb_generic_iterator_t
+xcb_input_device_ctl_data_resolution_resolution_values_end (const xcb_input_device_ctl_t *R,
+                                                            const xcb_input_device_ctl_data_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->resolution.resolution_values + S->resolution.num_valuators;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_input_device_ctl_data_serialize (void                              **_buffer,
+                                     uint16_t                            control_id,
+                                     const xcb_input_device_ctl_data_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[24];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(control_id == XCB_INPUT_DEVICE_CONTROL_RESOLUTION) {
+        /* xcb_input_device_ctl_data_t.resolution.first_valuator */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->resolution.first_valuator;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_ctl_data_t.resolution.num_valuators */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->resolution.num_valuators;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_ctl_data_t.resolution.pad0 */
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_block_len += sizeof(uint8_t)*2;
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* resolution_values */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->resolution.resolution_values;
+        xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = _aux->resolution.num_valuators * sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_CALIB) {
+        /* xcb_input_device_ctl_data_t.abs_calib.min_x */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.min_x;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_ctl_data_t.abs_calib.max_x */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.max_x;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_ctl_data_t.abs_calib.min_y */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.min_y;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_ctl_data_t.abs_calib.max_y */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.max_y;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_ctl_data_t.abs_calib.flip_x */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.flip_x;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_ctl_data_t.abs_calib.flip_y */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.flip_y;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_ctl_data_t.abs_calib.rotation */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.rotation;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_ctl_data_t.abs_calib.button_threshold */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_calib.button_threshold;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(control_id == XCB_INPUT_DEVICE_CONTROL_CORE) {
+        /* xcb_input_device_ctl_data_t.core.status */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->core.status;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_ctl_data_t.core.pad1 */
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_block_len += sizeof(uint8_t)*3;
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if(control_id == XCB_INPUT_DEVICE_CONTROL_ENABLE) {
+        /* xcb_input_device_ctl_data_t.enable.enable */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->enable.enable;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_ctl_data_t.enable.pad2 */
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_block_len += sizeof(uint8_t)*3;
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_AREA) {
+        /* xcb_input_device_ctl_data_t.abs_area.offset_x */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.offset_x;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_ctl_data_t.abs_area.offset_y */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.offset_y;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_ctl_data_t.abs_area.width */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.width;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_ctl_data_t.abs_area.height */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.height;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_ctl_data_t.abs_area.screen */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.screen;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_ctl_data_t.abs_area.following */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->abs_area.following;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_device_ctl_data_unpack (const void                   *_buffer,
+                                  uint16_t                      control_id,
+                                  xcb_input_device_ctl_data_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if(control_id == XCB_INPUT_DEVICE_CONTROL_RESOLUTION) {
+        /* xcb_input_device_ctl_data_t.resolution.first_valuator */
+        _aux->resolution.first_valuator = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_ctl_data_t.resolution.num_valuators */
+        _aux->resolution.num_valuators = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_ctl_data_t.resolution.pad0 */
+        _aux->resolution.pad0[0] = *(uint8_t *)xcb_tmp;
+        _aux->resolution.pad0[1] = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t) * 2;
+        xcb_tmp += sizeof(uint8_t) * 2;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* resolution_values */
+        _aux->resolution.resolution_values = (uint32_t *)xcb_tmp;
+        xcb_block_len += _aux->resolution.num_valuators * sizeof(uint32_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_CALIB) {
+        /* xcb_input_device_ctl_data_t.abs_calib.min_x */
+        _aux->abs_calib.min_x = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_ctl_data_t.abs_calib.max_x */
+        _aux->abs_calib.max_x = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_ctl_data_t.abs_calib.min_y */
+        _aux->abs_calib.min_y = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_ctl_data_t.abs_calib.max_y */
+        _aux->abs_calib.max_y = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_ctl_data_t.abs_calib.flip_x */
+        _aux->abs_calib.flip_x = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_ctl_data_t.abs_calib.flip_y */
+        _aux->abs_calib.flip_y = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_ctl_data_t.abs_calib.rotation */
+        _aux->abs_calib.rotation = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_ctl_data_t.abs_calib.button_threshold */
+        _aux->abs_calib.button_threshold = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(control_id == XCB_INPUT_DEVICE_CONTROL_CORE) {
+        /* xcb_input_device_ctl_data_t.core.status */
+        _aux->core.status = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_ctl_data_t.core.pad1 */
+        _aux->core.pad1[0] = *(uint8_t *)xcb_tmp;
+        _aux->core.pad1[1] = *(uint8_t *)xcb_tmp;
+        _aux->core.pad1[2] = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t) * 3;
+        xcb_tmp += sizeof(uint8_t) * 3;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if(control_id == XCB_INPUT_DEVICE_CONTROL_ENABLE) {
+        /* xcb_input_device_ctl_data_t.enable.enable */
+        _aux->enable.enable = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_ctl_data_t.enable.pad2 */
+        _aux->enable.pad2[0] = *(uint8_t *)xcb_tmp;
+        _aux->enable.pad2[1] = *(uint8_t *)xcb_tmp;
+        _aux->enable.pad2[2] = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t) * 3;
+        xcb_tmp += sizeof(uint8_t) * 3;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if(control_id == XCB_INPUT_DEVICE_CONTROL_ABS_AREA) {
+        /* xcb_input_device_ctl_data_t.abs_area.offset_x */
+        _aux->abs_area.offset_x = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_ctl_data_t.abs_area.offset_y */
+        _aux->abs_area.offset_y = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_ctl_data_t.abs_area.width */
+        _aux->abs_area.width = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_ctl_data_t.abs_area.height */
+        _aux->abs_area.height = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_ctl_data_t.abs_area.screen */
+        _aux->abs_area.screen = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+        /* xcb_input_device_ctl_data_t.abs_area.following */
+        _aux->abs_area.following = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_device_ctl_data_sizeof (const void  *_buffer,
+                                  uint16_t     control_id)
+{
+    xcb_input_device_ctl_data_t _aux;
+    return xcb_input_device_ctl_data_unpack(_buffer, control_id, &_aux);
+}
+
+int
+xcb_input_device_ctl_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_device_ctl_t *_aux = (xcb_input_device_ctl_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_device_ctl_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += xcb_input_device_ctl_data_sizeof(xcb_tmp, _aux->control_id);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+void *
+xcb_input_device_ctl_data (const xcb_input_device_ctl_t *R)
+{
+    return (void *) (R + 1);
+}
+
+void
+xcb_input_device_ctl_next (xcb_input_device_ctl_iterator_t *i)
+{
+    xcb_input_device_ctl_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_device_ctl_t *)(((char *)R) + xcb_input_device_ctl_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_device_ctl_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_device_ctl_end (xcb_input_device_ctl_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_device_ctl_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_input_change_device_control_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_change_device_control_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* control */
+    xcb_block_len += xcb_input_device_ctl_sizeof(xcb_tmp);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_device_ctl_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_change_device_control_cookie_t
+xcb_input_change_device_control (xcb_connection_t       *c,
+                                 uint16_t                control_id,
+                                 uint8_t                 device_id,
+                                 xcb_input_device_ctl_t *control)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_CHANGE_DEVICE_CONTROL,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_input_change_device_control_cookie_t xcb_ret;
+    xcb_input_change_device_control_request_t xcb_out;
+
+    xcb_out.control_id = control_id;
+    xcb_out.device_id = device_id;
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_device_ctl_t control */
+    xcb_parts[4].iov_base = (char *) control;
+    xcb_parts[4].iov_len =
+      xcb_input_device_ctl_sizeof (control);
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_change_device_control_cookie_t
+xcb_input_change_device_control_unchecked (xcb_connection_t       *c,
+                                           uint16_t                control_id,
+                                           uint8_t                 device_id,
+                                           xcb_input_device_ctl_t *control)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_CHANGE_DEVICE_CONTROL,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_input_change_device_control_cookie_t xcb_ret;
+    xcb_input_change_device_control_request_t xcb_out;
+
+    xcb_out.control_id = control_id;
+    xcb_out.device_id = device_id;
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_device_ctl_t control */
+    xcb_parts[4].iov_base = (char *) control;
+    xcb_parts[4].iov_len =
+      xcb_input_device_ctl_sizeof (control);
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_change_device_control_reply_t *
+xcb_input_change_device_control_reply (xcb_connection_t                          *c,
+                                       xcb_input_change_device_control_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e)
+{
+    return (xcb_input_change_device_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_input_list_device_properties_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_list_device_properties_reply_t *_aux = (xcb_input_list_device_properties_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_list_device_properties_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* atoms */
+    xcb_block_len += _aux->num_atoms * sizeof(xcb_atom_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_atom_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_list_device_properties_cookie_t
+xcb_input_list_device_properties (xcb_connection_t *c,
+                                  uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_LIST_DEVICE_PROPERTIES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_list_device_properties_cookie_t xcb_ret;
+    xcb_input_list_device_properties_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_list_device_properties_cookie_t
+xcb_input_list_device_properties_unchecked (xcb_connection_t *c,
+                                            uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_LIST_DEVICE_PROPERTIES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_list_device_properties_cookie_t xcb_ret;
+    xcb_input_list_device_properties_request_t xcb_out;
+
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_atom_t *
+xcb_input_list_device_properties_atoms (const xcb_input_list_device_properties_reply_t *R)
+{
+    return (xcb_atom_t *) (R + 1);
+}
+
+int
+xcb_input_list_device_properties_atoms_length (const xcb_input_list_device_properties_reply_t *R)
+{
+    return R->num_atoms;
+}
+
+xcb_generic_iterator_t
+xcb_input_list_device_properties_atoms_end (const xcb_input_list_device_properties_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_atom_t *) (R + 1)) + (R->num_atoms);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_list_device_properties_reply_t *
+xcb_input_list_device_properties_reply (xcb_connection_t                           *c,
+                                        xcb_input_list_device_properties_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e)
+{
+    return (xcb_input_list_device_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+uint8_t *
+xcb_input_change_device_property_items_data_8 (const xcb_input_change_device_property_items_t *S)
+{
+    return S->data8;
+}
+
+int
+xcb_input_change_device_property_items_data_8_length (const xcb_input_change_device_property_request_t *R,
+                                                      const xcb_input_change_device_property_items_t *S)
+{
+    return R->num_items;
+}
+
+xcb_generic_iterator_t
+xcb_input_change_device_property_items_data_8_end (const xcb_input_change_device_property_request_t *R,
+                                                   const xcb_input_change_device_property_items_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->data8 + R->num_items;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+uint16_t *
+xcb_input_change_device_property_items_data_16 (const xcb_input_change_device_property_items_t *S)
+{
+    return S->data16;
+}
+
+int
+xcb_input_change_device_property_items_data_16_length (const xcb_input_change_device_property_request_t *R,
+                                                       const xcb_input_change_device_property_items_t *S)
+{
+    return R->num_items;
+}
+
+xcb_generic_iterator_t
+xcb_input_change_device_property_items_data_16_end (const xcb_input_change_device_property_request_t *R,
+                                                    const xcb_input_change_device_property_items_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->data16 + R->num_items;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+uint32_t *
+xcb_input_change_device_property_items_data_32 (const xcb_input_change_device_property_items_t *S)
+{
+    return S->data32;
+}
+
+int
+xcb_input_change_device_property_items_data_32_length (const xcb_input_change_device_property_request_t *R,
+                                                       const xcb_input_change_device_property_items_t *S)
+{
+    return R->num_items;
+}
+
+xcb_generic_iterator_t
+xcb_input_change_device_property_items_data_32_end (const xcb_input_change_device_property_request_t *R,
+                                                    const xcb_input_change_device_property_items_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->data32 + R->num_items;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_input_change_device_property_items_serialize (void                                           **_buffer,
+                                                  uint32_t                                         num_items,
+                                                  uint8_t                                          format,
+                                                  const xcb_input_change_device_property_items_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[9];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data8 */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data8;
+        xcb_block_len += num_items * sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data16 */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data16;
+        xcb_block_len += num_items * sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data32 */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data32;
+        xcb_block_len += num_items * sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_change_device_property_items_unpack (const void                                *_buffer,
+                                               uint32_t                                   num_items,
+                                               uint8_t                                    format,
+                                               xcb_input_change_device_property_items_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data8 */
+        _aux->data8 = (uint8_t *)xcb_tmp;
+        xcb_block_len += num_items * sizeof(uint8_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data16 */
+        _aux->data16 = (uint16_t *)xcb_tmp;
+        xcb_block_len += num_items * sizeof(uint16_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint16_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data32 */
+        _aux->data32 = (uint32_t *)xcb_tmp;
+        xcb_block_len += num_items * sizeof(uint32_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_change_device_property_items_sizeof (const void  *_buffer,
+                                               uint32_t     num_items,
+                                               uint8_t      format)
+{
+    xcb_input_change_device_property_items_t _aux;
+    return xcb_input_change_device_property_items_unpack(_buffer, num_items, format, &_aux);
+}
+
+int
+xcb_input_change_device_property_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_change_device_property_request_t *_aux = (xcb_input_change_device_property_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_change_device_property_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* items */
+    xcb_block_len += xcb_input_change_device_property_items_sizeof(xcb_tmp, _aux->num_items, _aux->format);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_input_change_device_property_checked (xcb_connection_t *c,
+                                          xcb_atom_t        property,
+                                          xcb_atom_t        type,
+                                          uint8_t           device_id,
+                                          uint8_t           format,
+                                          uint8_t           mode,
+                                          uint32_t          num_items,
+                                          const void       *items)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_CHANGE_DEVICE_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_change_device_property_request_t xcb_out;
+
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.device_id = device_id;
+    xcb_out.format = format;
+    xcb_out.mode = mode;
+    xcb_out.pad0 = 0;
+    xcb_out.num_items = num_items;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_change_device_property_items_t items */
+    xcb_parts[4].iov_base = (char *) items;
+    xcb_parts[4].iov_len =
+      xcb_input_change_device_property_items_sizeof (items, num_items, format);
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_change_device_property (xcb_connection_t *c,
+                                  xcb_atom_t        property,
+                                  xcb_atom_t        type,
+                                  uint8_t           device_id,
+                                  uint8_t           format,
+                                  uint8_t           mode,
+                                  uint32_t          num_items,
+                                  const void       *items)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_CHANGE_DEVICE_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_change_device_property_request_t xcb_out;
+
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.device_id = device_id;
+    xcb_out.format = format;
+    xcb_out.mode = mode;
+    xcb_out.pad0 = 0;
+    xcb_out.num_items = num_items;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_change_device_property_items_t items */
+    xcb_parts[4].iov_base = (char *) items;
+    xcb_parts[4].iov_len =
+      xcb_input_change_device_property_items_sizeof (items, num_items, format);
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_change_device_property_aux_checked (xcb_connection_t                               *c,
+                                              xcb_atom_t                                      property,
+                                              xcb_atom_t                                      type,
+                                              uint8_t                                         device_id,
+                                              uint8_t                                         format,
+                                              uint8_t                                         mode,
+                                              uint32_t                                        num_items,
+                                              const xcb_input_change_device_property_items_t *items)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_CHANGE_DEVICE_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_change_device_property_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.device_id = device_id;
+    xcb_out.format = format;
+    xcb_out.mode = mode;
+    xcb_out.pad0 = 0;
+    xcb_out.num_items = num_items;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_change_device_property_items_t items */
+    xcb_parts[4].iov_len =
+      xcb_input_change_device_property_items_serialize (&xcb_aux0, num_items, format, items);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_change_device_property_aux (xcb_connection_t                               *c,
+                                      xcb_atom_t                                      property,
+                                      xcb_atom_t                                      type,
+                                      uint8_t                                         device_id,
+                                      uint8_t                                         format,
+                                      uint8_t                                         mode,
+                                      uint32_t                                        num_items,
+                                      const xcb_input_change_device_property_items_t *items)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_CHANGE_DEVICE_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_change_device_property_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.device_id = device_id;
+    xcb_out.format = format;
+    xcb_out.mode = mode;
+    xcb_out.pad0 = 0;
+    xcb_out.num_items = num_items;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_change_device_property_items_t items */
+    xcb_parts[4].iov_len =
+      xcb_input_change_device_property_items_serialize (&xcb_aux0, num_items, format, items);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+void *
+xcb_input_change_device_property_items (const xcb_input_change_device_property_request_t *R)
+{
+    return (void *) (R + 1);
+}
+
+xcb_void_cookie_t
+xcb_input_delete_device_property_checked (xcb_connection_t *c,
+                                          xcb_atom_t        property,
+                                          uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_DELETE_DEVICE_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_delete_device_property_request_t xcb_out;
+
+    xcb_out.property = property;
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_delete_device_property (xcb_connection_t *c,
+                                  xcb_atom_t        property,
+                                  uint8_t           device_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_DELETE_DEVICE_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_delete_device_property_request_t xcb_out;
+
+    xcb_out.property = property;
+    xcb_out.device_id = device_id;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_input_get_device_property_items_data_8 (const xcb_input_get_device_property_items_t *S)
+{
+    return S->data8;
+}
+
+int
+xcb_input_get_device_property_items_data_8_length (const xcb_input_get_device_property_reply_t *R,
+                                                   const xcb_input_get_device_property_items_t *S)
+{
+    return R->num_items;
+}
+
+xcb_generic_iterator_t
+xcb_input_get_device_property_items_data_8_end (const xcb_input_get_device_property_reply_t *R,
+                                                const xcb_input_get_device_property_items_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->data8 + R->num_items;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+uint16_t *
+xcb_input_get_device_property_items_data_16 (const xcb_input_get_device_property_items_t *S)
+{
+    return S->data16;
+}
+
+int
+xcb_input_get_device_property_items_data_16_length (const xcb_input_get_device_property_reply_t *R,
+                                                    const xcb_input_get_device_property_items_t *S)
+{
+    return R->num_items;
+}
+
+xcb_generic_iterator_t
+xcb_input_get_device_property_items_data_16_end (const xcb_input_get_device_property_reply_t *R,
+                                                 const xcb_input_get_device_property_items_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->data16 + R->num_items;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+uint32_t *
+xcb_input_get_device_property_items_data_32 (const xcb_input_get_device_property_items_t *S)
+{
+    return S->data32;
+}
+
+int
+xcb_input_get_device_property_items_data_32_length (const xcb_input_get_device_property_reply_t *R,
+                                                    const xcb_input_get_device_property_items_t *S)
+{
+    return R->num_items;
+}
+
+xcb_generic_iterator_t
+xcb_input_get_device_property_items_data_32_end (const xcb_input_get_device_property_reply_t *R,
+                                                 const xcb_input_get_device_property_items_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->data32 + R->num_items;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_input_get_device_property_items_serialize (void                                        **_buffer,
+                                               uint32_t                                      num_items,
+                                               uint8_t                                       format,
+                                               const xcb_input_get_device_property_items_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[9];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data8 */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data8;
+        xcb_block_len += num_items * sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data16 */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data16;
+        xcb_block_len += num_items * sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data32 */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data32;
+        xcb_block_len += num_items * sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_get_device_property_items_unpack (const void                             *_buffer,
+                                            uint32_t                                num_items,
+                                            uint8_t                                 format,
+                                            xcb_input_get_device_property_items_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data8 */
+        _aux->data8 = (uint8_t *)xcb_tmp;
+        xcb_block_len += num_items * sizeof(uint8_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data16 */
+        _aux->data16 = (uint16_t *)xcb_tmp;
+        xcb_block_len += num_items * sizeof(uint16_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint16_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data32 */
+        _aux->data32 = (uint32_t *)xcb_tmp;
+        xcb_block_len += num_items * sizeof(uint32_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_get_device_property_items_sizeof (const void  *_buffer,
+                                            uint32_t     num_items,
+                                            uint8_t      format)
+{
+    xcb_input_get_device_property_items_t _aux;
+    return xcb_input_get_device_property_items_unpack(_buffer, num_items, format, &_aux);
+}
+
+int
+xcb_input_get_device_property_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_get_device_property_reply_t *_aux = (xcb_input_get_device_property_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_get_device_property_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* items */
+    xcb_block_len += xcb_input_get_device_property_items_sizeof(xcb_tmp, _aux->num_items, _aux->format);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_get_device_property_cookie_t
+xcb_input_get_device_property (xcb_connection_t *c,
+                               xcb_atom_t        property,
+                               xcb_atom_t        type,
+                               uint32_t          offset,
+                               uint32_t          len,
+                               uint8_t           device_id,
+                               uint8_t           _delete)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_DEVICE_PROPERTY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_get_device_property_cookie_t xcb_ret;
+    xcb_input_get_device_property_request_t xcb_out;
+
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.offset = offset;
+    xcb_out.len = len;
+    xcb_out.device_id = device_id;
+    xcb_out._delete = _delete;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_get_device_property_cookie_t
+xcb_input_get_device_property_unchecked (xcb_connection_t *c,
+                                         xcb_atom_t        property,
+                                         xcb_atom_t        type,
+                                         uint32_t          offset,
+                                         uint32_t          len,
+                                         uint8_t           device_id,
+                                         uint8_t           _delete)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_GET_DEVICE_PROPERTY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_get_device_property_cookie_t xcb_ret;
+    xcb_input_get_device_property_request_t xcb_out;
+
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.offset = offset;
+    xcb_out.len = len;
+    xcb_out.device_id = device_id;
+    xcb_out._delete = _delete;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+void *
+xcb_input_get_device_property_items (const xcb_input_get_device_property_reply_t *R)
+{
+    return (void *) (R + 1);
+}
+
+xcb_input_get_device_property_reply_t *
+xcb_input_get_device_property_reply (xcb_connection_t                        *c,
+                                     xcb_input_get_device_property_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e)
+{
+    return (xcb_input_get_device_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+void
+xcb_input_group_info_next (xcb_input_group_info_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_group_info_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_group_info_end (xcb_input_group_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_modifier_info_next (xcb_input_modifier_info_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_modifier_info_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_modifier_info_end (xcb_input_modifier_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_input_xi_query_pointer_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_xi_query_pointer_reply_t *_aux = (xcb_input_xi_query_pointer_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_xi_query_pointer_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* buttons */
+    xcb_block_len += _aux->buttons_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_xi_query_pointer_cookie_t
+xcb_input_xi_query_pointer (xcb_connection_t      *c,
+                            xcb_window_t           window,
+                            xcb_input_device_id_t  deviceid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_QUERY_POINTER,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_xi_query_pointer_cookie_t xcb_ret;
+    xcb_input_xi_query_pointer_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.deviceid = deviceid;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_xi_query_pointer_cookie_t
+xcb_input_xi_query_pointer_unchecked (xcb_connection_t      *c,
+                                      xcb_window_t           window,
+                                      xcb_input_device_id_t  deviceid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_QUERY_POINTER,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_xi_query_pointer_cookie_t xcb_ret;
+    xcb_input_xi_query_pointer_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.deviceid = deviceid;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_input_xi_query_pointer_buttons (const xcb_input_xi_query_pointer_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_input_xi_query_pointer_buttons_length (const xcb_input_xi_query_pointer_reply_t *R)
+{
+    return R->buttons_len;
+}
+
+xcb_generic_iterator_t
+xcb_input_xi_query_pointer_buttons_end (const xcb_input_xi_query_pointer_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->buttons_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_xi_query_pointer_reply_t *
+xcb_input_xi_query_pointer_reply (xcb_connection_t                     *c,
+                                  xcb_input_xi_query_pointer_cookie_t   cookie  /**< */,
+                                  xcb_generic_error_t                 **e)
+{
+    return (xcb_input_xi_query_pointer_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_input_xi_warp_pointer_checked (xcb_connection_t      *c,
+                                   xcb_window_t           src_win,
+                                   xcb_window_t           dst_win,
+                                   xcb_input_fp1616_t     src_x,
+                                   xcb_input_fp1616_t     src_y,
+                                   uint16_t               src_width,
+                                   uint16_t               src_height,
+                                   xcb_input_fp1616_t     dst_x,
+                                   xcb_input_fp1616_t     dst_y,
+                                   xcb_input_device_id_t  deviceid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_WARP_POINTER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_warp_pointer_request_t xcb_out;
+
+    xcb_out.src_win = src_win;
+    xcb_out.dst_win = dst_win;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+    xcb_out.src_width = src_width;
+    xcb_out.src_height = src_height;
+    xcb_out.dst_x = dst_x;
+    xcb_out.dst_y = dst_y;
+    xcb_out.deviceid = deviceid;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_warp_pointer (xcb_connection_t      *c,
+                           xcb_window_t           src_win,
+                           xcb_window_t           dst_win,
+                           xcb_input_fp1616_t     src_x,
+                           xcb_input_fp1616_t     src_y,
+                           uint16_t               src_width,
+                           uint16_t               src_height,
+                           xcb_input_fp1616_t     dst_x,
+                           xcb_input_fp1616_t     dst_y,
+                           xcb_input_device_id_t  deviceid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_WARP_POINTER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_warp_pointer_request_t xcb_out;
+
+    xcb_out.src_win = src_win;
+    xcb_out.dst_win = dst_win;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+    xcb_out.src_width = src_width;
+    xcb_out.src_height = src_height;
+    xcb_out.dst_x = dst_x;
+    xcb_out.dst_y = dst_y;
+    xcb_out.deviceid = deviceid;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_change_cursor_checked (xcb_connection_t      *c,
+                                    xcb_window_t           window,
+                                    xcb_cursor_t           cursor,
+                                    xcb_input_device_id_t  deviceid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_CHANGE_CURSOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_change_cursor_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.cursor = cursor;
+    xcb_out.deviceid = deviceid;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_change_cursor (xcb_connection_t      *c,
+                            xcb_window_t           window,
+                            xcb_cursor_t           cursor,
+                            xcb_input_device_id_t  deviceid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_CHANGE_CURSOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_change_cursor_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.cursor = cursor;
+    xcb_out.deviceid = deviceid;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_input_add_master_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_add_master_t *_aux = (xcb_input_add_master_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_add_master_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->name_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+char *
+xcb_input_add_master_name (const xcb_input_add_master_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_input_add_master_name_length (const xcb_input_add_master_t *R)
+{
+    return R->name_len;
+}
+
+xcb_generic_iterator_t
+xcb_input_add_master_name_end (const xcb_input_add_master_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->name_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_input_add_master_next (xcb_input_add_master_iterator_t *i)
+{
+    xcb_input_add_master_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_add_master_t *)(((char *)R) + xcb_input_add_master_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_add_master_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_add_master_end (xcb_input_add_master_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_add_master_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+void
+xcb_input_remove_master_next (xcb_input_remove_master_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_remove_master_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_remove_master_end (xcb_input_remove_master_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_attach_slave_next (xcb_input_attach_slave_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_attach_slave_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_attach_slave_end (xcb_input_attach_slave_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_detach_slave_next (xcb_input_detach_slave_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_detach_slave_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_detach_slave_end (xcb_input_detach_slave_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+char *
+xcb_input_hierarchy_change_data_add_master_name (const xcb_input_hierarchy_change_data_t *S)
+{
+    return S->add_master.name;
+}
+
+int
+xcb_input_hierarchy_change_data_add_master_name_length (const xcb_input_hierarchy_change_t *R,
+                                                        const xcb_input_hierarchy_change_data_t *S)
+{
+    return S->add_master.name_len;
+}
+
+xcb_generic_iterator_t
+xcb_input_hierarchy_change_data_add_master_name_end (const xcb_input_hierarchy_change_t *R,
+                                                     const xcb_input_hierarchy_change_data_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->add_master.name + S->add_master.name_len;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_input_hierarchy_change_data_serialize (void                                    **_buffer,
+                                           uint16_t                                  type,
+                                           const xcb_input_hierarchy_change_data_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[16];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_ADD_MASTER) {
+        /* xcb_input_hierarchy_change_data_t.add_master.name_len */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->add_master.name_len;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_hierarchy_change_data_t.add_master.send_core */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->add_master.send_core;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_hierarchy_change_data_t.add_master.enable */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->add_master.enable;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* name */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->add_master.name;
+        xcb_block_len += _aux->add_master.name_len * sizeof(char);
+        xcb_parts[xcb_parts_idx].iov_len = _aux->add_master.name_len * sizeof(char);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(char);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_REMOVE_MASTER) {
+        /* xcb_input_hierarchy_change_data_t.remove_master.deviceid */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->remove_master.deviceid;
+        xcb_block_len += sizeof(xcb_input_device_id_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_input_device_id_t);
+        /* xcb_input_hierarchy_change_data_t.remove_master.return_mode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->remove_master.return_mode;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_hierarchy_change_data_t.remove_master.pad1 */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_hierarchy_change_data_t.remove_master.return_pointer */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->remove_master.return_pointer;
+        xcb_block_len += sizeof(xcb_input_device_id_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_input_device_id_t);
+        /* xcb_input_hierarchy_change_data_t.remove_master.return_keyboard */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->remove_master.return_keyboard;
+        xcb_block_len += sizeof(xcb_input_device_id_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_input_device_id_t);
+    }
+    if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_ATTACH_SLAVE) {
+        /* xcb_input_hierarchy_change_data_t.attach_slave.deviceid */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->attach_slave.deviceid;
+        xcb_block_len += sizeof(xcb_input_device_id_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_input_device_id_t);
+        /* xcb_input_hierarchy_change_data_t.attach_slave.master */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->attach_slave.master;
+        xcb_block_len += sizeof(xcb_input_device_id_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_input_device_id_t);
+    }
+    if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_DETACH_SLAVE) {
+        /* xcb_input_hierarchy_change_data_t.detach_slave.deviceid */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->detach_slave.deviceid;
+        xcb_block_len += sizeof(xcb_input_device_id_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_device_id_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_input_device_id_t);
+        /* xcb_input_hierarchy_change_data_t.detach_slave.pad2 */
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_block_len += sizeof(uint8_t)*2;
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_hierarchy_change_data_unpack (const void                         *_buffer,
+                                        uint16_t                            type,
+                                        xcb_input_hierarchy_change_data_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_ADD_MASTER) {
+        /* xcb_input_hierarchy_change_data_t.add_master.name_len */
+        _aux->add_master.name_len = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_hierarchy_change_data_t.add_master.send_core */
+        _aux->add_master.send_core = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_hierarchy_change_data_t.add_master.enable */
+        _aux->add_master.enable = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* name */
+        _aux->add_master.name = (char *)xcb_tmp;
+        xcb_block_len += _aux->add_master.name_len * sizeof(char);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(char);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_REMOVE_MASTER) {
+        /* xcb_input_hierarchy_change_data_t.remove_master.deviceid */
+        _aux->remove_master.deviceid = *(xcb_input_device_id_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_input_device_id_t);
+        xcb_tmp += sizeof(xcb_input_device_id_t);
+        xcb_align_to = ALIGNOF(xcb_input_device_id_t);
+        /* xcb_input_hierarchy_change_data_t.remove_master.return_mode */
+        _aux->remove_master.return_mode = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_hierarchy_change_data_t.remove_master.pad1 */
+        _aux->remove_master.pad1 = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_hierarchy_change_data_t.remove_master.return_pointer */
+        _aux->remove_master.return_pointer = *(xcb_input_device_id_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_input_device_id_t);
+        xcb_tmp += sizeof(xcb_input_device_id_t);
+        xcb_align_to = ALIGNOF(xcb_input_device_id_t);
+        /* xcb_input_hierarchy_change_data_t.remove_master.return_keyboard */
+        _aux->remove_master.return_keyboard = *(xcb_input_device_id_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_input_device_id_t);
+        xcb_tmp += sizeof(xcb_input_device_id_t);
+        xcb_align_to = ALIGNOF(xcb_input_device_id_t);
+    }
+    if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_ATTACH_SLAVE) {
+        /* xcb_input_hierarchy_change_data_t.attach_slave.deviceid */
+        _aux->attach_slave.deviceid = *(xcb_input_device_id_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_input_device_id_t);
+        xcb_tmp += sizeof(xcb_input_device_id_t);
+        xcb_align_to = ALIGNOF(xcb_input_device_id_t);
+        /* xcb_input_hierarchy_change_data_t.attach_slave.master */
+        _aux->attach_slave.master = *(xcb_input_device_id_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_input_device_id_t);
+        xcb_tmp += sizeof(xcb_input_device_id_t);
+        xcb_align_to = ALIGNOF(xcb_input_device_id_t);
+    }
+    if(type == XCB_INPUT_HIERARCHY_CHANGE_TYPE_DETACH_SLAVE) {
+        /* xcb_input_hierarchy_change_data_t.detach_slave.deviceid */
+        _aux->detach_slave.deviceid = *(xcb_input_device_id_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_input_device_id_t);
+        xcb_tmp += sizeof(xcb_input_device_id_t);
+        xcb_align_to = ALIGNOF(xcb_input_device_id_t);
+        /* xcb_input_hierarchy_change_data_t.detach_slave.pad2 */
+        _aux->detach_slave.pad2[0] = *(uint8_t *)xcb_tmp;
+        _aux->detach_slave.pad2[1] = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t) * 2;
+        xcb_tmp += sizeof(uint8_t) * 2;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_hierarchy_change_data_sizeof (const void  *_buffer,
+                                        uint16_t     type)
+{
+    xcb_input_hierarchy_change_data_t _aux;
+    return xcb_input_hierarchy_change_data_unpack(_buffer, type, &_aux);
+}
+
+int
+xcb_input_hierarchy_change_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_hierarchy_change_t *_aux = (xcb_input_hierarchy_change_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_hierarchy_change_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += xcb_input_hierarchy_change_data_sizeof(xcb_tmp, _aux->type);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+void *
+xcb_input_hierarchy_change_data (const xcb_input_hierarchy_change_t *R)
+{
+    return (void *) (R + 1);
+}
+
+void
+xcb_input_hierarchy_change_next (xcb_input_hierarchy_change_iterator_t *i)
+{
+    xcb_input_hierarchy_change_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_hierarchy_change_t *)(((char *)R) + xcb_input_hierarchy_change_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_hierarchy_change_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_hierarchy_change_end (xcb_input_hierarchy_change_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_hierarchy_change_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_input_xi_change_hierarchy_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_xi_change_hierarchy_request_t *_aux = (xcb_input_xi_change_hierarchy_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_input_xi_change_hierarchy_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* changes */
+    for(i=0; i<_aux->num_changes; i++) {
+        xcb_tmp_len = xcb_input_hierarchy_change_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_input_hierarchy_change_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_change_hierarchy_checked (xcb_connection_t                   *c,
+                                       uint8_t                             num_changes,
+                                       const xcb_input_hierarchy_change_t *changes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_CHANGE_HIERARCHY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_change_hierarchy_request_t xcb_out;
+    unsigned int xcb_tmp_len;
+    char *xcb_tmp;
+    unsigned int i;
+
+    xcb_out.num_changes = num_changes;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_hierarchy_change_t changes */
+    xcb_parts[4].iov_base = (char *) changes;
+    xcb_parts[4].iov_len = 0;
+    xcb_tmp = (char *)changes;
+    for(i=0; i<num_changes; i++) {
+        xcb_tmp_len = xcb_input_hierarchy_change_sizeof(xcb_tmp);
+        xcb_parts[4].iov_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_change_hierarchy (xcb_connection_t                   *c,
+                               uint8_t                             num_changes,
+                               const xcb_input_hierarchy_change_t *changes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_CHANGE_HIERARCHY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_change_hierarchy_request_t xcb_out;
+    unsigned int xcb_tmp_len;
+    char *xcb_tmp;
+    unsigned int i;
+
+    xcb_out.num_changes = num_changes;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_hierarchy_change_t changes */
+    xcb_parts[4].iov_base = (char *) changes;
+    xcb_parts[4].iov_len = 0;
+    xcb_tmp = (char *)changes;
+    for(i=0; i<num_changes; i++) {
+        xcb_tmp_len = xcb_input_hierarchy_change_sizeof(xcb_tmp);
+        xcb_parts[4].iov_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_input_xi_change_hierarchy_changes_length (const xcb_input_xi_change_hierarchy_request_t *R)
+{
+    return R->num_changes;
+}
+
+xcb_input_hierarchy_change_iterator_t
+xcb_input_xi_change_hierarchy_changes_iterator (const xcb_input_xi_change_hierarchy_request_t *R)
+{
+    xcb_input_hierarchy_change_iterator_t i;
+    i.data = (xcb_input_hierarchy_change_t *) (R + 1);
+    i.rem = R->num_changes;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_set_client_pointer_checked (xcb_connection_t      *c,
+                                         xcb_window_t           window,
+                                         xcb_input_device_id_t  deviceid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_SET_CLIENT_POINTER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_set_client_pointer_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.deviceid = deviceid;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_set_client_pointer (xcb_connection_t      *c,
+                                 xcb_window_t           window,
+                                 xcb_input_device_id_t  deviceid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_SET_CLIENT_POINTER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_set_client_pointer_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.deviceid = deviceid;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_xi_get_client_pointer_cookie_t
+xcb_input_xi_get_client_pointer (xcb_connection_t *c,
+                                 xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_GET_CLIENT_POINTER,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_xi_get_client_pointer_cookie_t xcb_ret;
+    xcb_input_xi_get_client_pointer_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_xi_get_client_pointer_cookie_t
+xcb_input_xi_get_client_pointer_unchecked (xcb_connection_t *c,
+                                           xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_GET_CLIENT_POINTER,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_xi_get_client_pointer_cookie_t xcb_ret;
+    xcb_input_xi_get_client_pointer_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_xi_get_client_pointer_reply_t *
+xcb_input_xi_get_client_pointer_reply (xcb_connection_t                          *c,
+                                       xcb_input_xi_get_client_pointer_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e)
+{
+    return (xcb_input_xi_get_client_pointer_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_input_event_mask_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_event_mask_t *_aux = (xcb_input_event_mask_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_event_mask_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* mask */
+    xcb_block_len += _aux->mask_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+uint32_t *
+xcb_input_event_mask_mask (const xcb_input_event_mask_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_input_event_mask_mask_length (const xcb_input_event_mask_t *R)
+{
+    return R->mask_len;
+}
+
+xcb_generic_iterator_t
+xcb_input_event_mask_mask_end (const xcb_input_event_mask_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->mask_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_input_event_mask_next (xcb_input_event_mask_iterator_t *i)
+{
+    xcb_input_event_mask_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_event_mask_t *)(((char *)R) + xcb_input_event_mask_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_event_mask_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_event_mask_end (xcb_input_event_mask_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_event_mask_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_input_xi_select_events_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_xi_select_events_request_t *_aux = (xcb_input_xi_select_events_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_input_xi_select_events_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* masks */
+    for(i=0; i<_aux->num_mask; i++) {
+        xcb_tmp_len = xcb_input_event_mask_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_input_event_mask_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_select_events_checked (xcb_connection_t             *c,
+                                    xcb_window_t                  window,
+                                    uint16_t                      num_mask,
+                                    const xcb_input_event_mask_t *masks)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_SELECT_EVENTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_select_events_request_t xcb_out;
+    unsigned int xcb_tmp_len;
+    char *xcb_tmp;
+    unsigned int i;
+
+    xcb_out.window = window;
+    xcb_out.num_mask = num_mask;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_event_mask_t masks */
+    xcb_parts[4].iov_base = (char *) masks;
+    xcb_parts[4].iov_len = 0;
+    xcb_tmp = (char *)masks;
+    for(i=0; i<num_mask; i++) {
+        xcb_tmp_len = xcb_input_event_mask_sizeof(xcb_tmp);
+        xcb_parts[4].iov_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_select_events (xcb_connection_t             *c,
+                            xcb_window_t                  window,
+                            uint16_t                      num_mask,
+                            const xcb_input_event_mask_t *masks)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_SELECT_EVENTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_select_events_request_t xcb_out;
+    unsigned int xcb_tmp_len;
+    char *xcb_tmp;
+    unsigned int i;
+
+    xcb_out.window = window;
+    xcb_out.num_mask = num_mask;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_event_mask_t masks */
+    xcb_parts[4].iov_base = (char *) masks;
+    xcb_parts[4].iov_len = 0;
+    xcb_tmp = (char *)masks;
+    for(i=0; i<num_mask; i++) {
+        xcb_tmp_len = xcb_input_event_mask_sizeof(xcb_tmp);
+        xcb_parts[4].iov_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_input_xi_select_events_masks_length (const xcb_input_xi_select_events_request_t *R)
+{
+    return R->num_mask;
+}
+
+xcb_input_event_mask_iterator_t
+xcb_input_xi_select_events_masks_iterator (const xcb_input_xi_select_events_request_t *R)
+{
+    xcb_input_event_mask_iterator_t i;
+    i.data = (xcb_input_event_mask_t *) (R + 1);
+    i.rem = R->num_mask;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_xi_query_version_cookie_t
+xcb_input_xi_query_version (xcb_connection_t *c,
+                            uint16_t          major_version,
+                            uint16_t          minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_xi_query_version_cookie_t xcb_ret;
+    xcb_input_xi_query_version_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_xi_query_version_cookie_t
+xcb_input_xi_query_version_unchecked (xcb_connection_t *c,
+                                      uint16_t          major_version,
+                                      uint16_t          minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_xi_query_version_cookie_t xcb_ret;
+    xcb_input_xi_query_version_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.minor_version = minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_xi_query_version_reply_t *
+xcb_input_xi_query_version_reply (xcb_connection_t                     *c,
+                                  xcb_input_xi_query_version_cookie_t   cookie  /**< */,
+                                  xcb_generic_error_t                 **e)
+{
+    return (xcb_input_xi_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_input_button_class_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_button_class_t *_aux = (xcb_input_button_class_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_button_class_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* state */
+    xcb_block_len += ((_aux->num_buttons + 31) / 32) * sizeof(xcb_atom_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* labels */
+    xcb_block_len += _aux->num_buttons * sizeof(xcb_atom_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_atom_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+uint32_t *
+xcb_input_button_class_state (const xcb_input_button_class_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_input_button_class_state_length (const xcb_input_button_class_t *R)
+{
+    return ((R->num_buttons + 31) / 32);
+}
+
+xcb_generic_iterator_t
+xcb_input_button_class_state_end (const xcb_input_button_class_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (((R->num_buttons + 31) / 32));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_atom_t *
+xcb_input_button_class_labels (const xcb_input_button_class_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_input_button_class_state_end(R);
+    return (xcb_atom_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_atom_t, prev.index) + 0);
+}
+
+int
+xcb_input_button_class_labels_length (const xcb_input_button_class_t *R)
+{
+    return R->num_buttons;
+}
+
+xcb_generic_iterator_t
+xcb_input_button_class_labels_end (const xcb_input_button_class_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_input_button_class_state_end(R);
+    i.data = ((xcb_atom_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_atom_t, prev.index))) + (R->num_buttons);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_input_button_class_next (xcb_input_button_class_iterator_t *i)
+{
+    xcb_input_button_class_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_button_class_t *)(((char *)R) + xcb_input_button_class_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_button_class_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_button_class_end (xcb_input_button_class_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_button_class_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_input_key_class_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_key_class_t *_aux = (xcb_input_key_class_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_key_class_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* keys */
+    xcb_block_len += _aux->num_keys * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+uint32_t *
+xcb_input_key_class_keys (const xcb_input_key_class_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_input_key_class_keys_length (const xcb_input_key_class_t *R)
+{
+    return R->num_keys;
+}
+
+xcb_generic_iterator_t
+xcb_input_key_class_keys_end (const xcb_input_key_class_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->num_keys);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_input_key_class_next (xcb_input_key_class_iterator_t *i)
+{
+    xcb_input_key_class_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_key_class_t *)(((char *)R) + xcb_input_key_class_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_key_class_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_key_class_end (xcb_input_key_class_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_key_class_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+void
+xcb_input_scroll_class_next (xcb_input_scroll_class_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_scroll_class_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_scroll_class_end (xcb_input_scroll_class_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_touch_class_next (xcb_input_touch_class_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_touch_class_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_touch_class_end (xcb_input_touch_class_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_gesture_class_next (xcb_input_gesture_class_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_gesture_class_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_gesture_class_end (xcb_input_gesture_class_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_input_valuator_class_next (xcb_input_valuator_class_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_valuator_class_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_valuator_class_end (xcb_input_valuator_class_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+uint32_t *
+xcb_input_device_class_data_key_keys (const xcb_input_device_class_data_t *S)
+{
+    return S->key.keys;
+}
+
+int
+xcb_input_device_class_data_key_keys_length (const xcb_input_device_class_t *R,
+                                             const xcb_input_device_class_data_t *S)
+{
+    return S->key.num_keys;
+}
+
+xcb_generic_iterator_t
+xcb_input_device_class_data_key_keys_end (const xcb_input_device_class_t *R,
+                                          const xcb_input_device_class_data_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->key.keys + S->key.num_keys;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+uint32_t *
+xcb_input_device_class_data_button_state (const xcb_input_device_class_data_t *S)
+{
+    return S->button.state;
+}
+
+int
+xcb_input_device_class_data_button_state_length (const xcb_input_device_class_t *R,
+                                                 const xcb_input_device_class_data_t *S)
+{
+    return ((S->button.num_buttons + 31) / 32);
+}
+
+xcb_generic_iterator_t
+xcb_input_device_class_data_button_state_end (const xcb_input_device_class_t *R,
+                                              const xcb_input_device_class_data_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->button.state + ((S->button.num_buttons + 31) / 32);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_atom_t *
+xcb_input_device_class_data_button_labels (const xcb_input_device_class_data_t *S)
+{
+    return S->button.labels;
+}
+
+int
+xcb_input_device_class_data_button_labels_length (const xcb_input_device_class_t *R,
+                                                  const xcb_input_device_class_data_t *S)
+{
+    return S->button.num_buttons;
+}
+
+xcb_generic_iterator_t
+xcb_input_device_class_data_button_labels_end (const xcb_input_device_class_t *R,
+                                               const xcb_input_device_class_data_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->button.labels + S->button.num_buttons;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_input_device_class_data_serialize (void                                **_buffer,
+                                       uint16_t                              type,
+                                       const xcb_input_device_class_data_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 2;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[26];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(type == XCB_INPUT_DEVICE_CLASS_TYPE_KEY) {
+        /* xcb_input_device_class_data_t.key.num_keys */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key.num_keys;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* keys */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->key.keys;
+        xcb_block_len += _aux->key.num_keys * sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = _aux->key.num_keys * sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(type == XCB_INPUT_DEVICE_CLASS_TYPE_BUTTON) {
+        /* xcb_input_device_class_data_t.button.num_buttons */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->button.num_buttons;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* state */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->button.state;
+        xcb_block_len += ((_aux->button.num_buttons + 31) / 32) * sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = ((_aux->button.num_buttons + 31) / 32) * sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* labels */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->button.labels;
+        xcb_block_len += _aux->button.num_buttons * sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = _aux->button.num_buttons * sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(type == XCB_INPUT_DEVICE_CLASS_TYPE_VALUATOR) {
+        /* xcb_input_device_class_data_t.valuator.number */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.number;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_device_class_data_t.valuator.label */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.label;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+        /* xcb_input_device_class_data_t.valuator.min */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.min;
+        xcb_block_len += sizeof(xcb_input_fp3232_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_fp3232_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
+        /* xcb_input_device_class_data_t.valuator.max */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.max;
+        xcb_block_len += sizeof(xcb_input_fp3232_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_fp3232_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
+        /* xcb_input_device_class_data_t.valuator.value */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.value;
+        xcb_block_len += sizeof(xcb_input_fp3232_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_fp3232_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
+        /* xcb_input_device_class_data_t.valuator.resolution */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.resolution;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_class_data_t.valuator.mode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valuator.mode;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_class_data_t.valuator.pad0 */
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_block_len += sizeof(uint8_t)*3;
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*3;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if(type == XCB_INPUT_DEVICE_CLASS_TYPE_SCROLL) {
+        /* xcb_input_device_class_data_t.scroll.number */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->scroll.number;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_device_class_data_t.scroll.scroll_type */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->scroll.scroll_type;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_device_class_data_t.scroll.pad1 */
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_block_len += sizeof(uint8_t)*2;
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_class_data_t.scroll.flags */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->scroll.flags;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_class_data_t.scroll.increment */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->scroll.increment;
+        xcb_block_len += sizeof(xcb_input_fp3232_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_input_fp3232_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
+    }
+    if(type == XCB_INPUT_DEVICE_CLASS_TYPE_TOUCH) {
+        /* xcb_input_device_class_data_t.touch.mode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->touch.mode;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_class_data_t.touch.num_touches */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->touch.num_touches;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if(type == XCB_INPUT_DEVICE_CLASS_TYPE_GESTURE) {
+        /* xcb_input_device_class_data_t.gesture.num_touches */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->gesture.num_touches;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_class_data_t.gesture.pad2 */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_device_class_data_unpack (const void                     *_buffer,
+                                    uint16_t                        type,
+                                    xcb_input_device_class_data_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 2;
+
+
+    if(type == XCB_INPUT_DEVICE_CLASS_TYPE_KEY) {
+        /* xcb_input_device_class_data_t.key.num_keys */
+        _aux->key.num_keys = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* keys */
+        _aux->key.keys = (uint32_t *)xcb_tmp;
+        xcb_block_len += _aux->key.num_keys * sizeof(uint32_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(type == XCB_INPUT_DEVICE_CLASS_TYPE_BUTTON) {
+        /* xcb_input_device_class_data_t.button.num_buttons */
+        _aux->button.num_buttons = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* state */
+        _aux->button.state = (uint32_t *)xcb_tmp;
+        xcb_block_len += ((_aux->button.num_buttons + 31) / 32) * sizeof(uint32_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* labels */
+        _aux->button.labels = (xcb_atom_t *)xcb_tmp;
+        xcb_block_len += _aux->button.num_buttons * sizeof(uint32_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(type == XCB_INPUT_DEVICE_CLASS_TYPE_VALUATOR) {
+        /* xcb_input_device_class_data_t.valuator.number */
+        _aux->valuator.number = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_device_class_data_t.valuator.label */
+        _aux->valuator.label = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+        /* xcb_input_device_class_data_t.valuator.min */
+        _aux->valuator.min = *(xcb_input_fp3232_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_input_fp3232_t);
+        xcb_tmp += sizeof(xcb_input_fp3232_t);
+        xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
+        /* xcb_input_device_class_data_t.valuator.max */
+        _aux->valuator.max = *(xcb_input_fp3232_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_input_fp3232_t);
+        xcb_tmp += sizeof(xcb_input_fp3232_t);
+        xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
+        /* xcb_input_device_class_data_t.valuator.value */
+        _aux->valuator.value = *(xcb_input_fp3232_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_input_fp3232_t);
+        xcb_tmp += sizeof(xcb_input_fp3232_t);
+        xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
+        /* xcb_input_device_class_data_t.valuator.resolution */
+        _aux->valuator.resolution = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_class_data_t.valuator.mode */
+        _aux->valuator.mode = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_class_data_t.valuator.pad0 */
+        _aux->valuator.pad0[0] = *(uint8_t *)xcb_tmp;
+        _aux->valuator.pad0[1] = *(uint8_t *)xcb_tmp;
+        _aux->valuator.pad0[2] = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t) * 3;
+        xcb_tmp += sizeof(uint8_t) * 3;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if(type == XCB_INPUT_DEVICE_CLASS_TYPE_SCROLL) {
+        /* xcb_input_device_class_data_t.scroll.number */
+        _aux->scroll.number = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_device_class_data_t.scroll.scroll_type */
+        _aux->scroll.scroll_type = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_input_device_class_data_t.scroll.pad1 */
+        _aux->scroll.pad1[0] = *(uint8_t *)xcb_tmp;
+        _aux->scroll.pad1[1] = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t) * 2;
+        xcb_tmp += sizeof(uint8_t) * 2;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_class_data_t.scroll.flags */
+        _aux->scroll.flags = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_input_device_class_data_t.scroll.increment */
+        _aux->scroll.increment = *(xcb_input_fp3232_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_input_fp3232_t);
+        xcb_tmp += sizeof(xcb_input_fp3232_t);
+        xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
+    }
+    if(type == XCB_INPUT_DEVICE_CLASS_TYPE_TOUCH) {
+        /* xcb_input_device_class_data_t.touch.mode */
+        _aux->touch.mode = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_class_data_t.touch.num_touches */
+        _aux->touch.num_touches = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if(type == XCB_INPUT_DEVICE_CLASS_TYPE_GESTURE) {
+        /* xcb_input_device_class_data_t.gesture.num_touches */
+        _aux->gesture.num_touches = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_input_device_class_data_t.gesture.pad2 */
+        _aux->gesture.pad2 = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_device_class_data_sizeof (const void  *_buffer,
+                                    uint16_t     type)
+{
+    xcb_input_device_class_data_t _aux;
+    return xcb_input_device_class_data_unpack(_buffer, type, &_aux);
+}
+
+int
+xcb_input_device_class_sizeof (const void  *_buffer)
+{
+    const xcb_input_device_class_t *_aux = (xcb_input_device_class_t *)_buffer;
+    return (_aux->len * 4);
+}
+
+void *
+xcb_input_device_class_data (const xcb_input_device_class_t *R)
+{
+    return (void *) (R + 1);
+}
+
+void
+xcb_input_device_class_next (xcb_input_device_class_iterator_t *i)
+{
+    xcb_input_device_class_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_device_class_t *)(((char *)R) + xcb_input_device_class_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_device_class_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_device_class_end (xcb_input_device_class_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_device_class_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_input_xi_device_info_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_xi_device_info_t *_aux = (xcb_input_xi_device_info_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_input_xi_device_info_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->name_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* classes */
+    for(i=0; i<_aux->num_classes; i++) {
+        xcb_tmp_len = xcb_input_device_class_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_input_device_class_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+char *
+xcb_input_xi_device_info_name (const xcb_input_xi_device_info_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_input_xi_device_info_name_length (const xcb_input_xi_device_info_t *R)
+{
+    return R->name_len;
+}
+
+xcb_generic_iterator_t
+xcb_input_xi_device_info_name_end (const xcb_input_xi_device_info_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->name_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_input_xi_device_info_classes_length (const xcb_input_xi_device_info_t *R)
+{
+    return R->num_classes;
+}
+
+xcb_input_device_class_iterator_t
+xcb_input_xi_device_info_classes_iterator (const xcb_input_xi_device_info_t *R)
+{
+    xcb_input_device_class_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_input_xi_device_info_name_end(R);
+    i.data = (xcb_input_device_class_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)));
+    i.rem = R->num_classes;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_input_xi_device_info_next (xcb_input_xi_device_info_iterator_t *i)
+{
+    xcb_input_xi_device_info_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_input_xi_device_info_t *)(((char *)R) + xcb_input_xi_device_info_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_input_xi_device_info_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_input_xi_device_info_end (xcb_input_xi_device_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_input_xi_device_info_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_input_xi_query_device_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_xi_query_device_reply_t *_aux = (xcb_input_xi_query_device_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_input_xi_query_device_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* infos */
+    for(i=0; i<_aux->num_infos; i++) {
+        xcb_tmp_len = xcb_input_xi_device_info_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_input_xi_device_info_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_xi_query_device_cookie_t
+xcb_input_xi_query_device (xcb_connection_t      *c,
+                           xcb_input_device_id_t  deviceid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_QUERY_DEVICE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_xi_query_device_cookie_t xcb_ret;
+    xcb_input_xi_query_device_request_t xcb_out;
+
+    xcb_out.deviceid = deviceid;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_xi_query_device_cookie_t
+xcb_input_xi_query_device_unchecked (xcb_connection_t      *c,
+                                     xcb_input_device_id_t  deviceid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_QUERY_DEVICE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_xi_query_device_cookie_t xcb_ret;
+    xcb_input_xi_query_device_request_t xcb_out;
+
+    xcb_out.deviceid = deviceid;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_input_xi_query_device_infos_length (const xcb_input_xi_query_device_reply_t *R)
+{
+    return R->num_infos;
+}
+
+xcb_input_xi_device_info_iterator_t
+xcb_input_xi_query_device_infos_iterator (const xcb_input_xi_query_device_reply_t *R)
+{
+    xcb_input_xi_device_info_iterator_t i;
+    i.data = (xcb_input_xi_device_info_t *) (R + 1);
+    i.rem = R->num_infos;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_xi_query_device_reply_t *
+xcb_input_xi_query_device_reply (xcb_connection_t                    *c,
+                                 xcb_input_xi_query_device_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e)
+{
+    return (xcb_input_xi_query_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_input_xi_set_focus_checked (xcb_connection_t      *c,
+                                xcb_window_t           window,
+                                xcb_timestamp_t        time,
+                                xcb_input_device_id_t  deviceid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_SET_FOCUS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_set_focus_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.time = time;
+    xcb_out.deviceid = deviceid;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_set_focus (xcb_connection_t      *c,
+                        xcb_window_t           window,
+                        xcb_timestamp_t        time,
+                        xcb_input_device_id_t  deviceid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_SET_FOCUS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_set_focus_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.time = time;
+    xcb_out.deviceid = deviceid;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_xi_get_focus_cookie_t
+xcb_input_xi_get_focus (xcb_connection_t      *c,
+                        xcb_input_device_id_t  deviceid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_GET_FOCUS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_xi_get_focus_cookie_t xcb_ret;
+    xcb_input_xi_get_focus_request_t xcb_out;
+
+    xcb_out.deviceid = deviceid;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_xi_get_focus_cookie_t
+xcb_input_xi_get_focus_unchecked (xcb_connection_t      *c,
+                                  xcb_input_device_id_t  deviceid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_GET_FOCUS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_xi_get_focus_cookie_t xcb_ret;
+    xcb_input_xi_get_focus_request_t xcb_out;
+
+    xcb_out.deviceid = deviceid;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_xi_get_focus_reply_t *
+xcb_input_xi_get_focus_reply (xcb_connection_t                 *c,
+                              xcb_input_xi_get_focus_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_input_xi_get_focus_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_input_xi_grab_device_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_xi_grab_device_request_t *_aux = (xcb_input_xi_grab_device_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_xi_grab_device_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* mask */
+    xcb_block_len += _aux->mask_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_xi_grab_device_cookie_t
+xcb_input_xi_grab_device (xcb_connection_t      *c,
+                          xcb_window_t           window,
+                          xcb_timestamp_t        time,
+                          xcb_cursor_t           cursor,
+                          xcb_input_device_id_t  deviceid,
+                          uint8_t                mode,
+                          uint8_t                paired_device_mode,
+                          uint8_t                owner_events,
+                          uint16_t               mask_len,
+                          const uint32_t        *mask)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_GRAB_DEVICE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_input_xi_grab_device_cookie_t xcb_ret;
+    xcb_input_xi_grab_device_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.time = time;
+    xcb_out.cursor = cursor;
+    xcb_out.deviceid = deviceid;
+    xcb_out.mode = mode;
+    xcb_out.paired_device_mode = paired_device_mode;
+    xcb_out.owner_events = owner_events;
+    xcb_out.pad0 = 0;
+    xcb_out.mask_len = mask_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t mask */
+    xcb_parts[4].iov_base = (char *) mask;
+    xcb_parts[4].iov_len = mask_len * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_xi_grab_device_cookie_t
+xcb_input_xi_grab_device_unchecked (xcb_connection_t      *c,
+                                    xcb_window_t           window,
+                                    xcb_timestamp_t        time,
+                                    xcb_cursor_t           cursor,
+                                    xcb_input_device_id_t  deviceid,
+                                    uint8_t                mode,
+                                    uint8_t                paired_device_mode,
+                                    uint8_t                owner_events,
+                                    uint16_t               mask_len,
+                                    const uint32_t        *mask)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_GRAB_DEVICE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_input_xi_grab_device_cookie_t xcb_ret;
+    xcb_input_xi_grab_device_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.time = time;
+    xcb_out.cursor = cursor;
+    xcb_out.deviceid = deviceid;
+    xcb_out.mode = mode;
+    xcb_out.paired_device_mode = paired_device_mode;
+    xcb_out.owner_events = owner_events;
+    xcb_out.pad0 = 0;
+    xcb_out.mask_len = mask_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t mask */
+    xcb_parts[4].iov_base = (char *) mask;
+    xcb_parts[4].iov_len = mask_len * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_xi_grab_device_reply_t *
+xcb_input_xi_grab_device_reply (xcb_connection_t                   *c,
+                                xcb_input_xi_grab_device_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e)
+{
+    return (xcb_input_xi_grab_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_input_xi_ungrab_device_checked (xcb_connection_t      *c,
+                                    xcb_timestamp_t        time,
+                                    xcb_input_device_id_t  deviceid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_UNGRAB_DEVICE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_ungrab_device_request_t xcb_out;
+
+    xcb_out.time = time;
+    xcb_out.deviceid = deviceid;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_ungrab_device (xcb_connection_t      *c,
+                            xcb_timestamp_t        time,
+                            xcb_input_device_id_t  deviceid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_UNGRAB_DEVICE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_ungrab_device_request_t xcb_out;
+
+    xcb_out.time = time;
+    xcb_out.deviceid = deviceid;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_allow_events_checked (xcb_connection_t      *c,
+                                   xcb_timestamp_t        time,
+                                   xcb_input_device_id_t  deviceid,
+                                   uint8_t                event_mode,
+                                   uint32_t               touchid,
+                                   xcb_window_t           grab_window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_ALLOW_EVENTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_allow_events_request_t xcb_out;
+
+    xcb_out.time = time;
+    xcb_out.deviceid = deviceid;
+    xcb_out.event_mode = event_mode;
+    xcb_out.pad0 = 0;
+    xcb_out.touchid = touchid;
+    xcb_out.grab_window = grab_window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_allow_events (xcb_connection_t      *c,
+                           xcb_timestamp_t        time,
+                           xcb_input_device_id_t  deviceid,
+                           uint8_t                event_mode,
+                           uint32_t               touchid,
+                           xcb_window_t           grab_window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_ALLOW_EVENTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_allow_events_request_t xcb_out;
+
+    xcb_out.time = time;
+    xcb_out.deviceid = deviceid;
+    xcb_out.event_mode = event_mode;
+    xcb_out.pad0 = 0;
+    xcb_out.touchid = touchid;
+    xcb_out.grab_window = grab_window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+void
+xcb_input_grab_modifier_info_next (xcb_input_grab_modifier_info_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_grab_modifier_info_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_grab_modifier_info_end (xcb_input_grab_modifier_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_input_xi_passive_grab_device_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_xi_passive_grab_device_request_t *_aux = (xcb_input_xi_passive_grab_device_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_xi_passive_grab_device_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* mask */
+    xcb_block_len += _aux->mask_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* modifiers */
+    xcb_block_len += _aux->num_modifiers * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_xi_passive_grab_device_cookie_t
+xcb_input_xi_passive_grab_device (xcb_connection_t      *c,
+                                  xcb_timestamp_t        time,
+                                  xcb_window_t           grab_window,
+                                  xcb_cursor_t           cursor,
+                                  uint32_t               detail,
+                                  xcb_input_device_id_t  deviceid,
+                                  uint16_t               num_modifiers,
+                                  uint16_t               mask_len,
+                                  uint8_t                grab_type,
+                                  uint8_t                grab_mode,
+                                  uint8_t                paired_device_mode,
+                                  uint8_t                owner_events,
+                                  const uint32_t        *mask,
+                                  const uint32_t        *modifiers)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_PASSIVE_GRAB_DEVICE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_input_xi_passive_grab_device_cookie_t xcb_ret;
+    xcb_input_xi_passive_grab_device_request_t xcb_out;
+
+    xcb_out.time = time;
+    xcb_out.grab_window = grab_window;
+    xcb_out.cursor = cursor;
+    xcb_out.detail = detail;
+    xcb_out.deviceid = deviceid;
+    xcb_out.num_modifiers = num_modifiers;
+    xcb_out.mask_len = mask_len;
+    xcb_out.grab_type = grab_type;
+    xcb_out.grab_mode = grab_mode;
+    xcb_out.paired_device_mode = paired_device_mode;
+    xcb_out.owner_events = owner_events;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t mask */
+    xcb_parts[4].iov_base = (char *) mask;
+    xcb_parts[4].iov_len = mask_len * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* uint32_t modifiers */
+    xcb_parts[6].iov_base = (char *) modifiers;
+    xcb_parts[6].iov_len = num_modifiers * sizeof(uint32_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_xi_passive_grab_device_cookie_t
+xcb_input_xi_passive_grab_device_unchecked (xcb_connection_t      *c,
+                                            xcb_timestamp_t        time,
+                                            xcb_window_t           grab_window,
+                                            xcb_cursor_t           cursor,
+                                            uint32_t               detail,
+                                            xcb_input_device_id_t  deviceid,
+                                            uint16_t               num_modifiers,
+                                            uint16_t               mask_len,
+                                            uint8_t                grab_type,
+                                            uint8_t                grab_mode,
+                                            uint8_t                paired_device_mode,
+                                            uint8_t                owner_events,
+                                            const uint32_t        *mask,
+                                            const uint32_t        *modifiers)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_PASSIVE_GRAB_DEVICE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_input_xi_passive_grab_device_cookie_t xcb_ret;
+    xcb_input_xi_passive_grab_device_request_t xcb_out;
+
+    xcb_out.time = time;
+    xcb_out.grab_window = grab_window;
+    xcb_out.cursor = cursor;
+    xcb_out.detail = detail;
+    xcb_out.deviceid = deviceid;
+    xcb_out.num_modifiers = num_modifiers;
+    xcb_out.mask_len = mask_len;
+    xcb_out.grab_type = grab_type;
+    xcb_out.grab_mode = grab_mode;
+    xcb_out.paired_device_mode = paired_device_mode;
+    xcb_out.owner_events = owner_events;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t mask */
+    xcb_parts[4].iov_base = (char *) mask;
+    xcb_parts[4].iov_len = mask_len * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* uint32_t modifiers */
+    xcb_parts[6].iov_base = (char *) modifiers;
+    xcb_parts[6].iov_len = num_modifiers * sizeof(uint32_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_grab_modifier_info_t *
+xcb_input_xi_passive_grab_device_modifiers (const xcb_input_xi_passive_grab_device_reply_t *R)
+{
+    return (xcb_input_grab_modifier_info_t *) (R + 1);
+}
+
+int
+xcb_input_xi_passive_grab_device_modifiers_length (const xcb_input_xi_passive_grab_device_reply_t *R)
+{
+    return R->num_modifiers;
+}
+
+xcb_input_grab_modifier_info_iterator_t
+xcb_input_xi_passive_grab_device_modifiers_iterator (const xcb_input_xi_passive_grab_device_reply_t *R)
+{
+    xcb_input_grab_modifier_info_iterator_t i;
+    i.data = (xcb_input_grab_modifier_info_t *) (R + 1);
+    i.rem = R->num_modifiers;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_xi_passive_grab_device_reply_t *
+xcb_input_xi_passive_grab_device_reply (xcb_connection_t                           *c,
+                                        xcb_input_xi_passive_grab_device_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e)
+{
+    return (xcb_input_xi_passive_grab_device_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_input_xi_passive_ungrab_device_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_xi_passive_ungrab_device_request_t *_aux = (xcb_input_xi_passive_ungrab_device_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_xi_passive_ungrab_device_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* modifiers */
+    xcb_block_len += _aux->num_modifiers * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_passive_ungrab_device_checked (xcb_connection_t      *c,
+                                            xcb_window_t           grab_window,
+                                            uint32_t               detail,
+                                            xcb_input_device_id_t  deviceid,
+                                            uint16_t               num_modifiers,
+                                            uint8_t                grab_type,
+                                            const uint32_t        *modifiers)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_PASSIVE_UNGRAB_DEVICE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_passive_ungrab_device_request_t xcb_out;
+
+    xcb_out.grab_window = grab_window;
+    xcb_out.detail = detail;
+    xcb_out.deviceid = deviceid;
+    xcb_out.num_modifiers = num_modifiers;
+    xcb_out.grab_type = grab_type;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t modifiers */
+    xcb_parts[4].iov_base = (char *) modifiers;
+    xcb_parts[4].iov_len = num_modifiers * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_passive_ungrab_device (xcb_connection_t      *c,
+                                    xcb_window_t           grab_window,
+                                    uint32_t               detail,
+                                    xcb_input_device_id_t  deviceid,
+                                    uint16_t               num_modifiers,
+                                    uint8_t                grab_type,
+                                    const uint32_t        *modifiers)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_PASSIVE_UNGRAB_DEVICE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_passive_ungrab_device_request_t xcb_out;
+
+    xcb_out.grab_window = grab_window;
+    xcb_out.detail = detail;
+    xcb_out.deviceid = deviceid;
+    xcb_out.num_modifiers = num_modifiers;
+    xcb_out.grab_type = grab_type;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t modifiers */
+    xcb_parts[4].iov_base = (char *) modifiers;
+    xcb_parts[4].iov_len = num_modifiers * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_input_xi_passive_ungrab_device_modifiers (const xcb_input_xi_passive_ungrab_device_request_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_input_xi_passive_ungrab_device_modifiers_length (const xcb_input_xi_passive_ungrab_device_request_t *R)
+{
+    return R->num_modifiers;
+}
+
+xcb_generic_iterator_t
+xcb_input_xi_passive_ungrab_device_modifiers_end (const xcb_input_xi_passive_ungrab_device_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->num_modifiers);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_input_xi_list_properties_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_xi_list_properties_reply_t *_aux = (xcb_input_xi_list_properties_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_xi_list_properties_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* properties */
+    xcb_block_len += _aux->num_properties * sizeof(xcb_atom_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_atom_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_xi_list_properties_cookie_t
+xcb_input_xi_list_properties (xcb_connection_t      *c,
+                              xcb_input_device_id_t  deviceid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_LIST_PROPERTIES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_xi_list_properties_cookie_t xcb_ret;
+    xcb_input_xi_list_properties_request_t xcb_out;
+
+    xcb_out.deviceid = deviceid;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_xi_list_properties_cookie_t
+xcb_input_xi_list_properties_unchecked (xcb_connection_t      *c,
+                                        xcb_input_device_id_t  deviceid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_LIST_PROPERTIES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_xi_list_properties_cookie_t xcb_ret;
+    xcb_input_xi_list_properties_request_t xcb_out;
+
+    xcb_out.deviceid = deviceid;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_atom_t *
+xcb_input_xi_list_properties_properties (const xcb_input_xi_list_properties_reply_t *R)
+{
+    return (xcb_atom_t *) (R + 1);
+}
+
+int
+xcb_input_xi_list_properties_properties_length (const xcb_input_xi_list_properties_reply_t *R)
+{
+    return R->num_properties;
+}
+
+xcb_generic_iterator_t
+xcb_input_xi_list_properties_properties_end (const xcb_input_xi_list_properties_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_atom_t *) (R + 1)) + (R->num_properties);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_xi_list_properties_reply_t *
+xcb_input_xi_list_properties_reply (xcb_connection_t                       *c,
+                                    xcb_input_xi_list_properties_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e)
+{
+    return (xcb_input_xi_list_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+uint8_t *
+xcb_input_xi_change_property_items_data_8 (const xcb_input_xi_change_property_items_t *S)
+{
+    return S->data8;
+}
+
+int
+xcb_input_xi_change_property_items_data_8_length (const xcb_input_xi_change_property_request_t *R,
+                                                  const xcb_input_xi_change_property_items_t *S)
+{
+    return R->num_items;
+}
+
+xcb_generic_iterator_t
+xcb_input_xi_change_property_items_data_8_end (const xcb_input_xi_change_property_request_t *R,
+                                               const xcb_input_xi_change_property_items_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->data8 + R->num_items;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+uint16_t *
+xcb_input_xi_change_property_items_data_16 (const xcb_input_xi_change_property_items_t *S)
+{
+    return S->data16;
+}
+
+int
+xcb_input_xi_change_property_items_data_16_length (const xcb_input_xi_change_property_request_t *R,
+                                                   const xcb_input_xi_change_property_items_t *S)
+{
+    return R->num_items;
+}
+
+xcb_generic_iterator_t
+xcb_input_xi_change_property_items_data_16_end (const xcb_input_xi_change_property_request_t *R,
+                                                const xcb_input_xi_change_property_items_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->data16 + R->num_items;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+uint32_t *
+xcb_input_xi_change_property_items_data_32 (const xcb_input_xi_change_property_items_t *S)
+{
+    return S->data32;
+}
+
+int
+xcb_input_xi_change_property_items_data_32_length (const xcb_input_xi_change_property_request_t *R,
+                                                   const xcb_input_xi_change_property_items_t *S)
+{
+    return R->num_items;
+}
+
+xcb_generic_iterator_t
+xcb_input_xi_change_property_items_data_32_end (const xcb_input_xi_change_property_request_t *R,
+                                                const xcb_input_xi_change_property_items_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->data32 + R->num_items;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_input_xi_change_property_items_serialize (void                                       **_buffer,
+                                              uint32_t                                     num_items,
+                                              uint8_t                                      format,
+                                              const xcb_input_xi_change_property_items_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[9];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data8 */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data8;
+        xcb_block_len += num_items * sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data16 */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data16;
+        xcb_block_len += num_items * sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data32 */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data32;
+        xcb_block_len += num_items * sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_xi_change_property_items_unpack (const void                            *_buffer,
+                                           uint32_t                               num_items,
+                                           uint8_t                                format,
+                                           xcb_input_xi_change_property_items_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data8 */
+        _aux->data8 = (uint8_t *)xcb_tmp;
+        xcb_block_len += num_items * sizeof(uint8_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data16 */
+        _aux->data16 = (uint16_t *)xcb_tmp;
+        xcb_block_len += num_items * sizeof(uint16_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint16_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data32 */
+        _aux->data32 = (uint32_t *)xcb_tmp;
+        xcb_block_len += num_items * sizeof(uint32_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_xi_change_property_items_sizeof (const void  *_buffer,
+                                           uint32_t     num_items,
+                                           uint8_t      format)
+{
+    xcb_input_xi_change_property_items_t _aux;
+    return xcb_input_xi_change_property_items_unpack(_buffer, num_items, format, &_aux);
+}
+
+int
+xcb_input_xi_change_property_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_xi_change_property_request_t *_aux = (xcb_input_xi_change_property_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_xi_change_property_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* items */
+    xcb_block_len += xcb_input_xi_change_property_items_sizeof(xcb_tmp, _aux->num_items, _aux->format);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_change_property_checked (xcb_connection_t      *c,
+                                      xcb_input_device_id_t  deviceid,
+                                      uint8_t                mode,
+                                      uint8_t                format,
+                                      xcb_atom_t             property,
+                                      xcb_atom_t             type,
+                                      uint32_t               num_items,
+                                      const void            *items)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_CHANGE_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_change_property_request_t xcb_out;
+
+    xcb_out.deviceid = deviceid;
+    xcb_out.mode = mode;
+    xcb_out.format = format;
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.num_items = num_items;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_xi_change_property_items_t items */
+    xcb_parts[4].iov_base = (char *) items;
+    xcb_parts[4].iov_len =
+      xcb_input_xi_change_property_items_sizeof (items, num_items, format);
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_change_property (xcb_connection_t      *c,
+                              xcb_input_device_id_t  deviceid,
+                              uint8_t                mode,
+                              uint8_t                format,
+                              xcb_atom_t             property,
+                              xcb_atom_t             type,
+                              uint32_t               num_items,
+                              const void            *items)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_CHANGE_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_change_property_request_t xcb_out;
+
+    xcb_out.deviceid = deviceid;
+    xcb_out.mode = mode;
+    xcb_out.format = format;
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.num_items = num_items;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_xi_change_property_items_t items */
+    xcb_parts[4].iov_base = (char *) items;
+    xcb_parts[4].iov_len =
+      xcb_input_xi_change_property_items_sizeof (items, num_items, format);
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_change_property_aux_checked (xcb_connection_t                           *c,
+                                          xcb_input_device_id_t                       deviceid,
+                                          uint8_t                                     mode,
+                                          uint8_t                                     format,
+                                          xcb_atom_t                                  property,
+                                          xcb_atom_t                                  type,
+                                          uint32_t                                    num_items,
+                                          const xcb_input_xi_change_property_items_t *items)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_CHANGE_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_change_property_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.deviceid = deviceid;
+    xcb_out.mode = mode;
+    xcb_out.format = format;
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.num_items = num_items;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_xi_change_property_items_t items */
+    xcb_parts[4].iov_len =
+      xcb_input_xi_change_property_items_serialize (&xcb_aux0, num_items, format, items);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_change_property_aux (xcb_connection_t                           *c,
+                                  xcb_input_device_id_t                       deviceid,
+                                  uint8_t                                     mode,
+                                  uint8_t                                     format,
+                                  xcb_atom_t                                  property,
+                                  xcb_atom_t                                  type,
+                                  uint32_t                                    num_items,
+                                  const xcb_input_xi_change_property_items_t *items)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_CHANGE_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_change_property_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.deviceid = deviceid;
+    xcb_out.mode = mode;
+    xcb_out.format = format;
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.num_items = num_items;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_xi_change_property_items_t items */
+    xcb_parts[4].iov_len =
+      xcb_input_xi_change_property_items_serialize (&xcb_aux0, num_items, format, items);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+void *
+xcb_input_xi_change_property_items (const xcb_input_xi_change_property_request_t *R)
+{
+    return (void *) (R + 1);
+}
+
+xcb_void_cookie_t
+xcb_input_xi_delete_property_checked (xcb_connection_t      *c,
+                                      xcb_input_device_id_t  deviceid,
+                                      xcb_atom_t             property)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_DELETE_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_delete_property_request_t xcb_out;
+
+    xcb_out.deviceid = deviceid;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.property = property;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_delete_property (xcb_connection_t      *c,
+                              xcb_input_device_id_t  deviceid,
+                              xcb_atom_t             property)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_DELETE_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_delete_property_request_t xcb_out;
+
+    xcb_out.deviceid = deviceid;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.property = property;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_input_xi_get_property_items_data_8 (const xcb_input_xi_get_property_items_t *S)
+{
+    return S->data8;
+}
+
+int
+xcb_input_xi_get_property_items_data_8_length (const xcb_input_xi_get_property_reply_t *R,
+                                               const xcb_input_xi_get_property_items_t *S)
+{
+    return R->num_items;
+}
+
+xcb_generic_iterator_t
+xcb_input_xi_get_property_items_data_8_end (const xcb_input_xi_get_property_reply_t *R,
+                                            const xcb_input_xi_get_property_items_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->data8 + R->num_items;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+uint16_t *
+xcb_input_xi_get_property_items_data_16 (const xcb_input_xi_get_property_items_t *S)
+{
+    return S->data16;
+}
+
+int
+xcb_input_xi_get_property_items_data_16_length (const xcb_input_xi_get_property_reply_t *R,
+                                                const xcb_input_xi_get_property_items_t *S)
+{
+    return R->num_items;
+}
+
+xcb_generic_iterator_t
+xcb_input_xi_get_property_items_data_16_end (const xcb_input_xi_get_property_reply_t *R,
+                                             const xcb_input_xi_get_property_items_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->data16 + R->num_items;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+uint32_t *
+xcb_input_xi_get_property_items_data_32 (const xcb_input_xi_get_property_items_t *S)
+{
+    return S->data32;
+}
+
+int
+xcb_input_xi_get_property_items_data_32_length (const xcb_input_xi_get_property_reply_t *R,
+                                                const xcb_input_xi_get_property_items_t *S)
+{
+    return R->num_items;
+}
+
+xcb_generic_iterator_t
+xcb_input_xi_get_property_items_data_32_end (const xcb_input_xi_get_property_reply_t *R,
+                                             const xcb_input_xi_get_property_items_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->data32 + R->num_items;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_input_xi_get_property_items_serialize (void                                    **_buffer,
+                                           uint32_t                                  num_items,
+                                           uint8_t                                   format,
+                                           const xcb_input_xi_get_property_items_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[9];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data8 */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data8;
+        xcb_block_len += num_items * sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data16 */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data16;
+        xcb_block_len += num_items * sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data32 */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->data32;
+        xcb_block_len += num_items * sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = num_items * sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_xi_get_property_items_unpack (const void                         *_buffer,
+                                        uint32_t                            num_items,
+                                        uint8_t                             format,
+                                        xcb_input_xi_get_property_items_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if(format == XCB_INPUT_PROPERTY_FORMAT_8_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data8 */
+        _aux->data8 = (uint8_t *)xcb_tmp;
+        xcb_block_len += num_items * sizeof(uint8_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(format == XCB_INPUT_PROPERTY_FORMAT_16_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data16 */
+        _aux->data16 = (uint16_t *)xcb_tmp;
+        xcb_block_len += num_items * sizeof(uint16_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint16_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(format == XCB_INPUT_PROPERTY_FORMAT_32_BITS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* data32 */
+        _aux->data32 = (uint32_t *)xcb_tmp;
+        xcb_block_len += num_items * sizeof(uint32_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_xi_get_property_items_sizeof (const void  *_buffer,
+                                        uint32_t     num_items,
+                                        uint8_t      format)
+{
+    xcb_input_xi_get_property_items_t _aux;
+    return xcb_input_xi_get_property_items_unpack(_buffer, num_items, format, &_aux);
+}
+
+int
+xcb_input_xi_get_property_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_xi_get_property_reply_t *_aux = (xcb_input_xi_get_property_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_xi_get_property_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* items */
+    xcb_block_len += xcb_input_xi_get_property_items_sizeof(xcb_tmp, _aux->num_items, _aux->format);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_xi_get_property_cookie_t
+xcb_input_xi_get_property (xcb_connection_t      *c,
+                           xcb_input_device_id_t  deviceid,
+                           uint8_t                _delete,
+                           xcb_atom_t             property,
+                           xcb_atom_t             type,
+                           uint32_t               offset,
+                           uint32_t               len)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_GET_PROPERTY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_xi_get_property_cookie_t xcb_ret;
+    xcb_input_xi_get_property_request_t xcb_out;
+
+    xcb_out.deviceid = deviceid;
+    xcb_out._delete = _delete;
+    xcb_out.pad0 = 0;
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.offset = offset;
+    xcb_out.len = len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_xi_get_property_cookie_t
+xcb_input_xi_get_property_unchecked (xcb_connection_t      *c,
+                                     xcb_input_device_id_t  deviceid,
+                                     uint8_t                _delete,
+                                     xcb_atom_t             property,
+                                     xcb_atom_t             type,
+                                     uint32_t               offset,
+                                     uint32_t               len)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_GET_PROPERTY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_xi_get_property_cookie_t xcb_ret;
+    xcb_input_xi_get_property_request_t xcb_out;
+
+    xcb_out.deviceid = deviceid;
+    xcb_out._delete = _delete;
+    xcb_out.pad0 = 0;
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.offset = offset;
+    xcb_out.len = len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+void *
+xcb_input_xi_get_property_items (const xcb_input_xi_get_property_reply_t *R)
+{
+    return (void *) (R + 1);
+}
+
+xcb_input_xi_get_property_reply_t *
+xcb_input_xi_get_property_reply (xcb_connection_t                    *c,
+                                 xcb_input_xi_get_property_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e)
+{
+    return (xcb_input_xi_get_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_input_xi_get_selected_events_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_xi_get_selected_events_reply_t *_aux = (xcb_input_xi_get_selected_events_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_input_xi_get_selected_events_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* masks */
+    for(i=0; i<_aux->num_masks; i++) {
+        xcb_tmp_len = xcb_input_event_mask_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_input_event_mask_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_xi_get_selected_events_cookie_t
+xcb_input_xi_get_selected_events (xcb_connection_t *c,
+                                  xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_GET_SELECTED_EVENTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_xi_get_selected_events_cookie_t xcb_ret;
+    xcb_input_xi_get_selected_events_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_xi_get_selected_events_cookie_t
+xcb_input_xi_get_selected_events_unchecked (xcb_connection_t *c,
+                                            xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_GET_SELECTED_EVENTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_input_xi_get_selected_events_cookie_t xcb_ret;
+    xcb_input_xi_get_selected_events_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_input_xi_get_selected_events_masks_length (const xcb_input_xi_get_selected_events_reply_t *R)
+{
+    return R->num_masks;
+}
+
+xcb_input_event_mask_iterator_t
+xcb_input_xi_get_selected_events_masks_iterator (const xcb_input_xi_get_selected_events_reply_t *R)
+{
+    xcb_input_event_mask_iterator_t i;
+    i.data = (xcb_input_event_mask_t *) (R + 1);
+    i.rem = R->num_masks;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_xi_get_selected_events_reply_t *
+xcb_input_xi_get_selected_events_reply (xcb_connection_t                           *c,
+                                        xcb_input_xi_get_selected_events_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e)
+{
+    return (xcb_input_xi_get_selected_events_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+void
+xcb_input_barrier_release_pointer_info_next (xcb_input_barrier_release_pointer_info_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_barrier_release_pointer_info_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_barrier_release_pointer_info_end (xcb_input_barrier_release_pointer_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_input_xi_barrier_release_pointer_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_xi_barrier_release_pointer_request_t *_aux = (xcb_input_xi_barrier_release_pointer_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_xi_barrier_release_pointer_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* barriers */
+    xcb_block_len += _aux->num_barriers * sizeof(xcb_input_barrier_release_pointer_info_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_barrier_release_pointer_info_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_barrier_release_pointer_checked (xcb_connection_t                               *c,
+                                              uint32_t                                        num_barriers,
+                                              const xcb_input_barrier_release_pointer_info_t *barriers)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_BARRIER_RELEASE_POINTER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_barrier_release_pointer_request_t xcb_out;
+
+    xcb_out.num_barriers = num_barriers;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_barrier_release_pointer_info_t barriers */
+    xcb_parts[4].iov_base = (char *) barriers;
+    xcb_parts[4].iov_len = num_barriers * sizeof(xcb_input_barrier_release_pointer_info_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_xi_barrier_release_pointer (xcb_connection_t                               *c,
+                                      uint32_t                                        num_barriers,
+                                      const xcb_input_barrier_release_pointer_info_t *barriers)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_XI_BARRIER_RELEASE_POINTER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_xi_barrier_release_pointer_request_t xcb_out;
+
+    xcb_out.num_barriers = num_barriers;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_barrier_release_pointer_info_t barriers */
+    xcb_parts[4].iov_base = (char *) barriers;
+    xcb_parts[4].iov_len = num_barriers * sizeof(xcb_input_barrier_release_pointer_info_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_barrier_release_pointer_info_t *
+xcb_input_xi_barrier_release_pointer_barriers (const xcb_input_xi_barrier_release_pointer_request_t *R)
+{
+    return (xcb_input_barrier_release_pointer_info_t *) (R + 1);
+}
+
+int
+xcb_input_xi_barrier_release_pointer_barriers_length (const xcb_input_xi_barrier_release_pointer_request_t *R)
+{
+    return R->num_barriers;
+}
+
+xcb_input_barrier_release_pointer_info_iterator_t
+xcb_input_xi_barrier_release_pointer_barriers_iterator (const xcb_input_xi_barrier_release_pointer_request_t *R)
+{
+    xcb_input_barrier_release_pointer_info_iterator_t i;
+    i.data = (xcb_input_barrier_release_pointer_info_t *) (R + 1);
+    i.rem = R->num_barriers;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_input_device_changed_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_device_changed_event_t *_aux = (xcb_input_device_changed_event_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_input_device_changed_event_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* classes */
+    for(i=0; i<_aux->num_classes; i++) {
+        xcb_tmp_len = xcb_input_device_class_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_input_device_class_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_input_device_changed_classes_length (const xcb_input_device_changed_event_t *R)
+{
+    return R->num_classes;
+}
+
+xcb_input_device_class_iterator_t
+xcb_input_device_changed_classes_iterator (const xcb_input_device_changed_event_t *R)
+{
+    xcb_input_device_class_iterator_t i;
+    i.data = (xcb_input_device_class_t *) (R + 1);
+    i.rem = R->num_classes;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_input_key_press_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_key_press_event_t *_aux = (xcb_input_key_press_event_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    int xcb_pre_tmp_1; /* sumof length */
+    int xcb_pre_tmp_2; /* sumof loop counter */
+    int64_t xcb_pre_tmp_3; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */
+
+    xcb_block_len += sizeof(xcb_input_key_press_event_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* button_mask */
+    xcb_block_len += _aux->buttons_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* valuator_mask */
+    xcb_block_len += _aux->valuators_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* axisvalues */
+    /* sumof start */
+    xcb_pre_tmp_1 = _aux->valuators_len;
+    xcb_pre_tmp_3 = 0;
+    xcb_pre_tmp_4 = xcb_input_key_press_valuator_mask(_aux);
+    for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_4;
+        xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_4++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_3 */
+    xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+uint32_t *
+xcb_input_key_press_button_mask (const xcb_input_key_press_event_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_input_key_press_button_mask_length (const xcb_input_key_press_event_t *R)
+{
+    return R->buttons_len;
+}
+
+xcb_generic_iterator_t
+xcb_input_key_press_button_mask_end (const xcb_input_key_press_event_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->buttons_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint32_t *
+xcb_input_key_press_valuator_mask (const xcb_input_key_press_event_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_input_key_press_button_mask_end(R);
+    return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0);
+}
+
+int
+xcb_input_key_press_valuator_mask_length (const xcb_input_key_press_event_t *R)
+{
+    return R->valuators_len;
+}
+
+xcb_generic_iterator_t
+xcb_input_key_press_valuator_mask_end (const xcb_input_key_press_event_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_input_key_press_button_mask_end(R);
+    i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->valuators_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_fp3232_t *
+xcb_input_key_press_axisvalues (const xcb_input_key_press_event_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_input_key_press_valuator_mask_end(R);
+    return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0);
+}
+
+int
+xcb_input_key_press_axisvalues_length (const xcb_input_key_press_event_t *R)
+{
+    int xcb_pre_tmp_5; /* sumof length */
+    int xcb_pre_tmp_6; /* sumof loop counter */
+    int64_t xcb_pre_tmp_7; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_5 = R->valuators_len;
+    xcb_pre_tmp_7 = 0;
+    xcb_pre_tmp_8 = xcb_input_key_press_valuator_mask(R);
+    for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_8;
+        xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_8++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_7 */
+    return xcb_pre_tmp_7;
+}
+
+xcb_input_fp3232_iterator_t
+xcb_input_key_press_axisvalues_iterator (const xcb_input_key_press_event_t *R)
+{
+    xcb_input_fp3232_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_input_key_press_valuator_mask_end(R);
+    int xcb_pre_tmp_9; /* sumof length */
+    int xcb_pre_tmp_10; /* sumof loop counter */
+    int64_t xcb_pre_tmp_11; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_9 = R->valuators_len;
+    xcb_pre_tmp_11 = 0;
+    xcb_pre_tmp_12 = xcb_input_key_press_valuator_mask(R);
+    for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_12;
+        xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_12++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_11 */
+    i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index));
+    i.rem = xcb_pre_tmp_11;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_input_key_release_sizeof (const void  *_buffer  /**< */)
+{
+    return xcb_input_key_press_sizeof(_buffer);
+}
+
+int
+xcb_input_button_press_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_button_press_event_t *_aux = (xcb_input_button_press_event_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    int xcb_pre_tmp_1; /* sumof length */
+    int xcb_pre_tmp_2; /* sumof loop counter */
+    int64_t xcb_pre_tmp_3; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */
+
+    xcb_block_len += sizeof(xcb_input_button_press_event_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* button_mask */
+    xcb_block_len += _aux->buttons_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* valuator_mask */
+    xcb_block_len += _aux->valuators_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* axisvalues */
+    /* sumof start */
+    xcb_pre_tmp_1 = _aux->valuators_len;
+    xcb_pre_tmp_3 = 0;
+    xcb_pre_tmp_4 = xcb_input_button_press_valuator_mask(_aux);
+    for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_4;
+        xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_4++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_3 */
+    xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+uint32_t *
+xcb_input_button_press_button_mask (const xcb_input_button_press_event_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_input_button_press_button_mask_length (const xcb_input_button_press_event_t *R)
+{
+    return R->buttons_len;
+}
+
+xcb_generic_iterator_t
+xcb_input_button_press_button_mask_end (const xcb_input_button_press_event_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->buttons_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint32_t *
+xcb_input_button_press_valuator_mask (const xcb_input_button_press_event_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_input_button_press_button_mask_end(R);
+    return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0);
+}
+
+int
+xcb_input_button_press_valuator_mask_length (const xcb_input_button_press_event_t *R)
+{
+    return R->valuators_len;
+}
+
+xcb_generic_iterator_t
+xcb_input_button_press_valuator_mask_end (const xcb_input_button_press_event_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_input_button_press_button_mask_end(R);
+    i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->valuators_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_fp3232_t *
+xcb_input_button_press_axisvalues (const xcb_input_button_press_event_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_input_button_press_valuator_mask_end(R);
+    return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0);
+}
+
+int
+xcb_input_button_press_axisvalues_length (const xcb_input_button_press_event_t *R)
+{
+    int xcb_pre_tmp_5; /* sumof length */
+    int xcb_pre_tmp_6; /* sumof loop counter */
+    int64_t xcb_pre_tmp_7; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_5 = R->valuators_len;
+    xcb_pre_tmp_7 = 0;
+    xcb_pre_tmp_8 = xcb_input_button_press_valuator_mask(R);
+    for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_8;
+        xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_8++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_7 */
+    return xcb_pre_tmp_7;
+}
+
+xcb_input_fp3232_iterator_t
+xcb_input_button_press_axisvalues_iterator (const xcb_input_button_press_event_t *R)
+{
+    xcb_input_fp3232_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_input_button_press_valuator_mask_end(R);
+    int xcb_pre_tmp_9; /* sumof length */
+    int xcb_pre_tmp_10; /* sumof loop counter */
+    int64_t xcb_pre_tmp_11; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_9 = R->valuators_len;
+    xcb_pre_tmp_11 = 0;
+    xcb_pre_tmp_12 = xcb_input_button_press_valuator_mask(R);
+    for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_12;
+        xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_12++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_11 */
+    i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index));
+    i.rem = xcb_pre_tmp_11;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_input_button_release_sizeof (const void  *_buffer  /**< */)
+{
+    return xcb_input_button_press_sizeof(_buffer);
+}
+
+int
+xcb_input_motion_sizeof (const void  *_buffer  /**< */)
+{
+    return xcb_input_button_press_sizeof(_buffer);
+}
+
+int
+xcb_input_enter_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_enter_event_t *_aux = (xcb_input_enter_event_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_enter_event_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* buttons */
+    xcb_block_len += _aux->buttons_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+uint32_t *
+xcb_input_enter_buttons (const xcb_input_enter_event_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_input_enter_buttons_length (const xcb_input_enter_event_t *R)
+{
+    return R->buttons_len;
+}
+
+xcb_generic_iterator_t
+xcb_input_enter_buttons_end (const xcb_input_enter_event_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->buttons_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_input_leave_sizeof (const void  *_buffer  /**< */)
+{
+    return xcb_input_enter_sizeof(_buffer);
+}
+
+int
+xcb_input_focus_in_sizeof (const void  *_buffer  /**< */)
+{
+    return xcb_input_enter_sizeof(_buffer);
+}
+
+int
+xcb_input_focus_out_sizeof (const void  *_buffer  /**< */)
+{
+    return xcb_input_enter_sizeof(_buffer);
+}
+
+void
+xcb_input_hierarchy_info_next (xcb_input_hierarchy_info_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_hierarchy_info_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_hierarchy_info_end (xcb_input_hierarchy_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_input_hierarchy_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_hierarchy_event_t *_aux = (xcb_input_hierarchy_event_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_hierarchy_event_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* infos */
+    xcb_block_len += _aux->num_infos * sizeof(xcb_input_hierarchy_info_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_hierarchy_info_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_input_hierarchy_info_t *
+xcb_input_hierarchy_infos (const xcb_input_hierarchy_event_t *R)
+{
+    return (xcb_input_hierarchy_info_t *) (R + 1);
+}
+
+int
+xcb_input_hierarchy_infos_length (const xcb_input_hierarchy_event_t *R)
+{
+    return R->num_infos;
+}
+
+xcb_input_hierarchy_info_iterator_t
+xcb_input_hierarchy_infos_iterator (const xcb_input_hierarchy_event_t *R)
+{
+    xcb_input_hierarchy_info_iterator_t i;
+    i.data = (xcb_input_hierarchy_info_t *) (R + 1);
+    i.rem = R->num_infos;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_input_raw_key_press_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_raw_key_press_event_t *_aux = (xcb_input_raw_key_press_event_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    int xcb_pre_tmp_1; /* sumof length */
+    int xcb_pre_tmp_2; /* sumof loop counter */
+    int64_t xcb_pre_tmp_3; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */
+    int xcb_pre_tmp_5; /* sumof length */
+    int xcb_pre_tmp_6; /* sumof loop counter */
+    int64_t xcb_pre_tmp_7; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */
+
+    xcb_block_len += sizeof(xcb_input_raw_key_press_event_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* valuator_mask */
+    xcb_block_len += _aux->valuators_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* axisvalues */
+    /* sumof start */
+    xcb_pre_tmp_1 = _aux->valuators_len;
+    xcb_pre_tmp_3 = 0;
+    xcb_pre_tmp_4 = xcb_input_raw_key_press_valuator_mask(_aux);
+    for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_4;
+        xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_4++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_3 */
+    xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* axisvalues_raw */
+    /* sumof start */
+    xcb_pre_tmp_5 = _aux->valuators_len;
+    xcb_pre_tmp_7 = 0;
+    xcb_pre_tmp_8 = xcb_input_raw_key_press_valuator_mask(_aux);
+    for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_8;
+        xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_8++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_7 */
+    xcb_block_len += xcb_pre_tmp_7 * sizeof(xcb_input_fp3232_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+uint32_t *
+xcb_input_raw_key_press_valuator_mask (const xcb_input_raw_key_press_event_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_input_raw_key_press_valuator_mask_length (const xcb_input_raw_key_press_event_t *R)
+{
+    return R->valuators_len;
+}
+
+xcb_generic_iterator_t
+xcb_input_raw_key_press_valuator_mask_end (const xcb_input_raw_key_press_event_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->valuators_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_fp3232_t *
+xcb_input_raw_key_press_axisvalues (const xcb_input_raw_key_press_event_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_input_raw_key_press_valuator_mask_end(R);
+    return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0);
+}
+
+int
+xcb_input_raw_key_press_axisvalues_length (const xcb_input_raw_key_press_event_t *R)
+{
+    int xcb_pre_tmp_9; /* sumof length */
+    int xcb_pre_tmp_10; /* sumof loop counter */
+    int64_t xcb_pre_tmp_11; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_9 = R->valuators_len;
+    xcb_pre_tmp_11 = 0;
+    xcb_pre_tmp_12 = xcb_input_raw_key_press_valuator_mask(R);
+    for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_12;
+        xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_12++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_11 */
+    return xcb_pre_tmp_11;
+}
+
+xcb_input_fp3232_iterator_t
+xcb_input_raw_key_press_axisvalues_iterator (const xcb_input_raw_key_press_event_t *R)
+{
+    xcb_input_fp3232_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_input_raw_key_press_valuator_mask_end(R);
+    int xcb_pre_tmp_13; /* sumof length */
+    int xcb_pre_tmp_14; /* sumof loop counter */
+    int64_t xcb_pre_tmp_15; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_16; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_13 = R->valuators_len;
+    xcb_pre_tmp_15 = 0;
+    xcb_pre_tmp_16 = xcb_input_raw_key_press_valuator_mask(R);
+    for (xcb_pre_tmp_14 = 0; xcb_pre_tmp_14 < xcb_pre_tmp_13; xcb_pre_tmp_14++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_16;
+        xcb_pre_tmp_15 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_16++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_15 */
+    i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index));
+    i.rem = xcb_pre_tmp_15;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_fp3232_t *
+xcb_input_raw_key_press_axisvalues_raw (const xcb_input_raw_key_press_event_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_key_press_axisvalues_iterator(R));
+    return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0);
+}
+
+int
+xcb_input_raw_key_press_axisvalues_raw_length (const xcb_input_raw_key_press_event_t *R)
+{
+    int xcb_pre_tmp_17; /* sumof length */
+    int xcb_pre_tmp_18; /* sumof loop counter */
+    int64_t xcb_pre_tmp_19; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_20; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_17 = R->valuators_len;
+    xcb_pre_tmp_19 = 0;
+    xcb_pre_tmp_20 = xcb_input_raw_key_press_valuator_mask(R);
+    for (xcb_pre_tmp_18 = 0; xcb_pre_tmp_18 < xcb_pre_tmp_17; xcb_pre_tmp_18++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_20;
+        xcb_pre_tmp_19 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_20++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_19 */
+    return xcb_pre_tmp_19;
+}
+
+xcb_input_fp3232_iterator_t
+xcb_input_raw_key_press_axisvalues_raw_iterator (const xcb_input_raw_key_press_event_t *R)
+{
+    xcb_input_fp3232_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_key_press_axisvalues_iterator(R));
+    int xcb_pre_tmp_21; /* sumof length */
+    int xcb_pre_tmp_22; /* sumof loop counter */
+    int64_t xcb_pre_tmp_23; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_24; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_21 = R->valuators_len;
+    xcb_pre_tmp_23 = 0;
+    xcb_pre_tmp_24 = xcb_input_raw_key_press_valuator_mask(R);
+    for (xcb_pre_tmp_22 = 0; xcb_pre_tmp_22 < xcb_pre_tmp_21; xcb_pre_tmp_22++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_24;
+        xcb_pre_tmp_23 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_24++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_23 */
+    i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index));
+    i.rem = xcb_pre_tmp_23;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_input_raw_key_release_sizeof (const void  *_buffer  /**< */)
+{
+    return xcb_input_raw_key_press_sizeof(_buffer);
+}
+
+int
+xcb_input_raw_button_press_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_raw_button_press_event_t *_aux = (xcb_input_raw_button_press_event_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    int xcb_pre_tmp_1; /* sumof length */
+    int xcb_pre_tmp_2; /* sumof loop counter */
+    int64_t xcb_pre_tmp_3; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */
+    int xcb_pre_tmp_5; /* sumof length */
+    int xcb_pre_tmp_6; /* sumof loop counter */
+    int64_t xcb_pre_tmp_7; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */
+
+    xcb_block_len += sizeof(xcb_input_raw_button_press_event_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* valuator_mask */
+    xcb_block_len += _aux->valuators_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* axisvalues */
+    /* sumof start */
+    xcb_pre_tmp_1 = _aux->valuators_len;
+    xcb_pre_tmp_3 = 0;
+    xcb_pre_tmp_4 = xcb_input_raw_button_press_valuator_mask(_aux);
+    for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_4;
+        xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_4++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_3 */
+    xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* axisvalues_raw */
+    /* sumof start */
+    xcb_pre_tmp_5 = _aux->valuators_len;
+    xcb_pre_tmp_7 = 0;
+    xcb_pre_tmp_8 = xcb_input_raw_button_press_valuator_mask(_aux);
+    for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_8;
+        xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_8++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_7 */
+    xcb_block_len += xcb_pre_tmp_7 * sizeof(xcb_input_fp3232_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+uint32_t *
+xcb_input_raw_button_press_valuator_mask (const xcb_input_raw_button_press_event_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_input_raw_button_press_valuator_mask_length (const xcb_input_raw_button_press_event_t *R)
+{
+    return R->valuators_len;
+}
+
+xcb_generic_iterator_t
+xcb_input_raw_button_press_valuator_mask_end (const xcb_input_raw_button_press_event_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->valuators_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_fp3232_t *
+xcb_input_raw_button_press_axisvalues (const xcb_input_raw_button_press_event_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_input_raw_button_press_valuator_mask_end(R);
+    return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0);
+}
+
+int
+xcb_input_raw_button_press_axisvalues_length (const xcb_input_raw_button_press_event_t *R)
+{
+    int xcb_pre_tmp_9; /* sumof length */
+    int xcb_pre_tmp_10; /* sumof loop counter */
+    int64_t xcb_pre_tmp_11; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_9 = R->valuators_len;
+    xcb_pre_tmp_11 = 0;
+    xcb_pre_tmp_12 = xcb_input_raw_button_press_valuator_mask(R);
+    for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_12;
+        xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_12++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_11 */
+    return xcb_pre_tmp_11;
+}
+
+xcb_input_fp3232_iterator_t
+xcb_input_raw_button_press_axisvalues_iterator (const xcb_input_raw_button_press_event_t *R)
+{
+    xcb_input_fp3232_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_input_raw_button_press_valuator_mask_end(R);
+    int xcb_pre_tmp_13; /* sumof length */
+    int xcb_pre_tmp_14; /* sumof loop counter */
+    int64_t xcb_pre_tmp_15; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_16; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_13 = R->valuators_len;
+    xcb_pre_tmp_15 = 0;
+    xcb_pre_tmp_16 = xcb_input_raw_button_press_valuator_mask(R);
+    for (xcb_pre_tmp_14 = 0; xcb_pre_tmp_14 < xcb_pre_tmp_13; xcb_pre_tmp_14++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_16;
+        xcb_pre_tmp_15 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_16++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_15 */
+    i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index));
+    i.rem = xcb_pre_tmp_15;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_fp3232_t *
+xcb_input_raw_button_press_axisvalues_raw (const xcb_input_raw_button_press_event_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_button_press_axisvalues_iterator(R));
+    return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0);
+}
+
+int
+xcb_input_raw_button_press_axisvalues_raw_length (const xcb_input_raw_button_press_event_t *R)
+{
+    int xcb_pre_tmp_17; /* sumof length */
+    int xcb_pre_tmp_18; /* sumof loop counter */
+    int64_t xcb_pre_tmp_19; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_20; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_17 = R->valuators_len;
+    xcb_pre_tmp_19 = 0;
+    xcb_pre_tmp_20 = xcb_input_raw_button_press_valuator_mask(R);
+    for (xcb_pre_tmp_18 = 0; xcb_pre_tmp_18 < xcb_pre_tmp_17; xcb_pre_tmp_18++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_20;
+        xcb_pre_tmp_19 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_20++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_19 */
+    return xcb_pre_tmp_19;
+}
+
+xcb_input_fp3232_iterator_t
+xcb_input_raw_button_press_axisvalues_raw_iterator (const xcb_input_raw_button_press_event_t *R)
+{
+    xcb_input_fp3232_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_button_press_axisvalues_iterator(R));
+    int xcb_pre_tmp_21; /* sumof length */
+    int xcb_pre_tmp_22; /* sumof loop counter */
+    int64_t xcb_pre_tmp_23; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_24; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_21 = R->valuators_len;
+    xcb_pre_tmp_23 = 0;
+    xcb_pre_tmp_24 = xcb_input_raw_button_press_valuator_mask(R);
+    for (xcb_pre_tmp_22 = 0; xcb_pre_tmp_22 < xcb_pre_tmp_21; xcb_pre_tmp_22++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_24;
+        xcb_pre_tmp_23 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_24++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_23 */
+    i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index));
+    i.rem = xcb_pre_tmp_23;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_input_raw_button_release_sizeof (const void  *_buffer  /**< */)
+{
+    return xcb_input_raw_button_press_sizeof(_buffer);
+}
+
+int
+xcb_input_raw_motion_sizeof (const void  *_buffer  /**< */)
+{
+    return xcb_input_raw_button_press_sizeof(_buffer);
+}
+
+int
+xcb_input_touch_begin_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_touch_begin_event_t *_aux = (xcb_input_touch_begin_event_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    int xcb_pre_tmp_1; /* sumof length */
+    int xcb_pre_tmp_2; /* sumof loop counter */
+    int64_t xcb_pre_tmp_3; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */
+
+    xcb_block_len += sizeof(xcb_input_touch_begin_event_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* button_mask */
+    xcb_block_len += _aux->buttons_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* valuator_mask */
+    xcb_block_len += _aux->valuators_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* axisvalues */
+    /* sumof start */
+    xcb_pre_tmp_1 = _aux->valuators_len;
+    xcb_pre_tmp_3 = 0;
+    xcb_pre_tmp_4 = xcb_input_touch_begin_valuator_mask(_aux);
+    for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_4;
+        xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_4++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_3 */
+    xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+uint32_t *
+xcb_input_touch_begin_button_mask (const xcb_input_touch_begin_event_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_input_touch_begin_button_mask_length (const xcb_input_touch_begin_event_t *R)
+{
+    return R->buttons_len;
+}
+
+xcb_generic_iterator_t
+xcb_input_touch_begin_button_mask_end (const xcb_input_touch_begin_event_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->buttons_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint32_t *
+xcb_input_touch_begin_valuator_mask (const xcb_input_touch_begin_event_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_input_touch_begin_button_mask_end(R);
+    return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0);
+}
+
+int
+xcb_input_touch_begin_valuator_mask_length (const xcb_input_touch_begin_event_t *R)
+{
+    return R->valuators_len;
+}
+
+xcb_generic_iterator_t
+xcb_input_touch_begin_valuator_mask_end (const xcb_input_touch_begin_event_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_input_touch_begin_button_mask_end(R);
+    i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->valuators_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_fp3232_t *
+xcb_input_touch_begin_axisvalues (const xcb_input_touch_begin_event_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_input_touch_begin_valuator_mask_end(R);
+    return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0);
+}
+
+int
+xcb_input_touch_begin_axisvalues_length (const xcb_input_touch_begin_event_t *R)
+{
+    int xcb_pre_tmp_5; /* sumof length */
+    int xcb_pre_tmp_6; /* sumof loop counter */
+    int64_t xcb_pre_tmp_7; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_5 = R->valuators_len;
+    xcb_pre_tmp_7 = 0;
+    xcb_pre_tmp_8 = xcb_input_touch_begin_valuator_mask(R);
+    for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_8;
+        xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_8++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_7 */
+    return xcb_pre_tmp_7;
+}
+
+xcb_input_fp3232_iterator_t
+xcb_input_touch_begin_axisvalues_iterator (const xcb_input_touch_begin_event_t *R)
+{
+    xcb_input_fp3232_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_input_touch_begin_valuator_mask_end(R);
+    int xcb_pre_tmp_9; /* sumof length */
+    int xcb_pre_tmp_10; /* sumof loop counter */
+    int64_t xcb_pre_tmp_11; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_9 = R->valuators_len;
+    xcb_pre_tmp_11 = 0;
+    xcb_pre_tmp_12 = xcb_input_touch_begin_valuator_mask(R);
+    for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_12;
+        xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_12++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_11 */
+    i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index));
+    i.rem = xcb_pre_tmp_11;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_input_touch_update_sizeof (const void  *_buffer  /**< */)
+{
+    return xcb_input_touch_begin_sizeof(_buffer);
+}
+
+int
+xcb_input_touch_end_sizeof (const void  *_buffer  /**< */)
+{
+    return xcb_input_touch_begin_sizeof(_buffer);
+}
+
+int
+xcb_input_raw_touch_begin_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_raw_touch_begin_event_t *_aux = (xcb_input_raw_touch_begin_event_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    int xcb_pre_tmp_1; /* sumof length */
+    int xcb_pre_tmp_2; /* sumof loop counter */
+    int64_t xcb_pre_tmp_3; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_4; /* sumof list ptr */
+    int xcb_pre_tmp_5; /* sumof length */
+    int xcb_pre_tmp_6; /* sumof loop counter */
+    int64_t xcb_pre_tmp_7; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_8; /* sumof list ptr */
+
+    xcb_block_len += sizeof(xcb_input_raw_touch_begin_event_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* valuator_mask */
+    xcb_block_len += _aux->valuators_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* axisvalues */
+    /* sumof start */
+    xcb_pre_tmp_1 = _aux->valuators_len;
+    xcb_pre_tmp_3 = 0;
+    xcb_pre_tmp_4 = xcb_input_raw_touch_begin_valuator_mask(_aux);
+    for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_4;
+        xcb_pre_tmp_3 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_4++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_3 */
+    xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_input_fp3232_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* axisvalues_raw */
+    /* sumof start */
+    xcb_pre_tmp_5 = _aux->valuators_len;
+    xcb_pre_tmp_7 = 0;
+    xcb_pre_tmp_8 = xcb_input_raw_touch_begin_valuator_mask(_aux);
+    for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_8;
+        xcb_pre_tmp_7 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_8++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_7 */
+    xcb_block_len += xcb_pre_tmp_7 * sizeof(xcb_input_fp3232_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_fp3232_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+uint32_t *
+xcb_input_raw_touch_begin_valuator_mask (const xcb_input_raw_touch_begin_event_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_input_raw_touch_begin_valuator_mask_length (const xcb_input_raw_touch_begin_event_t *R)
+{
+    return R->valuators_len;
+}
+
+xcb_generic_iterator_t
+xcb_input_raw_touch_begin_valuator_mask_end (const xcb_input_raw_touch_begin_event_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->valuators_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_fp3232_t *
+xcb_input_raw_touch_begin_axisvalues (const xcb_input_raw_touch_begin_event_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_input_raw_touch_begin_valuator_mask_end(R);
+    return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0);
+}
+
+int
+xcb_input_raw_touch_begin_axisvalues_length (const xcb_input_raw_touch_begin_event_t *R)
+{
+    int xcb_pre_tmp_9; /* sumof length */
+    int xcb_pre_tmp_10; /* sumof loop counter */
+    int64_t xcb_pre_tmp_11; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_12; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_9 = R->valuators_len;
+    xcb_pre_tmp_11 = 0;
+    xcb_pre_tmp_12 = xcb_input_raw_touch_begin_valuator_mask(R);
+    for (xcb_pre_tmp_10 = 0; xcb_pre_tmp_10 < xcb_pre_tmp_9; xcb_pre_tmp_10++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_12;
+        xcb_pre_tmp_11 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_12++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_11 */
+    return xcb_pre_tmp_11;
+}
+
+xcb_input_fp3232_iterator_t
+xcb_input_raw_touch_begin_axisvalues_iterator (const xcb_input_raw_touch_begin_event_t *R)
+{
+    xcb_input_fp3232_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_input_raw_touch_begin_valuator_mask_end(R);
+    int xcb_pre_tmp_13; /* sumof length */
+    int xcb_pre_tmp_14; /* sumof loop counter */
+    int64_t xcb_pre_tmp_15; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_16; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_13 = R->valuators_len;
+    xcb_pre_tmp_15 = 0;
+    xcb_pre_tmp_16 = xcb_input_raw_touch_begin_valuator_mask(R);
+    for (xcb_pre_tmp_14 = 0; xcb_pre_tmp_14 < xcb_pre_tmp_13; xcb_pre_tmp_14++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_16;
+        xcb_pre_tmp_15 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_16++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_15 */
+    i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index));
+    i.rem = xcb_pre_tmp_15;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_fp3232_t *
+xcb_input_raw_touch_begin_axisvalues_raw (const xcb_input_raw_touch_begin_event_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_touch_begin_axisvalues_iterator(R));
+    return (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index) + 0);
+}
+
+int
+xcb_input_raw_touch_begin_axisvalues_raw_length (const xcb_input_raw_touch_begin_event_t *R)
+{
+    int xcb_pre_tmp_17; /* sumof length */
+    int xcb_pre_tmp_18; /* sumof loop counter */
+    int64_t xcb_pre_tmp_19; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_20; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_17 = R->valuators_len;
+    xcb_pre_tmp_19 = 0;
+    xcb_pre_tmp_20 = xcb_input_raw_touch_begin_valuator_mask(R);
+    for (xcb_pre_tmp_18 = 0; xcb_pre_tmp_18 < xcb_pre_tmp_17; xcb_pre_tmp_18++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_20;
+        xcb_pre_tmp_19 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_20++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_19 */
+    return xcb_pre_tmp_19;
+}
+
+xcb_input_fp3232_iterator_t
+xcb_input_raw_touch_begin_axisvalues_raw_iterator (const xcb_input_raw_touch_begin_event_t *R)
+{
+    xcb_input_fp3232_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_input_fp3232_end(xcb_input_raw_touch_begin_axisvalues_iterator(R));
+    int xcb_pre_tmp_21; /* sumof length */
+    int xcb_pre_tmp_22; /* sumof loop counter */
+    int64_t xcb_pre_tmp_23; /* sumof sum */
+    const uint32_t* xcb_pre_tmp_24; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_21 = R->valuators_len;
+    xcb_pre_tmp_23 = 0;
+    xcb_pre_tmp_24 = xcb_input_raw_touch_begin_valuator_mask(R);
+    for (xcb_pre_tmp_22 = 0; xcb_pre_tmp_22 < xcb_pre_tmp_21; xcb_pre_tmp_22++) {
+        const uint32_t *xcb_listelement = xcb_pre_tmp_24;
+        xcb_pre_tmp_23 += xcb_popcount((*xcb_listelement));
+        xcb_pre_tmp_24++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_23 */
+    i.data = (xcb_input_fp3232_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_fp3232_t, prev.index));
+    i.rem = xcb_pre_tmp_23;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_input_raw_touch_update_sizeof (const void  *_buffer  /**< */)
+{
+    return xcb_input_raw_touch_begin_sizeof(_buffer);
+}
+
+int
+xcb_input_raw_touch_end_sizeof (const void  *_buffer  /**< */)
+{
+    return xcb_input_raw_touch_begin_sizeof(_buffer);
+}
+
+void
+xcb_input_event_for_send_next (xcb_input_event_for_send_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_input_event_for_send_t);
+}
+
+xcb_generic_iterator_t
+xcb_input_event_for_send_end (xcb_input_event_for_send_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_input_send_extension_event_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_input_send_extension_event_request_t *_aux = (xcb_input_send_extension_event_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_input_send_extension_event_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* events */
+    xcb_block_len += _aux->num_events * sizeof(xcb_input_event_for_send_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_event_for_send_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* classes */
+    xcb_block_len += _aux->num_classes * sizeof(xcb_input_event_class_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_input_event_class_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_input_send_extension_event_checked (xcb_connection_t                 *c,
+                                        xcb_window_t                      destination,
+                                        uint8_t                           device_id,
+                                        uint8_t                           propagate,
+                                        uint16_t                          num_classes,
+                                        uint8_t                           num_events,
+                                        const xcb_input_event_for_send_t *events,
+                                        const xcb_input_event_class_t    *classes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_SEND_EXTENSION_EVENT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_send_extension_event_request_t xcb_out;
+
+    xcb_out.destination = destination;
+    xcb_out.device_id = device_id;
+    xcb_out.propagate = propagate;
+    xcb_out.num_classes = num_classes;
+    xcb_out.num_events = num_events;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_event_for_send_t events */
+    xcb_parts[4].iov_base = (char *) events;
+    xcb_parts[4].iov_len = num_events * sizeof(xcb_input_event_for_send_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_input_event_class_t classes */
+    xcb_parts[6].iov_base = (char *) classes;
+    xcb_parts[6].iov_len = num_classes * sizeof(xcb_input_event_class_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_input_send_extension_event (xcb_connection_t                 *c,
+                                xcb_window_t                      destination,
+                                uint8_t                           device_id,
+                                uint8_t                           propagate,
+                                uint16_t                          num_classes,
+                                uint8_t                           num_events,
+                                const xcb_input_event_for_send_t *events,
+                                const xcb_input_event_class_t    *classes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_input_id,
+        .opcode = XCB_INPUT_SEND_EXTENSION_EVENT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_input_send_extension_event_request_t xcb_out;
+
+    xcb_out.destination = destination;
+    xcb_out.device_id = device_id;
+    xcb_out.propagate = propagate;
+    xcb_out.num_classes = num_classes;
+    xcb_out.num_events = num_events;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_input_event_for_send_t events */
+    xcb_parts[4].iov_base = (char *) events;
+    xcb_parts[4].iov_len = num_events * sizeof(xcb_input_event_for_send_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_input_event_class_t classes */
+    xcb_parts[6].iov_base = (char *) classes;
+    xcb_parts[6].iov_len = num_classes * sizeof(xcb_input_event_class_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_input_event_for_send_t *
+xcb_input_send_extension_event_events (const xcb_input_send_extension_event_request_t *R)
+{
+    return (xcb_input_event_for_send_t *) (R + 1);
+}
+
+int
+xcb_input_send_extension_event_events_length (const xcb_input_send_extension_event_request_t *R)
+{
+    return R->num_events;
+}
+
+xcb_input_event_for_send_iterator_t
+xcb_input_send_extension_event_events_iterator (const xcb_input_send_extension_event_request_t *R)
+{
+    xcb_input_event_for_send_iterator_t i;
+    i.data = (xcb_input_event_for_send_t *) (R + 1);
+    i.rem = R->num_events;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_input_event_class_t *
+xcb_input_send_extension_event_classes (const xcb_input_send_extension_event_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_input_event_for_send_end(xcb_input_send_extension_event_events_iterator(R));
+    return (xcb_input_event_class_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_input_event_class_t, prev.index) + 0);
+}
+
+int
+xcb_input_send_extension_event_classes_length (const xcb_input_send_extension_event_request_t *R)
+{
+    return R->num_classes;
+}
+
+xcb_generic_iterator_t
+xcb_input_send_extension_event_classes_end (const xcb_input_send_extension_event_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_input_event_for_send_end(xcb_input_send_extension_event_events_iterator(R));
+    i.data = ((xcb_input_event_class_t *) ((char*) prev.data + XCB_TYPE_PAD(xcb_input_event_class_t, prev.index))) + (R->num_classes);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
diff --git a/depends/libxcb/src/xkb.c b/depends/libxcb/src/xkb.c
new file mode 100644
index 0000000..6aee964
--- /dev/null
+++ b/depends/libxcb/src/xkb.c
@@ -0,0 +1,11625 @@
+/*
+ * This file generated automatically from xkb.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "xkb.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xproto.h"
+
+xcb_extension_t xcb_xkb_id = { "XKEYBOARD", 0 };
+
+void
+xcb_xkb_device_spec_next (xcb_xkb_device_spec_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_device_spec_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_device_spec_end (xcb_xkb_device_spec_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_led_class_spec_next (xcb_xkb_led_class_spec_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_led_class_spec_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_led_class_spec_end (xcb_xkb_led_class_spec_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_bell_class_spec_next (xcb_xkb_bell_class_spec_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_bell_class_spec_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_bell_class_spec_end (xcb_xkb_bell_class_spec_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_id_spec_next (xcb_xkb_id_spec_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_id_spec_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_id_spec_end (xcb_xkb_id_spec_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_indicator_map_next (xcb_xkb_indicator_map_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_indicator_map_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_indicator_map_end (xcb_xkb_indicator_map_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_mod_def_next (xcb_xkb_mod_def_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_mod_def_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_mod_def_end (xcb_xkb_mod_def_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_key_name_next (xcb_xkb_key_name_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_key_name_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_key_name_end (xcb_xkb_key_name_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_key_alias_next (xcb_xkb_key_alias_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_key_alias_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_key_alias_end (xcb_xkb_key_alias_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_xkb_counted_string_16_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_counted_string_16_t *_aux = (xcb_xkb_counted_string_16_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xkb_counted_string_16_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* string */
+    xcb_block_len += _aux->length * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* alignment_pad */
+    xcb_block_len += (((_aux->length + 5) & (~3)) - (_aux->length + 2)) * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+char *
+xcb_xkb_counted_string_16_string (const xcb_xkb_counted_string_16_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_xkb_counted_string_16_string_length (const xcb_xkb_counted_string_16_t *R)
+{
+    return R->length;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_counted_string_16_string_end (const xcb_xkb_counted_string_16_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->length);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void *
+xcb_xkb_counted_string_16_alignment_pad (const xcb_xkb_counted_string_16_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_xkb_counted_string_16_string_end(R);
+    return (void *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0);
+}
+
+int
+xcb_xkb_counted_string_16_alignment_pad_length (const xcb_xkb_counted_string_16_t *R)
+{
+    return (((R->length + 5) & (~3)) - (R->length + 2));
+}
+
+xcb_generic_iterator_t
+xcb_xkb_counted_string_16_alignment_pad_end (const xcb_xkb_counted_string_16_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_xkb_counted_string_16_string_end(R);
+    i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + ((((R->length + 5) & (~3)) - (R->length + 2)));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_xkb_counted_string_16_next (xcb_xkb_counted_string_16_iterator_t *i)
+{
+    xcb_xkb_counted_string_16_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_xkb_counted_string_16_t *)(((char *)R) + xcb_xkb_counted_string_16_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_xkb_counted_string_16_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_counted_string_16_end (xcb_xkb_counted_string_16_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_xkb_counted_string_16_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+void
+xcb_xkb_kt_map_entry_next (xcb_xkb_kt_map_entry_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_kt_map_entry_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_kt_map_entry_end (xcb_xkb_kt_map_entry_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_xkb_key_type_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_key_type_t *_aux = (xcb_xkb_key_type_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xkb_key_type_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* map */
+    xcb_block_len += _aux->nMapEntries * sizeof(xcb_xkb_kt_map_entry_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xkb_kt_map_entry_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* preserve */
+    xcb_block_len += (_aux->hasPreserve * _aux->nMapEntries) * sizeof(xcb_xkb_mod_def_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xkb_mod_def_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xkb_kt_map_entry_t *
+xcb_xkb_key_type_map (const xcb_xkb_key_type_t *R)
+{
+    return (xcb_xkb_kt_map_entry_t *) (R + 1);
+}
+
+int
+xcb_xkb_key_type_map_length (const xcb_xkb_key_type_t *R)
+{
+    return R->nMapEntries;
+}
+
+xcb_xkb_kt_map_entry_iterator_t
+xcb_xkb_key_type_map_iterator (const xcb_xkb_key_type_t *R)
+{
+    xcb_xkb_kt_map_entry_iterator_t i;
+    i.data = (xcb_xkb_kt_map_entry_t *) (R + 1);
+    i.rem = R->nMapEntries;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xkb_mod_def_t *
+xcb_xkb_key_type_preserve (const xcb_xkb_key_type_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_xkb_kt_map_entry_end(xcb_xkb_key_type_map_iterator(R));
+    return (xcb_xkb_mod_def_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_mod_def_t, prev.index) + 0);
+}
+
+int
+xcb_xkb_key_type_preserve_length (const xcb_xkb_key_type_t *R)
+{
+    return (R->hasPreserve * R->nMapEntries);
+}
+
+xcb_xkb_mod_def_iterator_t
+xcb_xkb_key_type_preserve_iterator (const xcb_xkb_key_type_t *R)
+{
+    xcb_xkb_mod_def_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_xkb_kt_map_entry_end(xcb_xkb_key_type_map_iterator(R));
+    i.data = (xcb_xkb_mod_def_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_mod_def_t, prev.index));
+    i.rem = (R->hasPreserve * R->nMapEntries);
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_xkb_key_type_next (xcb_xkb_key_type_iterator_t *i)
+{
+    xcb_xkb_key_type_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_xkb_key_type_t *)(((char *)R) + xcb_xkb_key_type_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_xkb_key_type_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_key_type_end (xcb_xkb_key_type_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_xkb_key_type_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_xkb_key_sym_map_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_key_sym_map_t *_aux = (xcb_xkb_key_sym_map_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xkb_key_sym_map_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* syms */
+    xcb_block_len += _aux->nSyms * sizeof(xcb_keysym_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_keysym_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_keysym_t *
+xcb_xkb_key_sym_map_syms (const xcb_xkb_key_sym_map_t *R)
+{
+    return (xcb_keysym_t *) (R + 1);
+}
+
+int
+xcb_xkb_key_sym_map_syms_length (const xcb_xkb_key_sym_map_t *R)
+{
+    return R->nSyms;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_key_sym_map_syms_end (const xcb_xkb_key_sym_map_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_keysym_t *) (R + 1)) + (R->nSyms);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_xkb_key_sym_map_next (xcb_xkb_key_sym_map_iterator_t *i)
+{
+    xcb_xkb_key_sym_map_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_xkb_key_sym_map_t *)(((char *)R) + xcb_xkb_key_sym_map_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_xkb_key_sym_map_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_key_sym_map_end (xcb_xkb_key_sym_map_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_xkb_key_sym_map_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+void
+xcb_xkb_common_behavior_next (xcb_xkb_common_behavior_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_common_behavior_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_common_behavior_end (xcb_xkb_common_behavior_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_default_behavior_next (xcb_xkb_default_behavior_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_default_behavior_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_default_behavior_end (xcb_xkb_default_behavior_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_lock_behavior_next (xcb_xkb_lock_behavior_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_lock_behavior_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_lock_behavior_end (xcb_xkb_lock_behavior_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_radio_group_behavior_next (xcb_xkb_radio_group_behavior_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_radio_group_behavior_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_radio_group_behavior_end (xcb_xkb_radio_group_behavior_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_overlay_behavior_next (xcb_xkb_overlay_behavior_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_overlay_behavior_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_overlay_behavior_end (xcb_xkb_overlay_behavior_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_permament_lock_behavior_next (xcb_xkb_permament_lock_behavior_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_permament_lock_behavior_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_permament_lock_behavior_end (xcb_xkb_permament_lock_behavior_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_permament_radio_group_behavior_next (xcb_xkb_permament_radio_group_behavior_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_permament_radio_group_behavior_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_permament_radio_group_behavior_end (xcb_xkb_permament_radio_group_behavior_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_permament_overlay_behavior_next (xcb_xkb_permament_overlay_behavior_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_permament_overlay_behavior_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_permament_overlay_behavior_end (xcb_xkb_permament_overlay_behavior_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_behavior_next (xcb_xkb_behavior_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_behavior_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_behavior_end (xcb_xkb_behavior_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_set_behavior_next (xcb_xkb_set_behavior_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_set_behavior_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_set_behavior_end (xcb_xkb_set_behavior_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_set_explicit_next (xcb_xkb_set_explicit_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_set_explicit_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_set_explicit_end (xcb_xkb_set_explicit_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_key_mod_map_next (xcb_xkb_key_mod_map_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_key_mod_map_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_key_mod_map_end (xcb_xkb_key_mod_map_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_key_v_mod_map_next (xcb_xkb_key_v_mod_map_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_key_v_mod_map_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_key_v_mod_map_end (xcb_xkb_key_v_mod_map_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_kt_set_map_entry_next (xcb_xkb_kt_set_map_entry_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_kt_set_map_entry_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_kt_set_map_entry_end (xcb_xkb_kt_set_map_entry_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_xkb_set_key_type_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_set_key_type_t *_aux = (xcb_xkb_set_key_type_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xkb_set_key_type_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* entries */
+    xcb_block_len += _aux->nMapEntries * sizeof(xcb_xkb_kt_set_map_entry_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xkb_kt_set_map_entry_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* preserve_entries */
+    xcb_block_len += (_aux->preserve * _aux->nMapEntries) * sizeof(xcb_xkb_kt_set_map_entry_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xkb_kt_set_map_entry_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xkb_kt_set_map_entry_t *
+xcb_xkb_set_key_type_entries (const xcb_xkb_set_key_type_t *R)
+{
+    return (xcb_xkb_kt_set_map_entry_t *) (R + 1);
+}
+
+int
+xcb_xkb_set_key_type_entries_length (const xcb_xkb_set_key_type_t *R)
+{
+    return R->nMapEntries;
+}
+
+xcb_xkb_kt_set_map_entry_iterator_t
+xcb_xkb_set_key_type_entries_iterator (const xcb_xkb_set_key_type_t *R)
+{
+    xcb_xkb_kt_set_map_entry_iterator_t i;
+    i.data = (xcb_xkb_kt_set_map_entry_t *) (R + 1);
+    i.rem = R->nMapEntries;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xkb_kt_set_map_entry_t *
+xcb_xkb_set_key_type_preserve_entries (const xcb_xkb_set_key_type_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_xkb_kt_set_map_entry_end(xcb_xkb_set_key_type_entries_iterator(R));
+    return (xcb_xkb_kt_set_map_entry_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_kt_set_map_entry_t, prev.index) + 0);
+}
+
+int
+xcb_xkb_set_key_type_preserve_entries_length (const xcb_xkb_set_key_type_t *R)
+{
+    return (R->preserve * R->nMapEntries);
+}
+
+xcb_xkb_kt_set_map_entry_iterator_t
+xcb_xkb_set_key_type_preserve_entries_iterator (const xcb_xkb_set_key_type_t *R)
+{
+    xcb_xkb_kt_set_map_entry_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_xkb_kt_set_map_entry_end(xcb_xkb_set_key_type_entries_iterator(R));
+    i.data = (xcb_xkb_kt_set_map_entry_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_kt_set_map_entry_t, prev.index));
+    i.rem = (R->preserve * R->nMapEntries);
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_xkb_set_key_type_next (xcb_xkb_set_key_type_iterator_t *i)
+{
+    xcb_xkb_set_key_type_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_xkb_set_key_type_t *)(((char *)R) + xcb_xkb_set_key_type_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_xkb_set_key_type_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_set_key_type_end (xcb_xkb_set_key_type_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_xkb_set_key_type_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+void
+xcb_xkb_string8_next (xcb_xkb_string8_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_string8_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_string8_end (xcb_xkb_string8_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_xkb_outline_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_outline_t *_aux = (xcb_xkb_outline_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xkb_outline_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* points */
+    xcb_block_len += _aux->nPoints * sizeof(xcb_point_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_point_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_point_t *
+xcb_xkb_outline_points (const xcb_xkb_outline_t *R)
+{
+    return (xcb_point_t *) (R + 1);
+}
+
+int
+xcb_xkb_outline_points_length (const xcb_xkb_outline_t *R)
+{
+    return R->nPoints;
+}
+
+xcb_point_iterator_t
+xcb_xkb_outline_points_iterator (const xcb_xkb_outline_t *R)
+{
+    xcb_point_iterator_t i;
+    i.data = (xcb_point_t *) (R + 1);
+    i.rem = R->nPoints;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_xkb_outline_next (xcb_xkb_outline_iterator_t *i)
+{
+    xcb_xkb_outline_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_xkb_outline_t *)(((char *)R) + xcb_xkb_outline_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_xkb_outline_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_outline_end (xcb_xkb_outline_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_xkb_outline_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_xkb_shape_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_shape_t *_aux = (xcb_xkb_shape_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_xkb_shape_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* outlines */
+    for(i=0; i<_aux->nOutlines; i++) {
+        xcb_tmp_len = xcb_xkb_outline_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_xkb_outline_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_xkb_shape_outlines_length (const xcb_xkb_shape_t *R)
+{
+    return R->nOutlines;
+}
+
+xcb_xkb_outline_iterator_t
+xcb_xkb_shape_outlines_iterator (const xcb_xkb_shape_t *R)
+{
+    xcb_xkb_outline_iterator_t i;
+    i.data = (xcb_xkb_outline_t *) (R + 1);
+    i.rem = R->nOutlines;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_xkb_shape_next (xcb_xkb_shape_iterator_t *i)
+{
+    xcb_xkb_shape_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_xkb_shape_t *)(((char *)R) + xcb_xkb_shape_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_xkb_shape_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_shape_end (xcb_xkb_shape_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_xkb_shape_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+void
+xcb_xkb_key_next (xcb_xkb_key_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_key_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_key_end (xcb_xkb_key_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_overlay_key_next (xcb_xkb_overlay_key_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_overlay_key_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_overlay_key_end (xcb_xkb_overlay_key_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_xkb_overlay_row_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_overlay_row_t *_aux = (xcb_xkb_overlay_row_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xkb_overlay_row_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* keys */
+    xcb_block_len += _aux->nKeys * sizeof(xcb_xkb_overlay_key_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xkb_overlay_key_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xkb_overlay_key_t *
+xcb_xkb_overlay_row_keys (const xcb_xkb_overlay_row_t *R)
+{
+    return (xcb_xkb_overlay_key_t *) (R + 1);
+}
+
+int
+xcb_xkb_overlay_row_keys_length (const xcb_xkb_overlay_row_t *R)
+{
+    return R->nKeys;
+}
+
+xcb_xkb_overlay_key_iterator_t
+xcb_xkb_overlay_row_keys_iterator (const xcb_xkb_overlay_row_t *R)
+{
+    xcb_xkb_overlay_key_iterator_t i;
+    i.data = (xcb_xkb_overlay_key_t *) (R + 1);
+    i.rem = R->nKeys;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_xkb_overlay_row_next (xcb_xkb_overlay_row_iterator_t *i)
+{
+    xcb_xkb_overlay_row_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_xkb_overlay_row_t *)(((char *)R) + xcb_xkb_overlay_row_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_xkb_overlay_row_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_overlay_row_end (xcb_xkb_overlay_row_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_xkb_overlay_row_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_xkb_overlay_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_overlay_t *_aux = (xcb_xkb_overlay_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_xkb_overlay_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* rows */
+    for(i=0; i<_aux->nRows; i++) {
+        xcb_tmp_len = xcb_xkb_overlay_row_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_xkb_overlay_row_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_xkb_overlay_rows_length (const xcb_xkb_overlay_t *R)
+{
+    return R->nRows;
+}
+
+xcb_xkb_overlay_row_iterator_t
+xcb_xkb_overlay_rows_iterator (const xcb_xkb_overlay_t *R)
+{
+    xcb_xkb_overlay_row_iterator_t i;
+    i.data = (xcb_xkb_overlay_row_t *) (R + 1);
+    i.rem = R->nRows;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_xkb_overlay_next (xcb_xkb_overlay_iterator_t *i)
+{
+    xcb_xkb_overlay_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_xkb_overlay_t *)(((char *)R) + xcb_xkb_overlay_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_xkb_overlay_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_overlay_end (xcb_xkb_overlay_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_xkb_overlay_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_xkb_row_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_row_t *_aux = (xcb_xkb_row_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xkb_row_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* keys */
+    xcb_block_len += _aux->nKeys * sizeof(xcb_xkb_key_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xkb_key_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xkb_key_t *
+xcb_xkb_row_keys (const xcb_xkb_row_t *R)
+{
+    return (xcb_xkb_key_t *) (R + 1);
+}
+
+int
+xcb_xkb_row_keys_length (const xcb_xkb_row_t *R)
+{
+    return R->nKeys;
+}
+
+xcb_xkb_key_iterator_t
+xcb_xkb_row_keys_iterator (const xcb_xkb_row_t *R)
+{
+    xcb_xkb_key_iterator_t i;
+    i.data = (xcb_xkb_key_t *) (R + 1);
+    i.rem = R->nKeys;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_xkb_row_next (xcb_xkb_row_iterator_t *i)
+{
+    xcb_xkb_row_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_xkb_row_t *)(((char *)R) + xcb_xkb_row_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_xkb_row_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_row_end (xcb_xkb_row_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_xkb_row_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_xkb_listing_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_listing_t *_aux = (xcb_xkb_listing_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xkb_listing_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* string */
+    xcb_block_len += _aux->length * sizeof(xcb_xkb_string8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xkb_string8_t);
+    xcb_align_to = 2;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xkb_string8_t *
+xcb_xkb_listing_string (const xcb_xkb_listing_t *R)
+{
+    return (xcb_xkb_string8_t *) (R + 1);
+}
+
+int
+xcb_xkb_listing_string_length (const xcb_xkb_listing_t *R)
+{
+    return R->length;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_listing_string_end (const xcb_xkb_listing_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_xkb_string8_t *) (R + 1)) + (R->length);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_xkb_listing_next (xcb_xkb_listing_iterator_t *i)
+{
+    xcb_xkb_listing_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_xkb_listing_t *)(((char *)R) + xcb_xkb_listing_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_xkb_listing_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_listing_end (xcb_xkb_listing_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_xkb_listing_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_xkb_device_led_info_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_device_led_info_t *_aux = (xcb_xkb_device_led_info_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xkb_device_led_info_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* names */
+    xcb_block_len += xcb_popcount(_aux->namesPresent) * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_atom_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* maps */
+    xcb_block_len += xcb_popcount(_aux->mapsPresent) * sizeof(xcb_xkb_indicator_map_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xkb_indicator_map_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_atom_t *
+xcb_xkb_device_led_info_names (const xcb_xkb_device_led_info_t *R)
+{
+    return (xcb_atom_t *) (R + 1);
+}
+
+int
+xcb_xkb_device_led_info_names_length (const xcb_xkb_device_led_info_t *R)
+{
+    return xcb_popcount(R->namesPresent);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_device_led_info_names_end (const xcb_xkb_device_led_info_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_atom_t *) (R + 1)) + (xcb_popcount(R->namesPresent));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xkb_indicator_map_t *
+xcb_xkb_device_led_info_maps (const xcb_xkb_device_led_info_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_xkb_device_led_info_names_end(R);
+    return (xcb_xkb_indicator_map_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_indicator_map_t, prev.index) + 0);
+}
+
+int
+xcb_xkb_device_led_info_maps_length (const xcb_xkb_device_led_info_t *R)
+{
+    return xcb_popcount(R->mapsPresent);
+}
+
+xcb_xkb_indicator_map_iterator_t
+xcb_xkb_device_led_info_maps_iterator (const xcb_xkb_device_led_info_t *R)
+{
+    xcb_xkb_indicator_map_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_xkb_device_led_info_names_end(R);
+    i.data = (xcb_xkb_indicator_map_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_indicator_map_t, prev.index));
+    i.rem = xcb_popcount(R->mapsPresent);
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_xkb_device_led_info_next (xcb_xkb_device_led_info_iterator_t *i)
+{
+    xcb_xkb_device_led_info_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_xkb_device_led_info_t *)(((char *)R) + xcb_xkb_device_led_info_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_xkb_device_led_info_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_device_led_info_end (xcb_xkb_device_led_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_xkb_device_led_info_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+void
+xcb_xkb_sa_no_action_next (xcb_xkb_sa_no_action_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_no_action_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_no_action_end (xcb_xkb_sa_no_action_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sa_set_mods_next (xcb_xkb_sa_set_mods_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_set_mods_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_set_mods_end (xcb_xkb_sa_set_mods_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sa_latch_mods_next (xcb_xkb_sa_latch_mods_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_latch_mods_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_latch_mods_end (xcb_xkb_sa_latch_mods_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sa_lock_mods_next (xcb_xkb_sa_lock_mods_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_lock_mods_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_lock_mods_end (xcb_xkb_sa_lock_mods_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sa_set_group_next (xcb_xkb_sa_set_group_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_set_group_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_set_group_end (xcb_xkb_sa_set_group_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sa_latch_group_next (xcb_xkb_sa_latch_group_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_latch_group_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_latch_group_end (xcb_xkb_sa_latch_group_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sa_lock_group_next (xcb_xkb_sa_lock_group_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_lock_group_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_lock_group_end (xcb_xkb_sa_lock_group_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sa_move_ptr_next (xcb_xkb_sa_move_ptr_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_move_ptr_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_move_ptr_end (xcb_xkb_sa_move_ptr_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sa_ptr_btn_next (xcb_xkb_sa_ptr_btn_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_ptr_btn_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_ptr_btn_end (xcb_xkb_sa_ptr_btn_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sa_lock_ptr_btn_next (xcb_xkb_sa_lock_ptr_btn_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_lock_ptr_btn_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_lock_ptr_btn_end (xcb_xkb_sa_lock_ptr_btn_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sa_set_ptr_dflt_next (xcb_xkb_sa_set_ptr_dflt_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_set_ptr_dflt_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_set_ptr_dflt_end (xcb_xkb_sa_set_ptr_dflt_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sa_iso_lock_next (xcb_xkb_sa_iso_lock_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_iso_lock_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_iso_lock_end (xcb_xkb_sa_iso_lock_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sa_terminate_next (xcb_xkb_sa_terminate_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_terminate_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_terminate_end (xcb_xkb_sa_terminate_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sa_switch_screen_next (xcb_xkb_sa_switch_screen_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_switch_screen_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_switch_screen_end (xcb_xkb_sa_switch_screen_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sa_set_controls_next (xcb_xkb_sa_set_controls_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_set_controls_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_set_controls_end (xcb_xkb_sa_set_controls_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sa_lock_controls_next (xcb_xkb_sa_lock_controls_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_lock_controls_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_lock_controls_end (xcb_xkb_sa_lock_controls_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sa_action_message_next (xcb_xkb_sa_action_message_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_action_message_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_action_message_end (xcb_xkb_sa_action_message_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sa_redirect_key_next (xcb_xkb_sa_redirect_key_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_redirect_key_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_redirect_key_end (xcb_xkb_sa_redirect_key_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sa_device_btn_next (xcb_xkb_sa_device_btn_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_device_btn_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_device_btn_end (xcb_xkb_sa_device_btn_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sa_lock_device_btn_next (xcb_xkb_sa_lock_device_btn_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_lock_device_btn_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_lock_device_btn_end (xcb_xkb_sa_lock_device_btn_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sa_device_valuator_next (xcb_xkb_sa_device_valuator_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sa_device_valuator_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sa_device_valuator_end (xcb_xkb_sa_device_valuator_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_si_action_next (xcb_xkb_si_action_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_si_action_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_si_action_end (xcb_xkb_si_action_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_sym_interpret_next (xcb_xkb_sym_interpret_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_sym_interpret_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_sym_interpret_end (xcb_xkb_sym_interpret_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xkb_action_next (xcb_xkb_action_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xkb_action_t);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_action_end (xcb_xkb_action_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+xcb_xkb_use_extension_cookie_t
+xcb_xkb_use_extension (xcb_connection_t *c,
+                       uint16_t          wantedMajor,
+                       uint16_t          wantedMinor)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_USE_EXTENSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_use_extension_cookie_t xcb_ret;
+    xcb_xkb_use_extension_request_t xcb_out;
+
+    xcb_out.wantedMajor = wantedMajor;
+    xcb_out.wantedMinor = wantedMinor;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_use_extension_cookie_t
+xcb_xkb_use_extension_unchecked (xcb_connection_t *c,
+                                 uint16_t          wantedMajor,
+                                 uint16_t          wantedMinor)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_USE_EXTENSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_use_extension_cookie_t xcb_ret;
+    xcb_xkb_use_extension_request_t xcb_out;
+
+    xcb_out.wantedMajor = wantedMajor;
+    xcb_out.wantedMinor = wantedMinor;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_use_extension_reply_t *
+xcb_xkb_use_extension_reply (xcb_connection_t                *c,
+                             xcb_xkb_use_extension_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_xkb_use_extension_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xkb_select_events_details_serialize (void                                  **_buffer,
+                                         uint16_t                                affectWhich,
+                                         uint16_t                                clear,
+                                         uint16_t                                selectAll,
+                                         const xcb_xkb_select_events_details_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[23];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY) {
+        /* xcb_xkb_select_events_details_t.affectNewKeyboard */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectNewKeyboard;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_select_events_details_t.newKeyboardDetails */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->newKeyboardDetails;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+    }
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_STATE_NOTIFY) {
+        /* xcb_xkb_select_events_details_t.affectState */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectState;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_select_events_details_t.stateDetails */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->stateDetails;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+    }
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_CONTROLS_NOTIFY) {
+        /* xcb_xkb_select_events_details_t.affectCtrls */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectCtrls;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_select_events_details_t.ctrlDetails */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->ctrlDetails;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_INDICATOR_STATE_NOTIFY) {
+        /* xcb_xkb_select_events_details_t.affectIndicatorState */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectIndicatorState;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_select_events_details_t.indicatorStateDetails */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->indicatorStateDetails;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_INDICATOR_MAP_NOTIFY) {
+        /* xcb_xkb_select_events_details_t.affectIndicatorMap */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectIndicatorMap;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_select_events_details_t.indicatorMapDetails */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->indicatorMapDetails;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_NAMES_NOTIFY) {
+        /* xcb_xkb_select_events_details_t.affectNames */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectNames;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_select_events_details_t.namesDetails */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->namesDetails;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+    }
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_COMPAT_MAP_NOTIFY) {
+        /* xcb_xkb_select_events_details_t.affectCompat */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectCompat;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_select_events_details_t.compatDetails */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compatDetails;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_BELL_NOTIFY) {
+        /* xcb_xkb_select_events_details_t.affectBell */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectBell;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_select_events_details_t.bellDetails */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bellDetails;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_ACTION_MESSAGE) {
+        /* xcb_xkb_select_events_details_t.affectMsgDetails */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectMsgDetails;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_select_events_details_t.msgDetails */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->msgDetails;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_ACCESS_X_NOTIFY) {
+        /* xcb_xkb_select_events_details_t.affectAccessX */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectAccessX;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_select_events_details_t.accessXDetails */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->accessXDetails;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+    }
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_EXTENSION_DEVICE_NOTIFY) {
+        /* xcb_xkb_select_events_details_t.affectExtDev */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->affectExtDev;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_select_events_details_t.extdevDetails */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->extdevDetails;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_xkb_select_events_details_unpack (const void                       *_buffer,
+                                      uint16_t                          affectWhich,
+                                      uint16_t                          clear,
+                                      uint16_t                          selectAll,
+                                      xcb_xkb_select_events_details_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY) {
+        /* xcb_xkb_select_events_details_t.affectNewKeyboard */
+        _aux->affectNewKeyboard = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_select_events_details_t.newKeyboardDetails */
+        _aux->newKeyboardDetails = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+    }
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_STATE_NOTIFY) {
+        /* xcb_xkb_select_events_details_t.affectState */
+        _aux->affectState = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_select_events_details_t.stateDetails */
+        _aux->stateDetails = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+    }
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_CONTROLS_NOTIFY) {
+        /* xcb_xkb_select_events_details_t.affectCtrls */
+        _aux->affectCtrls = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_select_events_details_t.ctrlDetails */
+        _aux->ctrlDetails = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_INDICATOR_STATE_NOTIFY) {
+        /* xcb_xkb_select_events_details_t.affectIndicatorState */
+        _aux->affectIndicatorState = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_select_events_details_t.indicatorStateDetails */
+        _aux->indicatorStateDetails = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_INDICATOR_MAP_NOTIFY) {
+        /* xcb_xkb_select_events_details_t.affectIndicatorMap */
+        _aux->affectIndicatorMap = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_select_events_details_t.indicatorMapDetails */
+        _aux->indicatorMapDetails = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_NAMES_NOTIFY) {
+        /* xcb_xkb_select_events_details_t.affectNames */
+        _aux->affectNames = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_select_events_details_t.namesDetails */
+        _aux->namesDetails = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+    }
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_COMPAT_MAP_NOTIFY) {
+        /* xcb_xkb_select_events_details_t.affectCompat */
+        _aux->affectCompat = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_select_events_details_t.compatDetails */
+        _aux->compatDetails = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_BELL_NOTIFY) {
+        /* xcb_xkb_select_events_details_t.affectBell */
+        _aux->affectBell = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_select_events_details_t.bellDetails */
+        _aux->bellDetails = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_ACTION_MESSAGE) {
+        /* xcb_xkb_select_events_details_t.affectMsgDetails */
+        _aux->affectMsgDetails = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_select_events_details_t.msgDetails */
+        _aux->msgDetails = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+    }
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_ACCESS_X_NOTIFY) {
+        /* xcb_xkb_select_events_details_t.affectAccessX */
+        _aux->affectAccessX = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_select_events_details_t.accessXDetails */
+        _aux->accessXDetails = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+    }
+    if((affectWhich & ((~clear) & (~selectAll))) & XCB_XKB_EVENT_TYPE_EXTENSION_DEVICE_NOTIFY) {
+        /* xcb_xkb_select_events_details_t.affectExtDev */
+        _aux->affectExtDev = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_select_events_details_t.extdevDetails */
+        _aux->extdevDetails = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_xkb_select_events_details_sizeof (const void  *_buffer,
+                                      uint16_t     affectWhich,
+                                      uint16_t     clear,
+                                      uint16_t     selectAll)
+{
+    xcb_xkb_select_events_details_t _aux;
+    return xcb_xkb_select_events_details_unpack(_buffer, affectWhich, clear, selectAll, &_aux);
+}
+
+int
+xcb_xkb_select_events_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_select_events_request_t *_aux = (xcb_xkb_select_events_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xkb_select_events_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* details */
+    xcb_block_len += xcb_xkb_select_events_details_sizeof(xcb_tmp, _aux->affectWhich, _aux->clear, _aux->selectAll);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_xkb_select_events_checked (xcb_connection_t      *c,
+                               xcb_xkb_device_spec_t  deviceSpec,
+                               uint16_t               affectWhich,
+                               uint16_t               clear,
+                               uint16_t               selectAll,
+                               uint16_t               affectMap,
+                               uint16_t               map,
+                               const void            *details)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SELECT_EVENTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_select_events_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.affectWhich = affectWhich;
+    xcb_out.clear = clear;
+    xcb_out.selectAll = selectAll;
+    xcb_out.affectMap = affectMap;
+    xcb_out.map = map;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_xkb_select_events_details_t details */
+    xcb_parts[4].iov_base = (char *) details;
+    xcb_parts[4].iov_len =
+      xcb_xkb_select_events_details_sizeof (details, affectWhich, clear, selectAll);
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xkb_select_events (xcb_connection_t      *c,
+                       xcb_xkb_device_spec_t  deviceSpec,
+                       uint16_t               affectWhich,
+                       uint16_t               clear,
+                       uint16_t               selectAll,
+                       uint16_t               affectMap,
+                       uint16_t               map,
+                       const void            *details)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SELECT_EVENTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_select_events_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.affectWhich = affectWhich;
+    xcb_out.clear = clear;
+    xcb_out.selectAll = selectAll;
+    xcb_out.affectMap = affectMap;
+    xcb_out.map = map;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_xkb_select_events_details_t details */
+    xcb_parts[4].iov_base = (char *) details;
+    xcb_parts[4].iov_len =
+      xcb_xkb_select_events_details_sizeof (details, affectWhich, clear, selectAll);
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xkb_select_events_aux_checked (xcb_connection_t                      *c,
+                                   xcb_xkb_device_spec_t                  deviceSpec,
+                                   uint16_t                               affectWhich,
+                                   uint16_t                               clear,
+                                   uint16_t                               selectAll,
+                                   uint16_t                               affectMap,
+                                   uint16_t                               map,
+                                   const xcb_xkb_select_events_details_t *details)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SELECT_EVENTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_select_events_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.affectWhich = affectWhich;
+    xcb_out.clear = clear;
+    xcb_out.selectAll = selectAll;
+    xcb_out.affectMap = affectMap;
+    xcb_out.map = map;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_xkb_select_events_details_t details */
+    xcb_parts[4].iov_len =
+      xcb_xkb_select_events_details_serialize (&xcb_aux0, affectWhich, clear, selectAll, details);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xkb_select_events_aux (xcb_connection_t                      *c,
+                           xcb_xkb_device_spec_t                  deviceSpec,
+                           uint16_t                               affectWhich,
+                           uint16_t                               clear,
+                           uint16_t                               selectAll,
+                           uint16_t                               affectMap,
+                           uint16_t                               map,
+                           const xcb_xkb_select_events_details_t *details)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SELECT_EVENTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_select_events_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.affectWhich = affectWhich;
+    xcb_out.clear = clear;
+    xcb_out.selectAll = selectAll;
+    xcb_out.affectMap = affectMap;
+    xcb_out.map = map;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_xkb_select_events_details_t details */
+    xcb_parts[4].iov_len =
+      xcb_xkb_select_events_details_serialize (&xcb_aux0, affectWhich, clear, selectAll, details);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+void *
+xcb_xkb_select_events_details (const xcb_xkb_select_events_request_t *R)
+{
+    return (void *) (R + 1);
+}
+
+xcb_void_cookie_t
+xcb_xkb_bell_checked (xcb_connection_t          *c,
+                      xcb_xkb_device_spec_t      deviceSpec,
+                      xcb_xkb_bell_class_spec_t  bellClass,
+                      xcb_xkb_id_spec_t          bellID,
+                      int8_t                     percent,
+                      uint8_t                    forceSound,
+                      uint8_t                    eventOnly,
+                      int16_t                    pitch,
+                      int16_t                    duration,
+                      xcb_atom_t                 name,
+                      xcb_window_t               window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_BELL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_bell_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.bellClass = bellClass;
+    xcb_out.bellID = bellID;
+    xcb_out.percent = percent;
+    xcb_out.forceSound = forceSound;
+    xcb_out.eventOnly = eventOnly;
+    xcb_out.pad0 = 0;
+    xcb_out.pitch = pitch;
+    xcb_out.duration = duration;
+    memset(xcb_out.pad1, 0, 2);
+    xcb_out.name = name;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xkb_bell (xcb_connection_t          *c,
+              xcb_xkb_device_spec_t      deviceSpec,
+              xcb_xkb_bell_class_spec_t  bellClass,
+              xcb_xkb_id_spec_t          bellID,
+              int8_t                     percent,
+              uint8_t                    forceSound,
+              uint8_t                    eventOnly,
+              int16_t                    pitch,
+              int16_t                    duration,
+              xcb_atom_t                 name,
+              xcb_window_t               window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_BELL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_bell_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.bellClass = bellClass;
+    xcb_out.bellID = bellID;
+    xcb_out.percent = percent;
+    xcb_out.forceSound = forceSound;
+    xcb_out.eventOnly = eventOnly;
+    xcb_out.pad0 = 0;
+    xcb_out.pitch = pitch;
+    xcb_out.duration = duration;
+    memset(xcb_out.pad1, 0, 2);
+    xcb_out.name = name;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_get_state_cookie_t
+xcb_xkb_get_state (xcb_connection_t      *c,
+                   xcb_xkb_device_spec_t  deviceSpec)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_GET_STATE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_get_state_cookie_t xcb_ret;
+    xcb_xkb_get_state_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_get_state_cookie_t
+xcb_xkb_get_state_unchecked (xcb_connection_t      *c,
+                             xcb_xkb_device_spec_t  deviceSpec)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_GET_STATE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_get_state_cookie_t xcb_ret;
+    xcb_xkb_get_state_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_get_state_reply_t *
+xcb_xkb_get_state_reply (xcb_connection_t            *c,
+                         xcb_xkb_get_state_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e)
+{
+    return (xcb_xkb_get_state_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_xkb_latch_lock_state_checked (xcb_connection_t      *c,
+                                  xcb_xkb_device_spec_t  deviceSpec,
+                                  uint8_t                affectModLocks,
+                                  uint8_t                modLocks,
+                                  uint8_t                lockGroup,
+                                  uint8_t                groupLock,
+                                  uint8_t                affectModLatches,
+                                  uint8_t                latchGroup,
+                                  uint16_t               groupLatch)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_LATCH_LOCK_STATE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_latch_lock_state_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.affectModLocks = affectModLocks;
+    xcb_out.modLocks = modLocks;
+    xcb_out.lockGroup = lockGroup;
+    xcb_out.groupLock = groupLock;
+    xcb_out.affectModLatches = affectModLatches;
+    xcb_out.pad0 = 0;
+    xcb_out.pad1 = 0;
+    xcb_out.latchGroup = latchGroup;
+    xcb_out.groupLatch = groupLatch;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xkb_latch_lock_state (xcb_connection_t      *c,
+                          xcb_xkb_device_spec_t  deviceSpec,
+                          uint8_t                affectModLocks,
+                          uint8_t                modLocks,
+                          uint8_t                lockGroup,
+                          uint8_t                groupLock,
+                          uint8_t                affectModLatches,
+                          uint8_t                latchGroup,
+                          uint16_t               groupLatch)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_LATCH_LOCK_STATE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_latch_lock_state_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.affectModLocks = affectModLocks;
+    xcb_out.modLocks = modLocks;
+    xcb_out.lockGroup = lockGroup;
+    xcb_out.groupLock = groupLock;
+    xcb_out.affectModLatches = affectModLatches;
+    xcb_out.pad0 = 0;
+    xcb_out.pad1 = 0;
+    xcb_out.latchGroup = latchGroup;
+    xcb_out.groupLatch = groupLatch;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_get_controls_cookie_t
+xcb_xkb_get_controls (xcb_connection_t      *c,
+                      xcb_xkb_device_spec_t  deviceSpec)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_GET_CONTROLS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_get_controls_cookie_t xcb_ret;
+    xcb_xkb_get_controls_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_get_controls_cookie_t
+xcb_xkb_get_controls_unchecked (xcb_connection_t      *c,
+                                xcb_xkb_device_spec_t  deviceSpec)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_GET_CONTROLS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_get_controls_cookie_t xcb_ret;
+    xcb_xkb_get_controls_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_get_controls_reply_t *
+xcb_xkb_get_controls_reply (xcb_connection_t               *c,
+                            xcb_xkb_get_controls_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e)
+{
+    return (xcb_xkb_get_controls_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_xkb_set_controls_checked (xcb_connection_t      *c,
+                              xcb_xkb_device_spec_t  deviceSpec,
+                              uint8_t                affectInternalRealMods,
+                              uint8_t                internalRealMods,
+                              uint8_t                affectIgnoreLockRealMods,
+                              uint8_t                ignoreLockRealMods,
+                              uint16_t               affectInternalVirtualMods,
+                              uint16_t               internalVirtualMods,
+                              uint16_t               affectIgnoreLockVirtualMods,
+                              uint16_t               ignoreLockVirtualMods,
+                              uint8_t                mouseKeysDfltBtn,
+                              uint8_t                groupsWrap,
+                              uint16_t               accessXOptions,
+                              uint32_t               affectEnabledControls,
+                              uint32_t               enabledControls,
+                              uint32_t               changeControls,
+                              uint16_t               repeatDelay,
+                              uint16_t               repeatInterval,
+                              uint16_t               slowKeysDelay,
+                              uint16_t               debounceDelay,
+                              uint16_t               mouseKeysDelay,
+                              uint16_t               mouseKeysInterval,
+                              uint16_t               mouseKeysTimeToMax,
+                              uint16_t               mouseKeysMaxSpeed,
+                              int16_t                mouseKeysCurve,
+                              uint16_t               accessXTimeout,
+                              uint32_t               accessXTimeoutMask,
+                              uint32_t               accessXTimeoutValues,
+                              uint16_t               accessXTimeoutOptionsMask,
+                              uint16_t               accessXTimeoutOptionsValues,
+                              const uint8_t         *perKeyRepeat)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SET_CONTROLS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_set_controls_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.affectInternalRealMods = affectInternalRealMods;
+    xcb_out.internalRealMods = internalRealMods;
+    xcb_out.affectIgnoreLockRealMods = affectIgnoreLockRealMods;
+    xcb_out.ignoreLockRealMods = ignoreLockRealMods;
+    xcb_out.affectInternalVirtualMods = affectInternalVirtualMods;
+    xcb_out.internalVirtualMods = internalVirtualMods;
+    xcb_out.affectIgnoreLockVirtualMods = affectIgnoreLockVirtualMods;
+    xcb_out.ignoreLockVirtualMods = ignoreLockVirtualMods;
+    xcb_out.mouseKeysDfltBtn = mouseKeysDfltBtn;
+    xcb_out.groupsWrap = groupsWrap;
+    xcb_out.accessXOptions = accessXOptions;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.affectEnabledControls = affectEnabledControls;
+    xcb_out.enabledControls = enabledControls;
+    xcb_out.changeControls = changeControls;
+    xcb_out.repeatDelay = repeatDelay;
+    xcb_out.repeatInterval = repeatInterval;
+    xcb_out.slowKeysDelay = slowKeysDelay;
+    xcb_out.debounceDelay = debounceDelay;
+    xcb_out.mouseKeysDelay = mouseKeysDelay;
+    xcb_out.mouseKeysInterval = mouseKeysInterval;
+    xcb_out.mouseKeysTimeToMax = mouseKeysTimeToMax;
+    xcb_out.mouseKeysMaxSpeed = mouseKeysMaxSpeed;
+    xcb_out.mouseKeysCurve = mouseKeysCurve;
+    xcb_out.accessXTimeout = accessXTimeout;
+    xcb_out.accessXTimeoutMask = accessXTimeoutMask;
+    xcb_out.accessXTimeoutValues = accessXTimeoutValues;
+    xcb_out.accessXTimeoutOptionsMask = accessXTimeoutOptionsMask;
+    xcb_out.accessXTimeoutOptionsValues = accessXTimeoutOptionsValues;
+    memcpy(xcb_out.perKeyRepeat, perKeyRepeat, 32);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xkb_set_controls (xcb_connection_t      *c,
+                      xcb_xkb_device_spec_t  deviceSpec,
+                      uint8_t                affectInternalRealMods,
+                      uint8_t                internalRealMods,
+                      uint8_t                affectIgnoreLockRealMods,
+                      uint8_t                ignoreLockRealMods,
+                      uint16_t               affectInternalVirtualMods,
+                      uint16_t               internalVirtualMods,
+                      uint16_t               affectIgnoreLockVirtualMods,
+                      uint16_t               ignoreLockVirtualMods,
+                      uint8_t                mouseKeysDfltBtn,
+                      uint8_t                groupsWrap,
+                      uint16_t               accessXOptions,
+                      uint32_t               affectEnabledControls,
+                      uint32_t               enabledControls,
+                      uint32_t               changeControls,
+                      uint16_t               repeatDelay,
+                      uint16_t               repeatInterval,
+                      uint16_t               slowKeysDelay,
+                      uint16_t               debounceDelay,
+                      uint16_t               mouseKeysDelay,
+                      uint16_t               mouseKeysInterval,
+                      uint16_t               mouseKeysTimeToMax,
+                      uint16_t               mouseKeysMaxSpeed,
+                      int16_t                mouseKeysCurve,
+                      uint16_t               accessXTimeout,
+                      uint32_t               accessXTimeoutMask,
+                      uint32_t               accessXTimeoutValues,
+                      uint16_t               accessXTimeoutOptionsMask,
+                      uint16_t               accessXTimeoutOptionsValues,
+                      const uint8_t         *perKeyRepeat)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SET_CONTROLS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_set_controls_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.affectInternalRealMods = affectInternalRealMods;
+    xcb_out.internalRealMods = internalRealMods;
+    xcb_out.affectIgnoreLockRealMods = affectIgnoreLockRealMods;
+    xcb_out.ignoreLockRealMods = ignoreLockRealMods;
+    xcb_out.affectInternalVirtualMods = affectInternalVirtualMods;
+    xcb_out.internalVirtualMods = internalVirtualMods;
+    xcb_out.affectIgnoreLockVirtualMods = affectIgnoreLockVirtualMods;
+    xcb_out.ignoreLockVirtualMods = ignoreLockVirtualMods;
+    xcb_out.mouseKeysDfltBtn = mouseKeysDfltBtn;
+    xcb_out.groupsWrap = groupsWrap;
+    xcb_out.accessXOptions = accessXOptions;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.affectEnabledControls = affectEnabledControls;
+    xcb_out.enabledControls = enabledControls;
+    xcb_out.changeControls = changeControls;
+    xcb_out.repeatDelay = repeatDelay;
+    xcb_out.repeatInterval = repeatInterval;
+    xcb_out.slowKeysDelay = slowKeysDelay;
+    xcb_out.debounceDelay = debounceDelay;
+    xcb_out.mouseKeysDelay = mouseKeysDelay;
+    xcb_out.mouseKeysInterval = mouseKeysInterval;
+    xcb_out.mouseKeysTimeToMax = mouseKeysTimeToMax;
+    xcb_out.mouseKeysMaxSpeed = mouseKeysMaxSpeed;
+    xcb_out.mouseKeysCurve = mouseKeysCurve;
+    xcb_out.accessXTimeout = accessXTimeout;
+    xcb_out.accessXTimeoutMask = accessXTimeoutMask;
+    xcb_out.accessXTimeoutValues = accessXTimeoutValues;
+    xcb_out.accessXTimeoutOptionsMask = accessXTimeoutOptionsMask;
+    xcb_out.accessXTimeoutOptionsValues = accessXTimeoutOptionsValues;
+    memcpy(xcb_out.perKeyRepeat, perKeyRepeat, 32);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_xkb_get_map_map_types_rtrn_length (const xcb_xkb_get_map_reply_t *R,
+                                       const xcb_xkb_get_map_map_t *S)
+{
+    return R->nTypes;
+}
+
+xcb_xkb_key_type_iterator_t
+xcb_xkb_get_map_map_types_rtrn_iterator (const xcb_xkb_get_map_reply_t *R,
+                                         const xcb_xkb_get_map_map_t *S)
+{
+    xcb_xkb_key_type_iterator_t i;
+    i.data = S->types_rtrn;
+    i.rem = R->nTypes;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_xkb_get_map_map_syms_rtrn_length (const xcb_xkb_get_map_reply_t *R,
+                                      const xcb_xkb_get_map_map_t *S)
+{
+    return R->nKeySyms;
+}
+
+xcb_xkb_key_sym_map_iterator_t
+xcb_xkb_get_map_map_syms_rtrn_iterator (const xcb_xkb_get_map_reply_t *R,
+                                        const xcb_xkb_get_map_map_t *S)
+{
+    xcb_xkb_key_sym_map_iterator_t i;
+    i.data = S->syms_rtrn;
+    i.rem = R->nKeySyms;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+uint8_t *
+xcb_xkb_get_map_map_acts_rtrn_count (const xcb_xkb_get_map_map_t *S)
+{
+    return S->acts_rtrn_count;
+}
+
+int
+xcb_xkb_get_map_map_acts_rtrn_count_length (const xcb_xkb_get_map_reply_t *R,
+                                            const xcb_xkb_get_map_map_t *S)
+{
+    return R->nKeyActions;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_get_map_map_acts_rtrn_count_end (const xcb_xkb_get_map_reply_t *R,
+                                         const xcb_xkb_get_map_map_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->acts_rtrn_count + R->nKeyActions;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_action_t *
+xcb_xkb_get_map_map_acts_rtrn_acts (const xcb_xkb_get_map_map_t *S)
+{
+    return S->acts_rtrn_acts;
+}
+
+int
+xcb_xkb_get_map_map_acts_rtrn_acts_length (const xcb_xkb_get_map_reply_t *R,
+                                           const xcb_xkb_get_map_map_t *S)
+{
+    return R->totalActions;
+}
+
+xcb_xkb_action_iterator_t
+xcb_xkb_get_map_map_acts_rtrn_acts_iterator (const xcb_xkb_get_map_reply_t *R,
+                                             const xcb_xkb_get_map_map_t *S)
+{
+    xcb_xkb_action_iterator_t i;
+    i.data = S->acts_rtrn_acts;
+    i.rem = R->totalActions;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_set_behavior_t *
+xcb_xkb_get_map_map_behaviors_rtrn (const xcb_xkb_get_map_map_t *S)
+{
+    return S->behaviors_rtrn;
+}
+
+int
+xcb_xkb_get_map_map_behaviors_rtrn_length (const xcb_xkb_get_map_reply_t *R,
+                                           const xcb_xkb_get_map_map_t *S)
+{
+    return R->totalKeyBehaviors;
+}
+
+xcb_xkb_set_behavior_iterator_t
+xcb_xkb_get_map_map_behaviors_rtrn_iterator (const xcb_xkb_get_map_reply_t *R,
+                                             const xcb_xkb_get_map_map_t *S)
+{
+    xcb_xkb_set_behavior_iterator_t i;
+    i.data = S->behaviors_rtrn;
+    i.rem = R->totalKeyBehaviors;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+uint8_t *
+xcb_xkb_get_map_map_vmods_rtrn (const xcb_xkb_get_map_map_t *S)
+{
+    return S->vmods_rtrn;
+}
+
+int
+xcb_xkb_get_map_map_vmods_rtrn_length (const xcb_xkb_get_map_reply_t *R,
+                                       const xcb_xkb_get_map_map_t *S)
+{
+    return xcb_popcount(R->virtualMods);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_get_map_map_vmods_rtrn_end (const xcb_xkb_get_map_reply_t *R,
+                                    const xcb_xkb_get_map_map_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->vmods_rtrn + xcb_popcount(R->virtualMods);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_set_explicit_t *
+xcb_xkb_get_map_map_explicit_rtrn (const xcb_xkb_get_map_map_t *S)
+{
+    return S->explicit_rtrn;
+}
+
+int
+xcb_xkb_get_map_map_explicit_rtrn_length (const xcb_xkb_get_map_reply_t *R,
+                                          const xcb_xkb_get_map_map_t *S)
+{
+    return R->totalKeyExplicit;
+}
+
+xcb_xkb_set_explicit_iterator_t
+xcb_xkb_get_map_map_explicit_rtrn_iterator (const xcb_xkb_get_map_reply_t *R,
+                                            const xcb_xkb_get_map_map_t *S)
+{
+    xcb_xkb_set_explicit_iterator_t i;
+    i.data = S->explicit_rtrn;
+    i.rem = R->totalKeyExplicit;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_key_mod_map_t *
+xcb_xkb_get_map_map_modmap_rtrn (const xcb_xkb_get_map_map_t *S)
+{
+    return S->modmap_rtrn;
+}
+
+int
+xcb_xkb_get_map_map_modmap_rtrn_length (const xcb_xkb_get_map_reply_t *R,
+                                        const xcb_xkb_get_map_map_t *S)
+{
+    return R->totalModMapKeys;
+}
+
+xcb_xkb_key_mod_map_iterator_t
+xcb_xkb_get_map_map_modmap_rtrn_iterator (const xcb_xkb_get_map_reply_t *R,
+                                          const xcb_xkb_get_map_map_t *S)
+{
+    xcb_xkb_key_mod_map_iterator_t i;
+    i.data = S->modmap_rtrn;
+    i.rem = R->totalModMapKeys;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_key_v_mod_map_t *
+xcb_xkb_get_map_map_vmodmap_rtrn (const xcb_xkb_get_map_map_t *S)
+{
+    return S->vmodmap_rtrn;
+}
+
+int
+xcb_xkb_get_map_map_vmodmap_rtrn_length (const xcb_xkb_get_map_reply_t *R,
+                                         const xcb_xkb_get_map_map_t *S)
+{
+    return R->totalVModMapKeys;
+}
+
+xcb_xkb_key_v_mod_map_iterator_t
+xcb_xkb_get_map_map_vmodmap_rtrn_iterator (const xcb_xkb_get_map_reply_t *R,
+                                           const xcb_xkb_get_map_map_t *S)
+{
+    xcb_xkb_key_v_mod_map_iterator_t i;
+    i.data = S->vmodmap_rtrn;
+    i.rem = R->totalVModMapKeys;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_xkb_get_map_map_serialize (void                        **_buffer,
+                               uint8_t                       nTypes,
+                               uint8_t                       nKeySyms,
+                               uint8_t                       nKeyActions,
+                               uint16_t                      totalActions,
+                               uint8_t                       totalKeyBehaviors,
+                               uint16_t                      virtualMods,
+                               uint8_t                       totalKeyExplicit,
+                               uint8_t                       totalModMapKeys,
+                               uint8_t                       totalVModMapKeys,
+                               uint16_t                      present,
+                               const xcb_xkb_get_map_map_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[23];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(present & XCB_XKB_MAP_PART_KEY_TYPES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* types_rtrn */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->types_rtrn;
+        xcb_parts[xcb_parts_idx].iov_len = 0;
+        xcb_tmp = (char *) _aux->types_rtrn;
+        for(i=0; i<nTypes; i++) { 
+            xcb_block_len = xcb_xkb_key_type_sizeof(xcb_tmp);
+            xcb_parts[xcb_parts_idx].iov_len += xcb_block_len;
+        }
+        xcb_block_len = xcb_parts[xcb_parts_idx].iov_len;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_type_t);
+    }
+    if(present & XCB_XKB_MAP_PART_KEY_SYMS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* syms_rtrn */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->syms_rtrn;
+        xcb_parts[xcb_parts_idx].iov_len = 0;
+        xcb_tmp = (char *) _aux->syms_rtrn;
+        for(i=0; i<nKeySyms; i++) { 
+            xcb_block_len = xcb_xkb_key_sym_map_sizeof(xcb_tmp);
+            xcb_parts[xcb_parts_idx].iov_len += xcb_block_len;
+        }
+        xcb_block_len = xcb_parts[xcb_parts_idx].iov_len;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_sym_map_t);
+    }
+    if(present & XCB_XKB_MAP_PART_KEY_ACTIONS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* acts_rtrn_count */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->acts_rtrn_count;
+        xcb_block_len += nKeyActions * sizeof(xcb_keycode_t);
+        xcb_parts[xcb_parts_idx].iov_len = nKeyActions * sizeof(xcb_keycode_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* acts_rtrn_acts */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->acts_rtrn_acts;
+        xcb_block_len += totalActions * sizeof(xcb_xkb_action_t);
+        xcb_parts[xcb_parts_idx].iov_len = totalActions * sizeof(xcb_xkb_action_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_action_t);
+    }
+    if(present & XCB_XKB_MAP_PART_KEY_BEHAVIORS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* behaviors_rtrn */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->behaviors_rtrn;
+        xcb_block_len += totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t);
+        xcb_parts[xcb_parts_idx].iov_len = totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_set_behavior_t);
+    }
+    if(present & XCB_XKB_MAP_PART_VIRTUAL_MODS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* vmods_rtrn */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->vmods_rtrn;
+        xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_keycode_t);
+        xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(virtualMods) * sizeof(xcb_keycode_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* explicit_rtrn */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->explicit_rtrn;
+        xcb_block_len += totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t);
+        xcb_parts[xcb_parts_idx].iov_len = totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_set_explicit_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(present & XCB_XKB_MAP_PART_MODIFIER_MAP) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* modmap_rtrn */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->modmap_rtrn;
+        xcb_block_len += totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t);
+        xcb_parts[xcb_parts_idx].iov_len = totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_mod_map_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(present & XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* vmodmap_rtrn */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->vmodmap_rtrn;
+        xcb_block_len += totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t);
+        xcb_parts[xcb_parts_idx].iov_len = totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_v_mod_map_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_xkb_get_map_map_unpack (const void             *_buffer,
+                            uint8_t                 nTypes,
+                            uint8_t                 nKeySyms,
+                            uint8_t                 nKeyActions,
+                            uint16_t                totalActions,
+                            uint8_t                 totalKeyBehaviors,
+                            uint16_t                virtualMods,
+                            uint8_t                 totalKeyExplicit,
+                            uint8_t                 totalModMapKeys,
+                            uint8_t                 totalVModMapKeys,
+                            uint16_t                present,
+                            xcb_xkb_get_map_map_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    if(present & XCB_XKB_MAP_PART_KEY_TYPES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* types_rtrn */
+        _aux->types_rtrn = (xcb_xkb_key_type_t *)xcb_tmp;
+        for(i=0; i<nTypes; i++) {
+            xcb_tmp_len = xcb_xkb_key_type_sizeof(xcb_tmp);
+            xcb_block_len += xcb_tmp_len;
+            xcb_tmp += xcb_tmp_len;
+        }
+        xcb_align_to = ALIGNOF(xcb_xkb_key_type_t);
+    }
+    if(present & XCB_XKB_MAP_PART_KEY_SYMS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* syms_rtrn */
+        _aux->syms_rtrn = (xcb_xkb_key_sym_map_t *)xcb_tmp;
+        for(i=0; i<nKeySyms; i++) {
+            xcb_tmp_len = xcb_xkb_key_sym_map_sizeof(xcb_tmp);
+            xcb_block_len += xcb_tmp_len;
+            xcb_tmp += xcb_tmp_len;
+        }
+        xcb_align_to = ALIGNOF(xcb_xkb_key_sym_map_t);
+    }
+    if(present & XCB_XKB_MAP_PART_KEY_ACTIONS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* acts_rtrn_count */
+        _aux->acts_rtrn_count = (uint8_t *)xcb_tmp;
+        xcb_block_len += nKeyActions * sizeof(xcb_keycode_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* acts_rtrn_acts */
+        _aux->acts_rtrn_acts = (xcb_xkb_action_t *)xcb_tmp;
+        xcb_block_len += totalActions * sizeof(xcb_xkb_action_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_action_t);
+    }
+    if(present & XCB_XKB_MAP_PART_KEY_BEHAVIORS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* behaviors_rtrn */
+        _aux->behaviors_rtrn = (xcb_xkb_set_behavior_t *)xcb_tmp;
+        xcb_block_len += totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_set_behavior_t);
+    }
+    if(present & XCB_XKB_MAP_PART_VIRTUAL_MODS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* vmods_rtrn */
+        _aux->vmods_rtrn = (uint8_t *)xcb_tmp;
+        xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_keycode_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* explicit_rtrn */
+        _aux->explicit_rtrn = (xcb_xkb_set_explicit_t *)xcb_tmp;
+        xcb_block_len += totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_set_explicit_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(present & XCB_XKB_MAP_PART_MODIFIER_MAP) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* modmap_rtrn */
+        _aux->modmap_rtrn = (xcb_xkb_key_mod_map_t *)xcb_tmp;
+        xcb_block_len += totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_mod_map_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(present & XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* vmodmap_rtrn */
+        _aux->vmodmap_rtrn = (xcb_xkb_key_v_mod_map_t *)xcb_tmp;
+        xcb_block_len += totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_v_mod_map_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_xkb_get_map_map_sizeof (const void  *_buffer,
+                            uint8_t      nTypes,
+                            uint8_t      nKeySyms,
+                            uint8_t      nKeyActions,
+                            uint16_t     totalActions,
+                            uint8_t      totalKeyBehaviors,
+                            uint16_t     virtualMods,
+                            uint8_t      totalKeyExplicit,
+                            uint8_t      totalModMapKeys,
+                            uint8_t      totalVModMapKeys,
+                            uint16_t     present)
+{
+    xcb_xkb_get_map_map_t _aux;
+    return xcb_xkb_get_map_map_unpack(_buffer, nTypes, nKeySyms, nKeyActions, totalActions, totalKeyBehaviors, virtualMods, totalKeyExplicit, totalModMapKeys, totalVModMapKeys, present, &_aux);
+}
+
+int
+xcb_xkb_get_map_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_get_map_reply_t *_aux = (xcb_xkb_get_map_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xkb_get_map_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* map */
+    xcb_block_len += xcb_xkb_get_map_map_sizeof(xcb_tmp, _aux->nTypes, _aux->nKeySyms, _aux->nKeyActions, _aux->totalActions, _aux->totalKeyBehaviors, _aux->virtualMods, _aux->totalKeyExplicit, _aux->totalModMapKeys, _aux->totalVModMapKeys, _aux->present);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xkb_get_map_cookie_t
+xcb_xkb_get_map (xcb_connection_t      *c,
+                 xcb_xkb_device_spec_t  deviceSpec,
+                 uint16_t               full,
+                 uint16_t               partial,
+                 uint8_t                firstType,
+                 uint8_t                nTypes,
+                 xcb_keycode_t          firstKeySym,
+                 uint8_t                nKeySyms,
+                 xcb_keycode_t          firstKeyAction,
+                 uint8_t                nKeyActions,
+                 xcb_keycode_t          firstKeyBehavior,
+                 uint8_t                nKeyBehaviors,
+                 uint16_t               virtualMods,
+                 xcb_keycode_t          firstKeyExplicit,
+                 uint8_t                nKeyExplicit,
+                 xcb_keycode_t          firstModMapKey,
+                 uint8_t                nModMapKeys,
+                 xcb_keycode_t          firstVModMapKey,
+                 uint8_t                nVModMapKeys)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_GET_MAP,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_get_map_cookie_t xcb_ret;
+    xcb_xkb_get_map_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.full = full;
+    xcb_out.partial = partial;
+    xcb_out.firstType = firstType;
+    xcb_out.nTypes = nTypes;
+    xcb_out.firstKeySym = firstKeySym;
+    xcb_out.nKeySyms = nKeySyms;
+    xcb_out.firstKeyAction = firstKeyAction;
+    xcb_out.nKeyActions = nKeyActions;
+    xcb_out.firstKeyBehavior = firstKeyBehavior;
+    xcb_out.nKeyBehaviors = nKeyBehaviors;
+    xcb_out.virtualMods = virtualMods;
+    xcb_out.firstKeyExplicit = firstKeyExplicit;
+    xcb_out.nKeyExplicit = nKeyExplicit;
+    xcb_out.firstModMapKey = firstModMapKey;
+    xcb_out.nModMapKeys = nModMapKeys;
+    xcb_out.firstVModMapKey = firstVModMapKey;
+    xcb_out.nVModMapKeys = nVModMapKeys;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_get_map_cookie_t
+xcb_xkb_get_map_unchecked (xcb_connection_t      *c,
+                           xcb_xkb_device_spec_t  deviceSpec,
+                           uint16_t               full,
+                           uint16_t               partial,
+                           uint8_t                firstType,
+                           uint8_t                nTypes,
+                           xcb_keycode_t          firstKeySym,
+                           uint8_t                nKeySyms,
+                           xcb_keycode_t          firstKeyAction,
+                           uint8_t                nKeyActions,
+                           xcb_keycode_t          firstKeyBehavior,
+                           uint8_t                nKeyBehaviors,
+                           uint16_t               virtualMods,
+                           xcb_keycode_t          firstKeyExplicit,
+                           uint8_t                nKeyExplicit,
+                           xcb_keycode_t          firstModMapKey,
+                           uint8_t                nModMapKeys,
+                           xcb_keycode_t          firstVModMapKey,
+                           uint8_t                nVModMapKeys)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_GET_MAP,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_get_map_cookie_t xcb_ret;
+    xcb_xkb_get_map_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.full = full;
+    xcb_out.partial = partial;
+    xcb_out.firstType = firstType;
+    xcb_out.nTypes = nTypes;
+    xcb_out.firstKeySym = firstKeySym;
+    xcb_out.nKeySyms = nKeySyms;
+    xcb_out.firstKeyAction = firstKeyAction;
+    xcb_out.nKeyActions = nKeyActions;
+    xcb_out.firstKeyBehavior = firstKeyBehavior;
+    xcb_out.nKeyBehaviors = nKeyBehaviors;
+    xcb_out.virtualMods = virtualMods;
+    xcb_out.firstKeyExplicit = firstKeyExplicit;
+    xcb_out.nKeyExplicit = nKeyExplicit;
+    xcb_out.firstModMapKey = firstModMapKey;
+    xcb_out.nModMapKeys = nModMapKeys;
+    xcb_out.firstVModMapKey = firstVModMapKey;
+    xcb_out.nVModMapKeys = nVModMapKeys;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+void *
+xcb_xkb_get_map_map (const xcb_xkb_get_map_reply_t *R)
+{
+    return (void *) (R + 1);
+}
+
+xcb_xkb_get_map_reply_t *
+xcb_xkb_get_map_reply (xcb_connection_t          *c,
+                       xcb_xkb_get_map_cookie_t   cookie  /**< */,
+                       xcb_generic_error_t      **e)
+{
+    return (xcb_xkb_get_map_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xkb_set_map_values_types_length (const xcb_xkb_set_map_request_t *R,
+                                     const xcb_xkb_set_map_values_t *S)
+{
+    return R->nTypes;
+}
+
+xcb_xkb_set_key_type_iterator_t
+xcb_xkb_set_map_values_types_iterator (const xcb_xkb_set_map_request_t *R,
+                                       const xcb_xkb_set_map_values_t *S)
+{
+    xcb_xkb_set_key_type_iterator_t i;
+    i.data = S->types;
+    i.rem = R->nTypes;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_xkb_set_map_values_syms_length (const xcb_xkb_set_map_request_t *R,
+                                    const xcb_xkb_set_map_values_t *S)
+{
+    return R->nKeySyms;
+}
+
+xcb_xkb_key_sym_map_iterator_t
+xcb_xkb_set_map_values_syms_iterator (const xcb_xkb_set_map_request_t *R,
+                                      const xcb_xkb_set_map_values_t *S)
+{
+    xcb_xkb_key_sym_map_iterator_t i;
+    i.data = S->syms;
+    i.rem = R->nKeySyms;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+uint8_t *
+xcb_xkb_set_map_values_actions_count (const xcb_xkb_set_map_values_t *S)
+{
+    return S->actionsCount;
+}
+
+int
+xcb_xkb_set_map_values_actions_count_length (const xcb_xkb_set_map_request_t *R,
+                                             const xcb_xkb_set_map_values_t *S)
+{
+    return R->nKeyActions;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_set_map_values_actions_count_end (const xcb_xkb_set_map_request_t *R,
+                                          const xcb_xkb_set_map_values_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->actionsCount + R->nKeyActions;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_action_t *
+xcb_xkb_set_map_values_actions (const xcb_xkb_set_map_values_t *S)
+{
+    return S->actions;
+}
+
+int
+xcb_xkb_set_map_values_actions_length (const xcb_xkb_set_map_request_t *R,
+                                       const xcb_xkb_set_map_values_t *S)
+{
+    return R->totalActions;
+}
+
+xcb_xkb_action_iterator_t
+xcb_xkb_set_map_values_actions_iterator (const xcb_xkb_set_map_request_t *R,
+                                         const xcb_xkb_set_map_values_t *S)
+{
+    xcb_xkb_action_iterator_t i;
+    i.data = S->actions;
+    i.rem = R->totalActions;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_set_behavior_t *
+xcb_xkb_set_map_values_behaviors (const xcb_xkb_set_map_values_t *S)
+{
+    return S->behaviors;
+}
+
+int
+xcb_xkb_set_map_values_behaviors_length (const xcb_xkb_set_map_request_t *R,
+                                         const xcb_xkb_set_map_values_t *S)
+{
+    return R->totalKeyBehaviors;
+}
+
+xcb_xkb_set_behavior_iterator_t
+xcb_xkb_set_map_values_behaviors_iterator (const xcb_xkb_set_map_request_t *R,
+                                           const xcb_xkb_set_map_values_t *S)
+{
+    xcb_xkb_set_behavior_iterator_t i;
+    i.data = S->behaviors;
+    i.rem = R->totalKeyBehaviors;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+uint8_t *
+xcb_xkb_set_map_values_vmods (const xcb_xkb_set_map_values_t *S)
+{
+    return S->vmods;
+}
+
+int
+xcb_xkb_set_map_values_vmods_length (const xcb_xkb_set_map_request_t *R,
+                                     const xcb_xkb_set_map_values_t *S)
+{
+    return xcb_popcount(R->virtualMods);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_set_map_values_vmods_end (const xcb_xkb_set_map_request_t *R,
+                                  const xcb_xkb_set_map_values_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->vmods + xcb_popcount(R->virtualMods);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_set_explicit_t *
+xcb_xkb_set_map_values_explicit (const xcb_xkb_set_map_values_t *S)
+{
+    return S->explicit;
+}
+
+int
+xcb_xkb_set_map_values_explicit_length (const xcb_xkb_set_map_request_t *R,
+                                        const xcb_xkb_set_map_values_t *S)
+{
+    return R->totalKeyExplicit;
+}
+
+xcb_xkb_set_explicit_iterator_t
+xcb_xkb_set_map_values_explicit_iterator (const xcb_xkb_set_map_request_t *R,
+                                          const xcb_xkb_set_map_values_t *S)
+{
+    xcb_xkb_set_explicit_iterator_t i;
+    i.data = S->explicit;
+    i.rem = R->totalKeyExplicit;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_key_mod_map_t *
+xcb_xkb_set_map_values_modmap (const xcb_xkb_set_map_values_t *S)
+{
+    return S->modmap;
+}
+
+int
+xcb_xkb_set_map_values_modmap_length (const xcb_xkb_set_map_request_t *R,
+                                      const xcb_xkb_set_map_values_t *S)
+{
+    return R->totalModMapKeys;
+}
+
+xcb_xkb_key_mod_map_iterator_t
+xcb_xkb_set_map_values_modmap_iterator (const xcb_xkb_set_map_request_t *R,
+                                        const xcb_xkb_set_map_values_t *S)
+{
+    xcb_xkb_key_mod_map_iterator_t i;
+    i.data = S->modmap;
+    i.rem = R->totalModMapKeys;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_key_v_mod_map_t *
+xcb_xkb_set_map_values_vmodmap (const xcb_xkb_set_map_values_t *S)
+{
+    return S->vmodmap;
+}
+
+int
+xcb_xkb_set_map_values_vmodmap_length (const xcb_xkb_set_map_request_t *R,
+                                       const xcb_xkb_set_map_values_t *S)
+{
+    return R->totalVModMapKeys;
+}
+
+xcb_xkb_key_v_mod_map_iterator_t
+xcb_xkb_set_map_values_vmodmap_iterator (const xcb_xkb_set_map_request_t *R,
+                                         const xcb_xkb_set_map_values_t *S)
+{
+    xcb_xkb_key_v_mod_map_iterator_t i;
+    i.data = S->vmodmap;
+    i.rem = R->totalVModMapKeys;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_xkb_set_map_values_serialize (void                           **_buffer,
+                                  uint8_t                          nTypes,
+                                  uint8_t                          nKeySyms,
+                                  uint8_t                          nKeyActions,
+                                  uint16_t                         totalActions,
+                                  uint8_t                          totalKeyBehaviors,
+                                  uint16_t                         virtualMods,
+                                  uint8_t                          totalKeyExplicit,
+                                  uint8_t                          totalModMapKeys,
+                                  uint8_t                          totalVModMapKeys,
+                                  uint16_t                         present,
+                                  const xcb_xkb_set_map_values_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[21];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(present & XCB_XKB_MAP_PART_KEY_TYPES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* types */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->types;
+        xcb_parts[xcb_parts_idx].iov_len = 0;
+        xcb_tmp = (char *) _aux->types;
+        for(i=0; i<nTypes; i++) { 
+            xcb_block_len = xcb_xkb_set_key_type_sizeof(xcb_tmp);
+            xcb_parts[xcb_parts_idx].iov_len += xcb_block_len;
+        }
+        xcb_block_len = xcb_parts[xcb_parts_idx].iov_len;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_set_key_type_t);
+    }
+    if(present & XCB_XKB_MAP_PART_KEY_SYMS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* syms */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->syms;
+        xcb_parts[xcb_parts_idx].iov_len = 0;
+        xcb_tmp = (char *) _aux->syms;
+        for(i=0; i<nKeySyms; i++) { 
+            xcb_block_len = xcb_xkb_key_sym_map_sizeof(xcb_tmp);
+            xcb_parts[xcb_parts_idx].iov_len += xcb_block_len;
+        }
+        xcb_block_len = xcb_parts[xcb_parts_idx].iov_len;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_sym_map_t);
+    }
+    if(present & XCB_XKB_MAP_PART_KEY_ACTIONS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* actionsCount */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->actionsCount;
+        xcb_block_len += nKeyActions * sizeof(xcb_keycode_t);
+        xcb_parts[xcb_parts_idx].iov_len = nKeyActions * sizeof(xcb_keycode_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* actions */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->actions;
+        xcb_block_len += totalActions * sizeof(xcb_xkb_action_t);
+        xcb_parts[xcb_parts_idx].iov_len = totalActions * sizeof(xcb_xkb_action_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_action_t);
+    }
+    if(present & XCB_XKB_MAP_PART_KEY_BEHAVIORS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* behaviors */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->behaviors;
+        xcb_block_len += totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t);
+        xcb_parts[xcb_parts_idx].iov_len = totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_set_behavior_t);
+    }
+    if(present & XCB_XKB_MAP_PART_VIRTUAL_MODS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* vmods */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->vmods;
+        xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_keycode_t);
+        xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(virtualMods) * sizeof(xcb_keycode_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* explicit */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->explicit;
+        xcb_block_len += totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t);
+        xcb_parts[xcb_parts_idx].iov_len = totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_set_explicit_t);
+    }
+    if(present & XCB_XKB_MAP_PART_MODIFIER_MAP) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* modmap */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->modmap;
+        xcb_block_len += totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t);
+        xcb_parts[xcb_parts_idx].iov_len = totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_mod_map_t);
+    }
+    if(present & XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* vmodmap */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->vmodmap;
+        xcb_block_len += totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t);
+        xcb_parts[xcb_parts_idx].iov_len = totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_v_mod_map_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_xkb_set_map_values_unpack (const void                *_buffer,
+                               uint8_t                    nTypes,
+                               uint8_t                    nKeySyms,
+                               uint8_t                    nKeyActions,
+                               uint16_t                   totalActions,
+                               uint8_t                    totalKeyBehaviors,
+                               uint16_t                   virtualMods,
+                               uint8_t                    totalKeyExplicit,
+                               uint8_t                    totalModMapKeys,
+                               uint8_t                    totalVModMapKeys,
+                               uint16_t                   present,
+                               xcb_xkb_set_map_values_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    if(present & XCB_XKB_MAP_PART_KEY_TYPES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* types */
+        _aux->types = (xcb_xkb_set_key_type_t *)xcb_tmp;
+        for(i=0; i<nTypes; i++) {
+            xcb_tmp_len = xcb_xkb_set_key_type_sizeof(xcb_tmp);
+            xcb_block_len += xcb_tmp_len;
+            xcb_tmp += xcb_tmp_len;
+        }
+        xcb_align_to = ALIGNOF(xcb_xkb_set_key_type_t);
+    }
+    if(present & XCB_XKB_MAP_PART_KEY_SYMS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* syms */
+        _aux->syms = (xcb_xkb_key_sym_map_t *)xcb_tmp;
+        for(i=0; i<nKeySyms; i++) {
+            xcb_tmp_len = xcb_xkb_key_sym_map_sizeof(xcb_tmp);
+            xcb_block_len += xcb_tmp_len;
+            xcb_tmp += xcb_tmp_len;
+        }
+        xcb_align_to = ALIGNOF(xcb_xkb_key_sym_map_t);
+    }
+    if(present & XCB_XKB_MAP_PART_KEY_ACTIONS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* actionsCount */
+        _aux->actionsCount = (uint8_t *)xcb_tmp;
+        xcb_block_len += nKeyActions * sizeof(xcb_keycode_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* actions */
+        _aux->actions = (xcb_xkb_action_t *)xcb_tmp;
+        xcb_block_len += totalActions * sizeof(xcb_xkb_action_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_action_t);
+    }
+    if(present & XCB_XKB_MAP_PART_KEY_BEHAVIORS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* behaviors */
+        _aux->behaviors = (xcb_xkb_set_behavior_t *)xcb_tmp;
+        xcb_block_len += totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_set_behavior_t);
+    }
+    if(present & XCB_XKB_MAP_PART_VIRTUAL_MODS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* vmods */
+        _aux->vmods = (uint8_t *)xcb_tmp;
+        xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_keycode_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* explicit */
+        _aux->explicit = (xcb_xkb_set_explicit_t *)xcb_tmp;
+        xcb_block_len += totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_set_explicit_t);
+    }
+    if(present & XCB_XKB_MAP_PART_MODIFIER_MAP) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* modmap */
+        _aux->modmap = (xcb_xkb_key_mod_map_t *)xcb_tmp;
+        xcb_block_len += totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_mod_map_t);
+    }
+    if(present & XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* vmodmap */
+        _aux->vmodmap = (xcb_xkb_key_v_mod_map_t *)xcb_tmp;
+        xcb_block_len += totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_v_mod_map_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_xkb_set_map_values_sizeof (const void  *_buffer,
+                               uint8_t      nTypes,
+                               uint8_t      nKeySyms,
+                               uint8_t      nKeyActions,
+                               uint16_t     totalActions,
+                               uint8_t      totalKeyBehaviors,
+                               uint16_t     virtualMods,
+                               uint8_t      totalKeyExplicit,
+                               uint8_t      totalModMapKeys,
+                               uint8_t      totalVModMapKeys,
+                               uint16_t     present)
+{
+    xcb_xkb_set_map_values_t _aux;
+    return xcb_xkb_set_map_values_unpack(_buffer, nTypes, nKeySyms, nKeyActions, totalActions, totalKeyBehaviors, virtualMods, totalKeyExplicit, totalModMapKeys, totalVModMapKeys, present, &_aux);
+}
+
+int
+xcb_xkb_set_map_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_set_map_request_t *_aux = (xcb_xkb_set_map_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xkb_set_map_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* values */
+    xcb_block_len += xcb_xkb_set_map_values_sizeof(xcb_tmp, _aux->nTypes, _aux->nKeySyms, _aux->nKeyActions, _aux->totalActions, _aux->totalKeyBehaviors, _aux->virtualMods, _aux->totalKeyExplicit, _aux->totalModMapKeys, _aux->totalVModMapKeys, _aux->present);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_xkb_set_map_checked (xcb_connection_t      *c,
+                         xcb_xkb_device_spec_t  deviceSpec,
+                         uint16_t               present,
+                         uint16_t               flags,
+                         xcb_keycode_t          minKeyCode,
+                         xcb_keycode_t          maxKeyCode,
+                         uint8_t                firstType,
+                         uint8_t                nTypes,
+                         xcb_keycode_t          firstKeySym,
+                         uint8_t                nKeySyms,
+                         uint16_t               totalSyms,
+                         xcb_keycode_t          firstKeyAction,
+                         uint8_t                nKeyActions,
+                         uint16_t               totalActions,
+                         xcb_keycode_t          firstKeyBehavior,
+                         uint8_t                nKeyBehaviors,
+                         uint8_t                totalKeyBehaviors,
+                         xcb_keycode_t          firstKeyExplicit,
+                         uint8_t                nKeyExplicit,
+                         uint8_t                totalKeyExplicit,
+                         xcb_keycode_t          firstModMapKey,
+                         uint8_t                nModMapKeys,
+                         uint8_t                totalModMapKeys,
+                         xcb_keycode_t          firstVModMapKey,
+                         uint8_t                nVModMapKeys,
+                         uint8_t                totalVModMapKeys,
+                         uint16_t               virtualMods,
+                         const void            *values)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SET_MAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_set_map_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.present = present;
+    xcb_out.flags = flags;
+    xcb_out.minKeyCode = minKeyCode;
+    xcb_out.maxKeyCode = maxKeyCode;
+    xcb_out.firstType = firstType;
+    xcb_out.nTypes = nTypes;
+    xcb_out.firstKeySym = firstKeySym;
+    xcb_out.nKeySyms = nKeySyms;
+    xcb_out.totalSyms = totalSyms;
+    xcb_out.firstKeyAction = firstKeyAction;
+    xcb_out.nKeyActions = nKeyActions;
+    xcb_out.totalActions = totalActions;
+    xcb_out.firstKeyBehavior = firstKeyBehavior;
+    xcb_out.nKeyBehaviors = nKeyBehaviors;
+    xcb_out.totalKeyBehaviors = totalKeyBehaviors;
+    xcb_out.firstKeyExplicit = firstKeyExplicit;
+    xcb_out.nKeyExplicit = nKeyExplicit;
+    xcb_out.totalKeyExplicit = totalKeyExplicit;
+    xcb_out.firstModMapKey = firstModMapKey;
+    xcb_out.nModMapKeys = nModMapKeys;
+    xcb_out.totalModMapKeys = totalModMapKeys;
+    xcb_out.firstVModMapKey = firstVModMapKey;
+    xcb_out.nVModMapKeys = nVModMapKeys;
+    xcb_out.totalVModMapKeys = totalVModMapKeys;
+    xcb_out.virtualMods = virtualMods;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_xkb_set_map_values_t values */
+    xcb_parts[4].iov_base = (char *) values;
+    xcb_parts[4].iov_len =
+      xcb_xkb_set_map_values_sizeof (values, nTypes, nKeySyms, nKeyActions, totalActions, totalKeyBehaviors, virtualMods, totalKeyExplicit, totalModMapKeys, totalVModMapKeys, present);
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xkb_set_map (xcb_connection_t      *c,
+                 xcb_xkb_device_spec_t  deviceSpec,
+                 uint16_t               present,
+                 uint16_t               flags,
+                 xcb_keycode_t          minKeyCode,
+                 xcb_keycode_t          maxKeyCode,
+                 uint8_t                firstType,
+                 uint8_t                nTypes,
+                 xcb_keycode_t          firstKeySym,
+                 uint8_t                nKeySyms,
+                 uint16_t               totalSyms,
+                 xcb_keycode_t          firstKeyAction,
+                 uint8_t                nKeyActions,
+                 uint16_t               totalActions,
+                 xcb_keycode_t          firstKeyBehavior,
+                 uint8_t                nKeyBehaviors,
+                 uint8_t                totalKeyBehaviors,
+                 xcb_keycode_t          firstKeyExplicit,
+                 uint8_t                nKeyExplicit,
+                 uint8_t                totalKeyExplicit,
+                 xcb_keycode_t          firstModMapKey,
+                 uint8_t                nModMapKeys,
+                 uint8_t                totalModMapKeys,
+                 xcb_keycode_t          firstVModMapKey,
+                 uint8_t                nVModMapKeys,
+                 uint8_t                totalVModMapKeys,
+                 uint16_t               virtualMods,
+                 const void            *values)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SET_MAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_set_map_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.present = present;
+    xcb_out.flags = flags;
+    xcb_out.minKeyCode = minKeyCode;
+    xcb_out.maxKeyCode = maxKeyCode;
+    xcb_out.firstType = firstType;
+    xcb_out.nTypes = nTypes;
+    xcb_out.firstKeySym = firstKeySym;
+    xcb_out.nKeySyms = nKeySyms;
+    xcb_out.totalSyms = totalSyms;
+    xcb_out.firstKeyAction = firstKeyAction;
+    xcb_out.nKeyActions = nKeyActions;
+    xcb_out.totalActions = totalActions;
+    xcb_out.firstKeyBehavior = firstKeyBehavior;
+    xcb_out.nKeyBehaviors = nKeyBehaviors;
+    xcb_out.totalKeyBehaviors = totalKeyBehaviors;
+    xcb_out.firstKeyExplicit = firstKeyExplicit;
+    xcb_out.nKeyExplicit = nKeyExplicit;
+    xcb_out.totalKeyExplicit = totalKeyExplicit;
+    xcb_out.firstModMapKey = firstModMapKey;
+    xcb_out.nModMapKeys = nModMapKeys;
+    xcb_out.totalModMapKeys = totalModMapKeys;
+    xcb_out.firstVModMapKey = firstVModMapKey;
+    xcb_out.nVModMapKeys = nVModMapKeys;
+    xcb_out.totalVModMapKeys = totalVModMapKeys;
+    xcb_out.virtualMods = virtualMods;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_xkb_set_map_values_t values */
+    xcb_parts[4].iov_base = (char *) values;
+    xcb_parts[4].iov_len =
+      xcb_xkb_set_map_values_sizeof (values, nTypes, nKeySyms, nKeyActions, totalActions, totalKeyBehaviors, virtualMods, totalKeyExplicit, totalModMapKeys, totalVModMapKeys, present);
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xkb_set_map_aux_checked (xcb_connection_t               *c,
+                             xcb_xkb_device_spec_t           deviceSpec,
+                             uint16_t                        present,
+                             uint16_t                        flags,
+                             xcb_keycode_t                   minKeyCode,
+                             xcb_keycode_t                   maxKeyCode,
+                             uint8_t                         firstType,
+                             uint8_t                         nTypes,
+                             xcb_keycode_t                   firstKeySym,
+                             uint8_t                         nKeySyms,
+                             uint16_t                        totalSyms,
+                             xcb_keycode_t                   firstKeyAction,
+                             uint8_t                         nKeyActions,
+                             uint16_t                        totalActions,
+                             xcb_keycode_t                   firstKeyBehavior,
+                             uint8_t                         nKeyBehaviors,
+                             uint8_t                         totalKeyBehaviors,
+                             xcb_keycode_t                   firstKeyExplicit,
+                             uint8_t                         nKeyExplicit,
+                             uint8_t                         totalKeyExplicit,
+                             xcb_keycode_t                   firstModMapKey,
+                             uint8_t                         nModMapKeys,
+                             uint8_t                         totalModMapKeys,
+                             xcb_keycode_t                   firstVModMapKey,
+                             uint8_t                         nVModMapKeys,
+                             uint8_t                         totalVModMapKeys,
+                             uint16_t                        virtualMods,
+                             const xcb_xkb_set_map_values_t *values)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SET_MAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_set_map_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.present = present;
+    xcb_out.flags = flags;
+    xcb_out.minKeyCode = minKeyCode;
+    xcb_out.maxKeyCode = maxKeyCode;
+    xcb_out.firstType = firstType;
+    xcb_out.nTypes = nTypes;
+    xcb_out.firstKeySym = firstKeySym;
+    xcb_out.nKeySyms = nKeySyms;
+    xcb_out.totalSyms = totalSyms;
+    xcb_out.firstKeyAction = firstKeyAction;
+    xcb_out.nKeyActions = nKeyActions;
+    xcb_out.totalActions = totalActions;
+    xcb_out.firstKeyBehavior = firstKeyBehavior;
+    xcb_out.nKeyBehaviors = nKeyBehaviors;
+    xcb_out.totalKeyBehaviors = totalKeyBehaviors;
+    xcb_out.firstKeyExplicit = firstKeyExplicit;
+    xcb_out.nKeyExplicit = nKeyExplicit;
+    xcb_out.totalKeyExplicit = totalKeyExplicit;
+    xcb_out.firstModMapKey = firstModMapKey;
+    xcb_out.nModMapKeys = nModMapKeys;
+    xcb_out.totalModMapKeys = totalModMapKeys;
+    xcb_out.firstVModMapKey = firstVModMapKey;
+    xcb_out.nVModMapKeys = nVModMapKeys;
+    xcb_out.totalVModMapKeys = totalVModMapKeys;
+    xcb_out.virtualMods = virtualMods;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_xkb_set_map_values_t values */
+    xcb_parts[4].iov_len =
+      xcb_xkb_set_map_values_serialize (&xcb_aux0, nTypes, nKeySyms, nKeyActions, totalActions, totalKeyBehaviors, virtualMods, totalKeyExplicit, totalModMapKeys, totalVModMapKeys, present, values);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xkb_set_map_aux (xcb_connection_t               *c,
+                     xcb_xkb_device_spec_t           deviceSpec,
+                     uint16_t                        present,
+                     uint16_t                        flags,
+                     xcb_keycode_t                   minKeyCode,
+                     xcb_keycode_t                   maxKeyCode,
+                     uint8_t                         firstType,
+                     uint8_t                         nTypes,
+                     xcb_keycode_t                   firstKeySym,
+                     uint8_t                         nKeySyms,
+                     uint16_t                        totalSyms,
+                     xcb_keycode_t                   firstKeyAction,
+                     uint8_t                         nKeyActions,
+                     uint16_t                        totalActions,
+                     xcb_keycode_t                   firstKeyBehavior,
+                     uint8_t                         nKeyBehaviors,
+                     uint8_t                         totalKeyBehaviors,
+                     xcb_keycode_t                   firstKeyExplicit,
+                     uint8_t                         nKeyExplicit,
+                     uint8_t                         totalKeyExplicit,
+                     xcb_keycode_t                   firstModMapKey,
+                     uint8_t                         nModMapKeys,
+                     uint8_t                         totalModMapKeys,
+                     xcb_keycode_t                   firstVModMapKey,
+                     uint8_t                         nVModMapKeys,
+                     uint8_t                         totalVModMapKeys,
+                     uint16_t                        virtualMods,
+                     const xcb_xkb_set_map_values_t *values)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SET_MAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_set_map_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.present = present;
+    xcb_out.flags = flags;
+    xcb_out.minKeyCode = minKeyCode;
+    xcb_out.maxKeyCode = maxKeyCode;
+    xcb_out.firstType = firstType;
+    xcb_out.nTypes = nTypes;
+    xcb_out.firstKeySym = firstKeySym;
+    xcb_out.nKeySyms = nKeySyms;
+    xcb_out.totalSyms = totalSyms;
+    xcb_out.firstKeyAction = firstKeyAction;
+    xcb_out.nKeyActions = nKeyActions;
+    xcb_out.totalActions = totalActions;
+    xcb_out.firstKeyBehavior = firstKeyBehavior;
+    xcb_out.nKeyBehaviors = nKeyBehaviors;
+    xcb_out.totalKeyBehaviors = totalKeyBehaviors;
+    xcb_out.firstKeyExplicit = firstKeyExplicit;
+    xcb_out.nKeyExplicit = nKeyExplicit;
+    xcb_out.totalKeyExplicit = totalKeyExplicit;
+    xcb_out.firstModMapKey = firstModMapKey;
+    xcb_out.nModMapKeys = nModMapKeys;
+    xcb_out.totalModMapKeys = totalModMapKeys;
+    xcb_out.firstVModMapKey = firstVModMapKey;
+    xcb_out.nVModMapKeys = nVModMapKeys;
+    xcb_out.totalVModMapKeys = totalVModMapKeys;
+    xcb_out.virtualMods = virtualMods;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_xkb_set_map_values_t values */
+    xcb_parts[4].iov_len =
+      xcb_xkb_set_map_values_serialize (&xcb_aux0, nTypes, nKeySyms, nKeyActions, totalActions, totalKeyBehaviors, virtualMods, totalKeyExplicit, totalModMapKeys, totalVModMapKeys, present, values);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+void *
+xcb_xkb_set_map_values (const xcb_xkb_set_map_request_t *R)
+{
+    return (void *) (R + 1);
+}
+
+int
+xcb_xkb_get_compat_map_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_get_compat_map_reply_t *_aux = (xcb_xkb_get_compat_map_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xkb_get_compat_map_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* si_rtrn */
+    xcb_block_len += _aux->nSIRtrn * sizeof(xcb_xkb_sym_interpret_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xkb_sym_interpret_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* group_rtrn */
+    xcb_block_len += xcb_popcount(_aux->groupsRtrn) * sizeof(xcb_xkb_mod_def_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xkb_mod_def_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xkb_get_compat_map_cookie_t
+xcb_xkb_get_compat_map (xcb_connection_t      *c,
+                        xcb_xkb_device_spec_t  deviceSpec,
+                        uint8_t                groups,
+                        uint8_t                getAllSI,
+                        uint16_t               firstSI,
+                        uint16_t               nSI)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_GET_COMPAT_MAP,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_get_compat_map_cookie_t xcb_ret;
+    xcb_xkb_get_compat_map_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.groups = groups;
+    xcb_out.getAllSI = getAllSI;
+    xcb_out.firstSI = firstSI;
+    xcb_out.nSI = nSI;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_get_compat_map_cookie_t
+xcb_xkb_get_compat_map_unchecked (xcb_connection_t      *c,
+                                  xcb_xkb_device_spec_t  deviceSpec,
+                                  uint8_t                groups,
+                                  uint8_t                getAllSI,
+                                  uint16_t               firstSI,
+                                  uint16_t               nSI)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_GET_COMPAT_MAP,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_get_compat_map_cookie_t xcb_ret;
+    xcb_xkb_get_compat_map_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.groups = groups;
+    xcb_out.getAllSI = getAllSI;
+    xcb_out.firstSI = firstSI;
+    xcb_out.nSI = nSI;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_sym_interpret_t *
+xcb_xkb_get_compat_map_si_rtrn (const xcb_xkb_get_compat_map_reply_t *R)
+{
+    return (xcb_xkb_sym_interpret_t *) (R + 1);
+}
+
+int
+xcb_xkb_get_compat_map_si_rtrn_length (const xcb_xkb_get_compat_map_reply_t *R)
+{
+    return R->nSIRtrn;
+}
+
+xcb_xkb_sym_interpret_iterator_t
+xcb_xkb_get_compat_map_si_rtrn_iterator (const xcb_xkb_get_compat_map_reply_t *R)
+{
+    xcb_xkb_sym_interpret_iterator_t i;
+    i.data = (xcb_xkb_sym_interpret_t *) (R + 1);
+    i.rem = R->nSIRtrn;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xkb_mod_def_t *
+xcb_xkb_get_compat_map_group_rtrn (const xcb_xkb_get_compat_map_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_xkb_sym_interpret_end(xcb_xkb_get_compat_map_si_rtrn_iterator(R));
+    return (xcb_xkb_mod_def_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_mod_def_t, prev.index) + 0);
+}
+
+int
+xcb_xkb_get_compat_map_group_rtrn_length (const xcb_xkb_get_compat_map_reply_t *R)
+{
+    return xcb_popcount(R->groupsRtrn);
+}
+
+xcb_xkb_mod_def_iterator_t
+xcb_xkb_get_compat_map_group_rtrn_iterator (const xcb_xkb_get_compat_map_reply_t *R)
+{
+    xcb_xkb_mod_def_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_xkb_sym_interpret_end(xcb_xkb_get_compat_map_si_rtrn_iterator(R));
+    i.data = (xcb_xkb_mod_def_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_mod_def_t, prev.index));
+    i.rem = xcb_popcount(R->groupsRtrn);
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xkb_get_compat_map_reply_t *
+xcb_xkb_get_compat_map_reply (xcb_connection_t                 *c,
+                              xcb_xkb_get_compat_map_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_xkb_get_compat_map_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xkb_set_compat_map_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_set_compat_map_request_t *_aux = (xcb_xkb_set_compat_map_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xkb_set_compat_map_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* si */
+    xcb_block_len += _aux->nSI * sizeof(xcb_xkb_sym_interpret_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xkb_sym_interpret_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* groupMaps */
+    xcb_block_len += xcb_popcount(_aux->groups) * sizeof(xcb_xkb_mod_def_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xkb_mod_def_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_xkb_set_compat_map_checked (xcb_connection_t              *c,
+                                xcb_xkb_device_spec_t          deviceSpec,
+                                uint8_t                        recomputeActions,
+                                uint8_t                        truncateSI,
+                                uint8_t                        groups,
+                                uint16_t                       firstSI,
+                                uint16_t                       nSI,
+                                const xcb_xkb_sym_interpret_t *si,
+                                const xcb_xkb_mod_def_t       *groupMaps)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SET_COMPAT_MAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_set_compat_map_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.pad0 = 0;
+    xcb_out.recomputeActions = recomputeActions;
+    xcb_out.truncateSI = truncateSI;
+    xcb_out.groups = groups;
+    xcb_out.firstSI = firstSI;
+    xcb_out.nSI = nSI;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_xkb_sym_interpret_t si */
+    xcb_parts[4].iov_base = (char *) si;
+    xcb_parts[4].iov_len = nSI * sizeof(xcb_xkb_sym_interpret_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_xkb_mod_def_t groupMaps */
+    xcb_parts[6].iov_base = (char *) groupMaps;
+    xcb_parts[6].iov_len = xcb_popcount(groups) * sizeof(xcb_xkb_mod_def_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xkb_set_compat_map (xcb_connection_t              *c,
+                        xcb_xkb_device_spec_t          deviceSpec,
+                        uint8_t                        recomputeActions,
+                        uint8_t                        truncateSI,
+                        uint8_t                        groups,
+                        uint16_t                       firstSI,
+                        uint16_t                       nSI,
+                        const xcb_xkb_sym_interpret_t *si,
+                        const xcb_xkb_mod_def_t       *groupMaps)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SET_COMPAT_MAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_set_compat_map_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.pad0 = 0;
+    xcb_out.recomputeActions = recomputeActions;
+    xcb_out.truncateSI = truncateSI;
+    xcb_out.groups = groups;
+    xcb_out.firstSI = firstSI;
+    xcb_out.nSI = nSI;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_xkb_sym_interpret_t si */
+    xcb_parts[4].iov_base = (char *) si;
+    xcb_parts[4].iov_len = nSI * sizeof(xcb_xkb_sym_interpret_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_xkb_mod_def_t groupMaps */
+    xcb_parts[6].iov_base = (char *) groupMaps;
+    xcb_parts[6].iov_len = xcb_popcount(groups) * sizeof(xcb_xkb_mod_def_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_sym_interpret_t *
+xcb_xkb_set_compat_map_si (const xcb_xkb_set_compat_map_request_t *R)
+{
+    return (xcb_xkb_sym_interpret_t *) (R + 1);
+}
+
+int
+xcb_xkb_set_compat_map_si_length (const xcb_xkb_set_compat_map_request_t *R)
+{
+    return R->nSI;
+}
+
+xcb_xkb_sym_interpret_iterator_t
+xcb_xkb_set_compat_map_si_iterator (const xcb_xkb_set_compat_map_request_t *R)
+{
+    xcb_xkb_sym_interpret_iterator_t i;
+    i.data = (xcb_xkb_sym_interpret_t *) (R + 1);
+    i.rem = R->nSI;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xkb_mod_def_t *
+xcb_xkb_set_compat_map_group_maps (const xcb_xkb_set_compat_map_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_xkb_sym_interpret_end(xcb_xkb_set_compat_map_si_iterator(R));
+    return (xcb_xkb_mod_def_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_mod_def_t, prev.index) + 0);
+}
+
+int
+xcb_xkb_set_compat_map_group_maps_length (const xcb_xkb_set_compat_map_request_t *R)
+{
+    return xcb_popcount(R->groups);
+}
+
+xcb_xkb_mod_def_iterator_t
+xcb_xkb_set_compat_map_group_maps_iterator (const xcb_xkb_set_compat_map_request_t *R)
+{
+    xcb_xkb_mod_def_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_xkb_sym_interpret_end(xcb_xkb_set_compat_map_si_iterator(R));
+    i.data = (xcb_xkb_mod_def_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_mod_def_t, prev.index));
+    i.rem = xcb_popcount(R->groups);
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xkb_get_indicator_state_cookie_t
+xcb_xkb_get_indicator_state (xcb_connection_t      *c,
+                             xcb_xkb_device_spec_t  deviceSpec)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_GET_INDICATOR_STATE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_get_indicator_state_cookie_t xcb_ret;
+    xcb_xkb_get_indicator_state_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_get_indicator_state_cookie_t
+xcb_xkb_get_indicator_state_unchecked (xcb_connection_t      *c,
+                                       xcb_xkb_device_spec_t  deviceSpec)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_GET_INDICATOR_STATE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_get_indicator_state_cookie_t xcb_ret;
+    xcb_xkb_get_indicator_state_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_get_indicator_state_reply_t *
+xcb_xkb_get_indicator_state_reply (xcb_connection_t                      *c,
+                                   xcb_xkb_get_indicator_state_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e)
+{
+    return (xcb_xkb_get_indicator_state_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xkb_get_indicator_map_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_get_indicator_map_reply_t *_aux = (xcb_xkb_get_indicator_map_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xkb_get_indicator_map_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* maps */
+    xcb_block_len += xcb_popcount(_aux->which) * sizeof(xcb_xkb_indicator_map_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xkb_indicator_map_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xkb_get_indicator_map_cookie_t
+xcb_xkb_get_indicator_map (xcb_connection_t      *c,
+                           xcb_xkb_device_spec_t  deviceSpec,
+                           uint32_t               which)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_GET_INDICATOR_MAP,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_get_indicator_map_cookie_t xcb_ret;
+    xcb_xkb_get_indicator_map_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.which = which;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_get_indicator_map_cookie_t
+xcb_xkb_get_indicator_map_unchecked (xcb_connection_t      *c,
+                                     xcb_xkb_device_spec_t  deviceSpec,
+                                     uint32_t               which)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_GET_INDICATOR_MAP,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_get_indicator_map_cookie_t xcb_ret;
+    xcb_xkb_get_indicator_map_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.which = which;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_indicator_map_t *
+xcb_xkb_get_indicator_map_maps (const xcb_xkb_get_indicator_map_reply_t *R)
+{
+    return (xcb_xkb_indicator_map_t *) (R + 1);
+}
+
+int
+xcb_xkb_get_indicator_map_maps_length (const xcb_xkb_get_indicator_map_reply_t *R)
+{
+    return xcb_popcount(R->which);
+}
+
+xcb_xkb_indicator_map_iterator_t
+xcb_xkb_get_indicator_map_maps_iterator (const xcb_xkb_get_indicator_map_reply_t *R)
+{
+    xcb_xkb_indicator_map_iterator_t i;
+    i.data = (xcb_xkb_indicator_map_t *) (R + 1);
+    i.rem = xcb_popcount(R->which);
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xkb_get_indicator_map_reply_t *
+xcb_xkb_get_indicator_map_reply (xcb_connection_t                    *c,
+                                 xcb_xkb_get_indicator_map_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e)
+{
+    return (xcb_xkb_get_indicator_map_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xkb_set_indicator_map_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_set_indicator_map_request_t *_aux = (xcb_xkb_set_indicator_map_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xkb_set_indicator_map_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* maps */
+    xcb_block_len += xcb_popcount(_aux->which) * sizeof(xcb_xkb_indicator_map_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xkb_indicator_map_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_xkb_set_indicator_map_checked (xcb_connection_t              *c,
+                                   xcb_xkb_device_spec_t          deviceSpec,
+                                   uint32_t                       which,
+                                   const xcb_xkb_indicator_map_t *maps)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SET_INDICATOR_MAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_set_indicator_map_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.which = which;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_xkb_indicator_map_t maps */
+    xcb_parts[4].iov_base = (char *) maps;
+    xcb_parts[4].iov_len = xcb_popcount(which) * sizeof(xcb_xkb_indicator_map_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xkb_set_indicator_map (xcb_connection_t              *c,
+                           xcb_xkb_device_spec_t          deviceSpec,
+                           uint32_t                       which,
+                           const xcb_xkb_indicator_map_t *maps)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SET_INDICATOR_MAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_set_indicator_map_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.which = which;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_xkb_indicator_map_t maps */
+    xcb_parts[4].iov_base = (char *) maps;
+    xcb_parts[4].iov_len = xcb_popcount(which) * sizeof(xcb_xkb_indicator_map_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_indicator_map_t *
+xcb_xkb_set_indicator_map_maps (const xcb_xkb_set_indicator_map_request_t *R)
+{
+    return (xcb_xkb_indicator_map_t *) (R + 1);
+}
+
+int
+xcb_xkb_set_indicator_map_maps_length (const xcb_xkb_set_indicator_map_request_t *R)
+{
+    return xcb_popcount(R->which);
+}
+
+xcb_xkb_indicator_map_iterator_t
+xcb_xkb_set_indicator_map_maps_iterator (const xcb_xkb_set_indicator_map_request_t *R)
+{
+    xcb_xkb_indicator_map_iterator_t i;
+    i.data = (xcb_xkb_indicator_map_t *) (R + 1);
+    i.rem = xcb_popcount(R->which);
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xkb_get_named_indicator_cookie_t
+xcb_xkb_get_named_indicator (xcb_connection_t         *c,
+                             xcb_xkb_device_spec_t     deviceSpec,
+                             xcb_xkb_led_class_spec_t  ledClass,
+                             xcb_xkb_id_spec_t         ledID,
+                             xcb_atom_t                indicator)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_GET_NAMED_INDICATOR,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_get_named_indicator_cookie_t xcb_ret;
+    xcb_xkb_get_named_indicator_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.ledClass = ledClass;
+    xcb_out.ledID = ledID;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.indicator = indicator;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_get_named_indicator_cookie_t
+xcb_xkb_get_named_indicator_unchecked (xcb_connection_t         *c,
+                                       xcb_xkb_device_spec_t     deviceSpec,
+                                       xcb_xkb_led_class_spec_t  ledClass,
+                                       xcb_xkb_id_spec_t         ledID,
+                                       xcb_atom_t                indicator)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_GET_NAMED_INDICATOR,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_get_named_indicator_cookie_t xcb_ret;
+    xcb_xkb_get_named_indicator_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.ledClass = ledClass;
+    xcb_out.ledID = ledID;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.indicator = indicator;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_get_named_indicator_reply_t *
+xcb_xkb_get_named_indicator_reply (xcb_connection_t                      *c,
+                                   xcb_xkb_get_named_indicator_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e)
+{
+    return (xcb_xkb_get_named_indicator_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_xkb_set_named_indicator_checked (xcb_connection_t         *c,
+                                     xcb_xkb_device_spec_t     deviceSpec,
+                                     xcb_xkb_led_class_spec_t  ledClass,
+                                     xcb_xkb_id_spec_t         ledID,
+                                     xcb_atom_t                indicator,
+                                     uint8_t                   setState,
+                                     uint8_t                   on,
+                                     uint8_t                   setMap,
+                                     uint8_t                   createMap,
+                                     uint8_t                   map_flags,
+                                     uint8_t                   map_whichGroups,
+                                     uint8_t                   map_groups,
+                                     uint8_t                   map_whichMods,
+                                     uint8_t                   map_realMods,
+                                     uint16_t                  map_vmods,
+                                     uint32_t                  map_ctrls)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SET_NAMED_INDICATOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_set_named_indicator_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.ledClass = ledClass;
+    xcb_out.ledID = ledID;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.indicator = indicator;
+    xcb_out.setState = setState;
+    xcb_out.on = on;
+    xcb_out.setMap = setMap;
+    xcb_out.createMap = createMap;
+    xcb_out.pad1 = 0;
+    xcb_out.map_flags = map_flags;
+    xcb_out.map_whichGroups = map_whichGroups;
+    xcb_out.map_groups = map_groups;
+    xcb_out.map_whichMods = map_whichMods;
+    xcb_out.map_realMods = map_realMods;
+    xcb_out.map_vmods = map_vmods;
+    xcb_out.map_ctrls = map_ctrls;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xkb_set_named_indicator (xcb_connection_t         *c,
+                             xcb_xkb_device_spec_t     deviceSpec,
+                             xcb_xkb_led_class_spec_t  ledClass,
+                             xcb_xkb_id_spec_t         ledID,
+                             xcb_atom_t                indicator,
+                             uint8_t                   setState,
+                             uint8_t                   on,
+                             uint8_t                   setMap,
+                             uint8_t                   createMap,
+                             uint8_t                   map_flags,
+                             uint8_t                   map_whichGroups,
+                             uint8_t                   map_groups,
+                             uint8_t                   map_whichMods,
+                             uint8_t                   map_realMods,
+                             uint16_t                  map_vmods,
+                             uint32_t                  map_ctrls)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SET_NAMED_INDICATOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_set_named_indicator_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.ledClass = ledClass;
+    xcb_out.ledID = ledID;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.indicator = indicator;
+    xcb_out.setState = setState;
+    xcb_out.on = on;
+    xcb_out.setMap = setMap;
+    xcb_out.createMap = createMap;
+    xcb_out.pad1 = 0;
+    xcb_out.map_flags = map_flags;
+    xcb_out.map_whichGroups = map_whichGroups;
+    xcb_out.map_groups = map_groups;
+    xcb_out.map_whichMods = map_whichMods;
+    xcb_out.map_realMods = map_realMods;
+    xcb_out.map_vmods = map_vmods;
+    xcb_out.map_ctrls = map_ctrls;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_atom_t *
+xcb_xkb_get_names_value_list_type_names (const xcb_xkb_get_names_value_list_t *S)
+{
+    return S->typeNames;
+}
+
+int
+xcb_xkb_get_names_value_list_type_names_length (const xcb_xkb_get_names_reply_t *R,
+                                                const xcb_xkb_get_names_value_list_t *S)
+{
+    return R->nTypes;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_get_names_value_list_type_names_end (const xcb_xkb_get_names_reply_t *R,
+                                             const xcb_xkb_get_names_value_list_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->typeNames + R->nTypes;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+uint8_t *
+xcb_xkb_get_names_value_list_n_levels_per_type (const xcb_xkb_get_names_value_list_t *S)
+{
+    return S->nLevelsPerType;
+}
+
+int
+xcb_xkb_get_names_value_list_n_levels_per_type_length (const xcb_xkb_get_names_reply_t *R,
+                                                       const xcb_xkb_get_names_value_list_t *S)
+{
+    return R->nTypes;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_get_names_value_list_n_levels_per_type_end (const xcb_xkb_get_names_reply_t *R,
+                                                    const xcb_xkb_get_names_value_list_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->nLevelsPerType + R->nTypes;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_atom_t *
+xcb_xkb_get_names_value_list_kt_level_names (const xcb_xkb_get_names_value_list_t *S)
+{
+    return S->ktLevelNames;
+}
+
+int
+xcb_xkb_get_names_value_list_kt_level_names_length (const xcb_xkb_get_names_reply_t *R,
+                                                    const xcb_xkb_get_names_value_list_t *S)
+{
+    int xcb_pre_tmp_1; /* sumof length */
+    int xcb_pre_tmp_2; /* sumof loop counter */
+    int64_t xcb_pre_tmp_3; /* sumof sum */
+    const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_1 = R->nTypes;
+    xcb_pre_tmp_3 = 0;
+    xcb_pre_tmp_4 = S->nLevelsPerType;
+    for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
+        xcb_pre_tmp_3 += *xcb_pre_tmp_4;
+        xcb_pre_tmp_4++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_3 */
+    return xcb_pre_tmp_3;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_get_names_value_list_kt_level_names_end (const xcb_xkb_get_names_reply_t *R,
+                                                 const xcb_xkb_get_names_value_list_t *S)
+{
+    xcb_generic_iterator_t i;
+    int xcb_pre_tmp_5; /* sumof length */
+    int xcb_pre_tmp_6; /* sumof loop counter */
+    int64_t xcb_pre_tmp_7; /* sumof sum */
+    const uint8_t* xcb_pre_tmp_8; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_5 = R->nTypes;
+    xcb_pre_tmp_7 = 0;
+    xcb_pre_tmp_8 = S->nLevelsPerType;
+    for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) {
+        xcb_pre_tmp_7 += *xcb_pre_tmp_8;
+        xcb_pre_tmp_8++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_7 */
+    i.data = S->ktLevelNames + xcb_pre_tmp_7;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_atom_t *
+xcb_xkb_get_names_value_list_indicator_names (const xcb_xkb_get_names_value_list_t *S)
+{
+    return S->indicatorNames;
+}
+
+int
+xcb_xkb_get_names_value_list_indicator_names_length (const xcb_xkb_get_names_reply_t *R,
+                                                     const xcb_xkb_get_names_value_list_t *S)
+{
+    return xcb_popcount(R->indicators);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_get_names_value_list_indicator_names_end (const xcb_xkb_get_names_reply_t *R,
+                                                  const xcb_xkb_get_names_value_list_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->indicatorNames + xcb_popcount(R->indicators);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_atom_t *
+xcb_xkb_get_names_value_list_virtual_mod_names (const xcb_xkb_get_names_value_list_t *S)
+{
+    return S->virtualModNames;
+}
+
+int
+xcb_xkb_get_names_value_list_virtual_mod_names_length (const xcb_xkb_get_names_reply_t *R,
+                                                       const xcb_xkb_get_names_value_list_t *S)
+{
+    return xcb_popcount(R->virtualMods);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_get_names_value_list_virtual_mod_names_end (const xcb_xkb_get_names_reply_t *R,
+                                                    const xcb_xkb_get_names_value_list_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->virtualModNames + xcb_popcount(R->virtualMods);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_atom_t *
+xcb_xkb_get_names_value_list_groups (const xcb_xkb_get_names_value_list_t *S)
+{
+    return S->groups;
+}
+
+int
+xcb_xkb_get_names_value_list_groups_length (const xcb_xkb_get_names_reply_t *R,
+                                            const xcb_xkb_get_names_value_list_t *S)
+{
+    return xcb_popcount(R->groupNames);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_get_names_value_list_groups_end (const xcb_xkb_get_names_reply_t *R,
+                                         const xcb_xkb_get_names_value_list_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->groups + xcb_popcount(R->groupNames);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_key_name_t *
+xcb_xkb_get_names_value_list_key_names (const xcb_xkb_get_names_value_list_t *S)
+{
+    return S->keyNames;
+}
+
+int
+xcb_xkb_get_names_value_list_key_names_length (const xcb_xkb_get_names_reply_t *R,
+                                               const xcb_xkb_get_names_value_list_t *S)
+{
+    return R->nKeys;
+}
+
+xcb_xkb_key_name_iterator_t
+xcb_xkb_get_names_value_list_key_names_iterator (const xcb_xkb_get_names_reply_t *R,
+                                                 const xcb_xkb_get_names_value_list_t *S)
+{
+    xcb_xkb_key_name_iterator_t i;
+    i.data = S->keyNames;
+    i.rem = R->nKeys;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_key_alias_t *
+xcb_xkb_get_names_value_list_key_aliases (const xcb_xkb_get_names_value_list_t *S)
+{
+    return S->keyAliases;
+}
+
+int
+xcb_xkb_get_names_value_list_key_aliases_length (const xcb_xkb_get_names_reply_t *R,
+                                                 const xcb_xkb_get_names_value_list_t *S)
+{
+    return R->nKeyAliases;
+}
+
+xcb_xkb_key_alias_iterator_t
+xcb_xkb_get_names_value_list_key_aliases_iterator (const xcb_xkb_get_names_reply_t *R,
+                                                   const xcb_xkb_get_names_value_list_t *S)
+{
+    xcb_xkb_key_alias_iterator_t i;
+    i.data = S->keyAliases;
+    i.rem = R->nKeyAliases;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_atom_t *
+xcb_xkb_get_names_value_list_radio_group_names (const xcb_xkb_get_names_value_list_t *S)
+{
+    return S->radioGroupNames;
+}
+
+int
+xcb_xkb_get_names_value_list_radio_group_names_length (const xcb_xkb_get_names_reply_t *R,
+                                                       const xcb_xkb_get_names_value_list_t *S)
+{
+    return R->nRadioGroups;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_get_names_value_list_radio_group_names_end (const xcb_xkb_get_names_reply_t *R,
+                                                    const xcb_xkb_get_names_value_list_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->radioGroupNames + R->nRadioGroups;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_xkb_get_names_value_list_serialize (void                                 **_buffer,
+                                        uint8_t                                nTypes,
+                                        uint32_t                               indicators,
+                                        uint16_t                               virtualMods,
+                                        uint8_t                                groupNames,
+                                        uint8_t                                nKeys,
+                                        uint8_t                                nKeyAliases,
+                                        uint8_t                                nRadioGroups,
+                                        uint32_t                               which,
+                                        const xcb_xkb_get_names_value_list_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    int xcb_pre_tmp_1; /* sumof length */
+    int xcb_pre_tmp_2; /* sumof loop counter */
+    int64_t xcb_pre_tmp_3; /* sumof sum */
+    const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[26];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(which & XCB_XKB_NAME_DETAIL_KEYCODES) {
+        /* xcb_xkb_get_names_value_list_t.keycodesName */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keycodesName;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_GEOMETRY) {
+        /* xcb_xkb_get_names_value_list_t.geometryName */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometryName;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_SYMBOLS) {
+        /* xcb_xkb_get_names_value_list_t.symbolsName */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->symbolsName;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_PHYS_SYMBOLS) {
+        /* xcb_xkb_get_names_value_list_t.physSymbolsName */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->physSymbolsName;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_TYPES) {
+        /* xcb_xkb_get_names_value_list_t.typesName */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->typesName;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_COMPAT) {
+        /* xcb_xkb_get_names_value_list_t.compatName */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compatName;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* typeNames */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->typeNames;
+        xcb_block_len += nTypes * sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = nTypes * sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* nLevelsPerType */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->nLevelsPerType;
+        xcb_block_len += nTypes * sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = nTypes * sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* ktLevelNames */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->ktLevelNames;
+        /* sumof start */
+        xcb_pre_tmp_1 = nTypes;
+        xcb_pre_tmp_3 = 0;
+        xcb_pre_tmp_4 = _aux->nLevelsPerType;
+        for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
+            xcb_pre_tmp_3 += *xcb_pre_tmp_4;
+            xcb_pre_tmp_4++;
+        }
+        /* sumof end. Result is in xcb_pre_tmp_3 */
+        xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pre_tmp_3 * sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_INDICATOR_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* indicatorNames */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->indicatorNames;
+        xcb_block_len += xcb_popcount(indicators) * sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(indicators) * sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* virtualModNames */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->virtualModNames;
+        xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(virtualMods) * sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_GROUP_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* groups */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->groups;
+        xcb_block_len += xcb_popcount(groupNames) * sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(groupNames) * sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KEY_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* keyNames */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyNames;
+        xcb_block_len += nKeys * sizeof(xcb_xkb_key_name_t);
+        xcb_parts[xcb_parts_idx].iov_len = nKeys * sizeof(xcb_xkb_key_name_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_name_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KEY_ALIASES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* keyAliases */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyAliases;
+        xcb_block_len += nKeyAliases * sizeof(xcb_xkb_key_alias_t);
+        xcb_parts[xcb_parts_idx].iov_len = nKeyAliases * sizeof(xcb_xkb_key_alias_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_alias_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_RG_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* radioGroupNames */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->radioGroupNames;
+        xcb_block_len += nRadioGroups * sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = nRadioGroups * sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_xkb_get_names_value_list_unpack (const void                      *_buffer,
+                                     uint8_t                          nTypes,
+                                     uint32_t                         indicators,
+                                     uint16_t                         virtualMods,
+                                     uint8_t                          groupNames,
+                                     uint8_t                          nKeys,
+                                     uint8_t                          nKeyAliases,
+                                     uint8_t                          nRadioGroups,
+                                     uint32_t                         which,
+                                     xcb_xkb_get_names_value_list_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    int xcb_pre_tmp_1; /* sumof length */
+    int xcb_pre_tmp_2; /* sumof loop counter */
+    int64_t xcb_pre_tmp_3; /* sumof sum */
+    const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */
+
+    if(which & XCB_XKB_NAME_DETAIL_KEYCODES) {
+        /* xcb_xkb_get_names_value_list_t.keycodesName */
+        _aux->keycodesName = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_GEOMETRY) {
+        /* xcb_xkb_get_names_value_list_t.geometryName */
+        _aux->geometryName = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_SYMBOLS) {
+        /* xcb_xkb_get_names_value_list_t.symbolsName */
+        _aux->symbolsName = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_PHYS_SYMBOLS) {
+        /* xcb_xkb_get_names_value_list_t.physSymbolsName */
+        _aux->physSymbolsName = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_TYPES) {
+        /* xcb_xkb_get_names_value_list_t.typesName */
+        _aux->typesName = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_COMPAT) {
+        /* xcb_xkb_get_names_value_list_t.compatName */
+        _aux->compatName = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* typeNames */
+        _aux->typeNames = (xcb_atom_t *)xcb_tmp;
+        xcb_block_len += nTypes * sizeof(xcb_atom_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* nLevelsPerType */
+        _aux->nLevelsPerType = (uint8_t *)xcb_tmp;
+        xcb_block_len += nTypes * sizeof(uint8_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* ktLevelNames */
+        _aux->ktLevelNames = (xcb_atom_t *)xcb_tmp;
+        /* sumof start */
+        xcb_pre_tmp_1 = nTypes;
+        xcb_pre_tmp_3 = 0;
+        xcb_pre_tmp_4 = _aux->nLevelsPerType;
+        for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
+            xcb_pre_tmp_3 += *xcb_pre_tmp_4;
+            xcb_pre_tmp_4++;
+        }
+        /* sumof end. Result is in xcb_pre_tmp_3 */
+        xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_atom_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_INDICATOR_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* indicatorNames */
+        _aux->indicatorNames = (xcb_atom_t *)xcb_tmp;
+        xcb_block_len += xcb_popcount(indicators) * sizeof(xcb_atom_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* virtualModNames */
+        _aux->virtualModNames = (xcb_atom_t *)xcb_tmp;
+        xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_atom_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_GROUP_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* groups */
+        _aux->groups = (xcb_atom_t *)xcb_tmp;
+        xcb_block_len += xcb_popcount(groupNames) * sizeof(xcb_atom_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KEY_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* keyNames */
+        _aux->keyNames = (xcb_xkb_key_name_t *)xcb_tmp;
+        xcb_block_len += nKeys * sizeof(xcb_xkb_key_name_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_name_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KEY_ALIASES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* keyAliases */
+        _aux->keyAliases = (xcb_xkb_key_alias_t *)xcb_tmp;
+        xcb_block_len += nKeyAliases * sizeof(xcb_xkb_key_alias_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_alias_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_RG_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* radioGroupNames */
+        _aux->radioGroupNames = (xcb_atom_t *)xcb_tmp;
+        xcb_block_len += nRadioGroups * sizeof(xcb_atom_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_xkb_get_names_value_list_sizeof (const void  *_buffer,
+                                     uint8_t      nTypes,
+                                     uint32_t     indicators,
+                                     uint16_t     virtualMods,
+                                     uint8_t      groupNames,
+                                     uint8_t      nKeys,
+                                     uint8_t      nKeyAliases,
+                                     uint8_t      nRadioGroups,
+                                     uint32_t     which)
+{
+    xcb_xkb_get_names_value_list_t _aux;
+    return xcb_xkb_get_names_value_list_unpack(_buffer, nTypes, indicators, virtualMods, groupNames, nKeys, nKeyAliases, nRadioGroups, which, &_aux);
+}
+
+int
+xcb_xkb_get_names_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_get_names_reply_t *_aux = (xcb_xkb_get_names_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xkb_get_names_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* valueList */
+    xcb_block_len += xcb_xkb_get_names_value_list_sizeof(xcb_tmp, _aux->nTypes, _aux->indicators, _aux->virtualMods, _aux->groupNames, _aux->nKeys, _aux->nKeyAliases, _aux->nRadioGroups, _aux->which);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xkb_get_names_cookie_t
+xcb_xkb_get_names (xcb_connection_t      *c,
+                   xcb_xkb_device_spec_t  deviceSpec,
+                   uint32_t               which)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_GET_NAMES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_get_names_cookie_t xcb_ret;
+    xcb_xkb_get_names_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.which = which;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_get_names_cookie_t
+xcb_xkb_get_names_unchecked (xcb_connection_t      *c,
+                             xcb_xkb_device_spec_t  deviceSpec,
+                             uint32_t               which)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_GET_NAMES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_get_names_cookie_t xcb_ret;
+    xcb_xkb_get_names_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.which = which;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+void *
+xcb_xkb_get_names_value_list (const xcb_xkb_get_names_reply_t *R)
+{
+    return (void *) (R + 1);
+}
+
+xcb_xkb_get_names_reply_t *
+xcb_xkb_get_names_reply (xcb_connection_t            *c,
+                         xcb_xkb_get_names_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e)
+{
+    return (xcb_xkb_get_names_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_atom_t *
+xcb_xkb_set_names_values_type_names (const xcb_xkb_set_names_values_t *S)
+{
+    return S->typeNames;
+}
+
+int
+xcb_xkb_set_names_values_type_names_length (const xcb_xkb_set_names_request_t *R,
+                                            const xcb_xkb_set_names_values_t *S)
+{
+    return R->nTypes;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_set_names_values_type_names_end (const xcb_xkb_set_names_request_t *R,
+                                         const xcb_xkb_set_names_values_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->typeNames + R->nTypes;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+uint8_t *
+xcb_xkb_set_names_values_n_levels_per_type (const xcb_xkb_set_names_values_t *S)
+{
+    return S->nLevelsPerType;
+}
+
+int
+xcb_xkb_set_names_values_n_levels_per_type_length (const xcb_xkb_set_names_request_t *R,
+                                                   const xcb_xkb_set_names_values_t *S)
+{
+    return R->nTypes;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_set_names_values_n_levels_per_type_end (const xcb_xkb_set_names_request_t *R,
+                                                const xcb_xkb_set_names_values_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->nLevelsPerType + R->nTypes;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_atom_t *
+xcb_xkb_set_names_values_kt_level_names (const xcb_xkb_set_names_values_t *S)
+{
+    return S->ktLevelNames;
+}
+
+int
+xcb_xkb_set_names_values_kt_level_names_length (const xcb_xkb_set_names_request_t *R,
+                                                const xcb_xkb_set_names_values_t *S)
+{
+    int xcb_pre_tmp_1; /* sumof length */
+    int xcb_pre_tmp_2; /* sumof loop counter */
+    int64_t xcb_pre_tmp_3; /* sumof sum */
+    const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_1 = R->nTypes;
+    xcb_pre_tmp_3 = 0;
+    xcb_pre_tmp_4 = S->nLevelsPerType;
+    for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
+        xcb_pre_tmp_3 += *xcb_pre_tmp_4;
+        xcb_pre_tmp_4++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_3 */
+    return xcb_pre_tmp_3;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_set_names_values_kt_level_names_end (const xcb_xkb_set_names_request_t *R,
+                                             const xcb_xkb_set_names_values_t *S)
+{
+    xcb_generic_iterator_t i;
+    int xcb_pre_tmp_5; /* sumof length */
+    int xcb_pre_tmp_6; /* sumof loop counter */
+    int64_t xcb_pre_tmp_7; /* sumof sum */
+    const uint8_t* xcb_pre_tmp_8; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_5 = R->nTypes;
+    xcb_pre_tmp_7 = 0;
+    xcb_pre_tmp_8 = S->nLevelsPerType;
+    for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) {
+        xcb_pre_tmp_7 += *xcb_pre_tmp_8;
+        xcb_pre_tmp_8++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_7 */
+    i.data = S->ktLevelNames + xcb_pre_tmp_7;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_atom_t *
+xcb_xkb_set_names_values_indicator_names (const xcb_xkb_set_names_values_t *S)
+{
+    return S->indicatorNames;
+}
+
+int
+xcb_xkb_set_names_values_indicator_names_length (const xcb_xkb_set_names_request_t *R,
+                                                 const xcb_xkb_set_names_values_t *S)
+{
+    return xcb_popcount(R->indicators);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_set_names_values_indicator_names_end (const xcb_xkb_set_names_request_t *R,
+                                              const xcb_xkb_set_names_values_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->indicatorNames + xcb_popcount(R->indicators);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_atom_t *
+xcb_xkb_set_names_values_virtual_mod_names (const xcb_xkb_set_names_values_t *S)
+{
+    return S->virtualModNames;
+}
+
+int
+xcb_xkb_set_names_values_virtual_mod_names_length (const xcb_xkb_set_names_request_t *R,
+                                                   const xcb_xkb_set_names_values_t *S)
+{
+    return xcb_popcount(R->virtualMods);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_set_names_values_virtual_mod_names_end (const xcb_xkb_set_names_request_t *R,
+                                                const xcb_xkb_set_names_values_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->virtualModNames + xcb_popcount(R->virtualMods);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_atom_t *
+xcb_xkb_set_names_values_groups (const xcb_xkb_set_names_values_t *S)
+{
+    return S->groups;
+}
+
+int
+xcb_xkb_set_names_values_groups_length (const xcb_xkb_set_names_request_t *R,
+                                        const xcb_xkb_set_names_values_t *S)
+{
+    return xcb_popcount(R->groupNames);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_set_names_values_groups_end (const xcb_xkb_set_names_request_t *R,
+                                     const xcb_xkb_set_names_values_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->groups + xcb_popcount(R->groupNames);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_key_name_t *
+xcb_xkb_set_names_values_key_names (const xcb_xkb_set_names_values_t *S)
+{
+    return S->keyNames;
+}
+
+int
+xcb_xkb_set_names_values_key_names_length (const xcb_xkb_set_names_request_t *R,
+                                           const xcb_xkb_set_names_values_t *S)
+{
+    return R->nKeys;
+}
+
+xcb_xkb_key_name_iterator_t
+xcb_xkb_set_names_values_key_names_iterator (const xcb_xkb_set_names_request_t *R,
+                                             const xcb_xkb_set_names_values_t *S)
+{
+    xcb_xkb_key_name_iterator_t i;
+    i.data = S->keyNames;
+    i.rem = R->nKeys;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_key_alias_t *
+xcb_xkb_set_names_values_key_aliases (const xcb_xkb_set_names_values_t *S)
+{
+    return S->keyAliases;
+}
+
+int
+xcb_xkb_set_names_values_key_aliases_length (const xcb_xkb_set_names_request_t *R,
+                                             const xcb_xkb_set_names_values_t *S)
+{
+    return R->nKeyAliases;
+}
+
+xcb_xkb_key_alias_iterator_t
+xcb_xkb_set_names_values_key_aliases_iterator (const xcb_xkb_set_names_request_t *R,
+                                               const xcb_xkb_set_names_values_t *S)
+{
+    xcb_xkb_key_alias_iterator_t i;
+    i.data = S->keyAliases;
+    i.rem = R->nKeyAliases;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_atom_t *
+xcb_xkb_set_names_values_radio_group_names (const xcb_xkb_set_names_values_t *S)
+{
+    return S->radioGroupNames;
+}
+
+int
+xcb_xkb_set_names_values_radio_group_names_length (const xcb_xkb_set_names_request_t *R,
+                                                   const xcb_xkb_set_names_values_t *S)
+{
+    return R->nRadioGroups;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_set_names_values_radio_group_names_end (const xcb_xkb_set_names_request_t *R,
+                                                const xcb_xkb_set_names_values_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->radioGroupNames + R->nRadioGroups;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_xkb_set_names_values_serialize (void                             **_buffer,
+                                    uint8_t                            nTypes,
+                                    uint32_t                           indicators,
+                                    uint16_t                           virtualMods,
+                                    uint8_t                            groupNames,
+                                    uint8_t                            nKeys,
+                                    uint8_t                            nKeyAliases,
+                                    uint8_t                            nRadioGroups,
+                                    uint32_t                           which,
+                                    const xcb_xkb_set_names_values_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    int xcb_pre_tmp_1; /* sumof length */
+    int xcb_pre_tmp_2; /* sumof loop counter */
+    int64_t xcb_pre_tmp_3; /* sumof sum */
+    const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[26];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(which & XCB_XKB_NAME_DETAIL_KEYCODES) {
+        /* xcb_xkb_set_names_values_t.keycodesName */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keycodesName;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_GEOMETRY) {
+        /* xcb_xkb_set_names_values_t.geometryName */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometryName;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_SYMBOLS) {
+        /* xcb_xkb_set_names_values_t.symbolsName */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->symbolsName;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_PHYS_SYMBOLS) {
+        /* xcb_xkb_set_names_values_t.physSymbolsName */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->physSymbolsName;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_TYPES) {
+        /* xcb_xkb_set_names_values_t.typesName */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->typesName;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_COMPAT) {
+        /* xcb_xkb_set_names_values_t.compatName */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compatName;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* typeNames */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->typeNames;
+        xcb_block_len += nTypes * sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = nTypes * sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* nLevelsPerType */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->nLevelsPerType;
+        xcb_block_len += nTypes * sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = nTypes * sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* ktLevelNames */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->ktLevelNames;
+        /* sumof start */
+        xcb_pre_tmp_1 = nTypes;
+        xcb_pre_tmp_3 = 0;
+        xcb_pre_tmp_4 = _aux->nLevelsPerType;
+        for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
+            xcb_pre_tmp_3 += *xcb_pre_tmp_4;
+            xcb_pre_tmp_4++;
+        }
+        /* sumof end. Result is in xcb_pre_tmp_3 */
+        xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pre_tmp_3 * sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_INDICATOR_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* indicatorNames */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->indicatorNames;
+        xcb_block_len += xcb_popcount(indicators) * sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(indicators) * sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* virtualModNames */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->virtualModNames;
+        xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(virtualMods) * sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_GROUP_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* groups */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->groups;
+        xcb_block_len += xcb_popcount(groupNames) * sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(groupNames) * sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KEY_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* keyNames */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyNames;
+        xcb_block_len += nKeys * sizeof(xcb_xkb_key_name_t);
+        xcb_parts[xcb_parts_idx].iov_len = nKeys * sizeof(xcb_xkb_key_name_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_name_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KEY_ALIASES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* keyAliases */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyAliases;
+        xcb_block_len += nKeyAliases * sizeof(xcb_xkb_key_alias_t);
+        xcb_parts[xcb_parts_idx].iov_len = nKeyAliases * sizeof(xcb_xkb_key_alias_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_alias_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_RG_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* radioGroupNames */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->radioGroupNames;
+        xcb_block_len += nRadioGroups * sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = nRadioGroups * sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_xkb_set_names_values_unpack (const void                  *_buffer,
+                                 uint8_t                      nTypes,
+                                 uint32_t                     indicators,
+                                 uint16_t                     virtualMods,
+                                 uint8_t                      groupNames,
+                                 uint8_t                      nKeys,
+                                 uint8_t                      nKeyAliases,
+                                 uint8_t                      nRadioGroups,
+                                 uint32_t                     which,
+                                 xcb_xkb_set_names_values_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    int xcb_pre_tmp_1; /* sumof length */
+    int xcb_pre_tmp_2; /* sumof loop counter */
+    int64_t xcb_pre_tmp_3; /* sumof sum */
+    const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */
+
+    if(which & XCB_XKB_NAME_DETAIL_KEYCODES) {
+        /* xcb_xkb_set_names_values_t.keycodesName */
+        _aux->keycodesName = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_GEOMETRY) {
+        /* xcb_xkb_set_names_values_t.geometryName */
+        _aux->geometryName = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_SYMBOLS) {
+        /* xcb_xkb_set_names_values_t.symbolsName */
+        _aux->symbolsName = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_PHYS_SYMBOLS) {
+        /* xcb_xkb_set_names_values_t.physSymbolsName */
+        _aux->physSymbolsName = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_TYPES) {
+        /* xcb_xkb_set_names_values_t.typesName */
+        _aux->typesName = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_COMPAT) {
+        /* xcb_xkb_set_names_values_t.compatName */
+        _aux->compatName = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* typeNames */
+        _aux->typeNames = (xcb_atom_t *)xcb_tmp;
+        xcb_block_len += nTypes * sizeof(xcb_atom_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* nLevelsPerType */
+        _aux->nLevelsPerType = (uint8_t *)xcb_tmp;
+        xcb_block_len += nTypes * sizeof(uint8_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* ktLevelNames */
+        _aux->ktLevelNames = (xcb_atom_t *)xcb_tmp;
+        /* sumof start */
+        xcb_pre_tmp_1 = nTypes;
+        xcb_pre_tmp_3 = 0;
+        xcb_pre_tmp_4 = _aux->nLevelsPerType;
+        for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
+            xcb_pre_tmp_3 += *xcb_pre_tmp_4;
+            xcb_pre_tmp_4++;
+        }
+        /* sumof end. Result is in xcb_pre_tmp_3 */
+        xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_atom_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_INDICATOR_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* indicatorNames */
+        _aux->indicatorNames = (xcb_atom_t *)xcb_tmp;
+        xcb_block_len += xcb_popcount(indicators) * sizeof(xcb_atom_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* virtualModNames */
+        _aux->virtualModNames = (xcb_atom_t *)xcb_tmp;
+        xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_atom_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_GROUP_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* groups */
+        _aux->groups = (xcb_atom_t *)xcb_tmp;
+        xcb_block_len += xcb_popcount(groupNames) * sizeof(xcb_atom_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KEY_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* keyNames */
+        _aux->keyNames = (xcb_xkb_key_name_t *)xcb_tmp;
+        xcb_block_len += nKeys * sizeof(xcb_xkb_key_name_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_name_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KEY_ALIASES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* keyAliases */
+        _aux->keyAliases = (xcb_xkb_key_alias_t *)xcb_tmp;
+        xcb_block_len += nKeyAliases * sizeof(xcb_xkb_key_alias_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_alias_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_RG_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* radioGroupNames */
+        _aux->radioGroupNames = (xcb_atom_t *)xcb_tmp;
+        xcb_block_len += nRadioGroups * sizeof(xcb_atom_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_xkb_set_names_values_sizeof (const void  *_buffer,
+                                 uint8_t      nTypes,
+                                 uint32_t     indicators,
+                                 uint16_t     virtualMods,
+                                 uint8_t      groupNames,
+                                 uint8_t      nKeys,
+                                 uint8_t      nKeyAliases,
+                                 uint8_t      nRadioGroups,
+                                 uint32_t     which)
+{
+    xcb_xkb_set_names_values_t _aux;
+    return xcb_xkb_set_names_values_unpack(_buffer, nTypes, indicators, virtualMods, groupNames, nKeys, nKeyAliases, nRadioGroups, which, &_aux);
+}
+
+int
+xcb_xkb_set_names_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_set_names_request_t *_aux = (xcb_xkb_set_names_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xkb_set_names_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* values */
+    xcb_block_len += xcb_xkb_set_names_values_sizeof(xcb_tmp, _aux->nTypes, _aux->indicators, _aux->virtualMods, _aux->groupNames, _aux->nKeys, _aux->nKeyAliases, _aux->nRadioGroups, _aux->which);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_xkb_set_names_checked (xcb_connection_t      *c,
+                           xcb_xkb_device_spec_t  deviceSpec,
+                           uint16_t               virtualMods,
+                           uint32_t               which,
+                           uint8_t                firstType,
+                           uint8_t                nTypes,
+                           uint8_t                firstKTLevelt,
+                           uint8_t                nKTLevels,
+                           uint32_t               indicators,
+                           uint8_t                groupNames,
+                           uint8_t                nRadioGroups,
+                           xcb_keycode_t          firstKey,
+                           uint8_t                nKeys,
+                           uint8_t                nKeyAliases,
+                           uint16_t               totalKTLevelNames,
+                           const void            *values)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SET_NAMES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_set_names_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.virtualMods = virtualMods;
+    xcb_out.which = which;
+    xcb_out.firstType = firstType;
+    xcb_out.nTypes = nTypes;
+    xcb_out.firstKTLevelt = firstKTLevelt;
+    xcb_out.nKTLevels = nKTLevels;
+    xcb_out.indicators = indicators;
+    xcb_out.groupNames = groupNames;
+    xcb_out.nRadioGroups = nRadioGroups;
+    xcb_out.firstKey = firstKey;
+    xcb_out.nKeys = nKeys;
+    xcb_out.nKeyAliases = nKeyAliases;
+    xcb_out.pad0 = 0;
+    xcb_out.totalKTLevelNames = totalKTLevelNames;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_xkb_set_names_values_t values */
+    xcb_parts[4].iov_base = (char *) values;
+    xcb_parts[4].iov_len =
+      xcb_xkb_set_names_values_sizeof (values, nTypes, indicators, virtualMods, groupNames, nKeys, nKeyAliases, nRadioGroups, which);
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xkb_set_names (xcb_connection_t      *c,
+                   xcb_xkb_device_spec_t  deviceSpec,
+                   uint16_t               virtualMods,
+                   uint32_t               which,
+                   uint8_t                firstType,
+                   uint8_t                nTypes,
+                   uint8_t                firstKTLevelt,
+                   uint8_t                nKTLevels,
+                   uint32_t               indicators,
+                   uint8_t                groupNames,
+                   uint8_t                nRadioGroups,
+                   xcb_keycode_t          firstKey,
+                   uint8_t                nKeys,
+                   uint8_t                nKeyAliases,
+                   uint16_t               totalKTLevelNames,
+                   const void            *values)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SET_NAMES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_set_names_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.virtualMods = virtualMods;
+    xcb_out.which = which;
+    xcb_out.firstType = firstType;
+    xcb_out.nTypes = nTypes;
+    xcb_out.firstKTLevelt = firstKTLevelt;
+    xcb_out.nKTLevels = nKTLevels;
+    xcb_out.indicators = indicators;
+    xcb_out.groupNames = groupNames;
+    xcb_out.nRadioGroups = nRadioGroups;
+    xcb_out.firstKey = firstKey;
+    xcb_out.nKeys = nKeys;
+    xcb_out.nKeyAliases = nKeyAliases;
+    xcb_out.pad0 = 0;
+    xcb_out.totalKTLevelNames = totalKTLevelNames;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_xkb_set_names_values_t values */
+    xcb_parts[4].iov_base = (char *) values;
+    xcb_parts[4].iov_len =
+      xcb_xkb_set_names_values_sizeof (values, nTypes, indicators, virtualMods, groupNames, nKeys, nKeyAliases, nRadioGroups, which);
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xkb_set_names_aux_checked (xcb_connection_t                 *c,
+                               xcb_xkb_device_spec_t             deviceSpec,
+                               uint16_t                          virtualMods,
+                               uint32_t                          which,
+                               uint8_t                           firstType,
+                               uint8_t                           nTypes,
+                               uint8_t                           firstKTLevelt,
+                               uint8_t                           nKTLevels,
+                               uint32_t                          indicators,
+                               uint8_t                           groupNames,
+                               uint8_t                           nRadioGroups,
+                               xcb_keycode_t                     firstKey,
+                               uint8_t                           nKeys,
+                               uint8_t                           nKeyAliases,
+                               uint16_t                          totalKTLevelNames,
+                               const xcb_xkb_set_names_values_t *values)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SET_NAMES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_set_names_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.virtualMods = virtualMods;
+    xcb_out.which = which;
+    xcb_out.firstType = firstType;
+    xcb_out.nTypes = nTypes;
+    xcb_out.firstKTLevelt = firstKTLevelt;
+    xcb_out.nKTLevels = nKTLevels;
+    xcb_out.indicators = indicators;
+    xcb_out.groupNames = groupNames;
+    xcb_out.nRadioGroups = nRadioGroups;
+    xcb_out.firstKey = firstKey;
+    xcb_out.nKeys = nKeys;
+    xcb_out.nKeyAliases = nKeyAliases;
+    xcb_out.pad0 = 0;
+    xcb_out.totalKTLevelNames = totalKTLevelNames;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_xkb_set_names_values_t values */
+    xcb_parts[4].iov_len =
+      xcb_xkb_set_names_values_serialize (&xcb_aux0, nTypes, indicators, virtualMods, groupNames, nKeys, nKeyAliases, nRadioGroups, which, values);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xkb_set_names_aux (xcb_connection_t                 *c,
+                       xcb_xkb_device_spec_t             deviceSpec,
+                       uint16_t                          virtualMods,
+                       uint32_t                          which,
+                       uint8_t                           firstType,
+                       uint8_t                           nTypes,
+                       uint8_t                           firstKTLevelt,
+                       uint8_t                           nKTLevels,
+                       uint32_t                          indicators,
+                       uint8_t                           groupNames,
+                       uint8_t                           nRadioGroups,
+                       xcb_keycode_t                     firstKey,
+                       uint8_t                           nKeys,
+                       uint8_t                           nKeyAliases,
+                       uint16_t                          totalKTLevelNames,
+                       const xcb_xkb_set_names_values_t *values)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SET_NAMES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_set_names_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.virtualMods = virtualMods;
+    xcb_out.which = which;
+    xcb_out.firstType = firstType;
+    xcb_out.nTypes = nTypes;
+    xcb_out.firstKTLevelt = firstKTLevelt;
+    xcb_out.nKTLevels = nKTLevels;
+    xcb_out.indicators = indicators;
+    xcb_out.groupNames = groupNames;
+    xcb_out.nRadioGroups = nRadioGroups;
+    xcb_out.firstKey = firstKey;
+    xcb_out.nKeys = nKeys;
+    xcb_out.nKeyAliases = nKeyAliases;
+    xcb_out.pad0 = 0;
+    xcb_out.totalKTLevelNames = totalKTLevelNames;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_xkb_set_names_values_t values */
+    xcb_parts[4].iov_len =
+      xcb_xkb_set_names_values_serialize (&xcb_aux0, nTypes, indicators, virtualMods, groupNames, nKeys, nKeyAliases, nRadioGroups, which, values);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+void *
+xcb_xkb_set_names_values (const xcb_xkb_set_names_request_t *R)
+{
+    return (void *) (R + 1);
+}
+
+xcb_xkb_per_client_flags_cookie_t
+xcb_xkb_per_client_flags (xcb_connection_t      *c,
+                          xcb_xkb_device_spec_t  deviceSpec,
+                          uint32_t               change,
+                          uint32_t               value,
+                          uint32_t               ctrlsToChange,
+                          uint32_t               autoCtrls,
+                          uint32_t               autoCtrlsValues)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_PER_CLIENT_FLAGS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_per_client_flags_cookie_t xcb_ret;
+    xcb_xkb_per_client_flags_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.change = change;
+    xcb_out.value = value;
+    xcb_out.ctrlsToChange = ctrlsToChange;
+    xcb_out.autoCtrls = autoCtrls;
+    xcb_out.autoCtrlsValues = autoCtrlsValues;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_per_client_flags_cookie_t
+xcb_xkb_per_client_flags_unchecked (xcb_connection_t      *c,
+                                    xcb_xkb_device_spec_t  deviceSpec,
+                                    uint32_t               change,
+                                    uint32_t               value,
+                                    uint32_t               ctrlsToChange,
+                                    uint32_t               autoCtrls,
+                                    uint32_t               autoCtrlsValues)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_PER_CLIENT_FLAGS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_per_client_flags_cookie_t xcb_ret;
+    xcb_xkb_per_client_flags_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.change = change;
+    xcb_out.value = value;
+    xcb_out.ctrlsToChange = ctrlsToChange;
+    xcb_out.autoCtrls = autoCtrls;
+    xcb_out.autoCtrlsValues = autoCtrlsValues;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_per_client_flags_reply_t *
+xcb_xkb_per_client_flags_reply (xcb_connection_t                   *c,
+                                xcb_xkb_per_client_flags_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e)
+{
+    return (xcb_xkb_per_client_flags_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xkb_list_components_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_list_components_reply_t *_aux = (xcb_xkb_list_components_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_xkb_list_components_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* keymaps */
+    for(i=0; i<_aux->nKeymaps; i++) {
+        xcb_tmp_len = xcb_xkb_listing_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_xkb_listing_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* keycodes */
+    for(i=0; i<_aux->nKeycodes; i++) {
+        xcb_tmp_len = xcb_xkb_listing_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_xkb_listing_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* types */
+    for(i=0; i<_aux->nTypes; i++) {
+        xcb_tmp_len = xcb_xkb_listing_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_xkb_listing_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* compatMaps */
+    for(i=0; i<_aux->nCompatMaps; i++) {
+        xcb_tmp_len = xcb_xkb_listing_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_xkb_listing_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* symbols */
+    for(i=0; i<_aux->nSymbols; i++) {
+        xcb_tmp_len = xcb_xkb_listing_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_xkb_listing_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* geometries */
+    for(i=0; i<_aux->nGeometries; i++) {
+        xcb_tmp_len = xcb_xkb_listing_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_xkb_listing_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xkb_list_components_cookie_t
+xcb_xkb_list_components (xcb_connection_t      *c,
+                         xcb_xkb_device_spec_t  deviceSpec,
+                         uint16_t               maxNames)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_LIST_COMPONENTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_list_components_cookie_t xcb_ret;
+    xcb_xkb_list_components_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.maxNames = maxNames;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_list_components_cookie_t
+xcb_xkb_list_components_unchecked (xcb_connection_t      *c,
+                                   xcb_xkb_device_spec_t  deviceSpec,
+                                   uint16_t               maxNames)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_LIST_COMPONENTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_list_components_cookie_t xcb_ret;
+    xcb_xkb_list_components_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.maxNames = maxNames;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_xkb_list_components_keymaps_length (const xcb_xkb_list_components_reply_t *R)
+{
+    return R->nKeymaps;
+}
+
+xcb_xkb_listing_iterator_t
+xcb_xkb_list_components_keymaps_iterator (const xcb_xkb_list_components_reply_t *R)
+{
+    xcb_xkb_listing_iterator_t i;
+    i.data = (xcb_xkb_listing_t *) (R + 1);
+    i.rem = R->nKeymaps;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_xkb_list_components_keycodes_length (const xcb_xkb_list_components_reply_t *R)
+{
+    return R->nKeycodes;
+}
+
+xcb_xkb_listing_iterator_t
+xcb_xkb_list_components_keycodes_iterator (const xcb_xkb_list_components_reply_t *R)
+{
+    xcb_xkb_listing_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_xkb_listing_end(xcb_xkb_list_components_keymaps_iterator(R));
+    i.data = (xcb_xkb_listing_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_listing_t, prev.index));
+    i.rem = R->nKeycodes;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_xkb_list_components_types_length (const xcb_xkb_list_components_reply_t *R)
+{
+    return R->nTypes;
+}
+
+xcb_xkb_listing_iterator_t
+xcb_xkb_list_components_types_iterator (const xcb_xkb_list_components_reply_t *R)
+{
+    xcb_xkb_listing_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_xkb_listing_end(xcb_xkb_list_components_keycodes_iterator(R));
+    i.data = (xcb_xkb_listing_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_listing_t, prev.index));
+    i.rem = R->nTypes;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_xkb_list_components_compat_maps_length (const xcb_xkb_list_components_reply_t *R)
+{
+    return R->nCompatMaps;
+}
+
+xcb_xkb_listing_iterator_t
+xcb_xkb_list_components_compat_maps_iterator (const xcb_xkb_list_components_reply_t *R)
+{
+    xcb_xkb_listing_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_xkb_listing_end(xcb_xkb_list_components_types_iterator(R));
+    i.data = (xcb_xkb_listing_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_listing_t, prev.index));
+    i.rem = R->nCompatMaps;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_xkb_list_components_symbols_length (const xcb_xkb_list_components_reply_t *R)
+{
+    return R->nSymbols;
+}
+
+xcb_xkb_listing_iterator_t
+xcb_xkb_list_components_symbols_iterator (const xcb_xkb_list_components_reply_t *R)
+{
+    xcb_xkb_listing_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_xkb_listing_end(xcb_xkb_list_components_compat_maps_iterator(R));
+    i.data = (xcb_xkb_listing_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_listing_t, prev.index));
+    i.rem = R->nSymbols;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_xkb_list_components_geometries_length (const xcb_xkb_list_components_reply_t *R)
+{
+    return R->nGeometries;
+}
+
+xcb_xkb_listing_iterator_t
+xcb_xkb_list_components_geometries_iterator (const xcb_xkb_list_components_reply_t *R)
+{
+    xcb_xkb_listing_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_xkb_listing_end(xcb_xkb_list_components_symbols_iterator(R));
+    i.data = (xcb_xkb_listing_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_listing_t, prev.index));
+    i.rem = R->nGeometries;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xkb_list_components_reply_t *
+xcb_xkb_list_components_reply (xcb_connection_t                  *c,
+                               xcb_xkb_list_components_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_xkb_list_components_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_types_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                             const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->types.nTypes;
+}
+
+xcb_xkb_key_type_iterator_t
+xcb_xkb_get_kbd_by_name_replies_types_map_types_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                               const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_xkb_key_type_iterator_t i;
+    i.data = S->types.map.types_rtrn;
+    i.rem = S->types.nTypes;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_syms_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                            const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->types.nKeySyms;
+}
+
+xcb_xkb_key_sym_map_iterator_t
+xcb_xkb_get_kbd_by_name_replies_types_map_syms_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                              const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_xkb_key_sym_map_iterator_t i;
+    i.data = S->types.map.syms_rtrn;
+    i.rem = S->types.nKeySyms;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+uint8_t *
+xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count (const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->types.map.acts_rtrn_count;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                  const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->types.nKeyActions;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_count_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                               const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->types.map.acts_rtrn_count + S->types.nKeyActions;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_action_t *
+xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts (const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->types.map.acts_rtrn_acts;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                 const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->types.totalActions;
+}
+
+xcb_xkb_action_iterator_t
+xcb_xkb_get_kbd_by_name_replies_types_map_acts_rtrn_acts_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                   const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_xkb_action_iterator_t i;
+    i.data = S->types.map.acts_rtrn_acts;
+    i.rem = S->types.totalActions;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_set_behavior_t *
+xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->types.map.behaviors_rtrn;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                 const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->types.totalKeyBehaviors;
+}
+
+xcb_xkb_set_behavior_iterator_t
+xcb_xkb_get_kbd_by_name_replies_types_map_behaviors_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                   const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_xkb_set_behavior_iterator_t i;
+    i.data = S->types.map.behaviors_rtrn;
+    i.rem = S->types.totalKeyBehaviors;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+uint8_t *
+xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->types.map.vmods_rtrn;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                             const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return xcb_popcount(S->types.virtualMods);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_get_kbd_by_name_replies_types_map_vmods_rtrn_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                          const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->types.map.vmods_rtrn + xcb_popcount(S->types.virtualMods);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_set_explicit_t *
+xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->types.map.explicit_rtrn;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->types.totalKeyExplicit;
+}
+
+xcb_xkb_set_explicit_iterator_t
+xcb_xkb_get_kbd_by_name_replies_types_map_explicit_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                  const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_xkb_set_explicit_iterator_t i;
+    i.data = S->types.map.explicit_rtrn;
+    i.rem = S->types.totalKeyExplicit;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_key_mod_map_t *
+xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->types.map.modmap_rtrn;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                              const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->types.totalModMapKeys;
+}
+
+xcb_xkb_key_mod_map_iterator_t
+xcb_xkb_get_kbd_by_name_replies_types_map_modmap_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_xkb_key_mod_map_iterator_t i;
+    i.data = S->types.map.modmap_rtrn;
+    i.rem = S->types.totalModMapKeys;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_key_v_mod_map_t *
+xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->types.map.vmodmap_rtrn;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                               const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->types.totalVModMapKeys;
+}
+
+xcb_xkb_key_v_mod_map_iterator_t
+xcb_xkb_get_kbd_by_name_replies_types_map_vmodmap_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                 const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_xkb_key_v_mod_map_iterator_t i;
+    i.data = S->types.map.vmodmap_rtrn;
+    i.rem = S->types.totalVModMapKeys;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_serialize (void                                              **_buffer,
+                                                     uint8_t                                             nTypes,
+                                                     uint8_t                                             nKeySyms,
+                                                     uint8_t                                             nKeyActions,
+                                                     uint16_t                                            totalActions,
+                                                     uint8_t                                             totalKeyBehaviors,
+                                                     uint16_t                                            virtualMods,
+                                                     uint8_t                                             totalKeyExplicit,
+                                                     uint8_t                                             totalModMapKeys,
+                                                     uint8_t                                             totalVModMapKeys,
+                                                     uint16_t                                            present,
+                                                     const xcb_xkb_get_kbd_by_name_replies_types_map_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[23];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(present & XCB_XKB_MAP_PART_KEY_TYPES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* types_rtrn */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->types_rtrn;
+        xcb_parts[xcb_parts_idx].iov_len = 0;
+        xcb_tmp = (char *) _aux->types_rtrn;
+        for(i=0; i<nTypes; i++) { 
+            xcb_block_len = xcb_xkb_key_type_sizeof(xcb_tmp);
+            xcb_parts[xcb_parts_idx].iov_len += xcb_block_len;
+        }
+        xcb_block_len = xcb_parts[xcb_parts_idx].iov_len;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_type_t);
+    }
+    if(present & XCB_XKB_MAP_PART_KEY_SYMS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* syms_rtrn */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->syms_rtrn;
+        xcb_parts[xcb_parts_idx].iov_len = 0;
+        xcb_tmp = (char *) _aux->syms_rtrn;
+        for(i=0; i<nKeySyms; i++) { 
+            xcb_block_len = xcb_xkb_key_sym_map_sizeof(xcb_tmp);
+            xcb_parts[xcb_parts_idx].iov_len += xcb_block_len;
+        }
+        xcb_block_len = xcb_parts[xcb_parts_idx].iov_len;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_sym_map_t);
+    }
+    if(present & XCB_XKB_MAP_PART_KEY_ACTIONS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* acts_rtrn_count */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->acts_rtrn_count;
+        xcb_block_len += nKeyActions * sizeof(xcb_keycode_t);
+        xcb_parts[xcb_parts_idx].iov_len = nKeyActions * sizeof(xcb_keycode_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* acts_rtrn_acts */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->acts_rtrn_acts;
+        xcb_block_len += totalActions * sizeof(xcb_xkb_action_t);
+        xcb_parts[xcb_parts_idx].iov_len = totalActions * sizeof(xcb_xkb_action_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_action_t);
+    }
+    if(present & XCB_XKB_MAP_PART_KEY_BEHAVIORS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* behaviors_rtrn */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->behaviors_rtrn;
+        xcb_block_len += totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t);
+        xcb_parts[xcb_parts_idx].iov_len = totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_set_behavior_t);
+    }
+    if(present & XCB_XKB_MAP_PART_VIRTUAL_MODS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* vmods_rtrn */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->vmods_rtrn;
+        xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_keycode_t);
+        xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(virtualMods) * sizeof(xcb_keycode_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* explicit_rtrn */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->explicit_rtrn;
+        xcb_block_len += totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t);
+        xcb_parts[xcb_parts_idx].iov_len = totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_set_explicit_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(present & XCB_XKB_MAP_PART_MODIFIER_MAP) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* modmap_rtrn */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->modmap_rtrn;
+        xcb_block_len += totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t);
+        xcb_parts[xcb_parts_idx].iov_len = totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_mod_map_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(present & XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* vmodmap_rtrn */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->vmodmap_rtrn;
+        xcb_block_len += totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t);
+        xcb_parts[xcb_parts_idx].iov_len = totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_v_mod_map_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_unpack (const void                                   *_buffer,
+                                                  uint8_t                                       nTypes,
+                                                  uint8_t                                       nKeySyms,
+                                                  uint8_t                                       nKeyActions,
+                                                  uint16_t                                      totalActions,
+                                                  uint8_t                                       totalKeyBehaviors,
+                                                  uint16_t                                      virtualMods,
+                                                  uint8_t                                       totalKeyExplicit,
+                                                  uint8_t                                       totalModMapKeys,
+                                                  uint8_t                                       totalVModMapKeys,
+                                                  uint16_t                                      present,
+                                                  xcb_xkb_get_kbd_by_name_replies_types_map_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    if(present & XCB_XKB_MAP_PART_KEY_TYPES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* types_rtrn */
+        _aux->types_rtrn = (xcb_xkb_key_type_t *)xcb_tmp;
+        for(i=0; i<nTypes; i++) {
+            xcb_tmp_len = xcb_xkb_key_type_sizeof(xcb_tmp);
+            xcb_block_len += xcb_tmp_len;
+            xcb_tmp += xcb_tmp_len;
+        }
+        xcb_align_to = ALIGNOF(xcb_xkb_key_type_t);
+    }
+    if(present & XCB_XKB_MAP_PART_KEY_SYMS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* syms_rtrn */
+        _aux->syms_rtrn = (xcb_xkb_key_sym_map_t *)xcb_tmp;
+        for(i=0; i<nKeySyms; i++) {
+            xcb_tmp_len = xcb_xkb_key_sym_map_sizeof(xcb_tmp);
+            xcb_block_len += xcb_tmp_len;
+            xcb_tmp += xcb_tmp_len;
+        }
+        xcb_align_to = ALIGNOF(xcb_xkb_key_sym_map_t);
+    }
+    if(present & XCB_XKB_MAP_PART_KEY_ACTIONS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* acts_rtrn_count */
+        _aux->acts_rtrn_count = (uint8_t *)xcb_tmp;
+        xcb_block_len += nKeyActions * sizeof(xcb_keycode_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* acts_rtrn_acts */
+        _aux->acts_rtrn_acts = (xcb_xkb_action_t *)xcb_tmp;
+        xcb_block_len += totalActions * sizeof(xcb_xkb_action_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_action_t);
+    }
+    if(present & XCB_XKB_MAP_PART_KEY_BEHAVIORS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* behaviors_rtrn */
+        _aux->behaviors_rtrn = (xcb_xkb_set_behavior_t *)xcb_tmp;
+        xcb_block_len += totalKeyBehaviors * sizeof(xcb_xkb_set_behavior_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_set_behavior_t);
+    }
+    if(present & XCB_XKB_MAP_PART_VIRTUAL_MODS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* vmods_rtrn */
+        _aux->vmods_rtrn = (uint8_t *)xcb_tmp;
+        xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_keycode_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(present & XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* explicit_rtrn */
+        _aux->explicit_rtrn = (xcb_xkb_set_explicit_t *)xcb_tmp;
+        xcb_block_len += totalKeyExplicit * sizeof(xcb_xkb_set_explicit_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_set_explicit_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(present & XCB_XKB_MAP_PART_MODIFIER_MAP) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* modmap_rtrn */
+        _aux->modmap_rtrn = (xcb_xkb_key_mod_map_t *)xcb_tmp;
+        xcb_block_len += totalModMapKeys * sizeof(xcb_xkb_key_mod_map_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_mod_map_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+    }
+    if(present & XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* vmodmap_rtrn */
+        _aux->vmodmap_rtrn = (xcb_xkb_key_v_mod_map_t *)xcb_tmp;
+        xcb_block_len += totalVModMapKeys * sizeof(xcb_xkb_key_v_mod_map_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_v_mod_map_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_types_map_sizeof (const void  *_buffer,
+                                                  uint8_t      nTypes,
+                                                  uint8_t      nKeySyms,
+                                                  uint8_t      nKeyActions,
+                                                  uint16_t     totalActions,
+                                                  uint8_t      totalKeyBehaviors,
+                                                  uint16_t     virtualMods,
+                                                  uint8_t      totalKeyExplicit,
+                                                  uint8_t      totalModMapKeys,
+                                                  uint8_t      totalVModMapKeys,
+                                                  uint16_t     present)
+{
+    xcb_xkb_get_kbd_by_name_replies_types_map_t _aux;
+    return xcb_xkb_get_kbd_by_name_replies_types_map_unpack(_buffer, nTypes, nKeySyms, nKeyActions, totalActions, totalKeyBehaviors, virtualMods, totalKeyExplicit, totalModMapKeys, totalVModMapKeys, present, &_aux);
+}
+
+xcb_atom_t *
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names (const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->key_names.valueList.typeNames;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                        const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->key_names.nTypes;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_type_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                     const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->key_names.valueList.typeNames + S->key_names.nTypes;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+uint8_t *
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type (const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->key_names.valueList.nLevelsPerType;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                               const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->key_names.nTypes;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_n_levels_per_type_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                            const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->key_names.valueList.nLevelsPerType + S->key_names.nTypes;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_atom_t *
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names (const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->key_names.valueList.ktLevelNames;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                            const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    int xcb_pre_tmp_1; /* sumof length */
+    int xcb_pre_tmp_2; /* sumof loop counter */
+    int64_t xcb_pre_tmp_3; /* sumof sum */
+    const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_1 = S->key_names.nTypes;
+    xcb_pre_tmp_3 = 0;
+    xcb_pre_tmp_4 = S->key_names.valueList.nLevelsPerType;
+    for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
+        xcb_pre_tmp_3 += *xcb_pre_tmp_4;
+        xcb_pre_tmp_4++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_3 */
+    return xcb_pre_tmp_3;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_kt_level_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                         const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_generic_iterator_t i;
+    int xcb_pre_tmp_5; /* sumof length */
+    int xcb_pre_tmp_6; /* sumof loop counter */
+    int64_t xcb_pre_tmp_7; /* sumof sum */
+    const uint8_t* xcb_pre_tmp_8; /* sumof list ptr */
+    /* sumof start */
+    xcb_pre_tmp_5 = S->key_names.nTypes;
+    xcb_pre_tmp_7 = 0;
+    xcb_pre_tmp_8 = S->key_names.valueList.nLevelsPerType;
+    for (xcb_pre_tmp_6 = 0; xcb_pre_tmp_6 < xcb_pre_tmp_5; xcb_pre_tmp_6++) {
+        xcb_pre_tmp_7 += *xcb_pre_tmp_8;
+        xcb_pre_tmp_8++;
+    }
+    /* sumof end. Result is in xcb_pre_tmp_7 */
+    i.data = S->key_names.valueList.ktLevelNames + xcb_pre_tmp_7;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_atom_t *
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names (const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->key_names.valueList.indicatorNames;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                             const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return xcb_popcount(S->key_names.indicators);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_indicator_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                          const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->key_names.valueList.indicatorNames + xcb_popcount(S->key_names.indicators);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_atom_t *
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names (const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->key_names.valueList.virtualModNames;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                               const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return xcb_popcount(S->key_names.virtualMods);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_virtual_mod_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                            const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->key_names.valueList.virtualModNames + xcb_popcount(S->key_names.virtualMods);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_atom_t *
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups (const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->key_names.valueList.groups;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                    const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return xcb_popcount(S->key_names.groupNames);
+}
+
+xcb_generic_iterator_t
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_groups_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                 const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->key_names.valueList.groups + xcb_popcount(S->key_names.groupNames);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_key_name_t *
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names (const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->key_names.valueList.keyNames;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                       const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->key_names.nKeys;
+}
+
+xcb_xkb_key_name_iterator_t
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_names_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                         const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_xkb_key_name_iterator_t i;
+    i.data = S->key_names.valueList.keyNames;
+    i.rem = S->key_names.nKeys;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_key_alias_t *
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases (const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->key_names.valueList.keyAliases;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                         const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->key_names.nKeyAliases;
+}
+
+xcb_xkb_key_alias_iterator_t
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_key_aliases_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                           const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_xkb_key_alias_iterator_t i;
+    i.data = S->key_names.valueList.keyAliases;
+    i.rem = S->key_names.nKeyAliases;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_atom_t *
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names (const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->key_names.valueList.radioGroupNames;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                               const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->key_names.nRadioGroups;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_radio_group_names_end (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                            const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_generic_iterator_t i;
+    i.data = S->key_names.valueList.radioGroupNames + S->key_names.nRadioGroups;
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize (void                                                         **_buffer,
+                                                                uint8_t                                                        nTypes,
+                                                                uint32_t                                                       indicators,
+                                                                uint16_t                                                       virtualMods,
+                                                                uint8_t                                                        groupNames,
+                                                                uint8_t                                                        nKeys,
+                                                                uint8_t                                                        nKeyAliases,
+                                                                uint8_t                                                        nRadioGroups,
+                                                                uint32_t                                                       which,
+                                                                const xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    int xcb_pre_tmp_1; /* sumof length */
+    int xcb_pre_tmp_2; /* sumof loop counter */
+    int64_t xcb_pre_tmp_3; /* sumof sum */
+    const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[26];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(which & XCB_XKB_NAME_DETAIL_KEYCODES) {
+        /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.keycodesName */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->keycodesName;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_GEOMETRY) {
+        /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.geometryName */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometryName;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_SYMBOLS) {
+        /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.symbolsName */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->symbolsName;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_PHYS_SYMBOLS) {
+        /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.physSymbolsName */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->physSymbolsName;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_TYPES) {
+        /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.typesName */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->typesName;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_COMPAT) {
+        /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.compatName */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compatName;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* typeNames */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->typeNames;
+        xcb_block_len += nTypes * sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = nTypes * sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* nLevelsPerType */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->nLevelsPerType;
+        xcb_block_len += nTypes * sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = nTypes * sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* ktLevelNames */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->ktLevelNames;
+        /* sumof start */
+        xcb_pre_tmp_1 = nTypes;
+        xcb_pre_tmp_3 = 0;
+        xcb_pre_tmp_4 = _aux->nLevelsPerType;
+        for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
+            xcb_pre_tmp_3 += *xcb_pre_tmp_4;
+            xcb_pre_tmp_4++;
+        }
+        /* sumof end. Result is in xcb_pre_tmp_3 */
+        xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pre_tmp_3 * sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_INDICATOR_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* indicatorNames */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->indicatorNames;
+        xcb_block_len += xcb_popcount(indicators) * sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(indicators) * sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* virtualModNames */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->virtualModNames;
+        xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(virtualMods) * sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_GROUP_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* groups */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->groups;
+        xcb_block_len += xcb_popcount(groupNames) * sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(groupNames) * sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KEY_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* keyNames */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyNames;
+        xcb_block_len += nKeys * sizeof(xcb_xkb_key_name_t);
+        xcb_parts[xcb_parts_idx].iov_len = nKeys * sizeof(xcb_xkb_key_name_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_name_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KEY_ALIASES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* keyAliases */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->keyAliases;
+        xcb_block_len += nKeyAliases * sizeof(xcb_xkb_key_alias_t);
+        xcb_parts[xcb_parts_idx].iov_len = nKeyAliases * sizeof(xcb_xkb_key_alias_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_alias_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_RG_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* radioGroupNames */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->radioGroupNames;
+        xcb_block_len += nRadioGroups * sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = nRadioGroups * sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack (const void                                              *_buffer,
+                                                             uint8_t                                                  nTypes,
+                                                             uint32_t                                                 indicators,
+                                                             uint16_t                                                 virtualMods,
+                                                             uint8_t                                                  groupNames,
+                                                             uint8_t                                                  nKeys,
+                                                             uint8_t                                                  nKeyAliases,
+                                                             uint8_t                                                  nRadioGroups,
+                                                             uint32_t                                                 which,
+                                                             xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    int xcb_pre_tmp_1; /* sumof length */
+    int xcb_pre_tmp_2; /* sumof loop counter */
+    int64_t xcb_pre_tmp_3; /* sumof sum */
+    const uint8_t* xcb_pre_tmp_4; /* sumof list ptr */
+
+    if(which & XCB_XKB_NAME_DETAIL_KEYCODES) {
+        /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.keycodesName */
+        _aux->keycodesName = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_GEOMETRY) {
+        /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.geometryName */
+        _aux->geometryName = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_SYMBOLS) {
+        /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.symbolsName */
+        _aux->symbolsName = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_PHYS_SYMBOLS) {
+        /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.physSymbolsName */
+        _aux->physSymbolsName = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_TYPES) {
+        /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.typesName */
+        _aux->typesName = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_COMPAT) {
+        /* xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t.compatName */
+        _aux->compatName = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* typeNames */
+        _aux->typeNames = (xcb_atom_t *)xcb_tmp;
+        xcb_block_len += nTypes * sizeof(xcb_atom_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* nLevelsPerType */
+        _aux->nLevelsPerType = (uint8_t *)xcb_tmp;
+        xcb_block_len += nTypes * sizeof(uint8_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(uint8_t);
+        xcb_align_to = 4;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* ktLevelNames */
+        _aux->ktLevelNames = (xcb_atom_t *)xcb_tmp;
+        /* sumof start */
+        xcb_pre_tmp_1 = nTypes;
+        xcb_pre_tmp_3 = 0;
+        xcb_pre_tmp_4 = _aux->nLevelsPerType;
+        for (xcb_pre_tmp_2 = 0; xcb_pre_tmp_2 < xcb_pre_tmp_1; xcb_pre_tmp_2++) {
+            xcb_pre_tmp_3 += *xcb_pre_tmp_4;
+            xcb_pre_tmp_4++;
+        }
+        /* sumof end. Result is in xcb_pre_tmp_3 */
+        xcb_block_len += xcb_pre_tmp_3 * sizeof(xcb_atom_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_INDICATOR_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* indicatorNames */
+        _aux->indicatorNames = (xcb_atom_t *)xcb_tmp;
+        xcb_block_len += xcb_popcount(indicators) * sizeof(xcb_atom_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* virtualModNames */
+        _aux->virtualModNames = (xcb_atom_t *)xcb_tmp;
+        xcb_block_len += xcb_popcount(virtualMods) * sizeof(xcb_atom_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_GROUP_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* groups */
+        _aux->groups = (xcb_atom_t *)xcb_tmp;
+        xcb_block_len += xcb_popcount(groupNames) * sizeof(xcb_atom_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KEY_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* keyNames */
+        _aux->keyNames = (xcb_xkb_key_name_t *)xcb_tmp;
+        xcb_block_len += nKeys * sizeof(xcb_xkb_key_name_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_name_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_KEY_ALIASES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* keyAliases */
+        _aux->keyAliases = (xcb_xkb_key_alias_t *)xcb_tmp;
+        xcb_block_len += nKeyAliases * sizeof(xcb_xkb_key_alias_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_key_alias_t);
+    }
+    if(which & XCB_XKB_NAME_DETAIL_RG_NAMES) {
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* radioGroupNames */
+        _aux->radioGroupNames = (xcb_atom_t *)xcb_tmp;
+        xcb_block_len += nRadioGroups * sizeof(xcb_atom_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_sizeof (const void  *_buffer,
+                                                             uint8_t      nTypes,
+                                                             uint32_t     indicators,
+                                                             uint16_t     virtualMods,
+                                                             uint8_t      groupNames,
+                                                             uint8_t      nKeys,
+                                                             uint8_t      nKeyAliases,
+                                                             uint8_t      nRadioGroups,
+                                                             uint32_t     which)
+{
+    xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t _aux;
+    return xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack(_buffer, nTypes, indicators, virtualMods, groupNames, nKeys, nKeyAliases, nRadioGroups, which, &_aux);
+}
+
+xcb_xkb_get_kbd_by_name_replies_types_map_t *
+xcb_xkb_get_kbd_by_name_replies_types_map (const xcb_xkb_get_kbd_by_name_replies_t *R)
+{
+    return (xcb_xkb_get_kbd_by_name_replies_types_map_t *) (R + 1);
+}
+
+xcb_xkb_sym_interpret_t *
+xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->compat_map.si_rtrn;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                           const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->compat_map.nSIRtrn;
+}
+
+xcb_xkb_sym_interpret_iterator_t
+xcb_xkb_get_kbd_by_name_replies_compat_map_si_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                             const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_xkb_sym_interpret_iterator_t i;
+    i.data = S->compat_map.si_rtrn;
+    i.rem = S->compat_map.nSIRtrn;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_mod_def_t *
+xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn (const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->compat_map.group_rtrn;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                              const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return xcb_popcount(S->compat_map.groupsRtrn);
+}
+
+xcb_xkb_mod_def_iterator_t
+xcb_xkb_get_kbd_by_name_replies_compat_map_group_rtrn_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                                const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_xkb_mod_def_iterator_t i;
+    i.data = S->compat_map.group_rtrn;
+    i.rem = xcb_popcount(S->compat_map.groupsRtrn);
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_indicator_map_t *
+xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps (const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->indicator_maps.maps;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps_length (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                            const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    return S->indicator_maps.nIndicators;
+}
+
+xcb_xkb_indicator_map_iterator_t
+xcb_xkb_get_kbd_by_name_replies_indicator_maps_maps_iterator (const xcb_xkb_get_kbd_by_name_reply_t *R,
+                                                              const xcb_xkb_get_kbd_by_name_replies_t *S)
+{
+    xcb_xkb_indicator_map_iterator_t i;
+    i.data = S->indicator_maps.maps;
+    i.rem = S->indicator_maps.nIndicators;
+    i.index = (char *) i.data - (char *) S;
+    return i;
+}
+
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t *
+xcb_xkb_get_kbd_by_name_replies_key_names_value_list (const xcb_xkb_get_kbd_by_name_replies_t *R)
+{
+    return (xcb_xkb_get_kbd_by_name_replies_key_names_value_list_t *) (R + 1);
+}
+
+xcb_xkb_counted_string_16_t *
+xcb_xkb_get_kbd_by_name_replies_geometry_label_font (const xcb_xkb_get_kbd_by_name_replies_t *R)
+{
+    return (xcb_xkb_counted_string_16_t *) (R + 1);
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_serialize (void                                    **_buffer,
+                                           uint16_t                                  reported,
+                                           const xcb_xkb_get_kbd_by_name_replies_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[96];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if((reported & XCB_XKB_GBN_DETAIL_TYPES) ||
+       (reported & XCB_XKB_GBN_DETAIL_CLIENT_SYMBOLS) ||
+       (reported & XCB_XKB_GBN_DETAIL_SERVER_SYMBOLS)) {
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.getmap_type */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.getmap_type;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.typeDeviceID */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.typeDeviceID;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.getmap_sequence */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.getmap_sequence;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.getmap_length */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.getmap_length;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.pad1 */
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_block_len += sizeof(uint8_t)*2;
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*2;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.typeMinKeyCode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.typeMinKeyCode;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.typeMaxKeyCode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.typeMaxKeyCode;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.present */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.present;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.firstType */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.firstType;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.nTypes */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.nTypes;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.totalTypes */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.totalTypes;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.firstKeySym */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.firstKeySym;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.totalSyms */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.totalSyms;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.nKeySyms */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.nKeySyms;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.firstKeyAction */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.firstKeyAction;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.totalActions */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.totalActions;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.nKeyActions */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.nKeyActions;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.firstKeyBehavior */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.firstKeyBehavior;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.nKeyBehaviors */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.nKeyBehaviors;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.totalKeyBehaviors */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.totalKeyBehaviors;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.firstKeyExplicit */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.firstKeyExplicit;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.nKeyExplicit */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.nKeyExplicit;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.totalKeyExplicit */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.totalKeyExplicit;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.firstModMapKey */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.firstModMapKey;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.nModMapKeys */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.nModMapKeys;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.totalModMapKeys */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.totalModMapKeys;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.firstVModMapKey */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.firstVModMapKey;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.nVModMapKeys */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.nVModMapKeys;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.totalVModMapKeys */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.totalVModMapKeys;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.pad2 */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.virtualMods */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->types.virtualMods;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* map */
+        xcb_parts[xcb_parts_idx].iov_base = (char *)0;
+        xcb_block_len += xcb_xkb_get_kbd_by_name_replies_types_map_serialize(&xcb_parts[xcb_parts_idx].iov_base, _aux->types.nTypes, _aux->types.nKeySyms, _aux->types.nKeyActions, _aux->types.totalActions, _aux->types.totalKeyBehaviors, _aux->types.virtualMods, _aux->types.totalKeyExplicit, _aux->types.totalModMapKeys, _aux->types.totalVModMapKeys, _aux->types.present, &_aux->types.map);
+        xcb_parts[xcb_parts_idx].iov_len = xcb_xkb_get_kbd_by_name_replies_types_map_serialize(&xcb_parts[xcb_parts_idx].iov_base, _aux->types.nTypes, _aux->types.nKeySyms, _aux->types.nKeyActions, _aux->types.totalActions, _aux->types.totalKeyBehaviors, _aux->types.virtualMods, _aux->types.totalKeyExplicit, _aux->types.totalModMapKeys, _aux->types.totalVModMapKeys, _aux->types.present, &_aux->types.map);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(char);
+    }
+    if(reported & XCB_XKB_GBN_DETAIL_COMPAT_MAP) {
+        /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.compatmap_type */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compat_map.compatmap_type;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.compatDeviceID */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compat_map.compatDeviceID;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.compatmap_sequence */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compat_map.compatmap_sequence;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.compatmap_length */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compat_map.compatmap_length;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.groupsRtrn */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compat_map.groupsRtrn;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.pad7 */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.firstSIRtrn */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compat_map.firstSIRtrn;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.nSIRtrn */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compat_map.nSIRtrn;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.nTotalSI */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->compat_map.nTotalSI;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.pad8 */
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_block_len += sizeof(uint8_t)*16;
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*16;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* si_rtrn */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->compat_map.si_rtrn;
+        xcb_block_len += _aux->compat_map.nSIRtrn * sizeof(xcb_xkb_sym_interpret_t);
+        xcb_parts[xcb_parts_idx].iov_len = _aux->compat_map.nSIRtrn * sizeof(xcb_xkb_sym_interpret_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_sym_interpret_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* group_rtrn */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->compat_map.group_rtrn;
+        xcb_block_len += xcb_popcount(_aux->compat_map.groupsRtrn) * sizeof(xcb_xkb_mod_def_t);
+        xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(_aux->compat_map.groupsRtrn) * sizeof(xcb_xkb_mod_def_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_mod_def_t);
+    }
+    if(reported & XCB_XKB_GBN_DETAIL_INDICATOR_MAPS) {
+        /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.indicatormap_type */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->indicator_maps.indicatormap_type;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.indicatorDeviceID */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->indicator_maps.indicatorDeviceID;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.indicatormap_sequence */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->indicator_maps.indicatormap_sequence;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.indicatormap_length */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->indicator_maps.indicatormap_length;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.which */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->indicator_maps.which;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.realIndicators */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->indicator_maps.realIndicators;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.nIndicators */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->indicator_maps.nIndicators;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.pad9 */
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_block_len += sizeof(uint8_t)*15;
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*15;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* maps */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->indicator_maps.maps;
+        xcb_block_len += _aux->indicator_maps.nIndicators * sizeof(xcb_xkb_indicator_map_t);
+        xcb_parts[xcb_parts_idx].iov_len = _aux->indicator_maps.nIndicators * sizeof(xcb_xkb_indicator_map_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_indicator_map_t);
+    }
+    if((reported & XCB_XKB_GBN_DETAIL_KEY_NAMES) ||
+       (reported & XCB_XKB_GBN_DETAIL_OTHER_NAMES)) {
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyname_type */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.keyname_type;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyDeviceID */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.keyDeviceID;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyname_sequence */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.keyname_sequence;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyname_length */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.keyname_length;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.which */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.which;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyMinKeyCode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.keyMinKeyCode;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyMaxKeyCode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.keyMaxKeyCode;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.nTypes */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.nTypes;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.groupNames */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.groupNames;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.virtualMods */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.virtualMods;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.firstKey */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.firstKey;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.nKeys */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.nKeys;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.indicators */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.indicators;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.nRadioGroups */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.nRadioGroups;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.nKeyAliases */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.nKeyAliases;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.nKTLevels */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_names.nKTLevels;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.pad10 */
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_block_len += sizeof(uint8_t)*4;
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t)*4;
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* valueList */
+        xcb_parts[xcb_parts_idx].iov_base = (char *)0;
+        xcb_block_len += xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize(&xcb_parts[xcb_parts_idx].iov_base, _aux->key_names.nTypes, _aux->key_names.indicators, _aux->key_names.virtualMods, _aux->key_names.groupNames, _aux->key_names.nKeys, _aux->key_names.nKeyAliases, _aux->key_names.nRadioGroups, _aux->key_names.which, &_aux->key_names.valueList);
+        xcb_parts[xcb_parts_idx].iov_len = xcb_xkb_get_kbd_by_name_replies_key_names_value_list_serialize(&xcb_parts[xcb_parts_idx].iov_base, _aux->key_names.nTypes, _aux->key_names.indicators, _aux->key_names.virtualMods, _aux->key_names.groupNames, _aux->key_names.nKeys, _aux->key_names.nKeyAliases, _aux->key_names.nRadioGroups, _aux->key_names.which, &_aux->key_names.valueList);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(char);
+    }
+    if(reported & XCB_XKB_GBN_DETAIL_GEOMETRY) {
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometry_type */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.geometry_type;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometryDeviceID */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.geometryDeviceID;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometry_sequence */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.geometry_sequence;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometry_length */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.geometry_length;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.name */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.name;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_atom_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometryFound */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.geometryFound;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.pad12 */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.widthMM */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.widthMM;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.heightMM */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.heightMM;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nProperties */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.nProperties;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nColors */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.nColors;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nShapes */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.nShapes;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nSections */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.nSections;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nDoodads */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.nDoodads;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nKeyAliases */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.nKeyAliases;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint16_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.baseColorNdx */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.baseColorNdx;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.labelColorNdx */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->geometry.labelColorNdx;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+            xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+            xcb_parts_idx++;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* labelFont */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) _aux->geometry.labelFont;
+        xcb_block_len += xcb_xkb_counted_string_16_sizeof(_aux->geometry.labelFont);
+        xcb_parts[xcb_parts_idx].iov_len = xcb_xkb_counted_string_16_sizeof(_aux->geometry.labelFont);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_xkb_counted_string_16_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_unpack (const void                         *_buffer,
+                                        uint16_t                            reported,
+                                        xcb_xkb_get_kbd_by_name_replies_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if((reported & XCB_XKB_GBN_DETAIL_TYPES) ||
+       (reported & XCB_XKB_GBN_DETAIL_CLIENT_SYMBOLS) ||
+       (reported & XCB_XKB_GBN_DETAIL_SERVER_SYMBOLS)) {
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.getmap_type */
+        _aux->types.getmap_type = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.typeDeviceID */
+        _aux->types.typeDeviceID = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.getmap_sequence */
+        _aux->types.getmap_sequence = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.getmap_length */
+        _aux->types.getmap_length = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.pad1 */
+        _aux->types.pad1[0] = *(uint8_t *)xcb_tmp;
+        _aux->types.pad1[1] = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t) * 2;
+        xcb_tmp += sizeof(uint8_t) * 2;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.typeMinKeyCode */
+        _aux->types.typeMinKeyCode = *(xcb_keycode_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_tmp += sizeof(xcb_keycode_t);
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.typeMaxKeyCode */
+        _aux->types.typeMaxKeyCode = *(xcb_keycode_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_tmp += sizeof(xcb_keycode_t);
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.present */
+        _aux->types.present = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.firstType */
+        _aux->types.firstType = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.nTypes */
+        _aux->types.nTypes = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.totalTypes */
+        _aux->types.totalTypes = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.firstKeySym */
+        _aux->types.firstKeySym = *(xcb_keycode_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_tmp += sizeof(xcb_keycode_t);
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.totalSyms */
+        _aux->types.totalSyms = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.nKeySyms */
+        _aux->types.nKeySyms = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.firstKeyAction */
+        _aux->types.firstKeyAction = *(xcb_keycode_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_tmp += sizeof(xcb_keycode_t);
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.totalActions */
+        _aux->types.totalActions = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.nKeyActions */
+        _aux->types.nKeyActions = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.firstKeyBehavior */
+        _aux->types.firstKeyBehavior = *(xcb_keycode_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_tmp += sizeof(xcb_keycode_t);
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.nKeyBehaviors */
+        _aux->types.nKeyBehaviors = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.totalKeyBehaviors */
+        _aux->types.totalKeyBehaviors = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.firstKeyExplicit */
+        _aux->types.firstKeyExplicit = *(xcb_keycode_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_tmp += sizeof(xcb_keycode_t);
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.nKeyExplicit */
+        _aux->types.nKeyExplicit = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.totalKeyExplicit */
+        _aux->types.totalKeyExplicit = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.firstModMapKey */
+        _aux->types.firstModMapKey = *(xcb_keycode_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_tmp += sizeof(xcb_keycode_t);
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.nModMapKeys */
+        _aux->types.nModMapKeys = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.totalModMapKeys */
+        _aux->types.totalModMapKeys = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.firstVModMapKey */
+        _aux->types.firstVModMapKey = *(xcb_keycode_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_tmp += sizeof(xcb_keycode_t);
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.nVModMapKeys */
+        _aux->types.nVModMapKeys = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.totalVModMapKeys */
+        _aux->types.totalVModMapKeys = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.pad2 */
+        _aux->types.pad2 = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.types.virtualMods */
+        _aux->types.virtualMods = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* map */
+        xcb_block_len += xcb_xkb_get_kbd_by_name_replies_types_map_unpack(xcb_tmp, _aux->types.nTypes, _aux->types.nKeySyms, _aux->types.nKeyActions, _aux->types.totalActions, _aux->types.totalKeyBehaviors, _aux->types.virtualMods, _aux->types.totalKeyExplicit, _aux->types.totalModMapKeys, _aux->types.totalVModMapKeys, _aux->types.present, &_aux->types.map);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(char);
+    }
+    if(reported & XCB_XKB_GBN_DETAIL_COMPAT_MAP) {
+        /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.compatmap_type */
+        _aux->compat_map.compatmap_type = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.compatDeviceID */
+        _aux->compat_map.compatDeviceID = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.compatmap_sequence */
+        _aux->compat_map.compatmap_sequence = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.compatmap_length */
+        _aux->compat_map.compatmap_length = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.groupsRtrn */
+        _aux->compat_map.groupsRtrn = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.pad7 */
+        _aux->compat_map.pad7 = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.firstSIRtrn */
+        _aux->compat_map.firstSIRtrn = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.nSIRtrn */
+        _aux->compat_map.nSIRtrn = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.nTotalSI */
+        _aux->compat_map.nTotalSI = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.compat_map.pad8 */
+        _aux->compat_map.pad8[0] = *(uint8_t *)xcb_tmp;
+        _aux->compat_map.pad8[1] = *(uint8_t *)xcb_tmp;
+        _aux->compat_map.pad8[2] = *(uint8_t *)xcb_tmp;
+        _aux->compat_map.pad8[3] = *(uint8_t *)xcb_tmp;
+        _aux->compat_map.pad8[4] = *(uint8_t *)xcb_tmp;
+        _aux->compat_map.pad8[5] = *(uint8_t *)xcb_tmp;
+        _aux->compat_map.pad8[6] = *(uint8_t *)xcb_tmp;
+        _aux->compat_map.pad8[7] = *(uint8_t *)xcb_tmp;
+        _aux->compat_map.pad8[8] = *(uint8_t *)xcb_tmp;
+        _aux->compat_map.pad8[9] = *(uint8_t *)xcb_tmp;
+        _aux->compat_map.pad8[10] = *(uint8_t *)xcb_tmp;
+        _aux->compat_map.pad8[11] = *(uint8_t *)xcb_tmp;
+        _aux->compat_map.pad8[12] = *(uint8_t *)xcb_tmp;
+        _aux->compat_map.pad8[13] = *(uint8_t *)xcb_tmp;
+        _aux->compat_map.pad8[14] = *(uint8_t *)xcb_tmp;
+        _aux->compat_map.pad8[15] = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t) * 16;
+        xcb_tmp += sizeof(uint8_t) * 16;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* si_rtrn */
+        _aux->compat_map.si_rtrn = (xcb_xkb_sym_interpret_t *)xcb_tmp;
+        xcb_block_len += _aux->compat_map.nSIRtrn * sizeof(xcb_xkb_sym_interpret_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_sym_interpret_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* group_rtrn */
+        _aux->compat_map.group_rtrn = (xcb_xkb_mod_def_t *)xcb_tmp;
+        xcb_block_len += xcb_popcount(_aux->compat_map.groupsRtrn) * sizeof(xcb_xkb_mod_def_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_mod_def_t);
+    }
+    if(reported & XCB_XKB_GBN_DETAIL_INDICATOR_MAPS) {
+        /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.indicatormap_type */
+        _aux->indicator_maps.indicatormap_type = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.indicatorDeviceID */
+        _aux->indicator_maps.indicatorDeviceID = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.indicatormap_sequence */
+        _aux->indicator_maps.indicatormap_sequence = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.indicatormap_length */
+        _aux->indicator_maps.indicatormap_length = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.which */
+        _aux->indicator_maps.which = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.realIndicators */
+        _aux->indicator_maps.realIndicators = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.nIndicators */
+        _aux->indicator_maps.nIndicators = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.indicator_maps.pad9 */
+        _aux->indicator_maps.pad9[0] = *(uint8_t *)xcb_tmp;
+        _aux->indicator_maps.pad9[1] = *(uint8_t *)xcb_tmp;
+        _aux->indicator_maps.pad9[2] = *(uint8_t *)xcb_tmp;
+        _aux->indicator_maps.pad9[3] = *(uint8_t *)xcb_tmp;
+        _aux->indicator_maps.pad9[4] = *(uint8_t *)xcb_tmp;
+        _aux->indicator_maps.pad9[5] = *(uint8_t *)xcb_tmp;
+        _aux->indicator_maps.pad9[6] = *(uint8_t *)xcb_tmp;
+        _aux->indicator_maps.pad9[7] = *(uint8_t *)xcb_tmp;
+        _aux->indicator_maps.pad9[8] = *(uint8_t *)xcb_tmp;
+        _aux->indicator_maps.pad9[9] = *(uint8_t *)xcb_tmp;
+        _aux->indicator_maps.pad9[10] = *(uint8_t *)xcb_tmp;
+        _aux->indicator_maps.pad9[11] = *(uint8_t *)xcb_tmp;
+        _aux->indicator_maps.pad9[12] = *(uint8_t *)xcb_tmp;
+        _aux->indicator_maps.pad9[13] = *(uint8_t *)xcb_tmp;
+        _aux->indicator_maps.pad9[14] = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t) * 15;
+        xcb_tmp += sizeof(uint8_t) * 15;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* maps */
+        _aux->indicator_maps.maps = (xcb_xkb_indicator_map_t *)xcb_tmp;
+        xcb_block_len += _aux->indicator_maps.nIndicators * sizeof(xcb_xkb_indicator_map_t);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_indicator_map_t);
+    }
+    if((reported & XCB_XKB_GBN_DETAIL_KEY_NAMES) ||
+       (reported & XCB_XKB_GBN_DETAIL_OTHER_NAMES)) {
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyname_type */
+        _aux->key_names.keyname_type = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyDeviceID */
+        _aux->key_names.keyDeviceID = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyname_sequence */
+        _aux->key_names.keyname_sequence = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyname_length */
+        _aux->key_names.keyname_length = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.which */
+        _aux->key_names.which = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyMinKeyCode */
+        _aux->key_names.keyMinKeyCode = *(xcb_keycode_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_tmp += sizeof(xcb_keycode_t);
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.keyMaxKeyCode */
+        _aux->key_names.keyMaxKeyCode = *(xcb_keycode_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_tmp += sizeof(xcb_keycode_t);
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.nTypes */
+        _aux->key_names.nTypes = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.groupNames */
+        _aux->key_names.groupNames = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.virtualMods */
+        _aux->key_names.virtualMods = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.firstKey */
+        _aux->key_names.firstKey = *(xcb_keycode_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_keycode_t);
+        xcb_tmp += sizeof(xcb_keycode_t);
+        xcb_align_to = ALIGNOF(xcb_keycode_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.nKeys */
+        _aux->key_names.nKeys = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.indicators */
+        _aux->key_names.indicators = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.nRadioGroups */
+        _aux->key_names.nRadioGroups = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.nKeyAliases */
+        _aux->key_names.nKeyAliases = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.nKTLevels */
+        _aux->key_names.nKTLevels = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.key_names.pad10 */
+        _aux->key_names.pad10[0] = *(uint8_t *)xcb_tmp;
+        _aux->key_names.pad10[1] = *(uint8_t *)xcb_tmp;
+        _aux->key_names.pad10[2] = *(uint8_t *)xcb_tmp;
+        _aux->key_names.pad10[3] = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t) * 4;
+        xcb_tmp += sizeof(uint8_t) * 4;
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* valueList */
+        xcb_block_len += xcb_xkb_get_kbd_by_name_replies_key_names_value_list_unpack(xcb_tmp, _aux->key_names.nTypes, _aux->key_names.indicators, _aux->key_names.virtualMods, _aux->key_names.groupNames, _aux->key_names.nKeys, _aux->key_names.nKeyAliases, _aux->key_names.nRadioGroups, _aux->key_names.which, &_aux->key_names.valueList);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(char);
+    }
+    if(reported & XCB_XKB_GBN_DETAIL_GEOMETRY) {
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometry_type */
+        _aux->geometry.geometry_type = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometryDeviceID */
+        _aux->geometry.geometryDeviceID = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometry_sequence */
+        _aux->geometry.geometry_sequence = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometry_length */
+        _aux->geometry.geometry_length = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.name */
+        _aux->geometry.name = *(xcb_atom_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_atom_t);
+        xcb_tmp += sizeof(xcb_atom_t);
+        xcb_align_to = ALIGNOF(xcb_atom_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.geometryFound */
+        _aux->geometry.geometryFound = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.pad12 */
+        _aux->geometry.pad12 = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.widthMM */
+        _aux->geometry.widthMM = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.heightMM */
+        _aux->geometry.heightMM = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nProperties */
+        _aux->geometry.nProperties = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nColors */
+        _aux->geometry.nColors = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nShapes */
+        _aux->geometry.nShapes = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nSections */
+        _aux->geometry.nSections = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nDoodads */
+        _aux->geometry.nDoodads = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.nKeyAliases */
+        _aux->geometry.nKeyAliases = *(uint16_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint16_t);
+        xcb_tmp += sizeof(uint16_t);
+        xcb_align_to = ALIGNOF(uint16_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.baseColorNdx */
+        _aux->geometry.baseColorNdx = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* xcb_xkb_get_kbd_by_name_replies_t.geometry.labelColorNdx */
+        _aux->geometry.labelColorNdx = *(uint8_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint8_t);
+        xcb_tmp += sizeof(uint8_t);
+        xcb_align_to = ALIGNOF(uint8_t);
+        /* insert padding */
+        xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+        xcb_buffer_len += xcb_block_len + xcb_pad;
+        if (0 != xcb_pad) {
+            xcb_tmp += xcb_pad;
+            xcb_pad = 0;
+        }
+        xcb_block_len = 0;
+        xcb_padding_offset = 0;
+        /* labelFont */
+        _aux->geometry.labelFont = (xcb_xkb_counted_string_16_t *)xcb_tmp;
+        xcb_block_len += xcb_xkb_counted_string_16_sizeof(xcb_tmp);
+        xcb_tmp += xcb_block_len;
+        xcb_align_to = ALIGNOF(xcb_xkb_counted_string_16_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_xkb_get_kbd_by_name_replies_sizeof (const void  *_buffer,
+                                        uint16_t     reported)
+{
+    xcb_xkb_get_kbd_by_name_replies_t _aux;
+    return xcb_xkb_get_kbd_by_name_replies_unpack(_buffer, reported, &_aux);
+}
+
+int
+xcb_xkb_get_kbd_by_name_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_get_kbd_by_name_reply_t *_aux = (xcb_xkb_get_kbd_by_name_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xkb_get_kbd_by_name_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* replies */
+    xcb_block_len += xcb_xkb_get_kbd_by_name_replies_sizeof(xcb_tmp, _aux->reported);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xkb_get_kbd_by_name_cookie_t
+xcb_xkb_get_kbd_by_name (xcb_connection_t      *c,
+                         xcb_xkb_device_spec_t  deviceSpec,
+                         uint16_t               need,
+                         uint16_t               want,
+                         uint8_t                load)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_GET_KBD_BY_NAME,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_get_kbd_by_name_cookie_t xcb_ret;
+    xcb_xkb_get_kbd_by_name_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.need = need;
+    xcb_out.want = want;
+    xcb_out.load = load;
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_get_kbd_by_name_cookie_t
+xcb_xkb_get_kbd_by_name_unchecked (xcb_connection_t      *c,
+                                   xcb_xkb_device_spec_t  deviceSpec,
+                                   uint16_t               need,
+                                   uint16_t               want,
+                                   uint8_t                load)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_GET_KBD_BY_NAME,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_get_kbd_by_name_cookie_t xcb_ret;
+    xcb_xkb_get_kbd_by_name_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.need = need;
+    xcb_out.want = want;
+    xcb_out.load = load;
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+void *
+xcb_xkb_get_kbd_by_name_replies (const xcb_xkb_get_kbd_by_name_reply_t *R)
+{
+    return (void *) (R + 1);
+}
+
+xcb_xkb_get_kbd_by_name_reply_t *
+xcb_xkb_get_kbd_by_name_reply (xcb_connection_t                  *c,
+                               xcb_xkb_get_kbd_by_name_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_xkb_get_kbd_by_name_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xkb_get_device_info_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_get_device_info_reply_t *_aux = (xcb_xkb_get_device_info_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_xkb_get_device_info_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->nameLen * sizeof(xcb_xkb_string8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xkb_string8_t);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* btnActions */
+    xcb_block_len += _aux->nBtnsRtrn * sizeof(xcb_xkb_action_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xkb_action_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* leds */
+    for(i=0; i<_aux->nDeviceLedFBs; i++) {
+        xcb_tmp_len = xcb_xkb_device_led_info_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_xkb_device_led_info_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xkb_get_device_info_cookie_t
+xcb_xkb_get_device_info (xcb_connection_t         *c,
+                         xcb_xkb_device_spec_t     deviceSpec,
+                         uint16_t                  wanted,
+                         uint8_t                   allButtons,
+                         uint8_t                   firstButton,
+                         uint8_t                   nButtons,
+                         xcb_xkb_led_class_spec_t  ledClass,
+                         xcb_xkb_id_spec_t         ledID)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_GET_DEVICE_INFO,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_get_device_info_cookie_t xcb_ret;
+    xcb_xkb_get_device_info_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.wanted = wanted;
+    xcb_out.allButtons = allButtons;
+    xcb_out.firstButton = firstButton;
+    xcb_out.nButtons = nButtons;
+    xcb_out.pad0 = 0;
+    xcb_out.ledClass = ledClass;
+    xcb_out.ledID = ledID;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_get_device_info_cookie_t
+xcb_xkb_get_device_info_unchecked (xcb_connection_t         *c,
+                                   xcb_xkb_device_spec_t     deviceSpec,
+                                   uint16_t                  wanted,
+                                   uint8_t                   allButtons,
+                                   uint8_t                   firstButton,
+                                   uint8_t                   nButtons,
+                                   xcb_xkb_led_class_spec_t  ledClass,
+                                   xcb_xkb_id_spec_t         ledID)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_GET_DEVICE_INFO,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xkb_get_device_info_cookie_t xcb_ret;
+    xcb_xkb_get_device_info_request_t xcb_out;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.wanted = wanted;
+    xcb_out.allButtons = allButtons;
+    xcb_out.firstButton = firstButton;
+    xcb_out.nButtons = nButtons;
+    xcb_out.pad0 = 0;
+    xcb_out.ledClass = ledClass;
+    xcb_out.ledID = ledID;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_string8_t *
+xcb_xkb_get_device_info_name (const xcb_xkb_get_device_info_reply_t *R)
+{
+    return (xcb_xkb_string8_t *) (R + 1);
+}
+
+int
+xcb_xkb_get_device_info_name_length (const xcb_xkb_get_device_info_reply_t *R)
+{
+    return R->nameLen;
+}
+
+xcb_generic_iterator_t
+xcb_xkb_get_device_info_name_end (const xcb_xkb_get_device_info_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_xkb_string8_t *) (R + 1)) + (R->nameLen);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xkb_action_t *
+xcb_xkb_get_device_info_btn_actions (const xcb_xkb_get_device_info_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_xkb_get_device_info_name_end(R);
+    return (xcb_xkb_action_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0);
+}
+
+int
+xcb_xkb_get_device_info_btn_actions_length (const xcb_xkb_get_device_info_reply_t *R)
+{
+    return R->nBtnsRtrn;
+}
+
+xcb_xkb_action_iterator_t
+xcb_xkb_get_device_info_btn_actions_iterator (const xcb_xkb_get_device_info_reply_t *R)
+{
+    xcb_xkb_action_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_xkb_get_device_info_name_end(R);
+    i.data = (xcb_xkb_action_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)));
+    i.rem = R->nBtnsRtrn;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_xkb_get_device_info_leds_length (const xcb_xkb_get_device_info_reply_t *R)
+{
+    return R->nDeviceLedFBs;
+}
+
+xcb_xkb_device_led_info_iterator_t
+xcb_xkb_get_device_info_leds_iterator (const xcb_xkb_get_device_info_reply_t *R)
+{
+    xcb_xkb_device_led_info_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_xkb_action_end(xcb_xkb_get_device_info_btn_actions_iterator(R));
+    i.data = (xcb_xkb_device_led_info_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_device_led_info_t, prev.index));
+    i.rem = R->nDeviceLedFBs;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xkb_get_device_info_reply_t *
+xcb_xkb_get_device_info_reply (xcb_connection_t                  *c,
+                               xcb_xkb_get_device_info_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_xkb_get_device_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xkb_set_device_info_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_set_device_info_request_t *_aux = (xcb_xkb_set_device_info_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_xkb_set_device_info_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* btnActions */
+    xcb_block_len += _aux->nBtns * sizeof(xcb_xkb_action_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xkb_action_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* leds */
+    for(i=0; i<_aux->nDeviceLedFBs; i++) {
+        xcb_tmp_len = xcb_xkb_device_led_info_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_xkb_device_led_info_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_xkb_set_device_info_checked (xcb_connection_t                *c,
+                                 xcb_xkb_device_spec_t            deviceSpec,
+                                 uint8_t                          firstBtn,
+                                 uint8_t                          nBtns,
+                                 uint16_t                         change,
+                                 uint16_t                         nDeviceLedFBs,
+                                 const xcb_xkb_action_t          *btnActions,
+                                 const xcb_xkb_device_led_info_t *leds)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SET_DEVICE_INFO,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_set_device_info_request_t xcb_out;
+    unsigned int xcb_tmp_len;
+    char *xcb_tmp;
+    unsigned int i;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.firstBtn = firstBtn;
+    xcb_out.nBtns = nBtns;
+    xcb_out.change = change;
+    xcb_out.nDeviceLedFBs = nDeviceLedFBs;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_xkb_action_t btnActions */
+    xcb_parts[4].iov_base = (char *) btnActions;
+    xcb_parts[4].iov_len = nBtns * sizeof(xcb_xkb_action_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_xkb_device_led_info_t leds */
+    xcb_parts[6].iov_base = (char *) leds;
+    xcb_parts[6].iov_len = 0;
+    xcb_tmp = (char *)leds;
+    for(i=0; i<nDeviceLedFBs; i++) {
+        xcb_tmp_len = xcb_xkb_device_led_info_sizeof(xcb_tmp);
+        xcb_parts[6].iov_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xkb_set_device_info (xcb_connection_t                *c,
+                         xcb_xkb_device_spec_t            deviceSpec,
+                         uint8_t                          firstBtn,
+                         uint8_t                          nBtns,
+                         uint16_t                         change,
+                         uint16_t                         nDeviceLedFBs,
+                         const xcb_xkb_action_t          *btnActions,
+                         const xcb_xkb_device_led_info_t *leds)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SET_DEVICE_INFO,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xkb_set_device_info_request_t xcb_out;
+    unsigned int xcb_tmp_len;
+    char *xcb_tmp;
+    unsigned int i;
+
+    xcb_out.deviceSpec = deviceSpec;
+    xcb_out.firstBtn = firstBtn;
+    xcb_out.nBtns = nBtns;
+    xcb_out.change = change;
+    xcb_out.nDeviceLedFBs = nDeviceLedFBs;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_xkb_action_t btnActions */
+    xcb_parts[4].iov_base = (char *) btnActions;
+    xcb_parts[4].iov_len = nBtns * sizeof(xcb_xkb_action_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_xkb_device_led_info_t leds */
+    xcb_parts[6].iov_base = (char *) leds;
+    xcb_parts[6].iov_len = 0;
+    xcb_tmp = (char *)leds;
+    for(i=0; i<nDeviceLedFBs; i++) {
+        xcb_tmp_len = xcb_xkb_device_led_info_sizeof(xcb_tmp);
+        xcb_parts[6].iov_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_action_t *
+xcb_xkb_set_device_info_btn_actions (const xcb_xkb_set_device_info_request_t *R)
+{
+    return (xcb_xkb_action_t *) (R + 1);
+}
+
+int
+xcb_xkb_set_device_info_btn_actions_length (const xcb_xkb_set_device_info_request_t *R)
+{
+    return R->nBtns;
+}
+
+xcb_xkb_action_iterator_t
+xcb_xkb_set_device_info_btn_actions_iterator (const xcb_xkb_set_device_info_request_t *R)
+{
+    xcb_xkb_action_iterator_t i;
+    i.data = (xcb_xkb_action_t *) (R + 1);
+    i.rem = R->nBtns;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_xkb_set_device_info_leds_length (const xcb_xkb_set_device_info_request_t *R)
+{
+    return R->nDeviceLedFBs;
+}
+
+xcb_xkb_device_led_info_iterator_t
+xcb_xkb_set_device_info_leds_iterator (const xcb_xkb_set_device_info_request_t *R)
+{
+    xcb_xkb_device_led_info_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_xkb_action_end(xcb_xkb_set_device_info_btn_actions_iterator(R));
+    i.data = (xcb_xkb_device_led_info_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_xkb_device_led_info_t, prev.index));
+    i.rem = R->nDeviceLedFBs;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_xkb_set_debugging_flags_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xkb_set_debugging_flags_request_t *_aux = (xcb_xkb_set_debugging_flags_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xkb_set_debugging_flags_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* message */
+    xcb_block_len += _aux->msgLength * sizeof(xcb_xkb_string8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xkb_string8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xkb_set_debugging_flags_cookie_t
+xcb_xkb_set_debugging_flags (xcb_connection_t        *c,
+                             uint16_t                 msgLength,
+                             uint32_t                 affectFlags,
+                             uint32_t                 flags,
+                             uint32_t                 affectCtrls,
+                             uint32_t                 ctrls,
+                             const xcb_xkb_string8_t *message)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SET_DEBUGGING_FLAGS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_xkb_set_debugging_flags_cookie_t xcb_ret;
+    xcb_xkb_set_debugging_flags_request_t xcb_out;
+
+    xcb_out.msgLength = msgLength;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.affectFlags = affectFlags;
+    xcb_out.flags = flags;
+    xcb_out.affectCtrls = affectCtrls;
+    xcb_out.ctrls = ctrls;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_xkb_string8_t message */
+    xcb_parts[4].iov_base = (char *) message;
+    xcb_parts[4].iov_len = msgLength * sizeof(xcb_xkb_string8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_set_debugging_flags_cookie_t
+xcb_xkb_set_debugging_flags_unchecked (xcb_connection_t        *c,
+                                       uint16_t                 msgLength,
+                                       uint32_t                 affectFlags,
+                                       uint32_t                 flags,
+                                       uint32_t                 affectCtrls,
+                                       uint32_t                 ctrls,
+                                       const xcb_xkb_string8_t *message)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_xkb_id,
+        .opcode = XCB_XKB_SET_DEBUGGING_FLAGS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_xkb_set_debugging_flags_cookie_t xcb_ret;
+    xcb_xkb_set_debugging_flags_request_t xcb_out;
+
+    xcb_out.msgLength = msgLength;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.affectFlags = affectFlags;
+    xcb_out.flags = flags;
+    xcb_out.affectCtrls = affectCtrls;
+    xcb_out.ctrls = ctrls;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_xkb_string8_t message */
+    xcb_parts[4].iov_base = (char *) message;
+    xcb_parts[4].iov_len = msgLength * sizeof(xcb_xkb_string8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xkb_set_debugging_flags_reply_t *
+xcb_xkb_set_debugging_flags_reply (xcb_connection_t                      *c,
+                                   xcb_xkb_set_debugging_flags_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e)
+{
+    return (xcb_xkb_set_debugging_flags_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
diff --git a/depends/libxcb/src/xprint.c b/depends/libxcb/src/xprint.c
new file mode 100644
index 0000000..b85ea70
--- /dev/null
+++ b/depends/libxcb/src/xprint.c
@@ -0,0 +1,2425 @@
+/*
+ * This file generated automatically from xprint.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "xprint.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xproto.h"
+
+xcb_extension_t xcb_x_print_id = { "XpExtension", 0 };
+
+void
+xcb_x_print_string8_next (xcb_x_print_string8_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_x_print_string8_t);
+}
+
+xcb_generic_iterator_t
+xcb_x_print_string8_end (xcb_x_print_string8_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_x_print_printer_serialize (void                        **_buffer,
+                               const xcb_x_print_printer_t  *_aux,
+                               const xcb_x_print_string8_t  *name,
+                               const xcb_x_print_string8_t  *description)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[7];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    /* xcb_x_print_printer_t.nameLen */
+    xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->nameLen;
+    xcb_block_len += sizeof(uint32_t);
+    xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+    xcb_parts_idx++;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* name */
+    xcb_parts[xcb_parts_idx].iov_base = (char *) name;
+    xcb_block_len += _aux->nameLen * sizeof(xcb_x_print_string8_t);
+    xcb_parts[xcb_parts_idx].iov_len = _aux->nameLen * sizeof(xcb_x_print_string8_t);
+    xcb_parts_idx++;
+    xcb_align_to = ALIGNOF(xcb_x_print_string8_t);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    xcb_block_len = 0;
+    /* xcb_x_print_printer_t.descLen */
+    xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->descLen;
+    xcb_block_len += sizeof(uint32_t);
+    xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+    xcb_parts_idx++;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* description */
+    xcb_parts[xcb_parts_idx].iov_base = (char *) description;
+    xcb_block_len += _aux->descLen * sizeof(xcb_x_print_string8_t);
+    xcb_parts[xcb_parts_idx].iov_len = _aux->descLen * sizeof(xcb_x_print_string8_t);
+    xcb_parts_idx++;
+    xcb_align_to = ALIGNOF(xcb_x_print_string8_t);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_x_print_printer_unserialize (const void              *_buffer,
+                                 xcb_x_print_printer_t  **_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    xcb_x_print_printer_t xcb_out;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    xcb_x_print_string8_t *name;
+    int name_len;
+    xcb_x_print_string8_t *description;
+    int description_len;
+
+    /* xcb_x_print_printer_t.nameLen */
+    xcb_out.nameLen = *(uint32_t *)xcb_tmp;
+    xcb_block_len += sizeof(uint32_t);
+    xcb_tmp += sizeof(uint32_t);
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* name */
+    name = (xcb_x_print_string8_t *)xcb_tmp;
+    name_len = xcb_out.nameLen * sizeof(xcb_x_print_string8_t);
+    xcb_block_len += name_len;
+    xcb_tmp += name_len;
+    xcb_align_to = ALIGNOF(xcb_x_print_string8_t);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    xcb_block_len = 0;
+    /* xcb_x_print_printer_t.descLen */
+    xcb_out.descLen = *(uint32_t *)xcb_tmp;
+    xcb_block_len += sizeof(uint32_t);
+    xcb_tmp += sizeof(uint32_t);
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* description */
+    description = (xcb_x_print_string8_t *)xcb_tmp;
+    description_len = xcb_out.descLen * sizeof(xcb_x_print_string8_t);
+    xcb_block_len += description_len;
+    xcb_tmp += description_len;
+    xcb_align_to = ALIGNOF(xcb_x_print_string8_t);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    if (NULL == _aux)
+        return xcb_buffer_len;
+
+    if (NULL == *_aux) {
+        /* allocate memory */
+        *_aux = malloc(xcb_buffer_len);
+    }
+
+    xcb_tmp = ((char *)*_aux)+xcb_buffer_len;
+    xcb_tmp -= description_len;
+    memmove(xcb_tmp, description, description_len);
+    xcb_tmp -= name_len;
+    memmove(xcb_tmp, name, name_len);
+    **_aux = xcb_out;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_x_print_printer_sizeof (const void  *_buffer)
+{
+    return xcb_x_print_printer_unserialize(_buffer, NULL);
+}
+
+xcb_x_print_string8_t *
+xcb_x_print_printer_name (const xcb_x_print_printer_t *R)
+{
+    return (xcb_x_print_string8_t *) (R + 1);
+}
+
+int
+xcb_x_print_printer_name_length (const xcb_x_print_printer_t *R)
+{
+    return R->nameLen;
+}
+
+xcb_generic_iterator_t
+xcb_x_print_printer_name_end (const xcb_x_print_printer_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_x_print_string8_t *) (R + 1)) + (R->nameLen);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_x_print_string8_t *
+xcb_x_print_printer_description (const xcb_x_print_printer_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_x_print_printer_name_end(R);
+    return (xcb_x_print_string8_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 4);
+}
+
+int
+xcb_x_print_printer_description_length (const xcb_x_print_printer_t *R)
+{
+    return R->descLen;
+}
+
+xcb_generic_iterator_t
+xcb_x_print_printer_description_end (const xcb_x_print_printer_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_x_print_printer_name_end(R);
+    i.data = ((xcb_x_print_string8_t *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (R->descLen);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_x_print_printer_next (xcb_x_print_printer_iterator_t *i)
+{
+    xcb_x_print_printer_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_x_print_printer_t *)(((char *)R) + xcb_x_print_printer_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_x_print_printer_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_x_print_printer_end (xcb_x_print_printer_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_x_print_printer_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+void
+xcb_x_print_pcontext_next (xcb_x_print_pcontext_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_x_print_pcontext_t);
+}
+
+xcb_generic_iterator_t
+xcb_x_print_pcontext_end (xcb_x_print_pcontext_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+xcb_x_print_print_query_version_cookie_t
+xcb_x_print_print_query_version (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_x_print_print_query_version_cookie_t xcb_ret;
+    xcb_x_print_print_query_version_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_query_version_cookie_t
+xcb_x_print_print_query_version_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_x_print_print_query_version_cookie_t xcb_ret;
+    xcb_x_print_print_query_version_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_query_version_reply_t *
+xcb_x_print_print_query_version_reply (xcb_connection_t                          *c,
+                                       xcb_x_print_print_query_version_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e)
+{
+    return (xcb_x_print_print_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_x_print_print_get_printer_list_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_x_print_print_get_printer_list_request_t *_aux = (xcb_x_print_print_get_printer_list_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_x_print_print_get_printer_list_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* printer_name */
+    xcb_block_len += _aux->printerNameLen * sizeof(xcb_x_print_string8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_x_print_string8_t);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* locale */
+    xcb_block_len += _aux->localeLen * sizeof(xcb_x_print_string8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_x_print_string8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_x_print_print_get_printer_list_cookie_t
+xcb_x_print_print_get_printer_list (xcb_connection_t            *c,
+                                    uint32_t                     printerNameLen,
+                                    uint32_t                     localeLen,
+                                    const xcb_x_print_string8_t *printer_name,
+                                    const xcb_x_print_string8_t *locale)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_GET_PRINTER_LIST,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_x_print_print_get_printer_list_cookie_t xcb_ret;
+    xcb_x_print_print_get_printer_list_request_t xcb_out;
+
+    xcb_out.printerNameLen = printerNameLen;
+    xcb_out.localeLen = localeLen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_x_print_string8_t printer_name */
+    xcb_parts[4].iov_base = (char *) printer_name;
+    xcb_parts[4].iov_len = printerNameLen * sizeof(xcb_x_print_string8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_x_print_string8_t locale */
+    xcb_parts[6].iov_base = (char *) locale;
+    xcb_parts[6].iov_len = localeLen * sizeof(xcb_x_print_string8_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_get_printer_list_cookie_t
+xcb_x_print_print_get_printer_list_unchecked (xcb_connection_t            *c,
+                                              uint32_t                     printerNameLen,
+                                              uint32_t                     localeLen,
+                                              const xcb_x_print_string8_t *printer_name,
+                                              const xcb_x_print_string8_t *locale)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_GET_PRINTER_LIST,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_x_print_print_get_printer_list_cookie_t xcb_ret;
+    xcb_x_print_print_get_printer_list_request_t xcb_out;
+
+    xcb_out.printerNameLen = printerNameLen;
+    xcb_out.localeLen = localeLen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_x_print_string8_t printer_name */
+    xcb_parts[4].iov_base = (char *) printer_name;
+    xcb_parts[4].iov_len = printerNameLen * sizeof(xcb_x_print_string8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_x_print_string8_t locale */
+    xcb_parts[6].iov_base = (char *) locale;
+    xcb_parts[6].iov_len = localeLen * sizeof(xcb_x_print_string8_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_x_print_print_get_printer_list_printers_length (const xcb_x_print_print_get_printer_list_reply_t *R)
+{
+    return R->listCount;
+}
+
+xcb_x_print_printer_iterator_t
+xcb_x_print_print_get_printer_list_printers_iterator (const xcb_x_print_print_get_printer_list_reply_t *R)
+{
+    xcb_x_print_printer_iterator_t i;
+    i.data = (xcb_x_print_printer_t *) (R + 1);
+    i.rem = R->listCount;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_x_print_print_get_printer_list_reply_t *
+xcb_x_print_print_get_printer_list_reply (xcb_connection_t                             *c,
+                                          xcb_x_print_print_get_printer_list_cookie_t   cookie  /**< */,
+                                          xcb_generic_error_t                         **e)
+{
+    xcb_x_print_print_get_printer_list_reply_t *reply = (xcb_x_print_print_get_printer_list_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+    int i;
+    xcb_x_print_printer_iterator_t printers_iter = xcb_x_print_print_get_printer_list_printers_iterator(reply);
+    int printers_len = xcb_x_print_print_get_printer_list_printers_length(reply);
+    xcb_x_print_printer_t *printers_data;
+    /* special cases: transform parts of the reply to match XCB data structures */
+    for(i=0; i<printers_len; i++) {
+        printers_data = printers_iter.data;
+        xcb_x_print_printer_unserialize((const void *)printers_data, &printers_data);
+        xcb_x_print_printer_next(&printers_iter);
+    }
+    return reply;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_rehash_printer_list_checked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_REHASH_PRINTER_LIST,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_rehash_printer_list_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_rehash_printer_list (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_REHASH_PRINTER_LIST,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_rehash_printer_list_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_x_print_create_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_x_print_create_context_request_t *_aux = (xcb_x_print_create_context_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_x_print_create_context_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* printerName */
+    xcb_block_len += _aux->printerNameLen * sizeof(xcb_x_print_string8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_x_print_string8_t);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* locale */
+    xcb_block_len += _aux->localeLen * sizeof(xcb_x_print_string8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_x_print_string8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_x_print_create_context_checked (xcb_connection_t            *c,
+                                    uint32_t                     context_id,
+                                    uint32_t                     printerNameLen,
+                                    uint32_t                     localeLen,
+                                    const xcb_x_print_string8_t *printerName,
+                                    const xcb_x_print_string8_t *locale)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_CREATE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_create_context_request_t xcb_out;
+
+    xcb_out.context_id = context_id;
+    xcb_out.printerNameLen = printerNameLen;
+    xcb_out.localeLen = localeLen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_x_print_string8_t printerName */
+    xcb_parts[4].iov_base = (char *) printerName;
+    xcb_parts[4].iov_len = printerNameLen * sizeof(xcb_x_print_string8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_x_print_string8_t locale */
+    xcb_parts[6].iov_base = (char *) locale;
+    xcb_parts[6].iov_len = localeLen * sizeof(xcb_x_print_string8_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_x_print_create_context (xcb_connection_t            *c,
+                            uint32_t                     context_id,
+                            uint32_t                     printerNameLen,
+                            uint32_t                     localeLen,
+                            const xcb_x_print_string8_t *printerName,
+                            const xcb_x_print_string8_t *locale)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 6,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_CREATE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[8];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_create_context_request_t xcb_out;
+
+    xcb_out.context_id = context_id;
+    xcb_out.printerNameLen = printerNameLen;
+    xcb_out.localeLen = localeLen;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_x_print_string8_t printerName */
+    xcb_parts[4].iov_base = (char *) printerName;
+    xcb_parts[4].iov_len = printerNameLen * sizeof(xcb_x_print_string8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_x_print_string8_t locale */
+    xcb_parts[6].iov_base = (char *) locale;
+    xcb_parts[6].iov_len = localeLen * sizeof(xcb_x_print_string8_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_string8_t *
+xcb_x_print_create_context_printer_name (const xcb_x_print_create_context_request_t *R)
+{
+    return (xcb_x_print_string8_t *) (R + 1);
+}
+
+int
+xcb_x_print_create_context_printer_name_length (const xcb_x_print_create_context_request_t *R)
+{
+    return R->printerNameLen;
+}
+
+xcb_generic_iterator_t
+xcb_x_print_create_context_printer_name_end (const xcb_x_print_create_context_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_x_print_string8_t *) (R + 1)) + (R->printerNameLen);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_x_print_string8_t *
+xcb_x_print_create_context_locale (const xcb_x_print_create_context_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_x_print_create_context_printer_name_end(R);
+    return (xcb_x_print_string8_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0);
+}
+
+int
+xcb_x_print_create_context_locale_length (const xcb_x_print_create_context_request_t *R)
+{
+    return R->localeLen;
+}
+
+xcb_generic_iterator_t
+xcb_x_print_create_context_locale_end (const xcb_x_print_create_context_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_x_print_create_context_printer_name_end(R);
+    i.data = ((xcb_x_print_string8_t *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (R->localeLen);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_set_context_checked (xcb_connection_t *c,
+                                       uint32_t          context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_SET_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_set_context_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_set_context (xcb_connection_t *c,
+                               uint32_t          context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_SET_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_set_context_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_get_context_cookie_t
+xcb_x_print_print_get_context (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_GET_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_x_print_print_get_context_cookie_t xcb_ret;
+    xcb_x_print_print_get_context_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_get_context_cookie_t
+xcb_x_print_print_get_context_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_GET_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_x_print_print_get_context_cookie_t xcb_ret;
+    xcb_x_print_print_get_context_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_get_context_reply_t *
+xcb_x_print_print_get_context_reply (xcb_connection_t                        *c,
+                                     xcb_x_print_print_get_context_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e)
+{
+    return (xcb_x_print_print_get_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_destroy_context_checked (xcb_connection_t *c,
+                                           uint32_t          context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_DESTROY_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_destroy_context_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_destroy_context (xcb_connection_t *c,
+                                   uint32_t          context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_DESTROY_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_destroy_context_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_get_screen_of_context_cookie_t
+xcb_x_print_print_get_screen_of_context (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_GET_SCREEN_OF_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_x_print_print_get_screen_of_context_cookie_t xcb_ret;
+    xcb_x_print_print_get_screen_of_context_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_get_screen_of_context_cookie_t
+xcb_x_print_print_get_screen_of_context_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_GET_SCREEN_OF_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_x_print_print_get_screen_of_context_cookie_t xcb_ret;
+    xcb_x_print_print_get_screen_of_context_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_get_screen_of_context_reply_t *
+xcb_x_print_print_get_screen_of_context_reply (xcb_connection_t                                  *c,
+                                               xcb_x_print_print_get_screen_of_context_cookie_t   cookie  /**< */,
+                                               xcb_generic_error_t                              **e)
+{
+    return (xcb_x_print_print_get_screen_of_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_start_job_checked (xcb_connection_t *c,
+                                     uint8_t           output_mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_START_JOB,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_start_job_request_t xcb_out;
+
+    xcb_out.output_mode = output_mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_start_job (xcb_connection_t *c,
+                             uint8_t           output_mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_START_JOB,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_start_job_request_t xcb_out;
+
+    xcb_out.output_mode = output_mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_end_job_checked (xcb_connection_t *c,
+                                   uint8_t           cancel)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_END_JOB,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_end_job_request_t xcb_out;
+
+    xcb_out.cancel = cancel;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_end_job (xcb_connection_t *c,
+                           uint8_t           cancel)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_END_JOB,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_end_job_request_t xcb_out;
+
+    xcb_out.cancel = cancel;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_start_doc_checked (xcb_connection_t *c,
+                                     uint8_t           driver_mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_START_DOC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_start_doc_request_t xcb_out;
+
+    xcb_out.driver_mode = driver_mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_start_doc (xcb_connection_t *c,
+                             uint8_t           driver_mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_START_DOC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_start_doc_request_t xcb_out;
+
+    xcb_out.driver_mode = driver_mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_end_doc_checked (xcb_connection_t *c,
+                                   uint8_t           cancel)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_END_DOC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_end_doc_request_t xcb_out;
+
+    xcb_out.cancel = cancel;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_end_doc (xcb_connection_t *c,
+                           uint8_t           cancel)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_END_DOC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_end_doc_request_t xcb_out;
+
+    xcb_out.cancel = cancel;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_x_print_print_put_document_data_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_x_print_print_put_document_data_request_t *_aux = (xcb_x_print_print_put_document_data_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_x_print_print_put_document_data_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->len_data * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* doc_format */
+    xcb_block_len += _aux->len_fmt * sizeof(xcb_x_print_string8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_x_print_string8_t);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* options */
+    xcb_block_len += _aux->len_options * sizeof(xcb_x_print_string8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_x_print_string8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_put_document_data_checked (xcb_connection_t            *c,
+                                             xcb_drawable_t               drawable,
+                                             uint32_t                     len_data,
+                                             uint16_t                     len_fmt,
+                                             uint16_t                     len_options,
+                                             const uint8_t               *data,
+                                             const xcb_x_print_string8_t *doc_format,
+                                             const xcb_x_print_string8_t *options)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 8,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_PUT_DOCUMENT_DATA,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[10];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_put_document_data_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.len_data = len_data;
+    xcb_out.len_fmt = len_fmt;
+    xcb_out.len_options = len_options;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t data */
+    xcb_parts[4].iov_base = (char *) data;
+    xcb_parts[4].iov_len = len_data * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_x_print_string8_t doc_format */
+    xcb_parts[6].iov_base = (char *) doc_format;
+    xcb_parts[6].iov_len = len_fmt * sizeof(xcb_x_print_string8_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+    /* xcb_x_print_string8_t options */
+    xcb_parts[8].iov_base = (char *) options;
+    xcb_parts[8].iov_len = len_options * sizeof(xcb_x_print_string8_t);
+    xcb_parts[9].iov_base = 0;
+    xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_put_document_data (xcb_connection_t            *c,
+                                     xcb_drawable_t               drawable,
+                                     uint32_t                     len_data,
+                                     uint16_t                     len_fmt,
+                                     uint16_t                     len_options,
+                                     const uint8_t               *data,
+                                     const xcb_x_print_string8_t *doc_format,
+                                     const xcb_x_print_string8_t *options)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 8,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_PUT_DOCUMENT_DATA,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[10];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_put_document_data_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.len_data = len_data;
+    xcb_out.len_fmt = len_fmt;
+    xcb_out.len_options = len_options;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t data */
+    xcb_parts[4].iov_base = (char *) data;
+    xcb_parts[4].iov_len = len_data * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+    /* xcb_x_print_string8_t doc_format */
+    xcb_parts[6].iov_base = (char *) doc_format;
+    xcb_parts[6].iov_len = len_fmt * sizeof(xcb_x_print_string8_t);
+    xcb_parts[7].iov_base = 0;
+    xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3;
+    /* xcb_x_print_string8_t options */
+    xcb_parts[8].iov_base = (char *) options;
+    xcb_parts[8].iov_len = len_options * sizeof(xcb_x_print_string8_t);
+    xcb_parts[9].iov_base = 0;
+    xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_x_print_print_put_document_data_data (const xcb_x_print_print_put_document_data_request_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_x_print_print_put_document_data_data_length (const xcb_x_print_print_put_document_data_request_t *R)
+{
+    return R->len_data;
+}
+
+xcb_generic_iterator_t
+xcb_x_print_print_put_document_data_data_end (const xcb_x_print_print_put_document_data_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + (R->len_data);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_x_print_string8_t *
+xcb_x_print_print_put_document_data_doc_format (const xcb_x_print_print_put_document_data_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_x_print_print_put_document_data_data_end(R);
+    return (xcb_x_print_string8_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0);
+}
+
+int
+xcb_x_print_print_put_document_data_doc_format_length (const xcb_x_print_print_put_document_data_request_t *R)
+{
+    return R->len_fmt;
+}
+
+xcb_generic_iterator_t
+xcb_x_print_print_put_document_data_doc_format_end (const xcb_x_print_print_put_document_data_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_x_print_print_put_document_data_data_end(R);
+    i.data = ((xcb_x_print_string8_t *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (R->len_fmt);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_x_print_string8_t *
+xcb_x_print_print_put_document_data_options (const xcb_x_print_print_put_document_data_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_x_print_print_put_document_data_doc_format_end(R);
+    return (xcb_x_print_string8_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0);
+}
+
+int
+xcb_x_print_print_put_document_data_options_length (const xcb_x_print_print_put_document_data_request_t *R)
+{
+    return R->len_options;
+}
+
+xcb_generic_iterator_t
+xcb_x_print_print_put_document_data_options_end (const xcb_x_print_print_put_document_data_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_x_print_print_put_document_data_doc_format_end(R);
+    i.data = ((xcb_x_print_string8_t *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (R->len_options);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_x_print_print_get_document_data_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_x_print_print_get_document_data_reply_t *_aux = (xcb_x_print_print_get_document_data_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_x_print_print_get_document_data_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->dataLen * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_x_print_print_get_document_data_cookie_t
+xcb_x_print_print_get_document_data (xcb_connection_t       *c,
+                                     xcb_x_print_pcontext_t  context,
+                                     uint32_t                max_bytes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_GET_DOCUMENT_DATA,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_x_print_print_get_document_data_cookie_t xcb_ret;
+    xcb_x_print_print_get_document_data_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.max_bytes = max_bytes;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_get_document_data_cookie_t
+xcb_x_print_print_get_document_data_unchecked (xcb_connection_t       *c,
+                                               xcb_x_print_pcontext_t  context,
+                                               uint32_t                max_bytes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_GET_DOCUMENT_DATA,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_x_print_print_get_document_data_cookie_t xcb_ret;
+    xcb_x_print_print_get_document_data_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.max_bytes = max_bytes;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_x_print_print_get_document_data_data (const xcb_x_print_print_get_document_data_reply_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_x_print_print_get_document_data_data_length (const xcb_x_print_print_get_document_data_reply_t *R)
+{
+    return R->dataLen;
+}
+
+xcb_generic_iterator_t
+xcb_x_print_print_get_document_data_data_end (const xcb_x_print_print_get_document_data_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + (R->dataLen);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_x_print_print_get_document_data_reply_t *
+xcb_x_print_print_get_document_data_reply (xcb_connection_t                              *c,
+                                           xcb_x_print_print_get_document_data_cookie_t   cookie  /**< */,
+                                           xcb_generic_error_t                          **e)
+{
+    return (xcb_x_print_print_get_document_data_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_start_page_checked (xcb_connection_t *c,
+                                      xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_START_PAGE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_start_page_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_start_page (xcb_connection_t *c,
+                              xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_START_PAGE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_start_page_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_end_page_checked (xcb_connection_t *c,
+                                    uint8_t           cancel)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_END_PAGE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_end_page_request_t xcb_out;
+
+    xcb_out.cancel = cancel;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_end_page (xcb_connection_t *c,
+                            uint8_t           cancel)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_END_PAGE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_end_page_request_t xcb_out;
+
+    xcb_out.cancel = cancel;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_select_input_checked (xcb_connection_t       *c,
+                                        xcb_x_print_pcontext_t  context,
+                                        uint32_t                event_mask)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_SELECT_INPUT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_select_input_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.event_mask = event_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_select_input (xcb_connection_t       *c,
+                                xcb_x_print_pcontext_t  context,
+                                uint32_t                event_mask)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_SELECT_INPUT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_select_input_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.event_mask = event_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_input_selected_cookie_t
+xcb_x_print_print_input_selected (xcb_connection_t       *c,
+                                  xcb_x_print_pcontext_t  context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_INPUT_SELECTED,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_x_print_print_input_selected_cookie_t xcb_ret;
+    xcb_x_print_print_input_selected_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_input_selected_cookie_t
+xcb_x_print_print_input_selected_unchecked (xcb_connection_t       *c,
+                                            xcb_x_print_pcontext_t  context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_INPUT_SELECTED,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_x_print_print_input_selected_cookie_t xcb_ret;
+    xcb_x_print_print_input_selected_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_input_selected_reply_t *
+xcb_x_print_print_input_selected_reply (xcb_connection_t                           *c,
+                                        xcb_x_print_print_input_selected_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e)
+{
+    return (xcb_x_print_print_input_selected_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_x_print_print_get_attributes_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_x_print_print_get_attributes_reply_t *_aux = (xcb_x_print_print_get_attributes_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_x_print_print_get_attributes_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* attributes */
+    xcb_block_len += _aux->stringLen * sizeof(xcb_x_print_string8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_x_print_string8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_x_print_print_get_attributes_cookie_t
+xcb_x_print_print_get_attributes (xcb_connection_t       *c,
+                                  xcb_x_print_pcontext_t  context,
+                                  uint8_t                 pool)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_GET_ATTRIBUTES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_x_print_print_get_attributes_cookie_t xcb_ret;
+    xcb_x_print_print_get_attributes_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.pool = pool;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_get_attributes_cookie_t
+xcb_x_print_print_get_attributes_unchecked (xcb_connection_t       *c,
+                                            xcb_x_print_pcontext_t  context,
+                                            uint8_t                 pool)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_GET_ATTRIBUTES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_x_print_print_get_attributes_cookie_t xcb_ret;
+    xcb_x_print_print_get_attributes_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.pool = pool;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_string8_t *
+xcb_x_print_print_get_attributes_attributes (const xcb_x_print_print_get_attributes_reply_t *R)
+{
+    return (xcb_x_print_string8_t *) (R + 1);
+}
+
+int
+xcb_x_print_print_get_attributes_attributes_length (const xcb_x_print_print_get_attributes_reply_t *R)
+{
+    return R->stringLen;
+}
+
+xcb_generic_iterator_t
+xcb_x_print_print_get_attributes_attributes_end (const xcb_x_print_print_get_attributes_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_x_print_string8_t *) (R + 1)) + (R->stringLen);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_x_print_print_get_attributes_reply_t *
+xcb_x_print_print_get_attributes_reply (xcb_connection_t                           *c,
+                                        xcb_x_print_print_get_attributes_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e)
+{
+    return (xcb_x_print_print_get_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_x_print_print_get_one_attributes_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_x_print_print_get_one_attributes_request_t *_aux = (xcb_x_print_print_get_one_attributes_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_x_print_print_get_one_attributes_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->nameLen * sizeof(xcb_x_print_string8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_x_print_string8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_x_print_print_get_one_attributes_cookie_t
+xcb_x_print_print_get_one_attributes (xcb_connection_t            *c,
+                                      xcb_x_print_pcontext_t       context,
+                                      uint32_t                     nameLen,
+                                      uint8_t                      pool,
+                                      const xcb_x_print_string8_t *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_GET_ONE_ATTRIBUTES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_x_print_print_get_one_attributes_cookie_t xcb_ret;
+    xcb_x_print_print_get_one_attributes_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.nameLen = nameLen;
+    xcb_out.pool = pool;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_x_print_string8_t name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = nameLen * sizeof(xcb_x_print_string8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_get_one_attributes_cookie_t
+xcb_x_print_print_get_one_attributes_unchecked (xcb_connection_t            *c,
+                                                xcb_x_print_pcontext_t       context,
+                                                uint32_t                     nameLen,
+                                                uint8_t                      pool,
+                                                const xcb_x_print_string8_t *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_GET_ONE_ATTRIBUTES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_x_print_print_get_one_attributes_cookie_t xcb_ret;
+    xcb_x_print_print_get_one_attributes_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.nameLen = nameLen;
+    xcb_out.pool = pool;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_x_print_string8_t name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = nameLen * sizeof(xcb_x_print_string8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_string8_t *
+xcb_x_print_print_get_one_attributes_value (const xcb_x_print_print_get_one_attributes_reply_t *R)
+{
+    return (xcb_x_print_string8_t *) (R + 1);
+}
+
+int
+xcb_x_print_print_get_one_attributes_value_length (const xcb_x_print_print_get_one_attributes_reply_t *R)
+{
+    return R->valueLen;
+}
+
+xcb_generic_iterator_t
+xcb_x_print_print_get_one_attributes_value_end (const xcb_x_print_print_get_one_attributes_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_x_print_string8_t *) (R + 1)) + (R->valueLen);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_x_print_print_get_one_attributes_reply_t *
+xcb_x_print_print_get_one_attributes_reply (xcb_connection_t                               *c,
+                                            xcb_x_print_print_get_one_attributes_cookie_t   cookie  /**< */,
+                                            xcb_generic_error_t                           **e)
+{
+    return (xcb_x_print_print_get_one_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_x_print_print_set_attributes_sizeof (const void  *_buffer,
+                                         uint32_t     attributes_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_x_print_print_set_attributes_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* attributes */
+    xcb_block_len += attributes_len * sizeof(xcb_x_print_string8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_x_print_string8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_set_attributes_checked (xcb_connection_t            *c,
+                                          xcb_x_print_pcontext_t       context,
+                                          uint32_t                     stringLen,
+                                          uint8_t                      pool,
+                                          uint8_t                      rule,
+                                          uint32_t                     attributes_len,
+                                          const xcb_x_print_string8_t *attributes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_SET_ATTRIBUTES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_set_attributes_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.stringLen = stringLen;
+    xcb_out.pool = pool;
+    xcb_out.rule = rule;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_x_print_string8_t attributes */
+    xcb_parts[4].iov_base = (char *) attributes;
+    xcb_parts[4].iov_len = attributes_len * sizeof(xcb_x_print_string8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_x_print_print_set_attributes (xcb_connection_t            *c,
+                                  xcb_x_print_pcontext_t       context,
+                                  uint32_t                     stringLen,
+                                  uint8_t                      pool,
+                                  uint8_t                      rule,
+                                  uint32_t                     attributes_len,
+                                  const xcb_x_print_string8_t *attributes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_SET_ATTRIBUTES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_x_print_print_set_attributes_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.stringLen = stringLen;
+    xcb_out.pool = pool;
+    xcb_out.rule = rule;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_x_print_string8_t attributes */
+    xcb_parts[4].iov_base = (char *) attributes;
+    xcb_parts[4].iov_len = attributes_len * sizeof(xcb_x_print_string8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_string8_t *
+xcb_x_print_print_set_attributes_attributes (const xcb_x_print_print_set_attributes_request_t *R)
+{
+    return (xcb_x_print_string8_t *) (R + 1);
+}
+
+int
+xcb_x_print_print_set_attributes_attributes_length (const xcb_x_print_print_set_attributes_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_x_print_print_set_attributes_request_t))/sizeof(xcb_x_print_string8_t));
+}
+
+xcb_generic_iterator_t
+xcb_x_print_print_set_attributes_attributes_end (const xcb_x_print_print_set_attributes_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_x_print_string8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_x_print_print_set_attributes_request_t))/sizeof(xcb_x_print_string8_t)));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_x_print_print_get_page_dimensions_cookie_t
+xcb_x_print_print_get_page_dimensions (xcb_connection_t       *c,
+                                       xcb_x_print_pcontext_t  context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_GET_PAGE_DIMENSIONS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_x_print_print_get_page_dimensions_cookie_t xcb_ret;
+    xcb_x_print_print_get_page_dimensions_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_get_page_dimensions_cookie_t
+xcb_x_print_print_get_page_dimensions_unchecked (xcb_connection_t       *c,
+                                                 xcb_x_print_pcontext_t  context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_GET_PAGE_DIMENSIONS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_x_print_print_get_page_dimensions_cookie_t xcb_ret;
+    xcb_x_print_print_get_page_dimensions_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_get_page_dimensions_reply_t *
+xcb_x_print_print_get_page_dimensions_reply (xcb_connection_t                                *c,
+                                             xcb_x_print_print_get_page_dimensions_cookie_t   cookie  /**< */,
+                                             xcb_generic_error_t                            **e)
+{
+    return (xcb_x_print_print_get_page_dimensions_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_x_print_print_query_screens_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_x_print_print_query_screens_reply_t *_aux = (xcb_x_print_print_query_screens_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_x_print_print_query_screens_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* roots */
+    xcb_block_len += _aux->listCount * sizeof(xcb_window_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_window_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_x_print_print_query_screens_cookie_t
+xcb_x_print_print_query_screens (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_QUERY_SCREENS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_x_print_print_query_screens_cookie_t xcb_ret;
+    xcb_x_print_print_query_screens_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_query_screens_cookie_t
+xcb_x_print_print_query_screens_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_QUERY_SCREENS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_x_print_print_query_screens_cookie_t xcb_ret;
+    xcb_x_print_print_query_screens_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_window_t *
+xcb_x_print_print_query_screens_roots (const xcb_x_print_print_query_screens_reply_t *R)
+{
+    return (xcb_window_t *) (R + 1);
+}
+
+int
+xcb_x_print_print_query_screens_roots_length (const xcb_x_print_print_query_screens_reply_t *R)
+{
+    return R->listCount;
+}
+
+xcb_generic_iterator_t
+xcb_x_print_print_query_screens_roots_end (const xcb_x_print_print_query_screens_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_window_t *) (R + 1)) + (R->listCount);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_x_print_print_query_screens_reply_t *
+xcb_x_print_print_query_screens_reply (xcb_connection_t                          *c,
+                                       xcb_x_print_print_query_screens_cookie_t   cookie  /**< */,
+                                       xcb_generic_error_t                      **e)
+{
+    return (xcb_x_print_print_query_screens_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_x_print_print_set_image_resolution_cookie_t
+xcb_x_print_print_set_image_resolution (xcb_connection_t       *c,
+                                        xcb_x_print_pcontext_t  context,
+                                        uint16_t                image_resolution)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_SET_IMAGE_RESOLUTION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_x_print_print_set_image_resolution_cookie_t xcb_ret;
+    xcb_x_print_print_set_image_resolution_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.image_resolution = image_resolution;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_set_image_resolution_cookie_t
+xcb_x_print_print_set_image_resolution_unchecked (xcb_connection_t       *c,
+                                                  xcb_x_print_pcontext_t  context,
+                                                  uint16_t                image_resolution)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_SET_IMAGE_RESOLUTION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_x_print_print_set_image_resolution_cookie_t xcb_ret;
+    xcb_x_print_print_set_image_resolution_request_t xcb_out;
+
+    xcb_out.context = context;
+    xcb_out.image_resolution = image_resolution;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_set_image_resolution_reply_t *
+xcb_x_print_print_set_image_resolution_reply (xcb_connection_t                                 *c,
+                                              xcb_x_print_print_set_image_resolution_cookie_t   cookie  /**< */,
+                                              xcb_generic_error_t                             **e)
+{
+    return (xcb_x_print_print_set_image_resolution_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_x_print_print_get_image_resolution_cookie_t
+xcb_x_print_print_get_image_resolution (xcb_connection_t       *c,
+                                        xcb_x_print_pcontext_t  context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_GET_IMAGE_RESOLUTION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_x_print_print_get_image_resolution_cookie_t xcb_ret;
+    xcb_x_print_print_get_image_resolution_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_get_image_resolution_cookie_t
+xcb_x_print_print_get_image_resolution_unchecked (xcb_connection_t       *c,
+                                                  xcb_x_print_pcontext_t  context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_x_print_id,
+        .opcode = XCB_X_PRINT_PRINT_GET_IMAGE_RESOLUTION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_x_print_print_get_image_resolution_cookie_t xcb_ret;
+    xcb_x_print_print_get_image_resolution_request_t xcb_out;
+
+    xcb_out.context = context;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_x_print_print_get_image_resolution_reply_t *
+xcb_x_print_print_get_image_resolution_reply (xcb_connection_t                                 *c,
+                                              xcb_x_print_print_get_image_resolution_cookie_t   cookie  /**< */,
+                                              xcb_generic_error_t                             **e)
+{
+    return (xcb_x_print_print_get_image_resolution_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
diff --git a/depends/libxcb/src/xproto.c b/depends/libxcb/src/xproto.c
new file mode 100644
index 0000000..d87420d
--- /dev/null
+++ b/depends/libxcb/src/xproto.c
@@ -0,0 +1,14547 @@
+/*
+ * This file generated automatically from xproto.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "xproto.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+
+void
+xcb_char2b_next (xcb_char2b_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_char2b_t);
+}
+
+xcb_generic_iterator_t
+xcb_char2b_end (xcb_char2b_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_window_next (xcb_window_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_window_t);
+}
+
+xcb_generic_iterator_t
+xcb_window_end (xcb_window_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_pixmap_next (xcb_pixmap_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_pixmap_t);
+}
+
+xcb_generic_iterator_t
+xcb_pixmap_end (xcb_pixmap_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_cursor_next (xcb_cursor_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_cursor_t);
+}
+
+xcb_generic_iterator_t
+xcb_cursor_end (xcb_cursor_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_font_next (xcb_font_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_font_t);
+}
+
+xcb_generic_iterator_t
+xcb_font_end (xcb_font_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_gcontext_next (xcb_gcontext_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_gcontext_t);
+}
+
+xcb_generic_iterator_t
+xcb_gcontext_end (xcb_gcontext_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_colormap_next (xcb_colormap_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_colormap_t);
+}
+
+xcb_generic_iterator_t
+xcb_colormap_end (xcb_colormap_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_atom_next (xcb_atom_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_atom_t);
+}
+
+xcb_generic_iterator_t
+xcb_atom_end (xcb_atom_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_drawable_next (xcb_drawable_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_drawable_t);
+}
+
+xcb_generic_iterator_t
+xcb_drawable_end (xcb_drawable_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_fontable_next (xcb_fontable_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_fontable_t);
+}
+
+xcb_generic_iterator_t
+xcb_fontable_end (xcb_fontable_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_bool32_next (xcb_bool32_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_bool32_t);
+}
+
+xcb_generic_iterator_t
+xcb_bool32_end (xcb_bool32_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_visualid_next (xcb_visualid_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_visualid_t);
+}
+
+xcb_generic_iterator_t
+xcb_visualid_end (xcb_visualid_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_timestamp_next (xcb_timestamp_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_timestamp_t);
+}
+
+xcb_generic_iterator_t
+xcb_timestamp_end (xcb_timestamp_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_keysym_next (xcb_keysym_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_keysym_t);
+}
+
+xcb_generic_iterator_t
+xcb_keysym_end (xcb_keysym_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_keycode_next (xcb_keycode_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_keycode_t);
+}
+
+xcb_generic_iterator_t
+xcb_keycode_end (xcb_keycode_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_keycode32_next (xcb_keycode32_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_keycode32_t);
+}
+
+xcb_generic_iterator_t
+xcb_keycode32_end (xcb_keycode32_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_button_next (xcb_button_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_button_t);
+}
+
+xcb_generic_iterator_t
+xcb_button_end (xcb_button_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_point_next (xcb_point_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_point_t);
+}
+
+xcb_generic_iterator_t
+xcb_point_end (xcb_point_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_rectangle_next (xcb_rectangle_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_rectangle_t);
+}
+
+xcb_generic_iterator_t
+xcb_rectangle_end (xcb_rectangle_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_arc_next (xcb_arc_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_arc_t);
+}
+
+xcb_generic_iterator_t
+xcb_arc_end (xcb_arc_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_format_next (xcb_format_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_format_t);
+}
+
+xcb_generic_iterator_t
+xcb_format_end (xcb_format_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_visualtype_next (xcb_visualtype_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_visualtype_t);
+}
+
+xcb_generic_iterator_t
+xcb_visualtype_end (xcb_visualtype_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_depth_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_depth_t *_aux = (xcb_depth_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_depth_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* visuals */
+    xcb_block_len += _aux->visuals_len * sizeof(xcb_visualtype_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_visualtype_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_visualtype_t *
+xcb_depth_visuals (const xcb_depth_t *R)
+{
+    return (xcb_visualtype_t *) (R + 1);
+}
+
+int
+xcb_depth_visuals_length (const xcb_depth_t *R)
+{
+    return R->visuals_len;
+}
+
+xcb_visualtype_iterator_t
+xcb_depth_visuals_iterator (const xcb_depth_t *R)
+{
+    xcb_visualtype_iterator_t i;
+    i.data = (xcb_visualtype_t *) (R + 1);
+    i.rem = R->visuals_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_depth_next (xcb_depth_iterator_t *i)
+{
+    xcb_depth_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_depth_t *)(((char *)R) + xcb_depth_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_depth_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_depth_end (xcb_depth_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_depth_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_screen_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_screen_t *_aux = (xcb_screen_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_screen_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* allowed_depths */
+    for(i=0; i<_aux->allowed_depths_len; i++) {
+        xcb_tmp_len = xcb_depth_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_depth_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_screen_allowed_depths_length (const xcb_screen_t *R)
+{
+    return R->allowed_depths_len;
+}
+
+xcb_depth_iterator_t
+xcb_screen_allowed_depths_iterator (const xcb_screen_t *R)
+{
+    xcb_depth_iterator_t i;
+    i.data = (xcb_depth_t *) (R + 1);
+    i.rem = R->allowed_depths_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_screen_next (xcb_screen_iterator_t *i)
+{
+    xcb_screen_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_screen_t *)(((char *)R) + xcb_screen_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_screen_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_screen_end (xcb_screen_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_screen_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_setup_request_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_setup_request_t *_aux = (xcb_setup_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_setup_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* authorization_protocol_name */
+    xcb_block_len += _aux->authorization_protocol_name_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* authorization_protocol_data */
+    xcb_block_len += _aux->authorization_protocol_data_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+char *
+xcb_setup_request_authorization_protocol_name (const xcb_setup_request_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_setup_request_authorization_protocol_name_length (const xcb_setup_request_t *R)
+{
+    return R->authorization_protocol_name_len;
+}
+
+xcb_generic_iterator_t
+xcb_setup_request_authorization_protocol_name_end (const xcb_setup_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->authorization_protocol_name_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+char *
+xcb_setup_request_authorization_protocol_data (const xcb_setup_request_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_setup_request_authorization_protocol_name_end(R);
+    return (char *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0);
+}
+
+int
+xcb_setup_request_authorization_protocol_data_length (const xcb_setup_request_t *R)
+{
+    return R->authorization_protocol_data_len;
+}
+
+xcb_generic_iterator_t
+xcb_setup_request_authorization_protocol_data_end (const xcb_setup_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_setup_request_authorization_protocol_name_end(R);
+    i.data = ((char *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (R->authorization_protocol_data_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_setup_request_next (xcb_setup_request_iterator_t *i)
+{
+    xcb_setup_request_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_setup_request_t *)(((char *)R) + xcb_setup_request_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_setup_request_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_setup_request_end (xcb_setup_request_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_setup_request_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_setup_failed_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_setup_failed_t *_aux = (xcb_setup_failed_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_setup_failed_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* reason */
+    xcb_block_len += _aux->reason_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+char *
+xcb_setup_failed_reason (const xcb_setup_failed_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_setup_failed_reason_length (const xcb_setup_failed_t *R)
+{
+    return R->reason_len;
+}
+
+xcb_generic_iterator_t
+xcb_setup_failed_reason_end (const xcb_setup_failed_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->reason_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_setup_failed_next (xcb_setup_failed_iterator_t *i)
+{
+    xcb_setup_failed_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_setup_failed_t *)(((char *)R) + xcb_setup_failed_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_setup_failed_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_setup_failed_end (xcb_setup_failed_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_setup_failed_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_setup_authenticate_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_setup_authenticate_t *_aux = (xcb_setup_authenticate_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_setup_authenticate_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* reason */
+    xcb_block_len += (_aux->length * 4) * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+char *
+xcb_setup_authenticate_reason (const xcb_setup_authenticate_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_setup_authenticate_reason_length (const xcb_setup_authenticate_t *R)
+{
+    return (R->length * 4);
+}
+
+xcb_generic_iterator_t
+xcb_setup_authenticate_reason_end (const xcb_setup_authenticate_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + ((R->length * 4));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_setup_authenticate_next (xcb_setup_authenticate_iterator_t *i)
+{
+    xcb_setup_authenticate_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_setup_authenticate_t *)(((char *)R) + xcb_setup_authenticate_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_setup_authenticate_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_setup_authenticate_end (xcb_setup_authenticate_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_setup_authenticate_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_setup_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_setup_t *_aux = (xcb_setup_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_setup_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* vendor */
+    xcb_block_len += _aux->vendor_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* pixmap_formats */
+    xcb_block_len += _aux->pixmap_formats_len * sizeof(xcb_format_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_format_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* roots */
+    for(i=0; i<_aux->roots_len; i++) {
+        xcb_tmp_len = xcb_screen_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_screen_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+char *
+xcb_setup_vendor (const xcb_setup_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_setup_vendor_length (const xcb_setup_t *R)
+{
+    return R->vendor_len;
+}
+
+xcb_generic_iterator_t
+xcb_setup_vendor_end (const xcb_setup_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->vendor_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_format_t *
+xcb_setup_pixmap_formats (const xcb_setup_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_setup_vendor_end(R);
+    return (xcb_format_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0);
+}
+
+int
+xcb_setup_pixmap_formats_length (const xcb_setup_t *R)
+{
+    return R->pixmap_formats_len;
+}
+
+xcb_format_iterator_t
+xcb_setup_pixmap_formats_iterator (const xcb_setup_t *R)
+{
+    xcb_format_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_setup_vendor_end(R);
+    i.data = (xcb_format_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)));
+    i.rem = R->pixmap_formats_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_setup_roots_length (const xcb_setup_t *R)
+{
+    return R->roots_len;
+}
+
+xcb_screen_iterator_t
+xcb_setup_roots_iterator (const xcb_setup_t *R)
+{
+    xcb_screen_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_format_end(xcb_setup_pixmap_formats_iterator(R));
+    i.data = (xcb_screen_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_screen_t, prev.index));
+    i.rem = R->roots_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_setup_next (xcb_setup_iterator_t *i)
+{
+    xcb_setup_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_setup_t *)(((char *)R) + xcb_setup_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_setup_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_setup_end (xcb_setup_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_setup_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+void
+xcb_client_message_data_next (xcb_client_message_data_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_client_message_data_t);
+}
+
+xcb_generic_iterator_t
+xcb_client_message_data_end (xcb_client_message_data_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_create_window_value_list_serialize (void                                 **_buffer,
+                                        uint32_t                               value_mask,
+                                        const xcb_create_window_value_list_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[16];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(value_mask & XCB_CW_BACK_PIXMAP) {
+        /* xcb_create_window_value_list_t.background_pixmap */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background_pixmap;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_CW_BACK_PIXEL) {
+        /* xcb_create_window_value_list_t.background_pixel */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background_pixel;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BORDER_PIXMAP) {
+        /* xcb_create_window_value_list_t.border_pixmap */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_pixmap;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_CW_BORDER_PIXEL) {
+        /* xcb_create_window_value_list_t.border_pixel */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_pixel;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BIT_GRAVITY) {
+        /* xcb_create_window_value_list_t.bit_gravity */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bit_gravity;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_WIN_GRAVITY) {
+        /* xcb_create_window_value_list_t.win_gravity */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->win_gravity;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BACKING_STORE) {
+        /* xcb_create_window_value_list_t.backing_store */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_store;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BACKING_PLANES) {
+        /* xcb_create_window_value_list_t.backing_planes */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_planes;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BACKING_PIXEL) {
+        /* xcb_create_window_value_list_t.backing_pixel */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_pixel;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_OVERRIDE_REDIRECT) {
+        /* xcb_create_window_value_list_t.override_redirect */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->override_redirect;
+        xcb_block_len += sizeof(xcb_bool32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_bool32_t);
+    }
+    if(value_mask & XCB_CW_SAVE_UNDER) {
+        /* xcb_create_window_value_list_t.save_under */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->save_under;
+        xcb_block_len += sizeof(xcb_bool32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_bool32_t);
+    }
+    if(value_mask & XCB_CW_EVENT_MASK) {
+        /* xcb_create_window_value_list_t.event_mask */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->event_mask;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_DONT_PROPAGATE) {
+        /* xcb_create_window_value_list_t.do_not_propogate_mask */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->do_not_propogate_mask;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_COLORMAP) {
+        /* xcb_create_window_value_list_t.colormap */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->colormap;
+        xcb_block_len += sizeof(xcb_colormap_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_colormap_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_colormap_t);
+    }
+    if(value_mask & XCB_CW_CURSOR) {
+        /* xcb_create_window_value_list_t.cursor */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->cursor;
+        xcb_block_len += sizeof(xcb_cursor_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_cursor_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_cursor_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_create_window_value_list_unpack (const void                      *_buffer,
+                                     uint32_t                         value_mask,
+                                     xcb_create_window_value_list_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if(value_mask & XCB_CW_BACK_PIXMAP) {
+        /* xcb_create_window_value_list_t.background_pixmap */
+        _aux->background_pixmap = *(xcb_pixmap_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_tmp += sizeof(xcb_pixmap_t);
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_CW_BACK_PIXEL) {
+        /* xcb_create_window_value_list_t.background_pixel */
+        _aux->background_pixel = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BORDER_PIXMAP) {
+        /* xcb_create_window_value_list_t.border_pixmap */
+        _aux->border_pixmap = *(xcb_pixmap_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_tmp += sizeof(xcb_pixmap_t);
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_CW_BORDER_PIXEL) {
+        /* xcb_create_window_value_list_t.border_pixel */
+        _aux->border_pixel = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BIT_GRAVITY) {
+        /* xcb_create_window_value_list_t.bit_gravity */
+        _aux->bit_gravity = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_WIN_GRAVITY) {
+        /* xcb_create_window_value_list_t.win_gravity */
+        _aux->win_gravity = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BACKING_STORE) {
+        /* xcb_create_window_value_list_t.backing_store */
+        _aux->backing_store = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BACKING_PLANES) {
+        /* xcb_create_window_value_list_t.backing_planes */
+        _aux->backing_planes = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BACKING_PIXEL) {
+        /* xcb_create_window_value_list_t.backing_pixel */
+        _aux->backing_pixel = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_OVERRIDE_REDIRECT) {
+        /* xcb_create_window_value_list_t.override_redirect */
+        _aux->override_redirect = *(xcb_bool32_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_bool32_t);
+        xcb_tmp += sizeof(xcb_bool32_t);
+        xcb_align_to = ALIGNOF(xcb_bool32_t);
+    }
+    if(value_mask & XCB_CW_SAVE_UNDER) {
+        /* xcb_create_window_value_list_t.save_under */
+        _aux->save_under = *(xcb_bool32_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_bool32_t);
+        xcb_tmp += sizeof(xcb_bool32_t);
+        xcb_align_to = ALIGNOF(xcb_bool32_t);
+    }
+    if(value_mask & XCB_CW_EVENT_MASK) {
+        /* xcb_create_window_value_list_t.event_mask */
+        _aux->event_mask = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_DONT_PROPAGATE) {
+        /* xcb_create_window_value_list_t.do_not_propogate_mask */
+        _aux->do_not_propogate_mask = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_COLORMAP) {
+        /* xcb_create_window_value_list_t.colormap */
+        _aux->colormap = *(xcb_colormap_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_colormap_t);
+        xcb_tmp += sizeof(xcb_colormap_t);
+        xcb_align_to = ALIGNOF(xcb_colormap_t);
+    }
+    if(value_mask & XCB_CW_CURSOR) {
+        /* xcb_create_window_value_list_t.cursor */
+        _aux->cursor = *(xcb_cursor_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_cursor_t);
+        xcb_tmp += sizeof(xcb_cursor_t);
+        xcb_align_to = ALIGNOF(xcb_cursor_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_create_window_value_list_sizeof (const void  *_buffer,
+                                     uint32_t     value_mask)
+{
+    xcb_create_window_value_list_t _aux;
+    return xcb_create_window_value_list_unpack(_buffer, value_mask, &_aux);
+}
+
+int
+xcb_create_window_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_create_window_request_t *_aux = (xcb_create_window_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_create_window_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* value_list */
+    xcb_block_len += xcb_create_window_value_list_sizeof(xcb_tmp, _aux->value_mask);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_create_window_checked (xcb_connection_t *c,
+                           uint8_t           depth,
+                           xcb_window_t      wid,
+                           xcb_window_t      parent,
+                           int16_t           x,
+                           int16_t           y,
+                           uint16_t          width,
+                           uint16_t          height,
+                           uint16_t          border_width,
+                           uint16_t          _class,
+                           xcb_visualid_t    visual,
+                           uint32_t          value_mask,
+                           const void       *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CREATE_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_create_window_request_t xcb_out;
+
+    xcb_out.depth = depth;
+    xcb_out.wid = wid;
+    xcb_out.parent = parent;
+    xcb_out.x = x;
+    xcb_out.y = y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.border_width = border_width;
+    xcb_out._class = _class;
+    xcb_out.visual = visual;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_create_window_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_create_window_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_create_window (xcb_connection_t *c,
+                   uint8_t           depth,
+                   xcb_window_t      wid,
+                   xcb_window_t      parent,
+                   int16_t           x,
+                   int16_t           y,
+                   uint16_t          width,
+                   uint16_t          height,
+                   uint16_t          border_width,
+                   uint16_t          _class,
+                   xcb_visualid_t    visual,
+                   uint32_t          value_mask,
+                   const void       *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CREATE_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_create_window_request_t xcb_out;
+
+    xcb_out.depth = depth;
+    xcb_out.wid = wid;
+    xcb_out.parent = parent;
+    xcb_out.x = x;
+    xcb_out.y = y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.border_width = border_width;
+    xcb_out._class = _class;
+    xcb_out.visual = visual;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_create_window_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_create_window_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_create_window_aux_checked (xcb_connection_t                     *c,
+                               uint8_t                               depth,
+                               xcb_window_t                          wid,
+                               xcb_window_t                          parent,
+                               int16_t                               x,
+                               int16_t                               y,
+                               uint16_t                              width,
+                               uint16_t                              height,
+                               uint16_t                              border_width,
+                               uint16_t                              _class,
+                               xcb_visualid_t                        visual,
+                               uint32_t                              value_mask,
+                               const xcb_create_window_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CREATE_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_create_window_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.depth = depth;
+    xcb_out.wid = wid;
+    xcb_out.parent = parent;
+    xcb_out.x = x;
+    xcb_out.y = y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.border_width = border_width;
+    xcb_out._class = _class;
+    xcb_out.visual = visual;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_create_window_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_create_window_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_create_window_aux (xcb_connection_t                     *c,
+                       uint8_t                               depth,
+                       xcb_window_t                          wid,
+                       xcb_window_t                          parent,
+                       int16_t                               x,
+                       int16_t                               y,
+                       uint16_t                              width,
+                       uint16_t                              height,
+                       uint16_t                              border_width,
+                       uint16_t                              _class,
+                       xcb_visualid_t                        visual,
+                       uint32_t                              value_mask,
+                       const xcb_create_window_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CREATE_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_create_window_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.depth = depth;
+    xcb_out.wid = wid;
+    xcb_out.parent = parent;
+    xcb_out.x = x;
+    xcb_out.y = y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.border_width = border_width;
+    xcb_out._class = _class;
+    xcb_out.visual = visual;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_create_window_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_create_window_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+void *
+xcb_create_window_value_list (const xcb_create_window_request_t *R)
+{
+    return (void *) (R + 1);
+}
+
+int
+xcb_change_window_attributes_value_list_serialize (void                                            **_buffer,
+                                                   uint32_t                                          value_mask,
+                                                   const xcb_change_window_attributes_value_list_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[16];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(value_mask & XCB_CW_BACK_PIXMAP) {
+        /* xcb_change_window_attributes_value_list_t.background_pixmap */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background_pixmap;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_CW_BACK_PIXEL) {
+        /* xcb_change_window_attributes_value_list_t.background_pixel */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background_pixel;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BORDER_PIXMAP) {
+        /* xcb_change_window_attributes_value_list_t.border_pixmap */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_pixmap;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_CW_BORDER_PIXEL) {
+        /* xcb_change_window_attributes_value_list_t.border_pixel */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_pixel;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BIT_GRAVITY) {
+        /* xcb_change_window_attributes_value_list_t.bit_gravity */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bit_gravity;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_WIN_GRAVITY) {
+        /* xcb_change_window_attributes_value_list_t.win_gravity */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->win_gravity;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BACKING_STORE) {
+        /* xcb_change_window_attributes_value_list_t.backing_store */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_store;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BACKING_PLANES) {
+        /* xcb_change_window_attributes_value_list_t.backing_planes */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_planes;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BACKING_PIXEL) {
+        /* xcb_change_window_attributes_value_list_t.backing_pixel */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_pixel;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_OVERRIDE_REDIRECT) {
+        /* xcb_change_window_attributes_value_list_t.override_redirect */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->override_redirect;
+        xcb_block_len += sizeof(xcb_bool32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_bool32_t);
+    }
+    if(value_mask & XCB_CW_SAVE_UNDER) {
+        /* xcb_change_window_attributes_value_list_t.save_under */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->save_under;
+        xcb_block_len += sizeof(xcb_bool32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_bool32_t);
+    }
+    if(value_mask & XCB_CW_EVENT_MASK) {
+        /* xcb_change_window_attributes_value_list_t.event_mask */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->event_mask;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_DONT_PROPAGATE) {
+        /* xcb_change_window_attributes_value_list_t.do_not_propogate_mask */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->do_not_propogate_mask;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_COLORMAP) {
+        /* xcb_change_window_attributes_value_list_t.colormap */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->colormap;
+        xcb_block_len += sizeof(xcb_colormap_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_colormap_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_colormap_t);
+    }
+    if(value_mask & XCB_CW_CURSOR) {
+        /* xcb_change_window_attributes_value_list_t.cursor */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->cursor;
+        xcb_block_len += sizeof(xcb_cursor_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_cursor_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_cursor_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_change_window_attributes_value_list_unpack (const void                                 *_buffer,
+                                                uint32_t                                    value_mask,
+                                                xcb_change_window_attributes_value_list_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if(value_mask & XCB_CW_BACK_PIXMAP) {
+        /* xcb_change_window_attributes_value_list_t.background_pixmap */
+        _aux->background_pixmap = *(xcb_pixmap_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_tmp += sizeof(xcb_pixmap_t);
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_CW_BACK_PIXEL) {
+        /* xcb_change_window_attributes_value_list_t.background_pixel */
+        _aux->background_pixel = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BORDER_PIXMAP) {
+        /* xcb_change_window_attributes_value_list_t.border_pixmap */
+        _aux->border_pixmap = *(xcb_pixmap_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_tmp += sizeof(xcb_pixmap_t);
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_CW_BORDER_PIXEL) {
+        /* xcb_change_window_attributes_value_list_t.border_pixel */
+        _aux->border_pixel = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BIT_GRAVITY) {
+        /* xcb_change_window_attributes_value_list_t.bit_gravity */
+        _aux->bit_gravity = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_WIN_GRAVITY) {
+        /* xcb_change_window_attributes_value_list_t.win_gravity */
+        _aux->win_gravity = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BACKING_STORE) {
+        /* xcb_change_window_attributes_value_list_t.backing_store */
+        _aux->backing_store = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BACKING_PLANES) {
+        /* xcb_change_window_attributes_value_list_t.backing_planes */
+        _aux->backing_planes = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_BACKING_PIXEL) {
+        /* xcb_change_window_attributes_value_list_t.backing_pixel */
+        _aux->backing_pixel = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_OVERRIDE_REDIRECT) {
+        /* xcb_change_window_attributes_value_list_t.override_redirect */
+        _aux->override_redirect = *(xcb_bool32_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_bool32_t);
+        xcb_tmp += sizeof(xcb_bool32_t);
+        xcb_align_to = ALIGNOF(xcb_bool32_t);
+    }
+    if(value_mask & XCB_CW_SAVE_UNDER) {
+        /* xcb_change_window_attributes_value_list_t.save_under */
+        _aux->save_under = *(xcb_bool32_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_bool32_t);
+        xcb_tmp += sizeof(xcb_bool32_t);
+        xcb_align_to = ALIGNOF(xcb_bool32_t);
+    }
+    if(value_mask & XCB_CW_EVENT_MASK) {
+        /* xcb_change_window_attributes_value_list_t.event_mask */
+        _aux->event_mask = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_DONT_PROPAGATE) {
+        /* xcb_change_window_attributes_value_list_t.do_not_propogate_mask */
+        _aux->do_not_propogate_mask = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CW_COLORMAP) {
+        /* xcb_change_window_attributes_value_list_t.colormap */
+        _aux->colormap = *(xcb_colormap_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_colormap_t);
+        xcb_tmp += sizeof(xcb_colormap_t);
+        xcb_align_to = ALIGNOF(xcb_colormap_t);
+    }
+    if(value_mask & XCB_CW_CURSOR) {
+        /* xcb_change_window_attributes_value_list_t.cursor */
+        _aux->cursor = *(xcb_cursor_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_cursor_t);
+        xcb_tmp += sizeof(xcb_cursor_t);
+        xcb_align_to = ALIGNOF(xcb_cursor_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_change_window_attributes_value_list_sizeof (const void  *_buffer,
+                                                uint32_t     value_mask)
+{
+    xcb_change_window_attributes_value_list_t _aux;
+    return xcb_change_window_attributes_value_list_unpack(_buffer, value_mask, &_aux);
+}
+
+int
+xcb_change_window_attributes_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_change_window_attributes_request_t *_aux = (xcb_change_window_attributes_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_change_window_attributes_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* value_list */
+    xcb_block_len += xcb_change_window_attributes_value_list_sizeof(xcb_tmp, _aux->value_mask);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_change_window_attributes_checked (xcb_connection_t *c,
+                                      xcb_window_t      window,
+                                      uint32_t          value_mask,
+                                      const void       *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CHANGE_WINDOW_ATTRIBUTES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_window_attributes_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_change_window_attributes_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_change_window_attributes_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_change_window_attributes (xcb_connection_t *c,
+                              xcb_window_t      window,
+                              uint32_t          value_mask,
+                              const void       *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CHANGE_WINDOW_ATTRIBUTES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_window_attributes_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_change_window_attributes_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_change_window_attributes_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_change_window_attributes_aux_checked (xcb_connection_t                                *c,
+                                          xcb_window_t                                     window,
+                                          uint32_t                                         value_mask,
+                                          const xcb_change_window_attributes_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CHANGE_WINDOW_ATTRIBUTES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_window_attributes_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_change_window_attributes_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_change_window_attributes_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_change_window_attributes_aux (xcb_connection_t                                *c,
+                                  xcb_window_t                                     window,
+                                  uint32_t                                         value_mask,
+                                  const xcb_change_window_attributes_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CHANGE_WINDOW_ATTRIBUTES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_window_attributes_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_change_window_attributes_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_change_window_attributes_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+void *
+xcb_change_window_attributes_value_list (const xcb_change_window_attributes_request_t *R)
+{
+    return (void *) (R + 1);
+}
+
+xcb_get_window_attributes_cookie_t
+xcb_get_window_attributes (xcb_connection_t *c,
+                           xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_WINDOW_ATTRIBUTES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_window_attributes_cookie_t xcb_ret;
+    xcb_get_window_attributes_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_window_attributes_cookie_t
+xcb_get_window_attributes_unchecked (xcb_connection_t *c,
+                                     xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_WINDOW_ATTRIBUTES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_window_attributes_cookie_t xcb_ret;
+    xcb_get_window_attributes_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_window_attributes_reply_t *
+xcb_get_window_attributes_reply (xcb_connection_t                    *c,
+                                 xcb_get_window_attributes_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e)
+{
+    return (xcb_get_window_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_destroy_window_checked (xcb_connection_t *c,
+                            xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_DESTROY_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_destroy_window_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_destroy_window (xcb_connection_t *c,
+                    xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_DESTROY_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_destroy_window_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_destroy_subwindows_checked (xcb_connection_t *c,
+                                xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_DESTROY_SUBWINDOWS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_destroy_subwindows_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_destroy_subwindows (xcb_connection_t *c,
+                        xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_DESTROY_SUBWINDOWS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_destroy_subwindows_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_change_save_set_checked (xcb_connection_t *c,
+                             uint8_t           mode,
+                             xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CHANGE_SAVE_SET,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_save_set_request_t xcb_out;
+
+    xcb_out.mode = mode;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_change_save_set (xcb_connection_t *c,
+                     uint8_t           mode,
+                     xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CHANGE_SAVE_SET,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_save_set_request_t xcb_out;
+
+    xcb_out.mode = mode;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_reparent_window_checked (xcb_connection_t *c,
+                             xcb_window_t      window,
+                             xcb_window_t      parent,
+                             int16_t           x,
+                             int16_t           y)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_REPARENT_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_reparent_window_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+    xcb_out.parent = parent;
+    xcb_out.x = x;
+    xcb_out.y = y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_reparent_window (xcb_connection_t *c,
+                     xcb_window_t      window,
+                     xcb_window_t      parent,
+                     int16_t           x,
+                     int16_t           y)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_REPARENT_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_reparent_window_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+    xcb_out.parent = parent;
+    xcb_out.x = x;
+    xcb_out.y = y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_map_window_checked (xcb_connection_t *c,
+                        xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_MAP_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_map_window_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_map_window (xcb_connection_t *c,
+                xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_MAP_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_map_window_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_map_subwindows_checked (xcb_connection_t *c,
+                            xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_MAP_SUBWINDOWS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_map_subwindows_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_map_subwindows (xcb_connection_t *c,
+                    xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_MAP_SUBWINDOWS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_map_subwindows_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_unmap_window_checked (xcb_connection_t *c,
+                          xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_UNMAP_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_unmap_window_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_unmap_window (xcb_connection_t *c,
+                  xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_UNMAP_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_unmap_window_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_unmap_subwindows_checked (xcb_connection_t *c,
+                              xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_UNMAP_SUBWINDOWS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_unmap_subwindows_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_unmap_subwindows (xcb_connection_t *c,
+                      xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_UNMAP_SUBWINDOWS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_unmap_subwindows_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_configure_window_value_list_serialize (void                                    **_buffer,
+                                           uint16_t                                  value_mask,
+                                           const xcb_configure_window_value_list_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[8];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(value_mask & XCB_CONFIG_WINDOW_X) {
+        /* xcb_configure_window_value_list_t.x */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->x;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_CONFIG_WINDOW_Y) {
+        /* xcb_configure_window_value_list_t.y */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->y;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_CONFIG_WINDOW_WIDTH) {
+        /* xcb_configure_window_value_list_t.width */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->width;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
+        /* xcb_configure_window_value_list_t.height */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->height;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) {
+        /* xcb_configure_window_value_list_t.border_width */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_width;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CONFIG_WINDOW_SIBLING) {
+        /* xcb_configure_window_value_list_t.sibling */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->sibling;
+        xcb_block_len += sizeof(xcb_window_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_window_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_window_t);
+    }
+    if(value_mask & XCB_CONFIG_WINDOW_STACK_MODE) {
+        /* xcb_configure_window_value_list_t.stack_mode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->stack_mode;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_configure_window_value_list_unpack (const void                         *_buffer,
+                                        uint16_t                            value_mask,
+                                        xcb_configure_window_value_list_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if(value_mask & XCB_CONFIG_WINDOW_X) {
+        /* xcb_configure_window_value_list_t.x */
+        _aux->x = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_CONFIG_WINDOW_Y) {
+        /* xcb_configure_window_value_list_t.y */
+        _aux->y = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_CONFIG_WINDOW_WIDTH) {
+        /* xcb_configure_window_value_list_t.width */
+        _aux->width = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
+        /* xcb_configure_window_value_list_t.height */
+        _aux->height = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) {
+        /* xcb_configure_window_value_list_t.border_width */
+        _aux->border_width = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_CONFIG_WINDOW_SIBLING) {
+        /* xcb_configure_window_value_list_t.sibling */
+        _aux->sibling = *(xcb_window_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_window_t);
+        xcb_tmp += sizeof(xcb_window_t);
+        xcb_align_to = ALIGNOF(xcb_window_t);
+    }
+    if(value_mask & XCB_CONFIG_WINDOW_STACK_MODE) {
+        /* xcb_configure_window_value_list_t.stack_mode */
+        _aux->stack_mode = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_configure_window_value_list_sizeof (const void  *_buffer,
+                                        uint16_t     value_mask)
+{
+    xcb_configure_window_value_list_t _aux;
+    return xcb_configure_window_value_list_unpack(_buffer, value_mask, &_aux);
+}
+
+int
+xcb_configure_window_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_configure_window_request_t *_aux = (xcb_configure_window_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_configure_window_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* value_list */
+    xcb_block_len += xcb_configure_window_value_list_sizeof(xcb_tmp, _aux->value_mask);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_configure_window_checked (xcb_connection_t *c,
+                              xcb_window_t      window,
+                              uint16_t          value_mask,
+                              const void       *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CONFIGURE_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_configure_window_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+    xcb_out.value_mask = value_mask;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_configure_window_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_configure_window_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_configure_window (xcb_connection_t *c,
+                      xcb_window_t      window,
+                      uint16_t          value_mask,
+                      const void       *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CONFIGURE_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_configure_window_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+    xcb_out.value_mask = value_mask;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_configure_window_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_configure_window_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_configure_window_aux_checked (xcb_connection_t                        *c,
+                                  xcb_window_t                             window,
+                                  uint16_t                                 value_mask,
+                                  const xcb_configure_window_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CONFIGURE_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_configure_window_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+    xcb_out.value_mask = value_mask;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_configure_window_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_configure_window_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_configure_window_aux (xcb_connection_t                        *c,
+                          xcb_window_t                             window,
+                          uint16_t                                 value_mask,
+                          const xcb_configure_window_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CONFIGURE_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_configure_window_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+    xcb_out.value_mask = value_mask;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_configure_window_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_configure_window_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+void *
+xcb_configure_window_value_list (const xcb_configure_window_request_t *R)
+{
+    return (void *) (R + 1);
+}
+
+xcb_void_cookie_t
+xcb_circulate_window_checked (xcb_connection_t *c,
+                              uint8_t           direction,
+                              xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CIRCULATE_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_circulate_window_request_t xcb_out;
+
+    xcb_out.direction = direction;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_circulate_window (xcb_connection_t *c,
+                      uint8_t           direction,
+                      xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CIRCULATE_WINDOW,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_circulate_window_request_t xcb_out;
+
+    xcb_out.direction = direction;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_geometry_cookie_t
+xcb_get_geometry (xcb_connection_t *c,
+                  xcb_drawable_t    drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_GEOMETRY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_geometry_cookie_t xcb_ret;
+    xcb_get_geometry_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_geometry_cookie_t
+xcb_get_geometry_unchecked (xcb_connection_t *c,
+                            xcb_drawable_t    drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_GEOMETRY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_geometry_cookie_t xcb_ret;
+    xcb_get_geometry_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_geometry_reply_t *
+xcb_get_geometry_reply (xcb_connection_t           *c,
+                        xcb_get_geometry_cookie_t   cookie  /**< */,
+                        xcb_generic_error_t       **e)
+{
+    return (xcb_get_geometry_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_query_tree_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_query_tree_reply_t *_aux = (xcb_query_tree_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_query_tree_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* children */
+    xcb_block_len += _aux->children_len * sizeof(xcb_window_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_window_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_query_tree_cookie_t
+xcb_query_tree (xcb_connection_t *c,
+                xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_QUERY_TREE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_query_tree_cookie_t xcb_ret;
+    xcb_query_tree_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_query_tree_cookie_t
+xcb_query_tree_unchecked (xcb_connection_t *c,
+                          xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_QUERY_TREE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_query_tree_cookie_t xcb_ret;
+    xcb_query_tree_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_window_t *
+xcb_query_tree_children (const xcb_query_tree_reply_t *R)
+{
+    return (xcb_window_t *) (R + 1);
+}
+
+int
+xcb_query_tree_children_length (const xcb_query_tree_reply_t *R)
+{
+    return R->children_len;
+}
+
+xcb_generic_iterator_t
+xcb_query_tree_children_end (const xcb_query_tree_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_window_t *) (R + 1)) + (R->children_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_query_tree_reply_t *
+xcb_query_tree_reply (xcb_connection_t         *c,
+                      xcb_query_tree_cookie_t   cookie  /**< */,
+                      xcb_generic_error_t     **e)
+{
+    return (xcb_query_tree_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_intern_atom_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_intern_atom_request_t *_aux = (xcb_intern_atom_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_intern_atom_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->name_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_intern_atom_cookie_t
+xcb_intern_atom (xcb_connection_t *c,
+                 uint8_t           only_if_exists,
+                 uint16_t          name_len,
+                 const char       *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_INTERN_ATOM,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_intern_atom_cookie_t xcb_ret;
+    xcb_intern_atom_request_t xcb_out;
+
+    xcb_out.only_if_exists = only_if_exists;
+    xcb_out.name_len = name_len;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = name_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_intern_atom_cookie_t
+xcb_intern_atom_unchecked (xcb_connection_t *c,
+                           uint8_t           only_if_exists,
+                           uint16_t          name_len,
+                           const char       *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_INTERN_ATOM,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_intern_atom_cookie_t xcb_ret;
+    xcb_intern_atom_request_t xcb_out;
+
+    xcb_out.only_if_exists = only_if_exists;
+    xcb_out.name_len = name_len;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = name_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_intern_atom_reply_t *
+xcb_intern_atom_reply (xcb_connection_t          *c,
+                       xcb_intern_atom_cookie_t   cookie  /**< */,
+                       xcb_generic_error_t      **e)
+{
+    return (xcb_intern_atom_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_get_atom_name_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_get_atom_name_reply_t *_aux = (xcb_get_atom_name_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_get_atom_name_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->name_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_get_atom_name_cookie_t
+xcb_get_atom_name (xcb_connection_t *c,
+                   xcb_atom_t        atom)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_ATOM_NAME,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_atom_name_cookie_t xcb_ret;
+    xcb_get_atom_name_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.atom = atom;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_atom_name_cookie_t
+xcb_get_atom_name_unchecked (xcb_connection_t *c,
+                             xcb_atom_t        atom)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_ATOM_NAME,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_atom_name_cookie_t xcb_ret;
+    xcb_get_atom_name_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.atom = atom;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_get_atom_name_name (const xcb_get_atom_name_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_get_atom_name_name_length (const xcb_get_atom_name_reply_t *R)
+{
+    return R->name_len;
+}
+
+xcb_generic_iterator_t
+xcb_get_atom_name_name_end (const xcb_get_atom_name_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->name_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_get_atom_name_reply_t *
+xcb_get_atom_name_reply (xcb_connection_t            *c,
+                         xcb_get_atom_name_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e)
+{
+    return (xcb_get_atom_name_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_change_property_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_change_property_request_t *_aux = (xcb_change_property_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_change_property_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += ((_aux->data_len * _aux->format) / 8) * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_change_property_checked (xcb_connection_t *c,
+                             uint8_t           mode,
+                             xcb_window_t      window,
+                             xcb_atom_t        property,
+                             xcb_atom_t        type,
+                             uint8_t           format,
+                             uint32_t          data_len,
+                             const void       *data)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_CHANGE_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_property_request_t xcb_out;
+
+    xcb_out.mode = mode;
+    xcb_out.window = window;
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.format = format;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.data_len = data_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* void data */
+    xcb_parts[4].iov_base = (char *) data;
+    xcb_parts[4].iov_len = ((data_len * format) / 8) * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_change_property (xcb_connection_t *c,
+                     uint8_t           mode,
+                     xcb_window_t      window,
+                     xcb_atom_t        property,
+                     xcb_atom_t        type,
+                     uint8_t           format,
+                     uint32_t          data_len,
+                     const void       *data)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_CHANGE_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_property_request_t xcb_out;
+
+    xcb_out.mode = mode;
+    xcb_out.window = window;
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.format = format;
+    memset(xcb_out.pad0, 0, 3);
+    xcb_out.data_len = data_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* void data */
+    xcb_parts[4].iov_base = (char *) data;
+    xcb_parts[4].iov_len = ((data_len * format) / 8) * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+void *
+xcb_change_property_data (const xcb_change_property_request_t *R)
+{
+    return (void *) (R + 1);
+}
+
+int
+xcb_change_property_data_length (const xcb_change_property_request_t *R)
+{
+    return ((R->data_len * R->format) / 8);
+}
+
+xcb_generic_iterator_t
+xcb_change_property_data_end (const xcb_change_property_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (((R->data_len * R->format) / 8));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_delete_property_checked (xcb_connection_t *c,
+                             xcb_window_t      window,
+                             xcb_atom_t        property)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_DELETE_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_delete_property_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+    xcb_out.property = property;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_delete_property (xcb_connection_t *c,
+                     xcb_window_t      window,
+                     xcb_atom_t        property)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_DELETE_PROPERTY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_delete_property_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+    xcb_out.property = property;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_get_property_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_get_property_reply_t *_aux = (xcb_get_property_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_get_property_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* value */
+    xcb_block_len += (_aux->value_len * (_aux->format / 8)) * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_get_property_cookie_t
+xcb_get_property (xcb_connection_t *c,
+                  uint8_t           _delete,
+                  xcb_window_t      window,
+                  xcb_atom_t        property,
+                  xcb_atom_t        type,
+                  uint32_t          long_offset,
+                  uint32_t          long_length)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_PROPERTY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_property_cookie_t xcb_ret;
+    xcb_get_property_request_t xcb_out;
+
+    xcb_out._delete = _delete;
+    xcb_out.window = window;
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.long_offset = long_offset;
+    xcb_out.long_length = long_length;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_property_cookie_t
+xcb_get_property_unchecked (xcb_connection_t *c,
+                            uint8_t           _delete,
+                            xcb_window_t      window,
+                            xcb_atom_t        property,
+                            xcb_atom_t        type,
+                            uint32_t          long_offset,
+                            uint32_t          long_length)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_PROPERTY,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_property_cookie_t xcb_ret;
+    xcb_get_property_request_t xcb_out;
+
+    xcb_out._delete = _delete;
+    xcb_out.window = window;
+    xcb_out.property = property;
+    xcb_out.type = type;
+    xcb_out.long_offset = long_offset;
+    xcb_out.long_length = long_length;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+void *
+xcb_get_property_value (const xcb_get_property_reply_t *R)
+{
+    return (void *) (R + 1);
+}
+
+int
+xcb_get_property_value_length (const xcb_get_property_reply_t *R)
+{
+    return (R->value_len * (R->format / 8));
+}
+
+xcb_generic_iterator_t
+xcb_get_property_value_end (const xcb_get_property_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + ((R->value_len * (R->format / 8)));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_get_property_reply_t *
+xcb_get_property_reply (xcb_connection_t           *c,
+                        xcb_get_property_cookie_t   cookie  /**< */,
+                        xcb_generic_error_t       **e)
+{
+    return (xcb_get_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_list_properties_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_list_properties_reply_t *_aux = (xcb_list_properties_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_list_properties_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* atoms */
+    xcb_block_len += _aux->atoms_len * sizeof(xcb_atom_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_atom_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_list_properties_cookie_t
+xcb_list_properties (xcb_connection_t *c,
+                     xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_LIST_PROPERTIES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_list_properties_cookie_t xcb_ret;
+    xcb_list_properties_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_list_properties_cookie_t
+xcb_list_properties_unchecked (xcb_connection_t *c,
+                               xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_LIST_PROPERTIES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_list_properties_cookie_t xcb_ret;
+    xcb_list_properties_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_atom_t *
+xcb_list_properties_atoms (const xcb_list_properties_reply_t *R)
+{
+    return (xcb_atom_t *) (R + 1);
+}
+
+int
+xcb_list_properties_atoms_length (const xcb_list_properties_reply_t *R)
+{
+    return R->atoms_len;
+}
+
+xcb_generic_iterator_t
+xcb_list_properties_atoms_end (const xcb_list_properties_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_atom_t *) (R + 1)) + (R->atoms_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_list_properties_reply_t *
+xcb_list_properties_reply (xcb_connection_t              *c,
+                           xcb_list_properties_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e)
+{
+    return (xcb_list_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_set_selection_owner_checked (xcb_connection_t *c,
+                                 xcb_window_t      owner,
+                                 xcb_atom_t        selection,
+                                 xcb_timestamp_t   time)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_SET_SELECTION_OWNER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_set_selection_owner_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.owner = owner;
+    xcb_out.selection = selection;
+    xcb_out.time = time;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_set_selection_owner (xcb_connection_t *c,
+                         xcb_window_t      owner,
+                         xcb_atom_t        selection,
+                         xcb_timestamp_t   time)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_SET_SELECTION_OWNER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_set_selection_owner_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.owner = owner;
+    xcb_out.selection = selection;
+    xcb_out.time = time;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_selection_owner_cookie_t
+xcb_get_selection_owner (xcb_connection_t *c,
+                         xcb_atom_t        selection)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_SELECTION_OWNER,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_selection_owner_cookie_t xcb_ret;
+    xcb_get_selection_owner_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.selection = selection;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_selection_owner_cookie_t
+xcb_get_selection_owner_unchecked (xcb_connection_t *c,
+                                   xcb_atom_t        selection)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_SELECTION_OWNER,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_selection_owner_cookie_t xcb_ret;
+    xcb_get_selection_owner_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.selection = selection;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_selection_owner_reply_t *
+xcb_get_selection_owner_reply (xcb_connection_t                  *c,
+                               xcb_get_selection_owner_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_get_selection_owner_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_convert_selection_checked (xcb_connection_t *c,
+                               xcb_window_t      requestor,
+                               xcb_atom_t        selection,
+                               xcb_atom_t        target,
+                               xcb_atom_t        property,
+                               xcb_timestamp_t   time)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CONVERT_SELECTION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_convert_selection_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.requestor = requestor;
+    xcb_out.selection = selection;
+    xcb_out.target = target;
+    xcb_out.property = property;
+    xcb_out.time = time;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_convert_selection (xcb_connection_t *c,
+                       xcb_window_t      requestor,
+                       xcb_atom_t        selection,
+                       xcb_atom_t        target,
+                       xcb_atom_t        property,
+                       xcb_timestamp_t   time)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CONVERT_SELECTION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_convert_selection_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.requestor = requestor;
+    xcb_out.selection = selection;
+    xcb_out.target = target;
+    xcb_out.property = property;
+    xcb_out.time = time;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_send_event_checked (xcb_connection_t *c,
+                        uint8_t           propagate,
+                        xcb_window_t      destination,
+                        uint32_t          event_mask,
+                        const char       *event)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_SEND_EVENT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_send_event_request_t xcb_out;
+
+    xcb_out.propagate = propagate;
+    xcb_out.destination = destination;
+    xcb_out.event_mask = event_mask;
+    memcpy(xcb_out.event, event, 32);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_send_event (xcb_connection_t *c,
+                uint8_t           propagate,
+                xcb_window_t      destination,
+                uint32_t          event_mask,
+                const char       *event)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_SEND_EVENT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_send_event_request_t xcb_out;
+
+    xcb_out.propagate = propagate;
+    xcb_out.destination = destination;
+    xcb_out.event_mask = event_mask;
+    memcpy(xcb_out.event, event, 32);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_grab_pointer_cookie_t
+xcb_grab_pointer (xcb_connection_t *c,
+                  uint8_t           owner_events,
+                  xcb_window_t      grab_window,
+                  uint16_t          event_mask,
+                  uint8_t           pointer_mode,
+                  uint8_t           keyboard_mode,
+                  xcb_window_t      confine_to,
+                  xcb_cursor_t      cursor,
+                  xcb_timestamp_t   time)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GRAB_POINTER,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_grab_pointer_cookie_t xcb_ret;
+    xcb_grab_pointer_request_t xcb_out;
+
+    xcb_out.owner_events = owner_events;
+    xcb_out.grab_window = grab_window;
+    xcb_out.event_mask = event_mask;
+    xcb_out.pointer_mode = pointer_mode;
+    xcb_out.keyboard_mode = keyboard_mode;
+    xcb_out.confine_to = confine_to;
+    xcb_out.cursor = cursor;
+    xcb_out.time = time;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_grab_pointer_cookie_t
+xcb_grab_pointer_unchecked (xcb_connection_t *c,
+                            uint8_t           owner_events,
+                            xcb_window_t      grab_window,
+                            uint16_t          event_mask,
+                            uint8_t           pointer_mode,
+                            uint8_t           keyboard_mode,
+                            xcb_window_t      confine_to,
+                            xcb_cursor_t      cursor,
+                            xcb_timestamp_t   time)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GRAB_POINTER,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_grab_pointer_cookie_t xcb_ret;
+    xcb_grab_pointer_request_t xcb_out;
+
+    xcb_out.owner_events = owner_events;
+    xcb_out.grab_window = grab_window;
+    xcb_out.event_mask = event_mask;
+    xcb_out.pointer_mode = pointer_mode;
+    xcb_out.keyboard_mode = keyboard_mode;
+    xcb_out.confine_to = confine_to;
+    xcb_out.cursor = cursor;
+    xcb_out.time = time;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_grab_pointer_reply_t *
+xcb_grab_pointer_reply (xcb_connection_t           *c,
+                        xcb_grab_pointer_cookie_t   cookie  /**< */,
+                        xcb_generic_error_t       **e)
+{
+    return (xcb_grab_pointer_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_ungrab_pointer_checked (xcb_connection_t *c,
+                            xcb_timestamp_t   time)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_UNGRAB_POINTER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_ungrab_pointer_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.time = time;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_ungrab_pointer (xcb_connection_t *c,
+                    xcb_timestamp_t   time)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_UNGRAB_POINTER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_ungrab_pointer_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.time = time;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_grab_button_checked (xcb_connection_t *c,
+                         uint8_t           owner_events,
+                         xcb_window_t      grab_window,
+                         uint16_t          event_mask,
+                         uint8_t           pointer_mode,
+                         uint8_t           keyboard_mode,
+                         xcb_window_t      confine_to,
+                         xcb_cursor_t      cursor,
+                         uint8_t           button,
+                         uint16_t          modifiers)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GRAB_BUTTON,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_grab_button_request_t xcb_out;
+
+    xcb_out.owner_events = owner_events;
+    xcb_out.grab_window = grab_window;
+    xcb_out.event_mask = event_mask;
+    xcb_out.pointer_mode = pointer_mode;
+    xcb_out.keyboard_mode = keyboard_mode;
+    xcb_out.confine_to = confine_to;
+    xcb_out.cursor = cursor;
+    xcb_out.button = button;
+    xcb_out.pad0 = 0;
+    xcb_out.modifiers = modifiers;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_grab_button (xcb_connection_t *c,
+                 uint8_t           owner_events,
+                 xcb_window_t      grab_window,
+                 uint16_t          event_mask,
+                 uint8_t           pointer_mode,
+                 uint8_t           keyboard_mode,
+                 xcb_window_t      confine_to,
+                 xcb_cursor_t      cursor,
+                 uint8_t           button,
+                 uint16_t          modifiers)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GRAB_BUTTON,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_grab_button_request_t xcb_out;
+
+    xcb_out.owner_events = owner_events;
+    xcb_out.grab_window = grab_window;
+    xcb_out.event_mask = event_mask;
+    xcb_out.pointer_mode = pointer_mode;
+    xcb_out.keyboard_mode = keyboard_mode;
+    xcb_out.confine_to = confine_to;
+    xcb_out.cursor = cursor;
+    xcb_out.button = button;
+    xcb_out.pad0 = 0;
+    xcb_out.modifiers = modifiers;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_ungrab_button_checked (xcb_connection_t *c,
+                           uint8_t           button,
+                           xcb_window_t      grab_window,
+                           uint16_t          modifiers)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_UNGRAB_BUTTON,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_ungrab_button_request_t xcb_out;
+
+    xcb_out.button = button;
+    xcb_out.grab_window = grab_window;
+    xcb_out.modifiers = modifiers;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_ungrab_button (xcb_connection_t *c,
+                   uint8_t           button,
+                   xcb_window_t      grab_window,
+                   uint16_t          modifiers)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_UNGRAB_BUTTON,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_ungrab_button_request_t xcb_out;
+
+    xcb_out.button = button;
+    xcb_out.grab_window = grab_window;
+    xcb_out.modifiers = modifiers;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_change_active_pointer_grab_checked (xcb_connection_t *c,
+                                        xcb_cursor_t      cursor,
+                                        xcb_timestamp_t   time,
+                                        uint16_t          event_mask)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CHANGE_ACTIVE_POINTER_GRAB,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_active_pointer_grab_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cursor = cursor;
+    xcb_out.time = time;
+    xcb_out.event_mask = event_mask;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_change_active_pointer_grab (xcb_connection_t *c,
+                                xcb_cursor_t      cursor,
+                                xcb_timestamp_t   time,
+                                uint16_t          event_mask)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CHANGE_ACTIVE_POINTER_GRAB,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_active_pointer_grab_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cursor = cursor;
+    xcb_out.time = time;
+    xcb_out.event_mask = event_mask;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_grab_keyboard_cookie_t
+xcb_grab_keyboard (xcb_connection_t *c,
+                   uint8_t           owner_events,
+                   xcb_window_t      grab_window,
+                   xcb_timestamp_t   time,
+                   uint8_t           pointer_mode,
+                   uint8_t           keyboard_mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GRAB_KEYBOARD,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_grab_keyboard_cookie_t xcb_ret;
+    xcb_grab_keyboard_request_t xcb_out;
+
+    xcb_out.owner_events = owner_events;
+    xcb_out.grab_window = grab_window;
+    xcb_out.time = time;
+    xcb_out.pointer_mode = pointer_mode;
+    xcb_out.keyboard_mode = keyboard_mode;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_grab_keyboard_cookie_t
+xcb_grab_keyboard_unchecked (xcb_connection_t *c,
+                             uint8_t           owner_events,
+                             xcb_window_t      grab_window,
+                             xcb_timestamp_t   time,
+                             uint8_t           pointer_mode,
+                             uint8_t           keyboard_mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GRAB_KEYBOARD,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_grab_keyboard_cookie_t xcb_ret;
+    xcb_grab_keyboard_request_t xcb_out;
+
+    xcb_out.owner_events = owner_events;
+    xcb_out.grab_window = grab_window;
+    xcb_out.time = time;
+    xcb_out.pointer_mode = pointer_mode;
+    xcb_out.keyboard_mode = keyboard_mode;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_grab_keyboard_reply_t *
+xcb_grab_keyboard_reply (xcb_connection_t            *c,
+                         xcb_grab_keyboard_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e)
+{
+    return (xcb_grab_keyboard_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_ungrab_keyboard_checked (xcb_connection_t *c,
+                             xcb_timestamp_t   time)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_UNGRAB_KEYBOARD,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_ungrab_keyboard_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.time = time;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_ungrab_keyboard (xcb_connection_t *c,
+                     xcb_timestamp_t   time)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_UNGRAB_KEYBOARD,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_ungrab_keyboard_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.time = time;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_grab_key_checked (xcb_connection_t *c,
+                      uint8_t           owner_events,
+                      xcb_window_t      grab_window,
+                      uint16_t          modifiers,
+                      xcb_keycode_t     key,
+                      uint8_t           pointer_mode,
+                      uint8_t           keyboard_mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GRAB_KEY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_grab_key_request_t xcb_out;
+
+    xcb_out.owner_events = owner_events;
+    xcb_out.grab_window = grab_window;
+    xcb_out.modifiers = modifiers;
+    xcb_out.key = key;
+    xcb_out.pointer_mode = pointer_mode;
+    xcb_out.keyboard_mode = keyboard_mode;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_grab_key (xcb_connection_t *c,
+              uint8_t           owner_events,
+              xcb_window_t      grab_window,
+              uint16_t          modifiers,
+              xcb_keycode_t     key,
+              uint8_t           pointer_mode,
+              uint8_t           keyboard_mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GRAB_KEY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_grab_key_request_t xcb_out;
+
+    xcb_out.owner_events = owner_events;
+    xcb_out.grab_window = grab_window;
+    xcb_out.modifiers = modifiers;
+    xcb_out.key = key;
+    xcb_out.pointer_mode = pointer_mode;
+    xcb_out.keyboard_mode = keyboard_mode;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_ungrab_key_checked (xcb_connection_t *c,
+                        xcb_keycode_t     key,
+                        xcb_window_t      grab_window,
+                        uint16_t          modifiers)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_UNGRAB_KEY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_ungrab_key_request_t xcb_out;
+
+    xcb_out.key = key;
+    xcb_out.grab_window = grab_window;
+    xcb_out.modifiers = modifiers;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_ungrab_key (xcb_connection_t *c,
+                xcb_keycode_t     key,
+                xcb_window_t      grab_window,
+                uint16_t          modifiers)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_UNGRAB_KEY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_ungrab_key_request_t xcb_out;
+
+    xcb_out.key = key;
+    xcb_out.grab_window = grab_window;
+    xcb_out.modifiers = modifiers;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_allow_events_checked (xcb_connection_t *c,
+                          uint8_t           mode,
+                          xcb_timestamp_t   time)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_ALLOW_EVENTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_allow_events_request_t xcb_out;
+
+    xcb_out.mode = mode;
+    xcb_out.time = time;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_allow_events (xcb_connection_t *c,
+                  uint8_t           mode,
+                  xcb_timestamp_t   time)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_ALLOW_EVENTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_allow_events_request_t xcb_out;
+
+    xcb_out.mode = mode;
+    xcb_out.time = time;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_grab_server_checked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GRAB_SERVER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_grab_server_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_grab_server (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GRAB_SERVER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_grab_server_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_ungrab_server_checked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_UNGRAB_SERVER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_ungrab_server_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_ungrab_server (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_UNGRAB_SERVER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_ungrab_server_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_query_pointer_cookie_t
+xcb_query_pointer (xcb_connection_t *c,
+                   xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_QUERY_POINTER,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_query_pointer_cookie_t xcb_ret;
+    xcb_query_pointer_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_query_pointer_cookie_t
+xcb_query_pointer_unchecked (xcb_connection_t *c,
+                             xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_QUERY_POINTER,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_query_pointer_cookie_t xcb_ret;
+    xcb_query_pointer_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_query_pointer_reply_t *
+xcb_query_pointer_reply (xcb_connection_t            *c,
+                         xcb_query_pointer_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e)
+{
+    return (xcb_query_pointer_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+void
+xcb_timecoord_next (xcb_timecoord_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_timecoord_t);
+}
+
+xcb_generic_iterator_t
+xcb_timecoord_end (xcb_timecoord_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_get_motion_events_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_get_motion_events_reply_t *_aux = (xcb_get_motion_events_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_get_motion_events_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* events */
+    xcb_block_len += _aux->events_len * sizeof(xcb_timecoord_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_timecoord_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_get_motion_events_cookie_t
+xcb_get_motion_events (xcb_connection_t *c,
+                       xcb_window_t      window,
+                       xcb_timestamp_t   start,
+                       xcb_timestamp_t   stop)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_MOTION_EVENTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_motion_events_cookie_t xcb_ret;
+    xcb_get_motion_events_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+    xcb_out.start = start;
+    xcb_out.stop = stop;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_motion_events_cookie_t
+xcb_get_motion_events_unchecked (xcb_connection_t *c,
+                                 xcb_window_t      window,
+                                 xcb_timestamp_t   start,
+                                 xcb_timestamp_t   stop)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_MOTION_EVENTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_motion_events_cookie_t xcb_ret;
+    xcb_get_motion_events_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+    xcb_out.start = start;
+    xcb_out.stop = stop;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_timecoord_t *
+xcb_get_motion_events_events (const xcb_get_motion_events_reply_t *R)
+{
+    return (xcb_timecoord_t *) (R + 1);
+}
+
+int
+xcb_get_motion_events_events_length (const xcb_get_motion_events_reply_t *R)
+{
+    return R->events_len;
+}
+
+xcb_timecoord_iterator_t
+xcb_get_motion_events_events_iterator (const xcb_get_motion_events_reply_t *R)
+{
+    xcb_timecoord_iterator_t i;
+    i.data = (xcb_timecoord_t *) (R + 1);
+    i.rem = R->events_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_get_motion_events_reply_t *
+xcb_get_motion_events_reply (xcb_connection_t                *c,
+                             xcb_get_motion_events_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_get_motion_events_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_translate_coordinates_cookie_t
+xcb_translate_coordinates (xcb_connection_t *c,
+                           xcb_window_t      src_window,
+                           xcb_window_t      dst_window,
+                           int16_t           src_x,
+                           int16_t           src_y)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_TRANSLATE_COORDINATES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_translate_coordinates_cookie_t xcb_ret;
+    xcb_translate_coordinates_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.src_window = src_window;
+    xcb_out.dst_window = dst_window;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_translate_coordinates_cookie_t
+xcb_translate_coordinates_unchecked (xcb_connection_t *c,
+                                     xcb_window_t      src_window,
+                                     xcb_window_t      dst_window,
+                                     int16_t           src_x,
+                                     int16_t           src_y)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_TRANSLATE_COORDINATES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_translate_coordinates_cookie_t xcb_ret;
+    xcb_translate_coordinates_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.src_window = src_window;
+    xcb_out.dst_window = dst_window;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_translate_coordinates_reply_t *
+xcb_translate_coordinates_reply (xcb_connection_t                    *c,
+                                 xcb_translate_coordinates_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e)
+{
+    return (xcb_translate_coordinates_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_warp_pointer_checked (xcb_connection_t *c,
+                          xcb_window_t      src_window,
+                          xcb_window_t      dst_window,
+                          int16_t           src_x,
+                          int16_t           src_y,
+                          uint16_t          src_width,
+                          uint16_t          src_height,
+                          int16_t           dst_x,
+                          int16_t           dst_y)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_WARP_POINTER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_warp_pointer_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.src_window = src_window;
+    xcb_out.dst_window = dst_window;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+    xcb_out.src_width = src_width;
+    xcb_out.src_height = src_height;
+    xcb_out.dst_x = dst_x;
+    xcb_out.dst_y = dst_y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_warp_pointer (xcb_connection_t *c,
+                  xcb_window_t      src_window,
+                  xcb_window_t      dst_window,
+                  int16_t           src_x,
+                  int16_t           src_y,
+                  uint16_t          src_width,
+                  uint16_t          src_height,
+                  int16_t           dst_x,
+                  int16_t           dst_y)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_WARP_POINTER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_warp_pointer_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.src_window = src_window;
+    xcb_out.dst_window = dst_window;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+    xcb_out.src_width = src_width;
+    xcb_out.src_height = src_height;
+    xcb_out.dst_x = dst_x;
+    xcb_out.dst_y = dst_y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_set_input_focus_checked (xcb_connection_t *c,
+                             uint8_t           revert_to,
+                             xcb_window_t      focus,
+                             xcb_timestamp_t   time)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_SET_INPUT_FOCUS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_set_input_focus_request_t xcb_out;
+
+    xcb_out.revert_to = revert_to;
+    xcb_out.focus = focus;
+    xcb_out.time = time;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_set_input_focus (xcb_connection_t *c,
+                     uint8_t           revert_to,
+                     xcb_window_t      focus,
+                     xcb_timestamp_t   time)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_SET_INPUT_FOCUS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_set_input_focus_request_t xcb_out;
+
+    xcb_out.revert_to = revert_to;
+    xcb_out.focus = focus;
+    xcb_out.time = time;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_input_focus_cookie_t
+xcb_get_input_focus (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_INPUT_FOCUS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_input_focus_cookie_t xcb_ret;
+    xcb_get_input_focus_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_input_focus_cookie_t
+xcb_get_input_focus_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_INPUT_FOCUS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_input_focus_cookie_t xcb_ret;
+    xcb_get_input_focus_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_input_focus_reply_t *
+xcb_get_input_focus_reply (xcb_connection_t              *c,
+                           xcb_get_input_focus_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e)
+{
+    return (xcb_get_input_focus_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_query_keymap_cookie_t
+xcb_query_keymap (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_QUERY_KEYMAP,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_query_keymap_cookie_t xcb_ret;
+    xcb_query_keymap_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_query_keymap_cookie_t
+xcb_query_keymap_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_QUERY_KEYMAP,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_query_keymap_cookie_t xcb_ret;
+    xcb_query_keymap_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_query_keymap_reply_t *
+xcb_query_keymap_reply (xcb_connection_t           *c,
+                        xcb_query_keymap_cookie_t   cookie  /**< */,
+                        xcb_generic_error_t       **e)
+{
+    return (xcb_query_keymap_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_open_font_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_open_font_request_t *_aux = (xcb_open_font_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_open_font_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->name_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_open_font_checked (xcb_connection_t *c,
+                       xcb_font_t        fid,
+                       uint16_t          name_len,
+                       const char       *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_OPEN_FONT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_open_font_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.fid = fid;
+    xcb_out.name_len = name_len;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = name_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_open_font (xcb_connection_t *c,
+               xcb_font_t        fid,
+               uint16_t          name_len,
+               const char       *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_OPEN_FONT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_open_font_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.fid = fid;
+    xcb_out.name_len = name_len;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = name_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_open_font_name (const xcb_open_font_request_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_open_font_name_length (const xcb_open_font_request_t *R)
+{
+    return R->name_len;
+}
+
+xcb_generic_iterator_t
+xcb_open_font_name_end (const xcb_open_font_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->name_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_close_font_checked (xcb_connection_t *c,
+                        xcb_font_t        font)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CLOSE_FONT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_close_font_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.font = font;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_close_font (xcb_connection_t *c,
+                xcb_font_t        font)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CLOSE_FONT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_close_font_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.font = font;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+void
+xcb_fontprop_next (xcb_fontprop_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_fontprop_t);
+}
+
+xcb_generic_iterator_t
+xcb_fontprop_end (xcb_fontprop_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_charinfo_next (xcb_charinfo_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_charinfo_t);
+}
+
+xcb_generic_iterator_t
+xcb_charinfo_end (xcb_charinfo_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_query_font_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_query_font_reply_t *_aux = (xcb_query_font_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_query_font_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* properties */
+    xcb_block_len += _aux->properties_len * sizeof(xcb_fontprop_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_fontprop_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* char_infos */
+    xcb_block_len += _aux->char_infos_len * sizeof(xcb_charinfo_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_charinfo_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_query_font_cookie_t
+xcb_query_font (xcb_connection_t *c,
+                xcb_fontable_t    font)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_QUERY_FONT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_query_font_cookie_t xcb_ret;
+    xcb_query_font_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.font = font;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_query_font_cookie_t
+xcb_query_font_unchecked (xcb_connection_t *c,
+                          xcb_fontable_t    font)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_QUERY_FONT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_query_font_cookie_t xcb_ret;
+    xcb_query_font_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.font = font;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_fontprop_t *
+xcb_query_font_properties (const xcb_query_font_reply_t *R)
+{
+    return (xcb_fontprop_t *) (R + 1);
+}
+
+int
+xcb_query_font_properties_length (const xcb_query_font_reply_t *R)
+{
+    return R->properties_len;
+}
+
+xcb_fontprop_iterator_t
+xcb_query_font_properties_iterator (const xcb_query_font_reply_t *R)
+{
+    xcb_fontprop_iterator_t i;
+    i.data = (xcb_fontprop_t *) (R + 1);
+    i.rem = R->properties_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_charinfo_t *
+xcb_query_font_char_infos (const xcb_query_font_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_fontprop_end(xcb_query_font_properties_iterator(R));
+    return (xcb_charinfo_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_charinfo_t, prev.index) + 0);
+}
+
+int
+xcb_query_font_char_infos_length (const xcb_query_font_reply_t *R)
+{
+    return R->char_infos_len;
+}
+
+xcb_charinfo_iterator_t
+xcb_query_font_char_infos_iterator (const xcb_query_font_reply_t *R)
+{
+    xcb_charinfo_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_fontprop_end(xcb_query_font_properties_iterator(R));
+    i.data = (xcb_charinfo_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_charinfo_t, prev.index));
+    i.rem = R->char_infos_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_query_font_reply_t *
+xcb_query_font_reply (xcb_connection_t         *c,
+                      xcb_query_font_cookie_t   cookie  /**< */,
+                      xcb_generic_error_t     **e)
+{
+    return (xcb_query_font_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_query_text_extents_sizeof (const void  *_buffer,
+                               uint32_t     string_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_query_text_extents_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* string */
+    xcb_block_len += string_len * sizeof(xcb_char2b_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_char2b_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_query_text_extents_cookie_t
+xcb_query_text_extents (xcb_connection_t   *c,
+                        xcb_fontable_t      font,
+                        uint32_t            string_len,
+                        const xcb_char2b_t *string)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_QUERY_TEXT_EXTENTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_query_text_extents_cookie_t xcb_ret;
+    xcb_query_text_extents_request_t xcb_out;
+
+    xcb_out.odd_length = (string_len & 1);
+    xcb_out.font = font;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_char2b_t string */
+    xcb_parts[4].iov_base = (char *) string;
+    xcb_parts[4].iov_len = string_len * sizeof(xcb_char2b_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_query_text_extents_cookie_t
+xcb_query_text_extents_unchecked (xcb_connection_t   *c,
+                                  xcb_fontable_t      font,
+                                  uint32_t            string_len,
+                                  const xcb_char2b_t *string)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_QUERY_TEXT_EXTENTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_query_text_extents_cookie_t xcb_ret;
+    xcb_query_text_extents_request_t xcb_out;
+
+    xcb_out.odd_length = (string_len & 1);
+    xcb_out.font = font;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_char2b_t string */
+    xcb_parts[4].iov_base = (char *) string;
+    xcb_parts[4].iov_len = string_len * sizeof(xcb_char2b_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_query_text_extents_reply_t *
+xcb_query_text_extents_reply (xcb_connection_t                 *c,
+                              xcb_query_text_extents_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_query_text_extents_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_str_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_str_t *_aux = (xcb_str_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_str_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->name_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+char *
+xcb_str_name (const xcb_str_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_str_name_length (const xcb_str_t *R)
+{
+    return R->name_len;
+}
+
+xcb_generic_iterator_t
+xcb_str_name_end (const xcb_str_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->name_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_str_next (xcb_str_iterator_t *i)
+{
+    xcb_str_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_str_t *)(((char *)R) + xcb_str_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_str_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_str_end (xcb_str_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_str_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_list_fonts_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_list_fonts_request_t *_aux = (xcb_list_fonts_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_list_fonts_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* pattern */
+    xcb_block_len += _aux->pattern_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_list_fonts_cookie_t
+xcb_list_fonts (xcb_connection_t *c,
+                uint16_t          max_names,
+                uint16_t          pattern_len,
+                const char       *pattern)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_LIST_FONTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_list_fonts_cookie_t xcb_ret;
+    xcb_list_fonts_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.max_names = max_names;
+    xcb_out.pattern_len = pattern_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char pattern */
+    xcb_parts[4].iov_base = (char *) pattern;
+    xcb_parts[4].iov_len = pattern_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_list_fonts_cookie_t
+xcb_list_fonts_unchecked (xcb_connection_t *c,
+                          uint16_t          max_names,
+                          uint16_t          pattern_len,
+                          const char       *pattern)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_LIST_FONTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_list_fonts_cookie_t xcb_ret;
+    xcb_list_fonts_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.max_names = max_names;
+    xcb_out.pattern_len = pattern_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char pattern */
+    xcb_parts[4].iov_base = (char *) pattern;
+    xcb_parts[4].iov_len = pattern_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_list_fonts_names_length (const xcb_list_fonts_reply_t *R)
+{
+    return R->names_len;
+}
+
+xcb_str_iterator_t
+xcb_list_fonts_names_iterator (const xcb_list_fonts_reply_t *R)
+{
+    xcb_str_iterator_t i;
+    i.data = (xcb_str_t *) (R + 1);
+    i.rem = R->names_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_list_fonts_reply_t *
+xcb_list_fonts_reply (xcb_connection_t         *c,
+                      xcb_list_fonts_cookie_t   cookie  /**< */,
+                      xcb_generic_error_t     **e)
+{
+    return (xcb_list_fonts_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_list_fonts_with_info_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_list_fonts_with_info_request_t *_aux = (xcb_list_fonts_with_info_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_list_fonts_with_info_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* pattern */
+    xcb_block_len += _aux->pattern_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_list_fonts_with_info_cookie_t
+xcb_list_fonts_with_info (xcb_connection_t *c,
+                          uint16_t          max_names,
+                          uint16_t          pattern_len,
+                          const char       *pattern)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_LIST_FONTS_WITH_INFO,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_list_fonts_with_info_cookie_t xcb_ret;
+    xcb_list_fonts_with_info_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.max_names = max_names;
+    xcb_out.pattern_len = pattern_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char pattern */
+    xcb_parts[4].iov_base = (char *) pattern;
+    xcb_parts[4].iov_len = pattern_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_list_fonts_with_info_cookie_t
+xcb_list_fonts_with_info_unchecked (xcb_connection_t *c,
+                                    uint16_t          max_names,
+                                    uint16_t          pattern_len,
+                                    const char       *pattern)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_LIST_FONTS_WITH_INFO,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_list_fonts_with_info_cookie_t xcb_ret;
+    xcb_list_fonts_with_info_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.max_names = max_names;
+    xcb_out.pattern_len = pattern_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char pattern */
+    xcb_parts[4].iov_base = (char *) pattern;
+    xcb_parts[4].iov_len = pattern_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_fontprop_t *
+xcb_list_fonts_with_info_properties (const xcb_list_fonts_with_info_reply_t *R)
+{
+    return (xcb_fontprop_t *) (R + 1);
+}
+
+int
+xcb_list_fonts_with_info_properties_length (const xcb_list_fonts_with_info_reply_t *R)
+{
+    return R->properties_len;
+}
+
+xcb_fontprop_iterator_t
+xcb_list_fonts_with_info_properties_iterator (const xcb_list_fonts_with_info_reply_t *R)
+{
+    xcb_fontprop_iterator_t i;
+    i.data = (xcb_fontprop_t *) (R + 1);
+    i.rem = R->properties_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+char *
+xcb_list_fonts_with_info_name (const xcb_list_fonts_with_info_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_fontprop_end(xcb_list_fonts_with_info_properties_iterator(R));
+    return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0);
+}
+
+int
+xcb_list_fonts_with_info_name_length (const xcb_list_fonts_with_info_reply_t *R)
+{
+    return R->name_len;
+}
+
+xcb_generic_iterator_t
+xcb_list_fonts_with_info_name_end (const xcb_list_fonts_with_info_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_fontprop_end(xcb_list_fonts_with_info_properties_iterator(R));
+    i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->name_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_list_fonts_with_info_reply_t *
+xcb_list_fonts_with_info_reply (xcb_connection_t                   *c,
+                                xcb_list_fonts_with_info_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e)
+{
+    return (xcb_list_fonts_with_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_set_font_path_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_set_font_path_request_t *_aux = (xcb_set_font_path_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_set_font_path_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* font */
+    for(i=0; i<_aux->font_qty; i++) {
+        xcb_tmp_len = xcb_str_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_str_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_set_font_path_checked (xcb_connection_t *c,
+                           uint16_t          font_qty,
+                           const xcb_str_t  *font)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_SET_FONT_PATH,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_set_font_path_request_t xcb_out;
+    unsigned int xcb_tmp_len;
+    char *xcb_tmp;
+    unsigned int i;
+
+    xcb_out.pad0 = 0;
+    xcb_out.font_qty = font_qty;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_str_t font */
+    xcb_parts[4].iov_base = (char *) font;
+    xcb_parts[4].iov_len = 0;
+    xcb_tmp = (char *)font;
+    for(i=0; i<font_qty; i++) {
+        xcb_tmp_len = xcb_str_sizeof(xcb_tmp);
+        xcb_parts[4].iov_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_set_font_path (xcb_connection_t *c,
+                   uint16_t          font_qty,
+                   const xcb_str_t  *font)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_SET_FONT_PATH,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_set_font_path_request_t xcb_out;
+    unsigned int xcb_tmp_len;
+    char *xcb_tmp;
+    unsigned int i;
+
+    xcb_out.pad0 = 0;
+    xcb_out.font_qty = font_qty;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_str_t font */
+    xcb_parts[4].iov_base = (char *) font;
+    xcb_parts[4].iov_len = 0;
+    xcb_tmp = (char *)font;
+    for(i=0; i<font_qty; i++) {
+        xcb_tmp_len = xcb_str_sizeof(xcb_tmp);
+        xcb_parts[4].iov_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_set_font_path_font_length (const xcb_set_font_path_request_t *R)
+{
+    return R->font_qty;
+}
+
+xcb_str_iterator_t
+xcb_set_font_path_font_iterator (const xcb_set_font_path_request_t *R)
+{
+    xcb_str_iterator_t i;
+    i.data = (xcb_str_t *) (R + 1);
+    i.rem = R->font_qty;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_get_font_path_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_get_font_path_reply_t *_aux = (xcb_get_font_path_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_get_font_path_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* path */
+    for(i=0; i<_aux->path_len; i++) {
+        xcb_tmp_len = xcb_str_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_str_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_get_font_path_cookie_t
+xcb_get_font_path (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_FONT_PATH,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_font_path_cookie_t xcb_ret;
+    xcb_get_font_path_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_font_path_cookie_t
+xcb_get_font_path_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_FONT_PATH,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_font_path_cookie_t xcb_ret;
+    xcb_get_font_path_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_get_font_path_path_length (const xcb_get_font_path_reply_t *R)
+{
+    return R->path_len;
+}
+
+xcb_str_iterator_t
+xcb_get_font_path_path_iterator (const xcb_get_font_path_reply_t *R)
+{
+    xcb_str_iterator_t i;
+    i.data = (xcb_str_t *) (R + 1);
+    i.rem = R->path_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_get_font_path_reply_t *
+xcb_get_font_path_reply (xcb_connection_t            *c,
+                         xcb_get_font_path_cookie_t   cookie  /**< */,
+                         xcb_generic_error_t        **e)
+{
+    return (xcb_get_font_path_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_create_pixmap_checked (xcb_connection_t *c,
+                           uint8_t           depth,
+                           xcb_pixmap_t      pid,
+                           xcb_drawable_t    drawable,
+                           uint16_t          width,
+                           uint16_t          height)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CREATE_PIXMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_create_pixmap_request_t xcb_out;
+
+    xcb_out.depth = depth;
+    xcb_out.pid = pid;
+    xcb_out.drawable = drawable;
+    xcb_out.width = width;
+    xcb_out.height = height;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_create_pixmap (xcb_connection_t *c,
+                   uint8_t           depth,
+                   xcb_pixmap_t      pid,
+                   xcb_drawable_t    drawable,
+                   uint16_t          width,
+                   uint16_t          height)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CREATE_PIXMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_create_pixmap_request_t xcb_out;
+
+    xcb_out.depth = depth;
+    xcb_out.pid = pid;
+    xcb_out.drawable = drawable;
+    xcb_out.width = width;
+    xcb_out.height = height;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_free_pixmap_checked (xcb_connection_t *c,
+                         xcb_pixmap_t      pixmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_FREE_PIXMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_free_pixmap_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.pixmap = pixmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_free_pixmap (xcb_connection_t *c,
+                 xcb_pixmap_t      pixmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_FREE_PIXMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_free_pixmap_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.pixmap = pixmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_create_gc_value_list_serialize (void                             **_buffer,
+                                    uint32_t                           value_mask,
+                                    const xcb_create_gc_value_list_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[24];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(value_mask & XCB_GC_FUNCTION) {
+        /* xcb_create_gc_value_list_t.function */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->function;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_PLANE_MASK) {
+        /* xcb_create_gc_value_list_t.plane_mask */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->plane_mask;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_FOREGROUND) {
+        /* xcb_create_gc_value_list_t.foreground */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->foreground;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_BACKGROUND) {
+        /* xcb_create_gc_value_list_t.background */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_LINE_WIDTH) {
+        /* xcb_create_gc_value_list_t.line_width */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->line_width;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_LINE_STYLE) {
+        /* xcb_create_gc_value_list_t.line_style */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->line_style;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_CAP_STYLE) {
+        /* xcb_create_gc_value_list_t.cap_style */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->cap_style;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_JOIN_STYLE) {
+        /* xcb_create_gc_value_list_t.join_style */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->join_style;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_FILL_STYLE) {
+        /* xcb_create_gc_value_list_t.fill_style */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->fill_style;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_FILL_RULE) {
+        /* xcb_create_gc_value_list_t.fill_rule */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->fill_rule;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_TILE) {
+        /* xcb_create_gc_value_list_t.tile */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->tile;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_GC_STIPPLE) {
+        /* xcb_create_gc_value_list_t.stipple */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->stipple;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_X) {
+        /* xcb_create_gc_value_list_t.tile_stipple_x_origin */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->tile_stipple_x_origin;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_Y) {
+        /* xcb_create_gc_value_list_t.tile_stipple_y_origin */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->tile_stipple_y_origin;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_GC_FONT) {
+        /* xcb_create_gc_value_list_t.font */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->font;
+        xcb_block_len += sizeof(xcb_font_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_font_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_font_t);
+    }
+    if(value_mask & XCB_GC_SUBWINDOW_MODE) {
+        /* xcb_create_gc_value_list_t.subwindow_mode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->subwindow_mode;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_GRAPHICS_EXPOSURES) {
+        /* xcb_create_gc_value_list_t.graphics_exposures */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->graphics_exposures;
+        xcb_block_len += sizeof(xcb_bool32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_bool32_t);
+    }
+    if(value_mask & XCB_GC_CLIP_ORIGIN_X) {
+        /* xcb_create_gc_value_list_t.clip_x_origin */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clip_x_origin;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_GC_CLIP_ORIGIN_Y) {
+        /* xcb_create_gc_value_list_t.clip_y_origin */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clip_y_origin;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_GC_CLIP_MASK) {
+        /* xcb_create_gc_value_list_t.clip_mask */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clip_mask;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_GC_DASH_OFFSET) {
+        /* xcb_create_gc_value_list_t.dash_offset */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->dash_offset;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_DASH_LIST) {
+        /* xcb_create_gc_value_list_t.dashes */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->dashes;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_ARC_MODE) {
+        /* xcb_create_gc_value_list_t.arc_mode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->arc_mode;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_create_gc_value_list_unpack (const void                  *_buffer,
+                                 uint32_t                     value_mask,
+                                 xcb_create_gc_value_list_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if(value_mask & XCB_GC_FUNCTION) {
+        /* xcb_create_gc_value_list_t.function */
+        _aux->function = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_PLANE_MASK) {
+        /* xcb_create_gc_value_list_t.plane_mask */
+        _aux->plane_mask = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_FOREGROUND) {
+        /* xcb_create_gc_value_list_t.foreground */
+        _aux->foreground = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_BACKGROUND) {
+        /* xcb_create_gc_value_list_t.background */
+        _aux->background = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_LINE_WIDTH) {
+        /* xcb_create_gc_value_list_t.line_width */
+        _aux->line_width = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_LINE_STYLE) {
+        /* xcb_create_gc_value_list_t.line_style */
+        _aux->line_style = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_CAP_STYLE) {
+        /* xcb_create_gc_value_list_t.cap_style */
+        _aux->cap_style = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_JOIN_STYLE) {
+        /* xcb_create_gc_value_list_t.join_style */
+        _aux->join_style = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_FILL_STYLE) {
+        /* xcb_create_gc_value_list_t.fill_style */
+        _aux->fill_style = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_FILL_RULE) {
+        /* xcb_create_gc_value_list_t.fill_rule */
+        _aux->fill_rule = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_TILE) {
+        /* xcb_create_gc_value_list_t.tile */
+        _aux->tile = *(xcb_pixmap_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_tmp += sizeof(xcb_pixmap_t);
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_GC_STIPPLE) {
+        /* xcb_create_gc_value_list_t.stipple */
+        _aux->stipple = *(xcb_pixmap_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_tmp += sizeof(xcb_pixmap_t);
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_X) {
+        /* xcb_create_gc_value_list_t.tile_stipple_x_origin */
+        _aux->tile_stipple_x_origin = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_Y) {
+        /* xcb_create_gc_value_list_t.tile_stipple_y_origin */
+        _aux->tile_stipple_y_origin = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_GC_FONT) {
+        /* xcb_create_gc_value_list_t.font */
+        _aux->font = *(xcb_font_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_font_t);
+        xcb_tmp += sizeof(xcb_font_t);
+        xcb_align_to = ALIGNOF(xcb_font_t);
+    }
+    if(value_mask & XCB_GC_SUBWINDOW_MODE) {
+        /* xcb_create_gc_value_list_t.subwindow_mode */
+        _aux->subwindow_mode = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_GRAPHICS_EXPOSURES) {
+        /* xcb_create_gc_value_list_t.graphics_exposures */
+        _aux->graphics_exposures = *(xcb_bool32_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_bool32_t);
+        xcb_tmp += sizeof(xcb_bool32_t);
+        xcb_align_to = ALIGNOF(xcb_bool32_t);
+    }
+    if(value_mask & XCB_GC_CLIP_ORIGIN_X) {
+        /* xcb_create_gc_value_list_t.clip_x_origin */
+        _aux->clip_x_origin = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_GC_CLIP_ORIGIN_Y) {
+        /* xcb_create_gc_value_list_t.clip_y_origin */
+        _aux->clip_y_origin = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_GC_CLIP_MASK) {
+        /* xcb_create_gc_value_list_t.clip_mask */
+        _aux->clip_mask = *(xcb_pixmap_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_tmp += sizeof(xcb_pixmap_t);
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_GC_DASH_OFFSET) {
+        /* xcb_create_gc_value_list_t.dash_offset */
+        _aux->dash_offset = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_DASH_LIST) {
+        /* xcb_create_gc_value_list_t.dashes */
+        _aux->dashes = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_ARC_MODE) {
+        /* xcb_create_gc_value_list_t.arc_mode */
+        _aux->arc_mode = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_create_gc_value_list_sizeof (const void  *_buffer,
+                                 uint32_t     value_mask)
+{
+    xcb_create_gc_value_list_t _aux;
+    return xcb_create_gc_value_list_unpack(_buffer, value_mask, &_aux);
+}
+
+int
+xcb_create_gc_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_create_gc_request_t *_aux = (xcb_create_gc_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_create_gc_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* value_list */
+    xcb_block_len += xcb_create_gc_value_list_sizeof(xcb_tmp, _aux->value_mask);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_create_gc_checked (xcb_connection_t *c,
+                       xcb_gcontext_t    cid,
+                       xcb_drawable_t    drawable,
+                       uint32_t          value_mask,
+                       const void       *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CREATE_GC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_create_gc_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cid = cid;
+    xcb_out.drawable = drawable;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_create_gc_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_create_gc_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_create_gc (xcb_connection_t *c,
+               xcb_gcontext_t    cid,
+               xcb_drawable_t    drawable,
+               uint32_t          value_mask,
+               const void       *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CREATE_GC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_create_gc_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cid = cid;
+    xcb_out.drawable = drawable;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_create_gc_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_create_gc_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_create_gc_aux_checked (xcb_connection_t                 *c,
+                           xcb_gcontext_t                    cid,
+                           xcb_drawable_t                    drawable,
+                           uint32_t                          value_mask,
+                           const xcb_create_gc_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CREATE_GC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_create_gc_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cid = cid;
+    xcb_out.drawable = drawable;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_create_gc_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_create_gc_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_create_gc_aux (xcb_connection_t                 *c,
+                   xcb_gcontext_t                    cid,
+                   xcb_drawable_t                    drawable,
+                   uint32_t                          value_mask,
+                   const xcb_create_gc_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CREATE_GC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_create_gc_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cid = cid;
+    xcb_out.drawable = drawable;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_create_gc_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_create_gc_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+void *
+xcb_create_gc_value_list (const xcb_create_gc_request_t *R)
+{
+    return (void *) (R + 1);
+}
+
+int
+xcb_change_gc_value_list_serialize (void                             **_buffer,
+                                    uint32_t                           value_mask,
+                                    const xcb_change_gc_value_list_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[24];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(value_mask & XCB_GC_FUNCTION) {
+        /* xcb_change_gc_value_list_t.function */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->function;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_PLANE_MASK) {
+        /* xcb_change_gc_value_list_t.plane_mask */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->plane_mask;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_FOREGROUND) {
+        /* xcb_change_gc_value_list_t.foreground */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->foreground;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_BACKGROUND) {
+        /* xcb_change_gc_value_list_t.background */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_LINE_WIDTH) {
+        /* xcb_change_gc_value_list_t.line_width */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->line_width;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_LINE_STYLE) {
+        /* xcb_change_gc_value_list_t.line_style */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->line_style;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_CAP_STYLE) {
+        /* xcb_change_gc_value_list_t.cap_style */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->cap_style;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_JOIN_STYLE) {
+        /* xcb_change_gc_value_list_t.join_style */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->join_style;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_FILL_STYLE) {
+        /* xcb_change_gc_value_list_t.fill_style */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->fill_style;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_FILL_RULE) {
+        /* xcb_change_gc_value_list_t.fill_rule */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->fill_rule;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_TILE) {
+        /* xcb_change_gc_value_list_t.tile */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->tile;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_GC_STIPPLE) {
+        /* xcb_change_gc_value_list_t.stipple */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->stipple;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_X) {
+        /* xcb_change_gc_value_list_t.tile_stipple_x_origin */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->tile_stipple_x_origin;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_Y) {
+        /* xcb_change_gc_value_list_t.tile_stipple_y_origin */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->tile_stipple_y_origin;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_GC_FONT) {
+        /* xcb_change_gc_value_list_t.font */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->font;
+        xcb_block_len += sizeof(xcb_font_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_font_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_font_t);
+    }
+    if(value_mask & XCB_GC_SUBWINDOW_MODE) {
+        /* xcb_change_gc_value_list_t.subwindow_mode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->subwindow_mode;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_GRAPHICS_EXPOSURES) {
+        /* xcb_change_gc_value_list_t.graphics_exposures */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->graphics_exposures;
+        xcb_block_len += sizeof(xcb_bool32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_bool32_t);
+    }
+    if(value_mask & XCB_GC_CLIP_ORIGIN_X) {
+        /* xcb_change_gc_value_list_t.clip_x_origin */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clip_x_origin;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_GC_CLIP_ORIGIN_Y) {
+        /* xcb_change_gc_value_list_t.clip_y_origin */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clip_y_origin;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_GC_CLIP_MASK) {
+        /* xcb_change_gc_value_list_t.clip_mask */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->clip_mask;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_GC_DASH_OFFSET) {
+        /* xcb_change_gc_value_list_t.dash_offset */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->dash_offset;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_DASH_LIST) {
+        /* xcb_change_gc_value_list_t.dashes */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->dashes;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_ARC_MODE) {
+        /* xcb_change_gc_value_list_t.arc_mode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->arc_mode;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_change_gc_value_list_unpack (const void                  *_buffer,
+                                 uint32_t                     value_mask,
+                                 xcb_change_gc_value_list_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if(value_mask & XCB_GC_FUNCTION) {
+        /* xcb_change_gc_value_list_t.function */
+        _aux->function = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_PLANE_MASK) {
+        /* xcb_change_gc_value_list_t.plane_mask */
+        _aux->plane_mask = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_FOREGROUND) {
+        /* xcb_change_gc_value_list_t.foreground */
+        _aux->foreground = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_BACKGROUND) {
+        /* xcb_change_gc_value_list_t.background */
+        _aux->background = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_LINE_WIDTH) {
+        /* xcb_change_gc_value_list_t.line_width */
+        _aux->line_width = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_LINE_STYLE) {
+        /* xcb_change_gc_value_list_t.line_style */
+        _aux->line_style = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_CAP_STYLE) {
+        /* xcb_change_gc_value_list_t.cap_style */
+        _aux->cap_style = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_JOIN_STYLE) {
+        /* xcb_change_gc_value_list_t.join_style */
+        _aux->join_style = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_FILL_STYLE) {
+        /* xcb_change_gc_value_list_t.fill_style */
+        _aux->fill_style = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_FILL_RULE) {
+        /* xcb_change_gc_value_list_t.fill_rule */
+        _aux->fill_rule = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_TILE) {
+        /* xcb_change_gc_value_list_t.tile */
+        _aux->tile = *(xcb_pixmap_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_tmp += sizeof(xcb_pixmap_t);
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_GC_STIPPLE) {
+        /* xcb_change_gc_value_list_t.stipple */
+        _aux->stipple = *(xcb_pixmap_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_tmp += sizeof(xcb_pixmap_t);
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_X) {
+        /* xcb_change_gc_value_list_t.tile_stipple_x_origin */
+        _aux->tile_stipple_x_origin = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_GC_TILE_STIPPLE_ORIGIN_Y) {
+        /* xcb_change_gc_value_list_t.tile_stipple_y_origin */
+        _aux->tile_stipple_y_origin = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_GC_FONT) {
+        /* xcb_change_gc_value_list_t.font */
+        _aux->font = *(xcb_font_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_font_t);
+        xcb_tmp += sizeof(xcb_font_t);
+        xcb_align_to = ALIGNOF(xcb_font_t);
+    }
+    if(value_mask & XCB_GC_SUBWINDOW_MODE) {
+        /* xcb_change_gc_value_list_t.subwindow_mode */
+        _aux->subwindow_mode = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_GRAPHICS_EXPOSURES) {
+        /* xcb_change_gc_value_list_t.graphics_exposures */
+        _aux->graphics_exposures = *(xcb_bool32_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_bool32_t);
+        xcb_tmp += sizeof(xcb_bool32_t);
+        xcb_align_to = ALIGNOF(xcb_bool32_t);
+    }
+    if(value_mask & XCB_GC_CLIP_ORIGIN_X) {
+        /* xcb_change_gc_value_list_t.clip_x_origin */
+        _aux->clip_x_origin = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_GC_CLIP_ORIGIN_Y) {
+        /* xcb_change_gc_value_list_t.clip_y_origin */
+        _aux->clip_y_origin = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_GC_CLIP_MASK) {
+        /* xcb_change_gc_value_list_t.clip_mask */
+        _aux->clip_mask = *(xcb_pixmap_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_pixmap_t);
+        xcb_tmp += sizeof(xcb_pixmap_t);
+        xcb_align_to = ALIGNOF(xcb_pixmap_t);
+    }
+    if(value_mask & XCB_GC_DASH_OFFSET) {
+        /* xcb_change_gc_value_list_t.dash_offset */
+        _aux->dash_offset = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_DASH_LIST) {
+        /* xcb_change_gc_value_list_t.dashes */
+        _aux->dashes = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_GC_ARC_MODE) {
+        /* xcb_change_gc_value_list_t.arc_mode */
+        _aux->arc_mode = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_change_gc_value_list_sizeof (const void  *_buffer,
+                                 uint32_t     value_mask)
+{
+    xcb_change_gc_value_list_t _aux;
+    return xcb_change_gc_value_list_unpack(_buffer, value_mask, &_aux);
+}
+
+int
+xcb_change_gc_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_change_gc_request_t *_aux = (xcb_change_gc_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_change_gc_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* value_list */
+    xcb_block_len += xcb_change_gc_value_list_sizeof(xcb_tmp, _aux->value_mask);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_change_gc_checked (xcb_connection_t *c,
+                       xcb_gcontext_t    gc,
+                       uint32_t          value_mask,
+                       const void       *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CHANGE_GC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_gc_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.gc = gc;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_change_gc_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_change_gc_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_change_gc (xcb_connection_t *c,
+               xcb_gcontext_t    gc,
+               uint32_t          value_mask,
+               const void       *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CHANGE_GC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_gc_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.gc = gc;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_change_gc_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_change_gc_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_change_gc_aux_checked (xcb_connection_t                 *c,
+                           xcb_gcontext_t                    gc,
+                           uint32_t                          value_mask,
+                           const xcb_change_gc_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CHANGE_GC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_gc_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.pad0 = 0;
+    xcb_out.gc = gc;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_change_gc_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_change_gc_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_change_gc_aux (xcb_connection_t                 *c,
+                   xcb_gcontext_t                    gc,
+                   uint32_t                          value_mask,
+                   const xcb_change_gc_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CHANGE_GC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_gc_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.pad0 = 0;
+    xcb_out.gc = gc;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_change_gc_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_change_gc_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+void *
+xcb_change_gc_value_list (const xcb_change_gc_request_t *R)
+{
+    return (void *) (R + 1);
+}
+
+xcb_void_cookie_t
+xcb_copy_gc_checked (xcb_connection_t *c,
+                     xcb_gcontext_t    src_gc,
+                     xcb_gcontext_t    dst_gc,
+                     uint32_t          value_mask)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_COPY_GC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_copy_gc_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.src_gc = src_gc;
+    xcb_out.dst_gc = dst_gc;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_copy_gc (xcb_connection_t *c,
+             xcb_gcontext_t    src_gc,
+             xcb_gcontext_t    dst_gc,
+             uint32_t          value_mask)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_COPY_GC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_copy_gc_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.src_gc = src_gc;
+    xcb_out.dst_gc = dst_gc;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_set_dashes_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_set_dashes_request_t *_aux = (xcb_set_dashes_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_set_dashes_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* dashes */
+    xcb_block_len += _aux->dashes_len * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_set_dashes_checked (xcb_connection_t *c,
+                        xcb_gcontext_t    gc,
+                        uint16_t          dash_offset,
+                        uint16_t          dashes_len,
+                        const uint8_t    *dashes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_SET_DASHES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_set_dashes_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.gc = gc;
+    xcb_out.dash_offset = dash_offset;
+    xcb_out.dashes_len = dashes_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t dashes */
+    xcb_parts[4].iov_base = (char *) dashes;
+    xcb_parts[4].iov_len = dashes_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_set_dashes (xcb_connection_t *c,
+                xcb_gcontext_t    gc,
+                uint16_t          dash_offset,
+                uint16_t          dashes_len,
+                const uint8_t    *dashes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_SET_DASHES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_set_dashes_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.gc = gc;
+    xcb_out.dash_offset = dash_offset;
+    xcb_out.dashes_len = dashes_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t dashes */
+    xcb_parts[4].iov_base = (char *) dashes;
+    xcb_parts[4].iov_len = dashes_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_set_dashes_dashes (const xcb_set_dashes_request_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_set_dashes_dashes_length (const xcb_set_dashes_request_t *R)
+{
+    return R->dashes_len;
+}
+
+xcb_generic_iterator_t
+xcb_set_dashes_dashes_end (const xcb_set_dashes_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + (R->dashes_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_set_clip_rectangles_sizeof (const void  *_buffer,
+                                uint32_t     rectangles_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_set_clip_rectangles_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* rectangles */
+    xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_rectangle_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_set_clip_rectangles_checked (xcb_connection_t      *c,
+                                 uint8_t                ordering,
+                                 xcb_gcontext_t         gc,
+                                 int16_t                clip_x_origin,
+                                 int16_t                clip_y_origin,
+                                 uint32_t               rectangles_len,
+                                 const xcb_rectangle_t *rectangles)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_SET_CLIP_RECTANGLES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_set_clip_rectangles_request_t xcb_out;
+
+    xcb_out.ordering = ordering;
+    xcb_out.gc = gc;
+    xcb_out.clip_x_origin = clip_x_origin;
+    xcb_out.clip_y_origin = clip_y_origin;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_rectangle_t rectangles */
+    xcb_parts[4].iov_base = (char *) rectangles;
+    xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_set_clip_rectangles (xcb_connection_t      *c,
+                         uint8_t                ordering,
+                         xcb_gcontext_t         gc,
+                         int16_t                clip_x_origin,
+                         int16_t                clip_y_origin,
+                         uint32_t               rectangles_len,
+                         const xcb_rectangle_t *rectangles)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_SET_CLIP_RECTANGLES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_set_clip_rectangles_request_t xcb_out;
+
+    xcb_out.ordering = ordering;
+    xcb_out.gc = gc;
+    xcb_out.clip_x_origin = clip_x_origin;
+    xcb_out.clip_y_origin = clip_y_origin;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_rectangle_t rectangles */
+    xcb_parts[4].iov_base = (char *) rectangles;
+    xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_rectangle_t *
+xcb_set_clip_rectangles_rectangles (const xcb_set_clip_rectangles_request_t *R)
+{
+    return (xcb_rectangle_t *) (R + 1);
+}
+
+int
+xcb_set_clip_rectangles_rectangles_length (const xcb_set_clip_rectangles_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_set_clip_rectangles_request_t))/sizeof(xcb_rectangle_t));
+}
+
+xcb_rectangle_iterator_t
+xcb_set_clip_rectangles_rectangles_iterator (const xcb_set_clip_rectangles_request_t *R)
+{
+    xcb_rectangle_iterator_t i;
+    i.data = (xcb_rectangle_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_set_clip_rectangles_request_t))/sizeof(xcb_rectangle_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_free_gc_checked (xcb_connection_t *c,
+                     xcb_gcontext_t    gc)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_FREE_GC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_free_gc_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.gc = gc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_free_gc (xcb_connection_t *c,
+             xcb_gcontext_t    gc)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_FREE_GC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_free_gc_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.gc = gc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_clear_area_checked (xcb_connection_t *c,
+                        uint8_t           exposures,
+                        xcb_window_t      window,
+                        int16_t           x,
+                        int16_t           y,
+                        uint16_t          width,
+                        uint16_t          height)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CLEAR_AREA,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_clear_area_request_t xcb_out;
+
+    xcb_out.exposures = exposures;
+    xcb_out.window = window;
+    xcb_out.x = x;
+    xcb_out.y = y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_clear_area (xcb_connection_t *c,
+                uint8_t           exposures,
+                xcb_window_t      window,
+                int16_t           x,
+                int16_t           y,
+                uint16_t          width,
+                uint16_t          height)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CLEAR_AREA,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_clear_area_request_t xcb_out;
+
+    xcb_out.exposures = exposures;
+    xcb_out.window = window;
+    xcb_out.x = x;
+    xcb_out.y = y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_copy_area_checked (xcb_connection_t *c,
+                       xcb_drawable_t    src_drawable,
+                       xcb_drawable_t    dst_drawable,
+                       xcb_gcontext_t    gc,
+                       int16_t           src_x,
+                       int16_t           src_y,
+                       int16_t           dst_x,
+                       int16_t           dst_y,
+                       uint16_t          width,
+                       uint16_t          height)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_COPY_AREA,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_copy_area_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.src_drawable = src_drawable;
+    xcb_out.dst_drawable = dst_drawable;
+    xcb_out.gc = gc;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+    xcb_out.dst_x = dst_x;
+    xcb_out.dst_y = dst_y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_copy_area (xcb_connection_t *c,
+               xcb_drawable_t    src_drawable,
+               xcb_drawable_t    dst_drawable,
+               xcb_gcontext_t    gc,
+               int16_t           src_x,
+               int16_t           src_y,
+               int16_t           dst_x,
+               int16_t           dst_y,
+               uint16_t          width,
+               uint16_t          height)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_COPY_AREA,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_copy_area_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.src_drawable = src_drawable;
+    xcb_out.dst_drawable = dst_drawable;
+    xcb_out.gc = gc;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+    xcb_out.dst_x = dst_x;
+    xcb_out.dst_y = dst_y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_copy_plane_checked (xcb_connection_t *c,
+                        xcb_drawable_t    src_drawable,
+                        xcb_drawable_t    dst_drawable,
+                        xcb_gcontext_t    gc,
+                        int16_t           src_x,
+                        int16_t           src_y,
+                        int16_t           dst_x,
+                        int16_t           dst_y,
+                        uint16_t          width,
+                        uint16_t          height,
+                        uint32_t          bit_plane)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_COPY_PLANE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_copy_plane_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.src_drawable = src_drawable;
+    xcb_out.dst_drawable = dst_drawable;
+    xcb_out.gc = gc;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+    xcb_out.dst_x = dst_x;
+    xcb_out.dst_y = dst_y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.bit_plane = bit_plane;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_copy_plane (xcb_connection_t *c,
+                xcb_drawable_t    src_drawable,
+                xcb_drawable_t    dst_drawable,
+                xcb_gcontext_t    gc,
+                int16_t           src_x,
+                int16_t           src_y,
+                int16_t           dst_x,
+                int16_t           dst_y,
+                uint16_t          width,
+                uint16_t          height,
+                uint32_t          bit_plane)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_COPY_PLANE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_copy_plane_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.src_drawable = src_drawable;
+    xcb_out.dst_drawable = dst_drawable;
+    xcb_out.gc = gc;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+    xcb_out.dst_x = dst_x;
+    xcb_out.dst_y = dst_y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.bit_plane = bit_plane;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_poly_point_sizeof (const void  *_buffer,
+                       uint32_t     points_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_poly_point_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* points */
+    xcb_block_len += points_len * sizeof(xcb_point_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_point_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_poly_point_checked (xcb_connection_t  *c,
+                        uint8_t            coordinate_mode,
+                        xcb_drawable_t     drawable,
+                        xcb_gcontext_t     gc,
+                        uint32_t           points_len,
+                        const xcb_point_t *points)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_POLY_POINT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_poly_point_request_t xcb_out;
+
+    xcb_out.coordinate_mode = coordinate_mode;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_point_t points */
+    xcb_parts[4].iov_base = (char *) points;
+    xcb_parts[4].iov_len = points_len * sizeof(xcb_point_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_poly_point (xcb_connection_t  *c,
+                uint8_t            coordinate_mode,
+                xcb_drawable_t     drawable,
+                xcb_gcontext_t     gc,
+                uint32_t           points_len,
+                const xcb_point_t *points)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_POLY_POINT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_poly_point_request_t xcb_out;
+
+    xcb_out.coordinate_mode = coordinate_mode;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_point_t points */
+    xcb_parts[4].iov_base = (char *) points;
+    xcb_parts[4].iov_len = points_len * sizeof(xcb_point_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_point_t *
+xcb_poly_point_points (const xcb_poly_point_request_t *R)
+{
+    return (xcb_point_t *) (R + 1);
+}
+
+int
+xcb_poly_point_points_length (const xcb_poly_point_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_poly_point_request_t))/sizeof(xcb_point_t));
+}
+
+xcb_point_iterator_t
+xcb_poly_point_points_iterator (const xcb_poly_point_request_t *R)
+{
+    xcb_point_iterator_t i;
+    i.data = (xcb_point_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_poly_point_request_t))/sizeof(xcb_point_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_poly_line_sizeof (const void  *_buffer,
+                      uint32_t     points_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_poly_line_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* points */
+    xcb_block_len += points_len * sizeof(xcb_point_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_point_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_poly_line_checked (xcb_connection_t  *c,
+                       uint8_t            coordinate_mode,
+                       xcb_drawable_t     drawable,
+                       xcb_gcontext_t     gc,
+                       uint32_t           points_len,
+                       const xcb_point_t *points)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_POLY_LINE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_poly_line_request_t xcb_out;
+
+    xcb_out.coordinate_mode = coordinate_mode;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_point_t points */
+    xcb_parts[4].iov_base = (char *) points;
+    xcb_parts[4].iov_len = points_len * sizeof(xcb_point_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_poly_line (xcb_connection_t  *c,
+               uint8_t            coordinate_mode,
+               xcb_drawable_t     drawable,
+               xcb_gcontext_t     gc,
+               uint32_t           points_len,
+               const xcb_point_t *points)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_POLY_LINE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_poly_line_request_t xcb_out;
+
+    xcb_out.coordinate_mode = coordinate_mode;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_point_t points */
+    xcb_parts[4].iov_base = (char *) points;
+    xcb_parts[4].iov_len = points_len * sizeof(xcb_point_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_point_t *
+xcb_poly_line_points (const xcb_poly_line_request_t *R)
+{
+    return (xcb_point_t *) (R + 1);
+}
+
+int
+xcb_poly_line_points_length (const xcb_poly_line_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_poly_line_request_t))/sizeof(xcb_point_t));
+}
+
+xcb_point_iterator_t
+xcb_poly_line_points_iterator (const xcb_poly_line_request_t *R)
+{
+    xcb_point_iterator_t i;
+    i.data = (xcb_point_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_poly_line_request_t))/sizeof(xcb_point_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_segment_next (xcb_segment_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_segment_t);
+}
+
+xcb_generic_iterator_t
+xcb_segment_end (xcb_segment_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_poly_segment_sizeof (const void  *_buffer,
+                         uint32_t     segments_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_poly_segment_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* segments */
+    xcb_block_len += segments_len * sizeof(xcb_segment_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_segment_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_poly_segment_checked (xcb_connection_t    *c,
+                          xcb_drawable_t       drawable,
+                          xcb_gcontext_t       gc,
+                          uint32_t             segments_len,
+                          const xcb_segment_t *segments)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_POLY_SEGMENT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_poly_segment_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_segment_t segments */
+    xcb_parts[4].iov_base = (char *) segments;
+    xcb_parts[4].iov_len = segments_len * sizeof(xcb_segment_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_poly_segment (xcb_connection_t    *c,
+                  xcb_drawable_t       drawable,
+                  xcb_gcontext_t       gc,
+                  uint32_t             segments_len,
+                  const xcb_segment_t *segments)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_POLY_SEGMENT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_poly_segment_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_segment_t segments */
+    xcb_parts[4].iov_base = (char *) segments;
+    xcb_parts[4].iov_len = segments_len * sizeof(xcb_segment_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_segment_t *
+xcb_poly_segment_segments (const xcb_poly_segment_request_t *R)
+{
+    return (xcb_segment_t *) (R + 1);
+}
+
+int
+xcb_poly_segment_segments_length (const xcb_poly_segment_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_poly_segment_request_t))/sizeof(xcb_segment_t));
+}
+
+xcb_segment_iterator_t
+xcb_poly_segment_segments_iterator (const xcb_poly_segment_request_t *R)
+{
+    xcb_segment_iterator_t i;
+    i.data = (xcb_segment_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_poly_segment_request_t))/sizeof(xcb_segment_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_poly_rectangle_sizeof (const void  *_buffer,
+                           uint32_t     rectangles_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_poly_rectangle_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* rectangles */
+    xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_rectangle_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_poly_rectangle_checked (xcb_connection_t      *c,
+                            xcb_drawable_t         drawable,
+                            xcb_gcontext_t         gc,
+                            uint32_t               rectangles_len,
+                            const xcb_rectangle_t *rectangles)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_POLY_RECTANGLE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_poly_rectangle_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_rectangle_t rectangles */
+    xcb_parts[4].iov_base = (char *) rectangles;
+    xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_poly_rectangle (xcb_connection_t      *c,
+                    xcb_drawable_t         drawable,
+                    xcb_gcontext_t         gc,
+                    uint32_t               rectangles_len,
+                    const xcb_rectangle_t *rectangles)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_POLY_RECTANGLE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_poly_rectangle_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_rectangle_t rectangles */
+    xcb_parts[4].iov_base = (char *) rectangles;
+    xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_rectangle_t *
+xcb_poly_rectangle_rectangles (const xcb_poly_rectangle_request_t *R)
+{
+    return (xcb_rectangle_t *) (R + 1);
+}
+
+int
+xcb_poly_rectangle_rectangles_length (const xcb_poly_rectangle_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_poly_rectangle_request_t))/sizeof(xcb_rectangle_t));
+}
+
+xcb_rectangle_iterator_t
+xcb_poly_rectangle_rectangles_iterator (const xcb_poly_rectangle_request_t *R)
+{
+    xcb_rectangle_iterator_t i;
+    i.data = (xcb_rectangle_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_poly_rectangle_request_t))/sizeof(xcb_rectangle_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_poly_arc_sizeof (const void  *_buffer,
+                     uint32_t     arcs_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_poly_arc_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* arcs */
+    xcb_block_len += arcs_len * sizeof(xcb_arc_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_arc_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_poly_arc_checked (xcb_connection_t *c,
+                      xcb_drawable_t    drawable,
+                      xcb_gcontext_t    gc,
+                      uint32_t          arcs_len,
+                      const xcb_arc_t  *arcs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_POLY_ARC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_poly_arc_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_arc_t arcs */
+    xcb_parts[4].iov_base = (char *) arcs;
+    xcb_parts[4].iov_len = arcs_len * sizeof(xcb_arc_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_poly_arc (xcb_connection_t *c,
+              xcb_drawable_t    drawable,
+              xcb_gcontext_t    gc,
+              uint32_t          arcs_len,
+              const xcb_arc_t  *arcs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_POLY_ARC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_poly_arc_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_arc_t arcs */
+    xcb_parts[4].iov_base = (char *) arcs;
+    xcb_parts[4].iov_len = arcs_len * sizeof(xcb_arc_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_arc_t *
+xcb_poly_arc_arcs (const xcb_poly_arc_request_t *R)
+{
+    return (xcb_arc_t *) (R + 1);
+}
+
+int
+xcb_poly_arc_arcs_length (const xcb_poly_arc_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_poly_arc_request_t))/sizeof(xcb_arc_t));
+}
+
+xcb_arc_iterator_t
+xcb_poly_arc_arcs_iterator (const xcb_poly_arc_request_t *R)
+{
+    xcb_arc_iterator_t i;
+    i.data = (xcb_arc_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_poly_arc_request_t))/sizeof(xcb_arc_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_fill_poly_sizeof (const void  *_buffer,
+                      uint32_t     points_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_fill_poly_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* points */
+    xcb_block_len += points_len * sizeof(xcb_point_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_point_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_fill_poly_checked (xcb_connection_t  *c,
+                       xcb_drawable_t     drawable,
+                       xcb_gcontext_t     gc,
+                       uint8_t            shape,
+                       uint8_t            coordinate_mode,
+                       uint32_t           points_len,
+                       const xcb_point_t *points)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_FILL_POLY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_fill_poly_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.shape = shape;
+    xcb_out.coordinate_mode = coordinate_mode;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_point_t points */
+    xcb_parts[4].iov_base = (char *) points;
+    xcb_parts[4].iov_len = points_len * sizeof(xcb_point_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_fill_poly (xcb_connection_t  *c,
+               xcb_drawable_t     drawable,
+               xcb_gcontext_t     gc,
+               uint8_t            shape,
+               uint8_t            coordinate_mode,
+               uint32_t           points_len,
+               const xcb_point_t *points)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_FILL_POLY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_fill_poly_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.shape = shape;
+    xcb_out.coordinate_mode = coordinate_mode;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_point_t points */
+    xcb_parts[4].iov_base = (char *) points;
+    xcb_parts[4].iov_len = points_len * sizeof(xcb_point_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_point_t *
+xcb_fill_poly_points (const xcb_fill_poly_request_t *R)
+{
+    return (xcb_point_t *) (R + 1);
+}
+
+int
+xcb_fill_poly_points_length (const xcb_fill_poly_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_fill_poly_request_t))/sizeof(xcb_point_t));
+}
+
+xcb_point_iterator_t
+xcb_fill_poly_points_iterator (const xcb_fill_poly_request_t *R)
+{
+    xcb_point_iterator_t i;
+    i.data = (xcb_point_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_fill_poly_request_t))/sizeof(xcb_point_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_poly_fill_rectangle_sizeof (const void  *_buffer,
+                                uint32_t     rectangles_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_poly_fill_rectangle_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* rectangles */
+    xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_rectangle_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_poly_fill_rectangle_checked (xcb_connection_t      *c,
+                                 xcb_drawable_t         drawable,
+                                 xcb_gcontext_t         gc,
+                                 uint32_t               rectangles_len,
+                                 const xcb_rectangle_t *rectangles)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_POLY_FILL_RECTANGLE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_poly_fill_rectangle_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_rectangle_t rectangles */
+    xcb_parts[4].iov_base = (char *) rectangles;
+    xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_poly_fill_rectangle (xcb_connection_t      *c,
+                         xcb_drawable_t         drawable,
+                         xcb_gcontext_t         gc,
+                         uint32_t               rectangles_len,
+                         const xcb_rectangle_t *rectangles)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_POLY_FILL_RECTANGLE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_poly_fill_rectangle_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_rectangle_t rectangles */
+    xcb_parts[4].iov_base = (char *) rectangles;
+    xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_rectangle_t *
+xcb_poly_fill_rectangle_rectangles (const xcb_poly_fill_rectangle_request_t *R)
+{
+    return (xcb_rectangle_t *) (R + 1);
+}
+
+int
+xcb_poly_fill_rectangle_rectangles_length (const xcb_poly_fill_rectangle_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_poly_fill_rectangle_request_t))/sizeof(xcb_rectangle_t));
+}
+
+xcb_rectangle_iterator_t
+xcb_poly_fill_rectangle_rectangles_iterator (const xcb_poly_fill_rectangle_request_t *R)
+{
+    xcb_rectangle_iterator_t i;
+    i.data = (xcb_rectangle_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_poly_fill_rectangle_request_t))/sizeof(xcb_rectangle_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_poly_fill_arc_sizeof (const void  *_buffer,
+                          uint32_t     arcs_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_poly_fill_arc_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* arcs */
+    xcb_block_len += arcs_len * sizeof(xcb_arc_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_arc_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_poly_fill_arc_checked (xcb_connection_t *c,
+                           xcb_drawable_t    drawable,
+                           xcb_gcontext_t    gc,
+                           uint32_t          arcs_len,
+                           const xcb_arc_t  *arcs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_POLY_FILL_ARC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_poly_fill_arc_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_arc_t arcs */
+    xcb_parts[4].iov_base = (char *) arcs;
+    xcb_parts[4].iov_len = arcs_len * sizeof(xcb_arc_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_poly_fill_arc (xcb_connection_t *c,
+                   xcb_drawable_t    drawable,
+                   xcb_gcontext_t    gc,
+                   uint32_t          arcs_len,
+                   const xcb_arc_t  *arcs)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_POLY_FILL_ARC,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_poly_fill_arc_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_arc_t arcs */
+    xcb_parts[4].iov_base = (char *) arcs;
+    xcb_parts[4].iov_len = arcs_len * sizeof(xcb_arc_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_arc_t *
+xcb_poly_fill_arc_arcs (const xcb_poly_fill_arc_request_t *R)
+{
+    return (xcb_arc_t *) (R + 1);
+}
+
+int
+xcb_poly_fill_arc_arcs_length (const xcb_poly_fill_arc_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_poly_fill_arc_request_t))/sizeof(xcb_arc_t));
+}
+
+xcb_arc_iterator_t
+xcb_poly_fill_arc_arcs_iterator (const xcb_poly_fill_arc_request_t *R)
+{
+    xcb_arc_iterator_t i;
+    i.data = (xcb_arc_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_poly_fill_arc_request_t))/sizeof(xcb_arc_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_put_image_sizeof (const void  *_buffer,
+                      uint32_t     data_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_put_image_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += data_len * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_put_image_checked (xcb_connection_t *c,
+                       uint8_t           format,
+                       xcb_drawable_t    drawable,
+                       xcb_gcontext_t    gc,
+                       uint16_t          width,
+                       uint16_t          height,
+                       int16_t           dst_x,
+                       int16_t           dst_y,
+                       uint8_t           left_pad,
+                       uint8_t           depth,
+                       uint32_t          data_len,
+                       const uint8_t    *data)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_PUT_IMAGE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_put_image_request_t xcb_out;
+
+    xcb_out.format = format;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.dst_x = dst_x;
+    xcb_out.dst_y = dst_y;
+    xcb_out.left_pad = left_pad;
+    xcb_out.depth = depth;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t data */
+    xcb_parts[4].iov_base = (char *) data;
+    xcb_parts[4].iov_len = data_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_put_image (xcb_connection_t *c,
+               uint8_t           format,
+               xcb_drawable_t    drawable,
+               xcb_gcontext_t    gc,
+               uint16_t          width,
+               uint16_t          height,
+               int16_t           dst_x,
+               int16_t           dst_y,
+               uint8_t           left_pad,
+               uint8_t           depth,
+               uint32_t          data_len,
+               const uint8_t    *data)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_PUT_IMAGE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_put_image_request_t xcb_out;
+
+    xcb_out.format = format;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.dst_x = dst_x;
+    xcb_out.dst_y = dst_y;
+    xcb_out.left_pad = left_pad;
+    xcb_out.depth = depth;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t data */
+    xcb_parts[4].iov_base = (char *) data;
+    xcb_parts[4].iov_len = data_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_put_image_data (const xcb_put_image_request_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_put_image_data_length (const xcb_put_image_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_put_image_request_t))/sizeof(uint8_t));
+}
+
+xcb_generic_iterator_t
+xcb_put_image_data_end (const xcb_put_image_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_put_image_request_t))/sizeof(uint8_t)));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_get_image_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_get_image_reply_t *_aux = (xcb_get_image_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_get_image_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += (_aux->length * 4) * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_get_image_cookie_t
+xcb_get_image (xcb_connection_t *c,
+               uint8_t           format,
+               xcb_drawable_t    drawable,
+               int16_t           x,
+               int16_t           y,
+               uint16_t          width,
+               uint16_t          height,
+               uint32_t          plane_mask)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_IMAGE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_image_cookie_t xcb_ret;
+    xcb_get_image_request_t xcb_out;
+
+    xcb_out.format = format;
+    xcb_out.drawable = drawable;
+    xcb_out.x = x;
+    xcb_out.y = y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.plane_mask = plane_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_image_cookie_t
+xcb_get_image_unchecked (xcb_connection_t *c,
+                         uint8_t           format,
+                         xcb_drawable_t    drawable,
+                         int16_t           x,
+                         int16_t           y,
+                         uint16_t          width,
+                         uint16_t          height,
+                         uint32_t          plane_mask)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_IMAGE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_image_cookie_t xcb_ret;
+    xcb_get_image_request_t xcb_out;
+
+    xcb_out.format = format;
+    xcb_out.drawable = drawable;
+    xcb_out.x = x;
+    xcb_out.y = y;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.plane_mask = plane_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_get_image_data (const xcb_get_image_reply_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_get_image_data_length (const xcb_get_image_reply_t *R)
+{
+    return (R->length * 4);
+}
+
+xcb_generic_iterator_t
+xcb_get_image_data_end (const xcb_get_image_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((R->length * 4));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_get_image_reply_t *
+xcb_get_image_reply (xcb_connection_t        *c,
+                     xcb_get_image_cookie_t   cookie  /**< */,
+                     xcb_generic_error_t    **e)
+{
+    return (xcb_get_image_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_poly_text_8_sizeof (const void  *_buffer,
+                        uint32_t     items_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_poly_text_8_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* items */
+    xcb_block_len += items_len * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_poly_text_8_checked (xcb_connection_t *c,
+                         xcb_drawable_t    drawable,
+                         xcb_gcontext_t    gc,
+                         int16_t           x,
+                         int16_t           y,
+                         uint32_t          items_len,
+                         const uint8_t    *items)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_POLY_TEXT_8,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_poly_text_8_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.x = x;
+    xcb_out.y = y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t items */
+    xcb_parts[4].iov_base = (char *) items;
+    xcb_parts[4].iov_len = items_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_poly_text_8 (xcb_connection_t *c,
+                 xcb_drawable_t    drawable,
+                 xcb_gcontext_t    gc,
+                 int16_t           x,
+                 int16_t           y,
+                 uint32_t          items_len,
+                 const uint8_t    *items)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_POLY_TEXT_8,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_poly_text_8_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.x = x;
+    xcb_out.y = y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t items */
+    xcb_parts[4].iov_base = (char *) items;
+    xcb_parts[4].iov_len = items_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_poly_text_8_items (const xcb_poly_text_8_request_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_poly_text_8_items_length (const xcb_poly_text_8_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_poly_text_8_request_t))/sizeof(uint8_t));
+}
+
+xcb_generic_iterator_t
+xcb_poly_text_8_items_end (const xcb_poly_text_8_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_poly_text_8_request_t))/sizeof(uint8_t)));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_poly_text_16_sizeof (const void  *_buffer,
+                         uint32_t     items_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_poly_text_16_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* items */
+    xcb_block_len += items_len * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_poly_text_16_checked (xcb_connection_t *c,
+                          xcb_drawable_t    drawable,
+                          xcb_gcontext_t    gc,
+                          int16_t           x,
+                          int16_t           y,
+                          uint32_t          items_len,
+                          const uint8_t    *items)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_POLY_TEXT_16,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_poly_text_16_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.x = x;
+    xcb_out.y = y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t items */
+    xcb_parts[4].iov_base = (char *) items;
+    xcb_parts[4].iov_len = items_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_poly_text_16 (xcb_connection_t *c,
+                  xcb_drawable_t    drawable,
+                  xcb_gcontext_t    gc,
+                  int16_t           x,
+                  int16_t           y,
+                  uint32_t          items_len,
+                  const uint8_t    *items)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_POLY_TEXT_16,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_poly_text_16_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.x = x;
+    xcb_out.y = y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t items */
+    xcb_parts[4].iov_base = (char *) items;
+    xcb_parts[4].iov_len = items_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_poly_text_16_items (const xcb_poly_text_16_request_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_poly_text_16_items_length (const xcb_poly_text_16_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_poly_text_16_request_t))/sizeof(uint8_t));
+}
+
+xcb_generic_iterator_t
+xcb_poly_text_16_items_end (const xcb_poly_text_16_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_poly_text_16_request_t))/sizeof(uint8_t)));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_image_text_8_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_image_text_8_request_t *_aux = (xcb_image_text_8_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_image_text_8_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* string */
+    xcb_block_len += _aux->string_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_image_text_8_checked (xcb_connection_t *c,
+                          uint8_t           string_len,
+                          xcb_drawable_t    drawable,
+                          xcb_gcontext_t    gc,
+                          int16_t           x,
+                          int16_t           y,
+                          const char       *string)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_IMAGE_TEXT_8,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_image_text_8_request_t xcb_out;
+
+    xcb_out.string_len = string_len;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.x = x;
+    xcb_out.y = y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char string */
+    xcb_parts[4].iov_base = (char *) string;
+    xcb_parts[4].iov_len = string_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_image_text_8 (xcb_connection_t *c,
+                  uint8_t           string_len,
+                  xcb_drawable_t    drawable,
+                  xcb_gcontext_t    gc,
+                  int16_t           x,
+                  int16_t           y,
+                  const char       *string)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_IMAGE_TEXT_8,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_image_text_8_request_t xcb_out;
+
+    xcb_out.string_len = string_len;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.x = x;
+    xcb_out.y = y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char string */
+    xcb_parts[4].iov_base = (char *) string;
+    xcb_parts[4].iov_len = string_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_image_text_8_string (const xcb_image_text_8_request_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_image_text_8_string_length (const xcb_image_text_8_request_t *R)
+{
+    return R->string_len;
+}
+
+xcb_generic_iterator_t
+xcb_image_text_8_string_end (const xcb_image_text_8_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->string_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_image_text_16_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_image_text_16_request_t *_aux = (xcb_image_text_16_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_image_text_16_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* string */
+    xcb_block_len += _aux->string_len * sizeof(xcb_char2b_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_char2b_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_image_text_16_checked (xcb_connection_t   *c,
+                           uint8_t             string_len,
+                           xcb_drawable_t      drawable,
+                           xcb_gcontext_t      gc,
+                           int16_t             x,
+                           int16_t             y,
+                           const xcb_char2b_t *string)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_IMAGE_TEXT_16,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_image_text_16_request_t xcb_out;
+
+    xcb_out.string_len = string_len;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.x = x;
+    xcb_out.y = y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_char2b_t string */
+    xcb_parts[4].iov_base = (char *) string;
+    xcb_parts[4].iov_len = string_len * sizeof(xcb_char2b_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_image_text_16 (xcb_connection_t   *c,
+                   uint8_t             string_len,
+                   xcb_drawable_t      drawable,
+                   xcb_gcontext_t      gc,
+                   int16_t             x,
+                   int16_t             y,
+                   const xcb_char2b_t *string)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_IMAGE_TEXT_16,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_image_text_16_request_t xcb_out;
+
+    xcb_out.string_len = string_len;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.x = x;
+    xcb_out.y = y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_char2b_t string */
+    xcb_parts[4].iov_base = (char *) string;
+    xcb_parts[4].iov_len = string_len * sizeof(xcb_char2b_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_char2b_t *
+xcb_image_text_16_string (const xcb_image_text_16_request_t *R)
+{
+    return (xcb_char2b_t *) (R + 1);
+}
+
+int
+xcb_image_text_16_string_length (const xcb_image_text_16_request_t *R)
+{
+    return R->string_len;
+}
+
+xcb_char2b_iterator_t
+xcb_image_text_16_string_iterator (const xcb_image_text_16_request_t *R)
+{
+    xcb_char2b_iterator_t i;
+    i.data = (xcb_char2b_t *) (R + 1);
+    i.rem = R->string_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_create_colormap_checked (xcb_connection_t *c,
+                             uint8_t           alloc,
+                             xcb_colormap_t    mid,
+                             xcb_window_t      window,
+                             xcb_visualid_t    visual)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CREATE_COLORMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_create_colormap_request_t xcb_out;
+
+    xcb_out.alloc = alloc;
+    xcb_out.mid = mid;
+    xcb_out.window = window;
+    xcb_out.visual = visual;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_create_colormap (xcb_connection_t *c,
+                     uint8_t           alloc,
+                     xcb_colormap_t    mid,
+                     xcb_window_t      window,
+                     xcb_visualid_t    visual)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CREATE_COLORMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_create_colormap_request_t xcb_out;
+
+    xcb_out.alloc = alloc;
+    xcb_out.mid = mid;
+    xcb_out.window = window;
+    xcb_out.visual = visual;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_free_colormap_checked (xcb_connection_t *c,
+                           xcb_colormap_t    cmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_FREE_COLORMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_free_colormap_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cmap = cmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_free_colormap (xcb_connection_t *c,
+                   xcb_colormap_t    cmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_FREE_COLORMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_free_colormap_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cmap = cmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_copy_colormap_and_free_checked (xcb_connection_t *c,
+                                    xcb_colormap_t    mid,
+                                    xcb_colormap_t    src_cmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_COPY_COLORMAP_AND_FREE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_copy_colormap_and_free_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.mid = mid;
+    xcb_out.src_cmap = src_cmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_copy_colormap_and_free (xcb_connection_t *c,
+                            xcb_colormap_t    mid,
+                            xcb_colormap_t    src_cmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_COPY_COLORMAP_AND_FREE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_copy_colormap_and_free_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.mid = mid;
+    xcb_out.src_cmap = src_cmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_install_colormap_checked (xcb_connection_t *c,
+                              xcb_colormap_t    cmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_INSTALL_COLORMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_install_colormap_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cmap = cmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_install_colormap (xcb_connection_t *c,
+                      xcb_colormap_t    cmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_INSTALL_COLORMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_install_colormap_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cmap = cmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_uninstall_colormap_checked (xcb_connection_t *c,
+                                xcb_colormap_t    cmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_UNINSTALL_COLORMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_uninstall_colormap_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cmap = cmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_uninstall_colormap (xcb_connection_t *c,
+                        xcb_colormap_t    cmap)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_UNINSTALL_COLORMAP,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_uninstall_colormap_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cmap = cmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_list_installed_colormaps_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_list_installed_colormaps_reply_t *_aux = (xcb_list_installed_colormaps_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_list_installed_colormaps_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* cmaps */
+    xcb_block_len += _aux->cmaps_len * sizeof(xcb_colormap_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_colormap_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_list_installed_colormaps_cookie_t
+xcb_list_installed_colormaps (xcb_connection_t *c,
+                              xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_LIST_INSTALLED_COLORMAPS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_list_installed_colormaps_cookie_t xcb_ret;
+    xcb_list_installed_colormaps_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_list_installed_colormaps_cookie_t
+xcb_list_installed_colormaps_unchecked (xcb_connection_t *c,
+                                        xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_LIST_INSTALLED_COLORMAPS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_list_installed_colormaps_cookie_t xcb_ret;
+    xcb_list_installed_colormaps_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_colormap_t *
+xcb_list_installed_colormaps_cmaps (const xcb_list_installed_colormaps_reply_t *R)
+{
+    return (xcb_colormap_t *) (R + 1);
+}
+
+int
+xcb_list_installed_colormaps_cmaps_length (const xcb_list_installed_colormaps_reply_t *R)
+{
+    return R->cmaps_len;
+}
+
+xcb_generic_iterator_t
+xcb_list_installed_colormaps_cmaps_end (const xcb_list_installed_colormaps_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_colormap_t *) (R + 1)) + (R->cmaps_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_list_installed_colormaps_reply_t *
+xcb_list_installed_colormaps_reply (xcb_connection_t                       *c,
+                                    xcb_list_installed_colormaps_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e)
+{
+    return (xcb_list_installed_colormaps_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_alloc_color_cookie_t
+xcb_alloc_color (xcb_connection_t *c,
+                 xcb_colormap_t    cmap,
+                 uint16_t          red,
+                 uint16_t          green,
+                 uint16_t          blue)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_ALLOC_COLOR,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_alloc_color_cookie_t xcb_ret;
+    xcb_alloc_color_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cmap = cmap;
+    xcb_out.red = red;
+    xcb_out.green = green;
+    xcb_out.blue = blue;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_alloc_color_cookie_t
+xcb_alloc_color_unchecked (xcb_connection_t *c,
+                           xcb_colormap_t    cmap,
+                           uint16_t          red,
+                           uint16_t          green,
+                           uint16_t          blue)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_ALLOC_COLOR,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_alloc_color_cookie_t xcb_ret;
+    xcb_alloc_color_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cmap = cmap;
+    xcb_out.red = red;
+    xcb_out.green = green;
+    xcb_out.blue = blue;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_alloc_color_reply_t *
+xcb_alloc_color_reply (xcb_connection_t          *c,
+                       xcb_alloc_color_cookie_t   cookie  /**< */,
+                       xcb_generic_error_t      **e)
+{
+    return (xcb_alloc_color_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_alloc_named_color_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_alloc_named_color_request_t *_aux = (xcb_alloc_named_color_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_alloc_named_color_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->name_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_alloc_named_color_cookie_t
+xcb_alloc_named_color (xcb_connection_t *c,
+                       xcb_colormap_t    cmap,
+                       uint16_t          name_len,
+                       const char       *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_ALLOC_NAMED_COLOR,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_alloc_named_color_cookie_t xcb_ret;
+    xcb_alloc_named_color_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cmap = cmap;
+    xcb_out.name_len = name_len;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = name_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_alloc_named_color_cookie_t
+xcb_alloc_named_color_unchecked (xcb_connection_t *c,
+                                 xcb_colormap_t    cmap,
+                                 uint16_t          name_len,
+                                 const char       *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_ALLOC_NAMED_COLOR,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_alloc_named_color_cookie_t xcb_ret;
+    xcb_alloc_named_color_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cmap = cmap;
+    xcb_out.name_len = name_len;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = name_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_alloc_named_color_reply_t *
+xcb_alloc_named_color_reply (xcb_connection_t                *c,
+                             xcb_alloc_named_color_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_alloc_named_color_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_alloc_color_cells_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_alloc_color_cells_reply_t *_aux = (xcb_alloc_color_cells_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_alloc_color_cells_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* pixels */
+    xcb_block_len += _aux->pixels_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* masks */
+    xcb_block_len += _aux->masks_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_alloc_color_cells_cookie_t
+xcb_alloc_color_cells (xcb_connection_t *c,
+                       uint8_t           contiguous,
+                       xcb_colormap_t    cmap,
+                       uint16_t          colors,
+                       uint16_t          planes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_ALLOC_COLOR_CELLS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_alloc_color_cells_cookie_t xcb_ret;
+    xcb_alloc_color_cells_request_t xcb_out;
+
+    xcb_out.contiguous = contiguous;
+    xcb_out.cmap = cmap;
+    xcb_out.colors = colors;
+    xcb_out.planes = planes;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_alloc_color_cells_cookie_t
+xcb_alloc_color_cells_unchecked (xcb_connection_t *c,
+                                 uint8_t           contiguous,
+                                 xcb_colormap_t    cmap,
+                                 uint16_t          colors,
+                                 uint16_t          planes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_ALLOC_COLOR_CELLS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_alloc_color_cells_cookie_t xcb_ret;
+    xcb_alloc_color_cells_request_t xcb_out;
+
+    xcb_out.contiguous = contiguous;
+    xcb_out.cmap = cmap;
+    xcb_out.colors = colors;
+    xcb_out.planes = planes;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_alloc_color_cells_pixels (const xcb_alloc_color_cells_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_alloc_color_cells_pixels_length (const xcb_alloc_color_cells_reply_t *R)
+{
+    return R->pixels_len;
+}
+
+xcb_generic_iterator_t
+xcb_alloc_color_cells_pixels_end (const xcb_alloc_color_cells_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->pixels_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint32_t *
+xcb_alloc_color_cells_masks (const xcb_alloc_color_cells_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_alloc_color_cells_pixels_end(R);
+    return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0);
+}
+
+int
+xcb_alloc_color_cells_masks_length (const xcb_alloc_color_cells_reply_t *R)
+{
+    return R->masks_len;
+}
+
+xcb_generic_iterator_t
+xcb_alloc_color_cells_masks_end (const xcb_alloc_color_cells_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_alloc_color_cells_pixels_end(R);
+    i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->masks_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_alloc_color_cells_reply_t *
+xcb_alloc_color_cells_reply (xcb_connection_t                *c,
+                             xcb_alloc_color_cells_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_alloc_color_cells_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_alloc_color_planes_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_alloc_color_planes_reply_t *_aux = (xcb_alloc_color_planes_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_alloc_color_planes_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* pixels */
+    xcb_block_len += _aux->pixels_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_alloc_color_planes_cookie_t
+xcb_alloc_color_planes (xcb_connection_t *c,
+                        uint8_t           contiguous,
+                        xcb_colormap_t    cmap,
+                        uint16_t          colors,
+                        uint16_t          reds,
+                        uint16_t          greens,
+                        uint16_t          blues)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_ALLOC_COLOR_PLANES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_alloc_color_planes_cookie_t xcb_ret;
+    xcb_alloc_color_planes_request_t xcb_out;
+
+    xcb_out.contiguous = contiguous;
+    xcb_out.cmap = cmap;
+    xcb_out.colors = colors;
+    xcb_out.reds = reds;
+    xcb_out.greens = greens;
+    xcb_out.blues = blues;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_alloc_color_planes_cookie_t
+xcb_alloc_color_planes_unchecked (xcb_connection_t *c,
+                                  uint8_t           contiguous,
+                                  xcb_colormap_t    cmap,
+                                  uint16_t          colors,
+                                  uint16_t          reds,
+                                  uint16_t          greens,
+                                  uint16_t          blues)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_ALLOC_COLOR_PLANES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_alloc_color_planes_cookie_t xcb_ret;
+    xcb_alloc_color_planes_request_t xcb_out;
+
+    xcb_out.contiguous = contiguous;
+    xcb_out.cmap = cmap;
+    xcb_out.colors = colors;
+    xcb_out.reds = reds;
+    xcb_out.greens = greens;
+    xcb_out.blues = blues;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_alloc_color_planes_pixels (const xcb_alloc_color_planes_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_alloc_color_planes_pixels_length (const xcb_alloc_color_planes_reply_t *R)
+{
+    return R->pixels_len;
+}
+
+xcb_generic_iterator_t
+xcb_alloc_color_planes_pixels_end (const xcb_alloc_color_planes_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->pixels_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_alloc_color_planes_reply_t *
+xcb_alloc_color_planes_reply (xcb_connection_t                 *c,
+                              xcb_alloc_color_planes_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_alloc_color_planes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_free_colors_sizeof (const void  *_buffer,
+                        uint32_t     pixels_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_free_colors_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* pixels */
+    xcb_block_len += pixels_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_free_colors_checked (xcb_connection_t *c,
+                         xcb_colormap_t    cmap,
+                         uint32_t          plane_mask,
+                         uint32_t          pixels_len,
+                         const uint32_t   *pixels)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_FREE_COLORS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_free_colors_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cmap = cmap;
+    xcb_out.plane_mask = plane_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t pixels */
+    xcb_parts[4].iov_base = (char *) pixels;
+    xcb_parts[4].iov_len = pixels_len * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_free_colors (xcb_connection_t *c,
+                 xcb_colormap_t    cmap,
+                 uint32_t          plane_mask,
+                 uint32_t          pixels_len,
+                 const uint32_t   *pixels)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_FREE_COLORS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_free_colors_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cmap = cmap;
+    xcb_out.plane_mask = plane_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t pixels */
+    xcb_parts[4].iov_base = (char *) pixels;
+    xcb_parts[4].iov_len = pixels_len * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_free_colors_pixels (const xcb_free_colors_request_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_free_colors_pixels_length (const xcb_free_colors_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_free_colors_request_t))/sizeof(uint32_t));
+}
+
+xcb_generic_iterator_t
+xcb_free_colors_pixels_end (const xcb_free_colors_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_free_colors_request_t))/sizeof(uint32_t)));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_coloritem_next (xcb_coloritem_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_coloritem_t);
+}
+
+xcb_generic_iterator_t
+xcb_coloritem_end (xcb_coloritem_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_store_colors_sizeof (const void  *_buffer,
+                         uint32_t     items_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_store_colors_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* items */
+    xcb_block_len += items_len * sizeof(xcb_coloritem_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_coloritem_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_store_colors_checked (xcb_connection_t      *c,
+                          xcb_colormap_t         cmap,
+                          uint32_t               items_len,
+                          const xcb_coloritem_t *items)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_STORE_COLORS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_store_colors_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cmap = cmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_coloritem_t items */
+    xcb_parts[4].iov_base = (char *) items;
+    xcb_parts[4].iov_len = items_len * sizeof(xcb_coloritem_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_store_colors (xcb_connection_t      *c,
+                  xcb_colormap_t         cmap,
+                  uint32_t               items_len,
+                  const xcb_coloritem_t *items)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_STORE_COLORS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_store_colors_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cmap = cmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_coloritem_t items */
+    xcb_parts[4].iov_base = (char *) items;
+    xcb_parts[4].iov_len = items_len * sizeof(xcb_coloritem_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_coloritem_t *
+xcb_store_colors_items (const xcb_store_colors_request_t *R)
+{
+    return (xcb_coloritem_t *) (R + 1);
+}
+
+int
+xcb_store_colors_items_length (const xcb_store_colors_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_store_colors_request_t))/sizeof(xcb_coloritem_t));
+}
+
+xcb_coloritem_iterator_t
+xcb_store_colors_items_iterator (const xcb_store_colors_request_t *R)
+{
+    xcb_coloritem_iterator_t i;
+    i.data = (xcb_coloritem_t *) (R + 1);
+    i.rem = (((R->length * 4) - sizeof(xcb_store_colors_request_t))/sizeof(xcb_coloritem_t));
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_store_named_color_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_store_named_color_request_t *_aux = (xcb_store_named_color_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_store_named_color_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->name_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_store_named_color_checked (xcb_connection_t *c,
+                               uint8_t           flags,
+                               xcb_colormap_t    cmap,
+                               uint32_t          pixel,
+                               uint16_t          name_len,
+                               const char       *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_STORE_NAMED_COLOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_store_named_color_request_t xcb_out;
+
+    xcb_out.flags = flags;
+    xcb_out.cmap = cmap;
+    xcb_out.pixel = pixel;
+    xcb_out.name_len = name_len;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = name_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_store_named_color (xcb_connection_t *c,
+                       uint8_t           flags,
+                       xcb_colormap_t    cmap,
+                       uint32_t          pixel,
+                       uint16_t          name_len,
+                       const char       *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_STORE_NAMED_COLOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_store_named_color_request_t xcb_out;
+
+    xcb_out.flags = flags;
+    xcb_out.cmap = cmap;
+    xcb_out.pixel = pixel;
+    xcb_out.name_len = name_len;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = name_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_store_named_color_name (const xcb_store_named_color_request_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_store_named_color_name_length (const xcb_store_named_color_request_t *R)
+{
+    return R->name_len;
+}
+
+xcb_generic_iterator_t
+xcb_store_named_color_name_end (const xcb_store_named_color_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->name_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_rgb_next (xcb_rgb_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_rgb_t);
+}
+
+xcb_generic_iterator_t
+xcb_rgb_end (xcb_rgb_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_query_colors_sizeof (const void  *_buffer,
+                         uint32_t     pixels_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_query_colors_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* pixels */
+    xcb_block_len += pixels_len * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_query_colors_cookie_t
+xcb_query_colors (xcb_connection_t *c,
+                  xcb_colormap_t    cmap,
+                  uint32_t          pixels_len,
+                  const uint32_t   *pixels)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_QUERY_COLORS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_query_colors_cookie_t xcb_ret;
+    xcb_query_colors_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cmap = cmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t pixels */
+    xcb_parts[4].iov_base = (char *) pixels;
+    xcb_parts[4].iov_len = pixels_len * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_query_colors_cookie_t
+xcb_query_colors_unchecked (xcb_connection_t *c,
+                            xcb_colormap_t    cmap,
+                            uint32_t          pixels_len,
+                            const uint32_t   *pixels)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_QUERY_COLORS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_query_colors_cookie_t xcb_ret;
+    xcb_query_colors_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cmap = cmap;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint32_t pixels */
+    xcb_parts[4].iov_base = (char *) pixels;
+    xcb_parts[4].iov_len = pixels_len * sizeof(uint32_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_rgb_t *
+xcb_query_colors_colors (const xcb_query_colors_reply_t *R)
+{
+    return (xcb_rgb_t *) (R + 1);
+}
+
+int
+xcb_query_colors_colors_length (const xcb_query_colors_reply_t *R)
+{
+    return R->colors_len;
+}
+
+xcb_rgb_iterator_t
+xcb_query_colors_colors_iterator (const xcb_query_colors_reply_t *R)
+{
+    xcb_rgb_iterator_t i;
+    i.data = (xcb_rgb_t *) (R + 1);
+    i.rem = R->colors_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_query_colors_reply_t *
+xcb_query_colors_reply (xcb_connection_t           *c,
+                        xcb_query_colors_cookie_t   cookie  /**< */,
+                        xcb_generic_error_t       **e)
+{
+    return (xcb_query_colors_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_lookup_color_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_lookup_color_request_t *_aux = (xcb_lookup_color_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_lookup_color_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->name_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_lookup_color_cookie_t
+xcb_lookup_color (xcb_connection_t *c,
+                  xcb_colormap_t    cmap,
+                  uint16_t          name_len,
+                  const char       *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_LOOKUP_COLOR,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_lookup_color_cookie_t xcb_ret;
+    xcb_lookup_color_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cmap = cmap;
+    xcb_out.name_len = name_len;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = name_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_lookup_color_cookie_t
+xcb_lookup_color_unchecked (xcb_connection_t *c,
+                            xcb_colormap_t    cmap,
+                            uint16_t          name_len,
+                            const char       *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_LOOKUP_COLOR,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_lookup_color_cookie_t xcb_ret;
+    xcb_lookup_color_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cmap = cmap;
+    xcb_out.name_len = name_len;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = name_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_lookup_color_reply_t *
+xcb_lookup_color_reply (xcb_connection_t           *c,
+                        xcb_lookup_color_cookie_t   cookie  /**< */,
+                        xcb_generic_error_t       **e)
+{
+    return (xcb_lookup_color_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_create_cursor_checked (xcb_connection_t *c,
+                           xcb_cursor_t      cid,
+                           xcb_pixmap_t      source,
+                           xcb_pixmap_t      mask,
+                           uint16_t          fore_red,
+                           uint16_t          fore_green,
+                           uint16_t          fore_blue,
+                           uint16_t          back_red,
+                           uint16_t          back_green,
+                           uint16_t          back_blue,
+                           uint16_t          x,
+                           uint16_t          y)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CREATE_CURSOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_create_cursor_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cid = cid;
+    xcb_out.source = source;
+    xcb_out.mask = mask;
+    xcb_out.fore_red = fore_red;
+    xcb_out.fore_green = fore_green;
+    xcb_out.fore_blue = fore_blue;
+    xcb_out.back_red = back_red;
+    xcb_out.back_green = back_green;
+    xcb_out.back_blue = back_blue;
+    xcb_out.x = x;
+    xcb_out.y = y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_create_cursor (xcb_connection_t *c,
+                   xcb_cursor_t      cid,
+                   xcb_pixmap_t      source,
+                   xcb_pixmap_t      mask,
+                   uint16_t          fore_red,
+                   uint16_t          fore_green,
+                   uint16_t          fore_blue,
+                   uint16_t          back_red,
+                   uint16_t          back_green,
+                   uint16_t          back_blue,
+                   uint16_t          x,
+                   uint16_t          y)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CREATE_CURSOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_create_cursor_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cid = cid;
+    xcb_out.source = source;
+    xcb_out.mask = mask;
+    xcb_out.fore_red = fore_red;
+    xcb_out.fore_green = fore_green;
+    xcb_out.fore_blue = fore_blue;
+    xcb_out.back_red = back_red;
+    xcb_out.back_green = back_green;
+    xcb_out.back_blue = back_blue;
+    xcb_out.x = x;
+    xcb_out.y = y;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_create_glyph_cursor_checked (xcb_connection_t *c,
+                                 xcb_cursor_t      cid,
+                                 xcb_font_t        source_font,
+                                 xcb_font_t        mask_font,
+                                 uint16_t          source_char,
+                                 uint16_t          mask_char,
+                                 uint16_t          fore_red,
+                                 uint16_t          fore_green,
+                                 uint16_t          fore_blue,
+                                 uint16_t          back_red,
+                                 uint16_t          back_green,
+                                 uint16_t          back_blue)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CREATE_GLYPH_CURSOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_create_glyph_cursor_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cid = cid;
+    xcb_out.source_font = source_font;
+    xcb_out.mask_font = mask_font;
+    xcb_out.source_char = source_char;
+    xcb_out.mask_char = mask_char;
+    xcb_out.fore_red = fore_red;
+    xcb_out.fore_green = fore_green;
+    xcb_out.fore_blue = fore_blue;
+    xcb_out.back_red = back_red;
+    xcb_out.back_green = back_green;
+    xcb_out.back_blue = back_blue;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_create_glyph_cursor (xcb_connection_t *c,
+                         xcb_cursor_t      cid,
+                         xcb_font_t        source_font,
+                         xcb_font_t        mask_font,
+                         uint16_t          source_char,
+                         uint16_t          mask_char,
+                         uint16_t          fore_red,
+                         uint16_t          fore_green,
+                         uint16_t          fore_blue,
+                         uint16_t          back_red,
+                         uint16_t          back_green,
+                         uint16_t          back_blue)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CREATE_GLYPH_CURSOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_create_glyph_cursor_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cid = cid;
+    xcb_out.source_font = source_font;
+    xcb_out.mask_font = mask_font;
+    xcb_out.source_char = source_char;
+    xcb_out.mask_char = mask_char;
+    xcb_out.fore_red = fore_red;
+    xcb_out.fore_green = fore_green;
+    xcb_out.fore_blue = fore_blue;
+    xcb_out.back_red = back_red;
+    xcb_out.back_green = back_green;
+    xcb_out.back_blue = back_blue;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_free_cursor_checked (xcb_connection_t *c,
+                         xcb_cursor_t      cursor)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_FREE_CURSOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_free_cursor_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cursor = cursor;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_free_cursor (xcb_connection_t *c,
+                 xcb_cursor_t      cursor)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_FREE_CURSOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_free_cursor_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cursor = cursor;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_recolor_cursor_checked (xcb_connection_t *c,
+                            xcb_cursor_t      cursor,
+                            uint16_t          fore_red,
+                            uint16_t          fore_green,
+                            uint16_t          fore_blue,
+                            uint16_t          back_red,
+                            uint16_t          back_green,
+                            uint16_t          back_blue)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_RECOLOR_CURSOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_recolor_cursor_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cursor = cursor;
+    xcb_out.fore_red = fore_red;
+    xcb_out.fore_green = fore_green;
+    xcb_out.fore_blue = fore_blue;
+    xcb_out.back_red = back_red;
+    xcb_out.back_green = back_green;
+    xcb_out.back_blue = back_blue;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_recolor_cursor (xcb_connection_t *c,
+                    xcb_cursor_t      cursor,
+                    uint16_t          fore_red,
+                    uint16_t          fore_green,
+                    uint16_t          fore_blue,
+                    uint16_t          back_red,
+                    uint16_t          back_green,
+                    uint16_t          back_blue)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_RECOLOR_CURSOR,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_recolor_cursor_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.cursor = cursor;
+    xcb_out.fore_red = fore_red;
+    xcb_out.fore_green = fore_green;
+    xcb_out.fore_blue = fore_blue;
+    xcb_out.back_red = back_red;
+    xcb_out.back_green = back_green;
+    xcb_out.back_blue = back_blue;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_query_best_size_cookie_t
+xcb_query_best_size (xcb_connection_t *c,
+                     uint8_t           _class,
+                     xcb_drawable_t    drawable,
+                     uint16_t          width,
+                     uint16_t          height)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_QUERY_BEST_SIZE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_query_best_size_cookie_t xcb_ret;
+    xcb_query_best_size_request_t xcb_out;
+
+    xcb_out._class = _class;
+    xcb_out.drawable = drawable;
+    xcb_out.width = width;
+    xcb_out.height = height;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_query_best_size_cookie_t
+xcb_query_best_size_unchecked (xcb_connection_t *c,
+                               uint8_t           _class,
+                               xcb_drawable_t    drawable,
+                               uint16_t          width,
+                               uint16_t          height)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_QUERY_BEST_SIZE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_query_best_size_cookie_t xcb_ret;
+    xcb_query_best_size_request_t xcb_out;
+
+    xcb_out._class = _class;
+    xcb_out.drawable = drawable;
+    xcb_out.width = width;
+    xcb_out.height = height;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_query_best_size_reply_t *
+xcb_query_best_size_reply (xcb_connection_t              *c,
+                           xcb_query_best_size_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e)
+{
+    return (xcb_query_best_size_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_query_extension_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_query_extension_request_t *_aux = (xcb_query_extension_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_query_extension_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->name_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_query_extension_cookie_t
+xcb_query_extension (xcb_connection_t *c,
+                     uint16_t          name_len,
+                     const char       *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_QUERY_EXTENSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_query_extension_cookie_t xcb_ret;
+    xcb_query_extension_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.name_len = name_len;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = name_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_query_extension_cookie_t
+xcb_query_extension_unchecked (xcb_connection_t *c,
+                               uint16_t          name_len,
+                               const char       *name)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_QUERY_EXTENSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_query_extension_cookie_t xcb_ret;
+    xcb_query_extension_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.name_len = name_len;
+    memset(xcb_out.pad1, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char name */
+    xcb_parts[4].iov_base = (char *) name;
+    xcb_parts[4].iov_len = name_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_query_extension_reply_t *
+xcb_query_extension_reply (xcb_connection_t              *c,
+                           xcb_query_extension_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e)
+{
+    return (xcb_query_extension_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_list_extensions_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_list_extensions_reply_t *_aux = (xcb_list_extensions_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_list_extensions_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* names */
+    for(i=0; i<_aux->names_len; i++) {
+        xcb_tmp_len = xcb_str_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_str_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_list_extensions_cookie_t
+xcb_list_extensions (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_LIST_EXTENSIONS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_list_extensions_cookie_t xcb_ret;
+    xcb_list_extensions_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_list_extensions_cookie_t
+xcb_list_extensions_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_LIST_EXTENSIONS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_list_extensions_cookie_t xcb_ret;
+    xcb_list_extensions_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_list_extensions_names_length (const xcb_list_extensions_reply_t *R)
+{
+    return R->names_len;
+}
+
+xcb_str_iterator_t
+xcb_list_extensions_names_iterator (const xcb_list_extensions_reply_t *R)
+{
+    xcb_str_iterator_t i;
+    i.data = (xcb_str_t *) (R + 1);
+    i.rem = R->names_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_list_extensions_reply_t *
+xcb_list_extensions_reply (xcb_connection_t              *c,
+                           xcb_list_extensions_cookie_t   cookie  /**< */,
+                           xcb_generic_error_t          **e)
+{
+    return (xcb_list_extensions_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_change_keyboard_mapping_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_change_keyboard_mapping_request_t *_aux = (xcb_change_keyboard_mapping_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_change_keyboard_mapping_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* keysyms */
+    xcb_block_len += (_aux->keycode_count * _aux->keysyms_per_keycode) * sizeof(xcb_keysym_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_keysym_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_change_keyboard_mapping_checked (xcb_connection_t   *c,
+                                     uint8_t             keycode_count,
+                                     xcb_keycode_t       first_keycode,
+                                     uint8_t             keysyms_per_keycode,
+                                     const xcb_keysym_t *keysyms)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_CHANGE_KEYBOARD_MAPPING,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_keyboard_mapping_request_t xcb_out;
+
+    xcb_out.keycode_count = keycode_count;
+    xcb_out.first_keycode = first_keycode;
+    xcb_out.keysyms_per_keycode = keysyms_per_keycode;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_keysym_t keysyms */
+    xcb_parts[4].iov_base = (char *) keysyms;
+    xcb_parts[4].iov_len = (keycode_count * keysyms_per_keycode) * sizeof(xcb_keysym_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_change_keyboard_mapping (xcb_connection_t   *c,
+                             uint8_t             keycode_count,
+                             xcb_keycode_t       first_keycode,
+                             uint8_t             keysyms_per_keycode,
+                             const xcb_keysym_t *keysyms)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_CHANGE_KEYBOARD_MAPPING,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_keyboard_mapping_request_t xcb_out;
+
+    xcb_out.keycode_count = keycode_count;
+    xcb_out.first_keycode = first_keycode;
+    xcb_out.keysyms_per_keycode = keysyms_per_keycode;
+    memset(xcb_out.pad0, 0, 2);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_keysym_t keysyms */
+    xcb_parts[4].iov_base = (char *) keysyms;
+    xcb_parts[4].iov_len = (keycode_count * keysyms_per_keycode) * sizeof(xcb_keysym_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_keysym_t *
+xcb_change_keyboard_mapping_keysyms (const xcb_change_keyboard_mapping_request_t *R)
+{
+    return (xcb_keysym_t *) (R + 1);
+}
+
+int
+xcb_change_keyboard_mapping_keysyms_length (const xcb_change_keyboard_mapping_request_t *R)
+{
+    return (R->keycode_count * R->keysyms_per_keycode);
+}
+
+xcb_generic_iterator_t
+xcb_change_keyboard_mapping_keysyms_end (const xcb_change_keyboard_mapping_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_keysym_t *) (R + 1)) + ((R->keycode_count * R->keysyms_per_keycode));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_get_keyboard_mapping_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_get_keyboard_mapping_reply_t *_aux = (xcb_get_keyboard_mapping_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_get_keyboard_mapping_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* keysyms */
+    xcb_block_len += _aux->length * sizeof(xcb_keysym_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_keysym_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_get_keyboard_mapping_cookie_t
+xcb_get_keyboard_mapping (xcb_connection_t *c,
+                          xcb_keycode_t     first_keycode,
+                          uint8_t           count)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_KEYBOARD_MAPPING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_keyboard_mapping_cookie_t xcb_ret;
+    xcb_get_keyboard_mapping_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.first_keycode = first_keycode;
+    xcb_out.count = count;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_keyboard_mapping_cookie_t
+xcb_get_keyboard_mapping_unchecked (xcb_connection_t *c,
+                                    xcb_keycode_t     first_keycode,
+                                    uint8_t           count)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_KEYBOARD_MAPPING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_keyboard_mapping_cookie_t xcb_ret;
+    xcb_get_keyboard_mapping_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.first_keycode = first_keycode;
+    xcb_out.count = count;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_keysym_t *
+xcb_get_keyboard_mapping_keysyms (const xcb_get_keyboard_mapping_reply_t *R)
+{
+    return (xcb_keysym_t *) (R + 1);
+}
+
+int
+xcb_get_keyboard_mapping_keysyms_length (const xcb_get_keyboard_mapping_reply_t *R)
+{
+    return R->length;
+}
+
+xcb_generic_iterator_t
+xcb_get_keyboard_mapping_keysyms_end (const xcb_get_keyboard_mapping_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_keysym_t *) (R + 1)) + (R->length);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_get_keyboard_mapping_reply_t *
+xcb_get_keyboard_mapping_reply (xcb_connection_t                   *c,
+                                xcb_get_keyboard_mapping_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e)
+{
+    return (xcb_get_keyboard_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_change_keyboard_control_value_list_serialize (void                                           **_buffer,
+                                                  uint32_t                                         value_mask,
+                                                  const xcb_change_keyboard_control_value_list_t  *_aux)
+{
+    char *xcb_out = *_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+    unsigned int xcb_pad = 0;
+    char xcb_pad0[3] = {0, 0, 0};
+    struct iovec xcb_parts[9];
+    unsigned int xcb_parts_idx = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int i;
+    char *xcb_tmp;
+
+    if(value_mask & XCB_KB_KEY_CLICK_PERCENT) {
+        /* xcb_change_keyboard_control_value_list_t.key_click_percent */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key_click_percent;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_KB_BELL_PERCENT) {
+        /* xcb_change_keyboard_control_value_list_t.bell_percent */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell_percent;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_KB_BELL_PITCH) {
+        /* xcb_change_keyboard_control_value_list_t.bell_pitch */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell_pitch;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_KB_BELL_DURATION) {
+        /* xcb_change_keyboard_control_value_list_t.bell_duration */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bell_duration;
+        xcb_block_len += sizeof(int32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(int32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_KB_LED) {
+        /* xcb_change_keyboard_control_value_list_t.led */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_KB_LED_MODE) {
+        /* xcb_change_keyboard_control_value_list_t.led_mode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->led_mode;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_KB_KEY) {
+        /* xcb_change_keyboard_control_value_list_t.key */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->key;
+        xcb_block_len += sizeof(xcb_keycode32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_keycode32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(xcb_keycode32_t);
+    }
+    if(value_mask & XCB_KB_AUTO_REPEAT_MODE) {
+        /* xcb_change_keyboard_control_value_list_t.auto_repeat_mode */
+        xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->auto_repeat_mode;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t);
+        xcb_parts_idx++;
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;
+        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;
+        xcb_parts_idx++;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    if (NULL == xcb_out) {
+        /* allocate memory */
+        xcb_out = malloc(xcb_buffer_len);
+        *_buffer = xcb_out;
+    }
+
+    xcb_tmp = xcb_out;
+    for(i=0; i<xcb_parts_idx; i++) {
+        if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len)
+            memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len);
+        if (0 != xcb_parts[i].iov_len)
+            xcb_tmp += xcb_parts[i].iov_len;
+    }
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_change_keyboard_control_value_list_unpack (const void                                *_buffer,
+                                               uint32_t                                   value_mask,
+                                               xcb_change_keyboard_control_value_list_t  *_aux)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+    unsigned int xcb_padding_offset = 0;
+
+
+    if(value_mask & XCB_KB_KEY_CLICK_PERCENT) {
+        /* xcb_change_keyboard_control_value_list_t.key_click_percent */
+        _aux->key_click_percent = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_KB_BELL_PERCENT) {
+        /* xcb_change_keyboard_control_value_list_t.bell_percent */
+        _aux->bell_percent = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_KB_BELL_PITCH) {
+        /* xcb_change_keyboard_control_value_list_t.bell_pitch */
+        _aux->bell_pitch = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_KB_BELL_DURATION) {
+        /* xcb_change_keyboard_control_value_list_t.bell_duration */
+        _aux->bell_duration = *(int32_t *)xcb_tmp;
+        xcb_block_len += sizeof(int32_t);
+        xcb_tmp += sizeof(int32_t);
+        xcb_align_to = ALIGNOF(int32_t);
+    }
+    if(value_mask & XCB_KB_LED) {
+        /* xcb_change_keyboard_control_value_list_t.led */
+        _aux->led = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_KB_LED_MODE) {
+        /* xcb_change_keyboard_control_value_list_t.led_mode */
+        _aux->led_mode = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    if(value_mask & XCB_KB_KEY) {
+        /* xcb_change_keyboard_control_value_list_t.key */
+        _aux->key = *(xcb_keycode32_t *)xcb_tmp;
+        xcb_block_len += sizeof(xcb_keycode32_t);
+        xcb_tmp += sizeof(xcb_keycode32_t);
+        xcb_align_to = ALIGNOF(xcb_keycode32_t);
+    }
+    if(value_mask & XCB_KB_AUTO_REPEAT_MODE) {
+        /* xcb_change_keyboard_control_value_list_t.auto_repeat_mode */
+        _aux->auto_repeat_mode = *(uint32_t *)xcb_tmp;
+        xcb_block_len += sizeof(uint32_t);
+        xcb_tmp += sizeof(uint32_t);
+        xcb_align_to = ALIGNOF(uint32_t);
+    }
+    /* insert padding */
+    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    xcb_padding_offset = 0;
+
+    return xcb_buffer_len;
+}
+
+int
+xcb_change_keyboard_control_value_list_sizeof (const void  *_buffer,
+                                               uint32_t     value_mask)
+{
+    xcb_change_keyboard_control_value_list_t _aux;
+    return xcb_change_keyboard_control_value_list_unpack(_buffer, value_mask, &_aux);
+}
+
+int
+xcb_change_keyboard_control_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_change_keyboard_control_request_t *_aux = (xcb_change_keyboard_control_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_change_keyboard_control_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* value_list */
+    xcb_block_len += xcb_change_keyboard_control_value_list_sizeof(xcb_tmp, _aux->value_mask);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_change_keyboard_control_checked (xcb_connection_t *c,
+                                     uint32_t          value_mask,
+                                     const void       *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CHANGE_KEYBOARD_CONTROL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_keyboard_control_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_change_keyboard_control_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_change_keyboard_control_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_change_keyboard_control (xcb_connection_t *c,
+                             uint32_t          value_mask,
+                             const void       *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CHANGE_KEYBOARD_CONTROL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_keyboard_control_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_change_keyboard_control_value_list_t value_list */
+    xcb_parts[4].iov_base = (char *) value_list;
+    xcb_parts[4].iov_len =
+      xcb_change_keyboard_control_value_list_sizeof (value_list, value_mask);
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_change_keyboard_control_aux_checked (xcb_connection_t                               *c,
+                                         uint32_t                                        value_mask,
+                                         const xcb_change_keyboard_control_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CHANGE_KEYBOARD_CONTROL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_keyboard_control_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.pad0 = 0;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_change_keyboard_control_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_change_keyboard_control_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_change_keyboard_control_aux (xcb_connection_t                               *c,
+                                 uint32_t                                        value_mask,
+                                 const xcb_change_keyboard_control_value_list_t *value_list)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 3,
+        .ext = 0,
+        .opcode = XCB_CHANGE_KEYBOARD_CONTROL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[5];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_keyboard_control_request_t xcb_out;
+    void *xcb_aux0 = 0;
+
+    xcb_out.pad0 = 0;
+    xcb_out.value_mask = value_mask;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_change_keyboard_control_value_list_t value_list */
+    xcb_parts[4].iov_len =
+      xcb_change_keyboard_control_value_list_serialize (&xcb_aux0, value_mask, value_list);
+    xcb_parts[4].iov_base = xcb_aux0;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    free(xcb_aux0);
+    return xcb_ret;
+}
+
+void *
+xcb_change_keyboard_control_value_list (const xcb_change_keyboard_control_request_t *R)
+{
+    return (void *) (R + 1);
+}
+
+xcb_get_keyboard_control_cookie_t
+xcb_get_keyboard_control (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_KEYBOARD_CONTROL,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_keyboard_control_cookie_t xcb_ret;
+    xcb_get_keyboard_control_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_keyboard_control_cookie_t
+xcb_get_keyboard_control_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_KEYBOARD_CONTROL,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_keyboard_control_cookie_t xcb_ret;
+    xcb_get_keyboard_control_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_keyboard_control_reply_t *
+xcb_get_keyboard_control_reply (xcb_connection_t                   *c,
+                                xcb_get_keyboard_control_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e)
+{
+    return (xcb_get_keyboard_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_bell_checked (xcb_connection_t *c,
+                  int8_t            percent)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_BELL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_bell_request_t xcb_out;
+
+    xcb_out.percent = percent;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_bell (xcb_connection_t *c,
+          int8_t            percent)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_BELL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_bell_request_t xcb_out;
+
+    xcb_out.percent = percent;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_change_pointer_control_checked (xcb_connection_t *c,
+                                    int16_t           acceleration_numerator,
+                                    int16_t           acceleration_denominator,
+                                    int16_t           threshold,
+                                    uint8_t           do_acceleration,
+                                    uint8_t           do_threshold)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CHANGE_POINTER_CONTROL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_pointer_control_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.acceleration_numerator = acceleration_numerator;
+    xcb_out.acceleration_denominator = acceleration_denominator;
+    xcb_out.threshold = threshold;
+    xcb_out.do_acceleration = do_acceleration;
+    xcb_out.do_threshold = do_threshold;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_change_pointer_control (xcb_connection_t *c,
+                            int16_t           acceleration_numerator,
+                            int16_t           acceleration_denominator,
+                            int16_t           threshold,
+                            uint8_t           do_acceleration,
+                            uint8_t           do_threshold)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_CHANGE_POINTER_CONTROL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_pointer_control_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.acceleration_numerator = acceleration_numerator;
+    xcb_out.acceleration_denominator = acceleration_denominator;
+    xcb_out.threshold = threshold;
+    xcb_out.do_acceleration = do_acceleration;
+    xcb_out.do_threshold = do_threshold;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_pointer_control_cookie_t
+xcb_get_pointer_control (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_POINTER_CONTROL,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_pointer_control_cookie_t xcb_ret;
+    xcb_get_pointer_control_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_pointer_control_cookie_t
+xcb_get_pointer_control_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_POINTER_CONTROL,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_pointer_control_cookie_t xcb_ret;
+    xcb_get_pointer_control_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_pointer_control_reply_t *
+xcb_get_pointer_control_reply (xcb_connection_t                  *c,
+                               xcb_get_pointer_control_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_get_pointer_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_set_screen_saver_checked (xcb_connection_t *c,
+                              int16_t           timeout,
+                              int16_t           interval,
+                              uint8_t           prefer_blanking,
+                              uint8_t           allow_exposures)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_SET_SCREEN_SAVER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_set_screen_saver_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.timeout = timeout;
+    xcb_out.interval = interval;
+    xcb_out.prefer_blanking = prefer_blanking;
+    xcb_out.allow_exposures = allow_exposures;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_set_screen_saver (xcb_connection_t *c,
+                      int16_t           timeout,
+                      int16_t           interval,
+                      uint8_t           prefer_blanking,
+                      uint8_t           allow_exposures)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_SET_SCREEN_SAVER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_set_screen_saver_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.timeout = timeout;
+    xcb_out.interval = interval;
+    xcb_out.prefer_blanking = prefer_blanking;
+    xcb_out.allow_exposures = allow_exposures;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_screen_saver_cookie_t
+xcb_get_screen_saver (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_SCREEN_SAVER,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_screen_saver_cookie_t xcb_ret;
+    xcb_get_screen_saver_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_screen_saver_cookie_t
+xcb_get_screen_saver_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_SCREEN_SAVER,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_screen_saver_cookie_t xcb_ret;
+    xcb_get_screen_saver_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_screen_saver_reply_t *
+xcb_get_screen_saver_reply (xcb_connection_t               *c,
+                            xcb_get_screen_saver_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e)
+{
+    return (xcb_get_screen_saver_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_change_hosts_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_change_hosts_request_t *_aux = (xcb_change_hosts_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_change_hosts_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* address */
+    xcb_block_len += _aux->address_len * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_change_hosts_checked (xcb_connection_t *c,
+                          uint8_t           mode,
+                          uint8_t           family,
+                          uint16_t          address_len,
+                          const uint8_t    *address)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_CHANGE_HOSTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_hosts_request_t xcb_out;
+
+    xcb_out.mode = mode;
+    xcb_out.family = family;
+    xcb_out.pad0 = 0;
+    xcb_out.address_len = address_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t address */
+    xcb_parts[4].iov_base = (char *) address;
+    xcb_parts[4].iov_len = address_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_change_hosts (xcb_connection_t *c,
+                  uint8_t           mode,
+                  uint8_t           family,
+                  uint16_t          address_len,
+                  const uint8_t    *address)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_CHANGE_HOSTS,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_change_hosts_request_t xcb_out;
+
+    xcb_out.mode = mode;
+    xcb_out.family = family;
+    xcb_out.pad0 = 0;
+    xcb_out.address_len = address_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t address */
+    xcb_parts[4].iov_base = (char *) address;
+    xcb_parts[4].iov_len = address_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_change_hosts_address (const xcb_change_hosts_request_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_change_hosts_address_length (const xcb_change_hosts_request_t *R)
+{
+    return R->address_len;
+}
+
+xcb_generic_iterator_t
+xcb_change_hosts_address_end (const xcb_change_hosts_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + (R->address_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_host_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_host_t *_aux = (xcb_host_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_host_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* address */
+    xcb_block_len += _aux->address_len * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+uint8_t *
+xcb_host_address (const xcb_host_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_host_address_length (const xcb_host_t *R)
+{
+    return R->address_len;
+}
+
+xcb_generic_iterator_t
+xcb_host_address_end (const xcb_host_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + (R->address_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_host_next (xcb_host_iterator_t *i)
+{
+    xcb_host_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_host_t *)(((char *)R) + xcb_host_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_host_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_host_end (xcb_host_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_host_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_list_hosts_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_list_hosts_reply_t *_aux = (xcb_list_hosts_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_list_hosts_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* hosts */
+    for(i=0; i<_aux->hosts_len; i++) {
+        xcb_tmp_len = xcb_host_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_host_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_list_hosts_cookie_t
+xcb_list_hosts (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_LIST_HOSTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_list_hosts_cookie_t xcb_ret;
+    xcb_list_hosts_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_list_hosts_cookie_t
+xcb_list_hosts_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_LIST_HOSTS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_list_hosts_cookie_t xcb_ret;
+    xcb_list_hosts_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_list_hosts_hosts_length (const xcb_list_hosts_reply_t *R)
+{
+    return R->hosts_len;
+}
+
+xcb_host_iterator_t
+xcb_list_hosts_hosts_iterator (const xcb_list_hosts_reply_t *R)
+{
+    xcb_host_iterator_t i;
+    i.data = (xcb_host_t *) (R + 1);
+    i.rem = R->hosts_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_list_hosts_reply_t *
+xcb_list_hosts_reply (xcb_connection_t         *c,
+                      xcb_list_hosts_cookie_t   cookie  /**< */,
+                      xcb_generic_error_t     **e)
+{
+    return (xcb_list_hosts_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_set_access_control_checked (xcb_connection_t *c,
+                                uint8_t           mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_SET_ACCESS_CONTROL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_set_access_control_request_t xcb_out;
+
+    xcb_out.mode = mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_set_access_control (xcb_connection_t *c,
+                        uint8_t           mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_SET_ACCESS_CONTROL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_set_access_control_request_t xcb_out;
+
+    xcb_out.mode = mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_set_close_down_mode_checked (xcb_connection_t *c,
+                                 uint8_t           mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_SET_CLOSE_DOWN_MODE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_set_close_down_mode_request_t xcb_out;
+
+    xcb_out.mode = mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_set_close_down_mode (xcb_connection_t *c,
+                         uint8_t           mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_SET_CLOSE_DOWN_MODE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_set_close_down_mode_request_t xcb_out;
+
+    xcb_out.mode = mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_kill_client_checked (xcb_connection_t *c,
+                         uint32_t          resource)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_KILL_CLIENT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_kill_client_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.resource = resource;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_kill_client (xcb_connection_t *c,
+                 uint32_t          resource)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_KILL_CLIENT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_kill_client_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.resource = resource;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_rotate_properties_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_rotate_properties_request_t *_aux = (xcb_rotate_properties_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_rotate_properties_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* atoms */
+    xcb_block_len += _aux->atoms_len * sizeof(xcb_atom_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_atom_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_rotate_properties_checked (xcb_connection_t *c,
+                               xcb_window_t      window,
+                               uint16_t          atoms_len,
+                               int16_t           delta,
+                               const xcb_atom_t *atoms)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_ROTATE_PROPERTIES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_rotate_properties_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+    xcb_out.atoms_len = atoms_len;
+    xcb_out.delta = delta;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_atom_t atoms */
+    xcb_parts[4].iov_base = (char *) atoms;
+    xcb_parts[4].iov_len = atoms_len * sizeof(xcb_atom_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_rotate_properties (xcb_connection_t *c,
+                       xcb_window_t      window,
+                       uint16_t          atoms_len,
+                       int16_t           delta,
+                       const xcb_atom_t *atoms)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_ROTATE_PROPERTIES,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_rotate_properties_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.window = window;
+    xcb_out.atoms_len = atoms_len;
+    xcb_out.delta = delta;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_atom_t atoms */
+    xcb_parts[4].iov_base = (char *) atoms;
+    xcb_parts[4].iov_len = atoms_len * sizeof(xcb_atom_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_atom_t *
+xcb_rotate_properties_atoms (const xcb_rotate_properties_request_t *R)
+{
+    return (xcb_atom_t *) (R + 1);
+}
+
+int
+xcb_rotate_properties_atoms_length (const xcb_rotate_properties_request_t *R)
+{
+    return R->atoms_len;
+}
+
+xcb_generic_iterator_t
+xcb_rotate_properties_atoms_end (const xcb_rotate_properties_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_atom_t *) (R + 1)) + (R->atoms_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_force_screen_saver_checked (xcb_connection_t *c,
+                                uint8_t           mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_FORCE_SCREEN_SAVER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_force_screen_saver_request_t xcb_out;
+
+    xcb_out.mode = mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_force_screen_saver (xcb_connection_t *c,
+                        uint8_t           mode)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_FORCE_SCREEN_SAVER,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_force_screen_saver_request_t xcb_out;
+
+    xcb_out.mode = mode;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_set_pointer_mapping_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_set_pointer_mapping_request_t *_aux = (xcb_set_pointer_mapping_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_set_pointer_mapping_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* map */
+    xcb_block_len += _aux->map_len * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_set_pointer_mapping_cookie_t
+xcb_set_pointer_mapping (xcb_connection_t *c,
+                         uint8_t           map_len,
+                         const uint8_t    *map)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_SET_POINTER_MAPPING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_set_pointer_mapping_cookie_t xcb_ret;
+    xcb_set_pointer_mapping_request_t xcb_out;
+
+    xcb_out.map_len = map_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t map */
+    xcb_parts[4].iov_base = (char *) map;
+    xcb_parts[4].iov_len = map_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_set_pointer_mapping_cookie_t
+xcb_set_pointer_mapping_unchecked (xcb_connection_t *c,
+                                   uint8_t           map_len,
+                                   const uint8_t    *map)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_SET_POINTER_MAPPING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_set_pointer_mapping_cookie_t xcb_ret;
+    xcb_set_pointer_mapping_request_t xcb_out;
+
+    xcb_out.map_len = map_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t map */
+    xcb_parts[4].iov_base = (char *) map;
+    xcb_parts[4].iov_len = map_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_set_pointer_mapping_reply_t *
+xcb_set_pointer_mapping_reply (xcb_connection_t                  *c,
+                               xcb_set_pointer_mapping_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_set_pointer_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_get_pointer_mapping_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_get_pointer_mapping_reply_t *_aux = (xcb_get_pointer_mapping_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_get_pointer_mapping_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* map */
+    xcb_block_len += _aux->map_len * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_get_pointer_mapping_cookie_t
+xcb_get_pointer_mapping (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_POINTER_MAPPING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_pointer_mapping_cookie_t xcb_ret;
+    xcb_get_pointer_mapping_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_pointer_mapping_cookie_t
+xcb_get_pointer_mapping_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_POINTER_MAPPING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_pointer_mapping_cookie_t xcb_ret;
+    xcb_get_pointer_mapping_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_get_pointer_mapping_map (const xcb_get_pointer_mapping_reply_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_get_pointer_mapping_map_length (const xcb_get_pointer_mapping_reply_t *R)
+{
+    return R->map_len;
+}
+
+xcb_generic_iterator_t
+xcb_get_pointer_mapping_map_end (const xcb_get_pointer_mapping_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + (R->map_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_get_pointer_mapping_reply_t *
+xcb_get_pointer_mapping_reply (xcb_connection_t                  *c,
+                               xcb_get_pointer_mapping_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_get_pointer_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_set_modifier_mapping_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_set_modifier_mapping_request_t *_aux = (xcb_set_modifier_mapping_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_set_modifier_mapping_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* keycodes */
+    xcb_block_len += (_aux->keycodes_per_modifier * 8) * sizeof(xcb_keycode_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_keycode_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_set_modifier_mapping_cookie_t
+xcb_set_modifier_mapping (xcb_connection_t    *c,
+                          uint8_t              keycodes_per_modifier,
+                          const xcb_keycode_t *keycodes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_SET_MODIFIER_MAPPING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_set_modifier_mapping_cookie_t xcb_ret;
+    xcb_set_modifier_mapping_request_t xcb_out;
+
+    xcb_out.keycodes_per_modifier = keycodes_per_modifier;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_keycode_t keycodes */
+    xcb_parts[4].iov_base = (char *) keycodes;
+    xcb_parts[4].iov_len = (keycodes_per_modifier * 8) * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_set_modifier_mapping_cookie_t
+xcb_set_modifier_mapping_unchecked (xcb_connection_t    *c,
+                                    uint8_t              keycodes_per_modifier,
+                                    const xcb_keycode_t *keycodes)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = 0,
+        .opcode = XCB_SET_MODIFIER_MAPPING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_set_modifier_mapping_cookie_t xcb_ret;
+    xcb_set_modifier_mapping_request_t xcb_out;
+
+    xcb_out.keycodes_per_modifier = keycodes_per_modifier;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* xcb_keycode_t keycodes */
+    xcb_parts[4].iov_base = (char *) keycodes;
+    xcb_parts[4].iov_len = (keycodes_per_modifier * 8) * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_set_modifier_mapping_reply_t *
+xcb_set_modifier_mapping_reply (xcb_connection_t                   *c,
+                                xcb_set_modifier_mapping_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e)
+{
+    return (xcb_set_modifier_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_get_modifier_mapping_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_get_modifier_mapping_reply_t *_aux = (xcb_get_modifier_mapping_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_get_modifier_mapping_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* keycodes */
+    xcb_block_len += (_aux->keycodes_per_modifier * 8) * sizeof(xcb_keycode_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_keycode_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_get_modifier_mapping_cookie_t
+xcb_get_modifier_mapping (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_MODIFIER_MAPPING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_modifier_mapping_cookie_t xcb_ret;
+    xcb_get_modifier_mapping_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_get_modifier_mapping_cookie_t
+xcb_get_modifier_mapping_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_GET_MODIFIER_MAPPING,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_get_modifier_mapping_cookie_t xcb_ret;
+    xcb_get_modifier_mapping_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_keycode_t *
+xcb_get_modifier_mapping_keycodes (const xcb_get_modifier_mapping_reply_t *R)
+{
+    return (xcb_keycode_t *) (R + 1);
+}
+
+int
+xcb_get_modifier_mapping_keycodes_length (const xcb_get_modifier_mapping_reply_t *R)
+{
+    return (R->keycodes_per_modifier * 8);
+}
+
+xcb_generic_iterator_t
+xcb_get_modifier_mapping_keycodes_end (const xcb_get_modifier_mapping_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((xcb_keycode_t *) (R + 1)) + ((R->keycodes_per_modifier * 8));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_get_modifier_mapping_reply_t *
+xcb_get_modifier_mapping_reply (xcb_connection_t                   *c,
+                                xcb_get_modifier_mapping_cookie_t   cookie  /**< */,
+                                xcb_generic_error_t               **e)
+{
+    return (xcb_get_modifier_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_no_operation_checked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_NO_OPERATION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_no_operation_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_no_operation (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = 0,
+        .opcode = XCB_NO_OPERATION,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_no_operation_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
diff --git a/depends/libxcb/src/xselinux.c b/depends/libxcb/src/xselinux.c
new file mode 100644
index 0000000..539dd61
--- /dev/null
+++ b/depends/libxcb/src/xselinux.c
@@ -0,0 +1,2710 @@
+/*
+ * This file generated automatically from xselinux.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "xselinux.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xproto.h"
+
+xcb_extension_t xcb_selinux_id = { "SELinux", 0 };
+
+xcb_selinux_query_version_cookie_t
+xcb_selinux_query_version (xcb_connection_t *c,
+                           uint8_t           client_major,
+                           uint8_t           client_minor)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_query_version_cookie_t xcb_ret;
+    xcb_selinux_query_version_request_t xcb_out;
+
+    xcb_out.client_major = client_major;
+    xcb_out.client_minor = client_minor;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_selinux_query_version_cookie_t
+xcb_selinux_query_version_unchecked (xcb_connection_t *c,
+                                     uint8_t           client_major,
+                                     uint8_t           client_minor)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_query_version_cookie_t xcb_ret;
+    xcb_selinux_query_version_request_t xcb_out;
+
+    xcb_out.client_major = client_major;
+    xcb_out.client_minor = client_minor;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_selinux_query_version_reply_t *
+xcb_selinux_query_version_reply (xcb_connection_t                    *c,
+                                 xcb_selinux_query_version_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e)
+{
+    return (xcb_selinux_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_selinux_set_device_create_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_set_device_create_context_request_t *_aux = (xcb_selinux_set_device_create_context_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_set_device_create_context_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* context */
+    xcb_block_len += _aux->context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_selinux_set_device_create_context_checked (xcb_connection_t *c,
+                                               uint32_t          context_len,
+                                               const char       *context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_SET_DEVICE_CREATE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_selinux_set_device_create_context_request_t xcb_out;
+
+    xcb_out.context_len = context_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char context */
+    xcb_parts[4].iov_base = (char *) context;
+    xcb_parts[4].iov_len = context_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_selinux_set_device_create_context (xcb_connection_t *c,
+                                       uint32_t          context_len,
+                                       const char       *context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_SET_DEVICE_CREATE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_selinux_set_device_create_context_request_t xcb_out;
+
+    xcb_out.context_len = context_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char context */
+    xcb_parts[4].iov_base = (char *) context;
+    xcb_parts[4].iov_len = context_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_selinux_set_device_create_context_context (const xcb_selinux_set_device_create_context_request_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_set_device_create_context_context_length (const xcb_selinux_set_device_create_context_request_t *R)
+{
+    return R->context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_set_device_create_context_context_end (const xcb_selinux_set_device_create_context_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_selinux_get_device_create_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_get_device_create_context_reply_t *_aux = (xcb_selinux_get_device_create_context_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_get_device_create_context_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* context */
+    xcb_block_len += _aux->context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_selinux_get_device_create_context_cookie_t
+xcb_selinux_get_device_create_context (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_DEVICE_CREATE_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_device_create_context_cookie_t xcb_ret;
+    xcb_selinux_get_device_create_context_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_selinux_get_device_create_context_cookie_t
+xcb_selinux_get_device_create_context_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_DEVICE_CREATE_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_device_create_context_cookie_t xcb_ret;
+    xcb_selinux_get_device_create_context_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_selinux_get_device_create_context_context (const xcb_selinux_get_device_create_context_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_get_device_create_context_context_length (const xcb_selinux_get_device_create_context_reply_t *R)
+{
+    return R->context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_get_device_create_context_context_end (const xcb_selinux_get_device_create_context_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_selinux_get_device_create_context_reply_t *
+xcb_selinux_get_device_create_context_reply (xcb_connection_t                                *c,
+                                             xcb_selinux_get_device_create_context_cookie_t   cookie  /**< */,
+                                             xcb_generic_error_t                            **e)
+{
+    return (xcb_selinux_get_device_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_selinux_set_device_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_set_device_context_request_t *_aux = (xcb_selinux_set_device_context_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_set_device_context_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* context */
+    xcb_block_len += _aux->context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_selinux_set_device_context_checked (xcb_connection_t *c,
+                                        uint32_t          device,
+                                        uint32_t          context_len,
+                                        const char       *context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_SET_DEVICE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_selinux_set_device_context_request_t xcb_out;
+
+    xcb_out.device = device;
+    xcb_out.context_len = context_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char context */
+    xcb_parts[4].iov_base = (char *) context;
+    xcb_parts[4].iov_len = context_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_selinux_set_device_context (xcb_connection_t *c,
+                                uint32_t          device,
+                                uint32_t          context_len,
+                                const char       *context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_SET_DEVICE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_selinux_set_device_context_request_t xcb_out;
+
+    xcb_out.device = device;
+    xcb_out.context_len = context_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char context */
+    xcb_parts[4].iov_base = (char *) context;
+    xcb_parts[4].iov_len = context_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_selinux_set_device_context_context (const xcb_selinux_set_device_context_request_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_set_device_context_context_length (const xcb_selinux_set_device_context_request_t *R)
+{
+    return R->context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_set_device_context_context_end (const xcb_selinux_set_device_context_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_selinux_get_device_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_get_device_context_reply_t *_aux = (xcb_selinux_get_device_context_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_get_device_context_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* context */
+    xcb_block_len += _aux->context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_selinux_get_device_context_cookie_t
+xcb_selinux_get_device_context (xcb_connection_t *c,
+                                uint32_t          device)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_DEVICE_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_device_context_cookie_t xcb_ret;
+    xcb_selinux_get_device_context_request_t xcb_out;
+
+    xcb_out.device = device;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_selinux_get_device_context_cookie_t
+xcb_selinux_get_device_context_unchecked (xcb_connection_t *c,
+                                          uint32_t          device)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_DEVICE_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_device_context_cookie_t xcb_ret;
+    xcb_selinux_get_device_context_request_t xcb_out;
+
+    xcb_out.device = device;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_selinux_get_device_context_context (const xcb_selinux_get_device_context_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_get_device_context_context_length (const xcb_selinux_get_device_context_reply_t *R)
+{
+    return R->context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_get_device_context_context_end (const xcb_selinux_get_device_context_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_selinux_get_device_context_reply_t *
+xcb_selinux_get_device_context_reply (xcb_connection_t                         *c,
+                                      xcb_selinux_get_device_context_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e)
+{
+    return (xcb_selinux_get_device_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_selinux_set_window_create_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_set_window_create_context_request_t *_aux = (xcb_selinux_set_window_create_context_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_set_window_create_context_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* context */
+    xcb_block_len += _aux->context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_selinux_set_window_create_context_checked (xcb_connection_t *c,
+                                               uint32_t          context_len,
+                                               const char       *context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_SET_WINDOW_CREATE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_selinux_set_window_create_context_request_t xcb_out;
+
+    xcb_out.context_len = context_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char context */
+    xcb_parts[4].iov_base = (char *) context;
+    xcb_parts[4].iov_len = context_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_selinux_set_window_create_context (xcb_connection_t *c,
+                                       uint32_t          context_len,
+                                       const char       *context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_SET_WINDOW_CREATE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_selinux_set_window_create_context_request_t xcb_out;
+
+    xcb_out.context_len = context_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char context */
+    xcb_parts[4].iov_base = (char *) context;
+    xcb_parts[4].iov_len = context_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_selinux_set_window_create_context_context (const xcb_selinux_set_window_create_context_request_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_set_window_create_context_context_length (const xcb_selinux_set_window_create_context_request_t *R)
+{
+    return R->context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_set_window_create_context_context_end (const xcb_selinux_set_window_create_context_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_selinux_get_window_create_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_get_window_create_context_reply_t *_aux = (xcb_selinux_get_window_create_context_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_get_window_create_context_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* context */
+    xcb_block_len += _aux->context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_selinux_get_window_create_context_cookie_t
+xcb_selinux_get_window_create_context (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_WINDOW_CREATE_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_window_create_context_cookie_t xcb_ret;
+    xcb_selinux_get_window_create_context_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_selinux_get_window_create_context_cookie_t
+xcb_selinux_get_window_create_context_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_WINDOW_CREATE_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_window_create_context_cookie_t xcb_ret;
+    xcb_selinux_get_window_create_context_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_selinux_get_window_create_context_context (const xcb_selinux_get_window_create_context_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_get_window_create_context_context_length (const xcb_selinux_get_window_create_context_reply_t *R)
+{
+    return R->context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_get_window_create_context_context_end (const xcb_selinux_get_window_create_context_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_selinux_get_window_create_context_reply_t *
+xcb_selinux_get_window_create_context_reply (xcb_connection_t                                *c,
+                                             xcb_selinux_get_window_create_context_cookie_t   cookie  /**< */,
+                                             xcb_generic_error_t                            **e)
+{
+    return (xcb_selinux_get_window_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_selinux_get_window_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_get_window_context_reply_t *_aux = (xcb_selinux_get_window_context_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_get_window_context_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* context */
+    xcb_block_len += _aux->context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_selinux_get_window_context_cookie_t
+xcb_selinux_get_window_context (xcb_connection_t *c,
+                                xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_WINDOW_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_window_context_cookie_t xcb_ret;
+    xcb_selinux_get_window_context_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_selinux_get_window_context_cookie_t
+xcb_selinux_get_window_context_unchecked (xcb_connection_t *c,
+                                          xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_WINDOW_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_window_context_cookie_t xcb_ret;
+    xcb_selinux_get_window_context_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_selinux_get_window_context_context (const xcb_selinux_get_window_context_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_get_window_context_context_length (const xcb_selinux_get_window_context_reply_t *R)
+{
+    return R->context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_get_window_context_context_end (const xcb_selinux_get_window_context_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_selinux_get_window_context_reply_t *
+xcb_selinux_get_window_context_reply (xcb_connection_t                         *c,
+                                      xcb_selinux_get_window_context_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e)
+{
+    return (xcb_selinux_get_window_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_selinux_list_item_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_list_item_t *_aux = (xcb_selinux_list_item_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_list_item_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* object_context */
+    xcb_block_len += _aux->object_context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* data_context */
+    xcb_block_len += _aux->data_context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+char *
+xcb_selinux_list_item_object_context (const xcb_selinux_list_item_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_list_item_object_context_length (const xcb_selinux_list_item_t *R)
+{
+    return R->object_context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_list_item_object_context_end (const xcb_selinux_list_item_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->object_context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+char *
+xcb_selinux_list_item_data_context (const xcb_selinux_list_item_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_selinux_list_item_object_context_end(R);
+    return (char *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0);
+}
+
+int
+xcb_selinux_list_item_data_context_length (const xcb_selinux_list_item_t *R)
+{
+    return R->data_context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_list_item_data_context_end (const xcb_selinux_list_item_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_selinux_list_item_object_context_end(R);
+    i.data = ((char *) ((char*) prev.data + ((-prev.index) & (4 - 1)))) + (R->data_context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_selinux_list_item_next (xcb_selinux_list_item_iterator_t *i)
+{
+    xcb_selinux_list_item_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_selinux_list_item_t *)(((char *)R) + xcb_selinux_list_item_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_selinux_list_item_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_list_item_end (xcb_selinux_list_item_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_selinux_list_item_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_selinux_set_property_create_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_set_property_create_context_request_t *_aux = (xcb_selinux_set_property_create_context_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_set_property_create_context_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* context */
+    xcb_block_len += _aux->context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_selinux_set_property_create_context_checked (xcb_connection_t *c,
+                                                 uint32_t          context_len,
+                                                 const char       *context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_SET_PROPERTY_CREATE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_selinux_set_property_create_context_request_t xcb_out;
+
+    xcb_out.context_len = context_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char context */
+    xcb_parts[4].iov_base = (char *) context;
+    xcb_parts[4].iov_len = context_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_selinux_set_property_create_context (xcb_connection_t *c,
+                                         uint32_t          context_len,
+                                         const char       *context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_SET_PROPERTY_CREATE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_selinux_set_property_create_context_request_t xcb_out;
+
+    xcb_out.context_len = context_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char context */
+    xcb_parts[4].iov_base = (char *) context;
+    xcb_parts[4].iov_len = context_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_selinux_set_property_create_context_context (const xcb_selinux_set_property_create_context_request_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_set_property_create_context_context_length (const xcb_selinux_set_property_create_context_request_t *R)
+{
+    return R->context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_set_property_create_context_context_end (const xcb_selinux_set_property_create_context_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_selinux_get_property_create_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_get_property_create_context_reply_t *_aux = (xcb_selinux_get_property_create_context_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_get_property_create_context_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* context */
+    xcb_block_len += _aux->context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_selinux_get_property_create_context_cookie_t
+xcb_selinux_get_property_create_context (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_PROPERTY_CREATE_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_property_create_context_cookie_t xcb_ret;
+    xcb_selinux_get_property_create_context_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_selinux_get_property_create_context_cookie_t
+xcb_selinux_get_property_create_context_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_PROPERTY_CREATE_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_property_create_context_cookie_t xcb_ret;
+    xcb_selinux_get_property_create_context_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_selinux_get_property_create_context_context (const xcb_selinux_get_property_create_context_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_get_property_create_context_context_length (const xcb_selinux_get_property_create_context_reply_t *R)
+{
+    return R->context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_get_property_create_context_context_end (const xcb_selinux_get_property_create_context_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_selinux_get_property_create_context_reply_t *
+xcb_selinux_get_property_create_context_reply (xcb_connection_t                                  *c,
+                                               xcb_selinux_get_property_create_context_cookie_t   cookie  /**< */,
+                                               xcb_generic_error_t                              **e)
+{
+    return (xcb_selinux_get_property_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_selinux_set_property_use_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_set_property_use_context_request_t *_aux = (xcb_selinux_set_property_use_context_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_set_property_use_context_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* context */
+    xcb_block_len += _aux->context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_selinux_set_property_use_context_checked (xcb_connection_t *c,
+                                              uint32_t          context_len,
+                                              const char       *context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_SET_PROPERTY_USE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_selinux_set_property_use_context_request_t xcb_out;
+
+    xcb_out.context_len = context_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char context */
+    xcb_parts[4].iov_base = (char *) context;
+    xcb_parts[4].iov_len = context_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_selinux_set_property_use_context (xcb_connection_t *c,
+                                      uint32_t          context_len,
+                                      const char       *context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_SET_PROPERTY_USE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_selinux_set_property_use_context_request_t xcb_out;
+
+    xcb_out.context_len = context_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char context */
+    xcb_parts[4].iov_base = (char *) context;
+    xcb_parts[4].iov_len = context_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_selinux_set_property_use_context_context (const xcb_selinux_set_property_use_context_request_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_set_property_use_context_context_length (const xcb_selinux_set_property_use_context_request_t *R)
+{
+    return R->context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_set_property_use_context_context_end (const xcb_selinux_set_property_use_context_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_selinux_get_property_use_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_get_property_use_context_reply_t *_aux = (xcb_selinux_get_property_use_context_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_get_property_use_context_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* context */
+    xcb_block_len += _aux->context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_selinux_get_property_use_context_cookie_t
+xcb_selinux_get_property_use_context (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_PROPERTY_USE_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_property_use_context_cookie_t xcb_ret;
+    xcb_selinux_get_property_use_context_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_selinux_get_property_use_context_cookie_t
+xcb_selinux_get_property_use_context_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_PROPERTY_USE_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_property_use_context_cookie_t xcb_ret;
+    xcb_selinux_get_property_use_context_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_selinux_get_property_use_context_context (const xcb_selinux_get_property_use_context_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_get_property_use_context_context_length (const xcb_selinux_get_property_use_context_reply_t *R)
+{
+    return R->context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_get_property_use_context_context_end (const xcb_selinux_get_property_use_context_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_selinux_get_property_use_context_reply_t *
+xcb_selinux_get_property_use_context_reply (xcb_connection_t                               *c,
+                                            xcb_selinux_get_property_use_context_cookie_t   cookie  /**< */,
+                                            xcb_generic_error_t                           **e)
+{
+    return (xcb_selinux_get_property_use_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_selinux_get_property_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_get_property_context_reply_t *_aux = (xcb_selinux_get_property_context_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_get_property_context_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* context */
+    xcb_block_len += _aux->context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_selinux_get_property_context_cookie_t
+xcb_selinux_get_property_context (xcb_connection_t *c,
+                                  xcb_window_t      window,
+                                  xcb_atom_t        property)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_PROPERTY_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_property_context_cookie_t xcb_ret;
+    xcb_selinux_get_property_context_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.property = property;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_selinux_get_property_context_cookie_t
+xcb_selinux_get_property_context_unchecked (xcb_connection_t *c,
+                                            xcb_window_t      window,
+                                            xcb_atom_t        property)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_PROPERTY_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_property_context_cookie_t xcb_ret;
+    xcb_selinux_get_property_context_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.property = property;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_selinux_get_property_context_context (const xcb_selinux_get_property_context_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_get_property_context_context_length (const xcb_selinux_get_property_context_reply_t *R)
+{
+    return R->context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_get_property_context_context_end (const xcb_selinux_get_property_context_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_selinux_get_property_context_reply_t *
+xcb_selinux_get_property_context_reply (xcb_connection_t                           *c,
+                                        xcb_selinux_get_property_context_cookie_t   cookie  /**< */,
+                                        xcb_generic_error_t                       **e)
+{
+    return (xcb_selinux_get_property_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_selinux_get_property_data_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_get_property_data_context_reply_t *_aux = (xcb_selinux_get_property_data_context_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_get_property_data_context_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* context */
+    xcb_block_len += _aux->context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_selinux_get_property_data_context_cookie_t
+xcb_selinux_get_property_data_context (xcb_connection_t *c,
+                                       xcb_window_t      window,
+                                       xcb_atom_t        property)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_PROPERTY_DATA_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_property_data_context_cookie_t xcb_ret;
+    xcb_selinux_get_property_data_context_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.property = property;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_selinux_get_property_data_context_cookie_t
+xcb_selinux_get_property_data_context_unchecked (xcb_connection_t *c,
+                                                 xcb_window_t      window,
+                                                 xcb_atom_t        property)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_PROPERTY_DATA_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_property_data_context_cookie_t xcb_ret;
+    xcb_selinux_get_property_data_context_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.property = property;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_selinux_get_property_data_context_context (const xcb_selinux_get_property_data_context_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_get_property_data_context_context_length (const xcb_selinux_get_property_data_context_reply_t *R)
+{
+    return R->context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_get_property_data_context_context_end (const xcb_selinux_get_property_data_context_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_selinux_get_property_data_context_reply_t *
+xcb_selinux_get_property_data_context_reply (xcb_connection_t                                *c,
+                                             xcb_selinux_get_property_data_context_cookie_t   cookie  /**< */,
+                                             xcb_generic_error_t                            **e)
+{
+    return (xcb_selinux_get_property_data_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_selinux_list_properties_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_list_properties_reply_t *_aux = (xcb_selinux_list_properties_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_selinux_list_properties_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* properties */
+    for(i=0; i<_aux->properties_len; i++) {
+        xcb_tmp_len = xcb_selinux_list_item_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_selinux_list_item_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_selinux_list_properties_cookie_t
+xcb_selinux_list_properties (xcb_connection_t *c,
+                             xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_LIST_PROPERTIES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_list_properties_cookie_t xcb_ret;
+    xcb_selinux_list_properties_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_selinux_list_properties_cookie_t
+xcb_selinux_list_properties_unchecked (xcb_connection_t *c,
+                                       xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_LIST_PROPERTIES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_list_properties_cookie_t xcb_ret;
+    xcb_selinux_list_properties_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_selinux_list_properties_properties_length (const xcb_selinux_list_properties_reply_t *R)
+{
+    return R->properties_len;
+}
+
+xcb_selinux_list_item_iterator_t
+xcb_selinux_list_properties_properties_iterator (const xcb_selinux_list_properties_reply_t *R)
+{
+    xcb_selinux_list_item_iterator_t i;
+    i.data = (xcb_selinux_list_item_t *) (R + 1);
+    i.rem = R->properties_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_selinux_list_properties_reply_t *
+xcb_selinux_list_properties_reply (xcb_connection_t                      *c,
+                                   xcb_selinux_list_properties_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e)
+{
+    return (xcb_selinux_list_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_selinux_set_selection_create_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_set_selection_create_context_request_t *_aux = (xcb_selinux_set_selection_create_context_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_set_selection_create_context_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* context */
+    xcb_block_len += _aux->context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_selinux_set_selection_create_context_checked (xcb_connection_t *c,
+                                                  uint32_t          context_len,
+                                                  const char       *context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_SET_SELECTION_CREATE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_selinux_set_selection_create_context_request_t xcb_out;
+
+    xcb_out.context_len = context_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char context */
+    xcb_parts[4].iov_base = (char *) context;
+    xcb_parts[4].iov_len = context_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_selinux_set_selection_create_context (xcb_connection_t *c,
+                                          uint32_t          context_len,
+                                          const char       *context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_SET_SELECTION_CREATE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_selinux_set_selection_create_context_request_t xcb_out;
+
+    xcb_out.context_len = context_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char context */
+    xcb_parts[4].iov_base = (char *) context;
+    xcb_parts[4].iov_len = context_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_selinux_set_selection_create_context_context (const xcb_selinux_set_selection_create_context_request_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_set_selection_create_context_context_length (const xcb_selinux_set_selection_create_context_request_t *R)
+{
+    return R->context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_set_selection_create_context_context_end (const xcb_selinux_set_selection_create_context_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_selinux_get_selection_create_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_get_selection_create_context_reply_t *_aux = (xcb_selinux_get_selection_create_context_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_get_selection_create_context_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* context */
+    xcb_block_len += _aux->context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_selinux_get_selection_create_context_cookie_t
+xcb_selinux_get_selection_create_context (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_SELECTION_CREATE_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_selection_create_context_cookie_t xcb_ret;
+    xcb_selinux_get_selection_create_context_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_selinux_get_selection_create_context_cookie_t
+xcb_selinux_get_selection_create_context_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_SELECTION_CREATE_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_selection_create_context_cookie_t xcb_ret;
+    xcb_selinux_get_selection_create_context_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_selinux_get_selection_create_context_context (const xcb_selinux_get_selection_create_context_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_get_selection_create_context_context_length (const xcb_selinux_get_selection_create_context_reply_t *R)
+{
+    return R->context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_get_selection_create_context_context_end (const xcb_selinux_get_selection_create_context_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_selinux_get_selection_create_context_reply_t *
+xcb_selinux_get_selection_create_context_reply (xcb_connection_t                                   *c,
+                                                xcb_selinux_get_selection_create_context_cookie_t   cookie  /**< */,
+                                                xcb_generic_error_t                               **e)
+{
+    return (xcb_selinux_get_selection_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_selinux_set_selection_use_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_set_selection_use_context_request_t *_aux = (xcb_selinux_set_selection_use_context_request_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_set_selection_use_context_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* context */
+    xcb_block_len += _aux->context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_selinux_set_selection_use_context_checked (xcb_connection_t *c,
+                                               uint32_t          context_len,
+                                               const char       *context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_SET_SELECTION_USE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_selinux_set_selection_use_context_request_t xcb_out;
+
+    xcb_out.context_len = context_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char context */
+    xcb_parts[4].iov_base = (char *) context;
+    xcb_parts[4].iov_len = context_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_selinux_set_selection_use_context (xcb_connection_t *c,
+                                       uint32_t          context_len,
+                                       const char       *context)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_SET_SELECTION_USE_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_selinux_set_selection_use_context_request_t xcb_out;
+
+    xcb_out.context_len = context_len;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* char context */
+    xcb_parts[4].iov_base = (char *) context;
+    xcb_parts[4].iov_len = context_len * sizeof(char);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_selinux_set_selection_use_context_context (const xcb_selinux_set_selection_use_context_request_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_set_selection_use_context_context_length (const xcb_selinux_set_selection_use_context_request_t *R)
+{
+    return R->context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_set_selection_use_context_context_end (const xcb_selinux_set_selection_use_context_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+int
+xcb_selinux_get_selection_use_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_get_selection_use_context_reply_t *_aux = (xcb_selinux_get_selection_use_context_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_get_selection_use_context_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* context */
+    xcb_block_len += _aux->context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_selinux_get_selection_use_context_cookie_t
+xcb_selinux_get_selection_use_context (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_SELECTION_USE_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_selection_use_context_cookie_t xcb_ret;
+    xcb_selinux_get_selection_use_context_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_selinux_get_selection_use_context_cookie_t
+xcb_selinux_get_selection_use_context_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_SELECTION_USE_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_selection_use_context_cookie_t xcb_ret;
+    xcb_selinux_get_selection_use_context_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_selinux_get_selection_use_context_context (const xcb_selinux_get_selection_use_context_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_get_selection_use_context_context_length (const xcb_selinux_get_selection_use_context_reply_t *R)
+{
+    return R->context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_get_selection_use_context_context_end (const xcb_selinux_get_selection_use_context_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_selinux_get_selection_use_context_reply_t *
+xcb_selinux_get_selection_use_context_reply (xcb_connection_t                                *c,
+                                             xcb_selinux_get_selection_use_context_cookie_t   cookie  /**< */,
+                                             xcb_generic_error_t                            **e)
+{
+    return (xcb_selinux_get_selection_use_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_selinux_get_selection_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_get_selection_context_reply_t *_aux = (xcb_selinux_get_selection_context_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_get_selection_context_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* context */
+    xcb_block_len += _aux->context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_selinux_get_selection_context_cookie_t
+xcb_selinux_get_selection_context (xcb_connection_t *c,
+                                   xcb_atom_t        selection)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_SELECTION_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_selection_context_cookie_t xcb_ret;
+    xcb_selinux_get_selection_context_request_t xcb_out;
+
+    xcb_out.selection = selection;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_selinux_get_selection_context_cookie_t
+xcb_selinux_get_selection_context_unchecked (xcb_connection_t *c,
+                                             xcb_atom_t        selection)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_SELECTION_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_selection_context_cookie_t xcb_ret;
+    xcb_selinux_get_selection_context_request_t xcb_out;
+
+    xcb_out.selection = selection;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_selinux_get_selection_context_context (const xcb_selinux_get_selection_context_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_get_selection_context_context_length (const xcb_selinux_get_selection_context_reply_t *R)
+{
+    return R->context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_get_selection_context_context_end (const xcb_selinux_get_selection_context_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_selinux_get_selection_context_reply_t *
+xcb_selinux_get_selection_context_reply (xcb_connection_t                            *c,
+                                         xcb_selinux_get_selection_context_cookie_t   cookie  /**< */,
+                                         xcb_generic_error_t                        **e)
+{
+    return (xcb_selinux_get_selection_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_selinux_get_selection_data_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_get_selection_data_context_reply_t *_aux = (xcb_selinux_get_selection_data_context_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_get_selection_data_context_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* context */
+    xcb_block_len += _aux->context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_selinux_get_selection_data_context_cookie_t
+xcb_selinux_get_selection_data_context (xcb_connection_t *c,
+                                        xcb_atom_t        selection)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_SELECTION_DATA_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_selection_data_context_cookie_t xcb_ret;
+    xcb_selinux_get_selection_data_context_request_t xcb_out;
+
+    xcb_out.selection = selection;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_selinux_get_selection_data_context_cookie_t
+xcb_selinux_get_selection_data_context_unchecked (xcb_connection_t *c,
+                                                  xcb_atom_t        selection)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_SELECTION_DATA_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_selection_data_context_cookie_t xcb_ret;
+    xcb_selinux_get_selection_data_context_request_t xcb_out;
+
+    xcb_out.selection = selection;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_selinux_get_selection_data_context_context (const xcb_selinux_get_selection_data_context_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_get_selection_data_context_context_length (const xcb_selinux_get_selection_data_context_reply_t *R)
+{
+    return R->context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_get_selection_data_context_context_end (const xcb_selinux_get_selection_data_context_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_selinux_get_selection_data_context_reply_t *
+xcb_selinux_get_selection_data_context_reply (xcb_connection_t                                 *c,
+                                              xcb_selinux_get_selection_data_context_cookie_t   cookie  /**< */,
+                                              xcb_generic_error_t                             **e)
+{
+    return (xcb_selinux_get_selection_data_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_selinux_list_selections_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_list_selections_reply_t *_aux = (xcb_selinux_list_selections_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_selinux_list_selections_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* selections */
+    for(i=0; i<_aux->selections_len; i++) {
+        xcb_tmp_len = xcb_selinux_list_item_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_selinux_list_item_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_selinux_list_selections_cookie_t
+xcb_selinux_list_selections (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_LIST_SELECTIONS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_list_selections_cookie_t xcb_ret;
+    xcb_selinux_list_selections_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_selinux_list_selections_cookie_t
+xcb_selinux_list_selections_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_LIST_SELECTIONS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_list_selections_cookie_t xcb_ret;
+    xcb_selinux_list_selections_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_selinux_list_selections_selections_length (const xcb_selinux_list_selections_reply_t *R)
+{
+    return R->selections_len;
+}
+
+xcb_selinux_list_item_iterator_t
+xcb_selinux_list_selections_selections_iterator (const xcb_selinux_list_selections_reply_t *R)
+{
+    xcb_selinux_list_item_iterator_t i;
+    i.data = (xcb_selinux_list_item_t *) (R + 1);
+    i.rem = R->selections_len;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_selinux_list_selections_reply_t *
+xcb_selinux_list_selections_reply (xcb_connection_t                      *c,
+                                   xcb_selinux_list_selections_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e)
+{
+    return (xcb_selinux_list_selections_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_selinux_get_client_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_selinux_get_client_context_reply_t *_aux = (xcb_selinux_get_client_context_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_selinux_get_client_context_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* context */
+    xcb_block_len += _aux->context_len * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_selinux_get_client_context_cookie_t
+xcb_selinux_get_client_context (xcb_connection_t *c,
+                                uint32_t          resource)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_CLIENT_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_client_context_cookie_t xcb_ret;
+    xcb_selinux_get_client_context_request_t xcb_out;
+
+    xcb_out.resource = resource;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_selinux_get_client_context_cookie_t
+xcb_selinux_get_client_context_unchecked (xcb_connection_t *c,
+                                          uint32_t          resource)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_selinux_id,
+        .opcode = XCB_SELINUX_GET_CLIENT_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_selinux_get_client_context_cookie_t xcb_ret;
+    xcb_selinux_get_client_context_request_t xcb_out;
+
+    xcb_out.resource = resource;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+char *
+xcb_selinux_get_client_context_context (const xcb_selinux_get_client_context_reply_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_selinux_get_client_context_context_length (const xcb_selinux_get_client_context_reply_t *R)
+{
+    return R->context_len;
+}
+
+xcb_generic_iterator_t
+xcb_selinux_get_client_context_context_end (const xcb_selinux_get_client_context_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->context_len);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_selinux_get_client_context_reply_t *
+xcb_selinux_get_client_context_reply (xcb_connection_t                         *c,
+                                      xcb_selinux_get_client_context_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e)
+{
+    return (xcb_selinux_get_client_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
diff --git a/depends/libxcb/src/xtest.c b/depends/libxcb/src/xtest.c
new file mode 100644
index 0000000..1dd5ff6
--- /dev/null
+++ b/depends/libxcb/src/xtest.c
@@ -0,0 +1,286 @@
+/*
+ * This file generated automatically from xtest.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "xtest.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xproto.h"
+
+xcb_extension_t xcb_test_id = { "XTEST", 0 };
+
+xcb_test_get_version_cookie_t
+xcb_test_get_version (xcb_connection_t *c,
+                      uint8_t           major_version,
+                      uint16_t          minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_test_id,
+        .opcode = XCB_TEST_GET_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_test_get_version_cookie_t xcb_ret;
+    xcb_test_get_version_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.pad0 = 0;
+    xcb_out.minor_version = minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_test_get_version_cookie_t
+xcb_test_get_version_unchecked (xcb_connection_t *c,
+                                uint8_t           major_version,
+                                uint16_t          minor_version)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_test_id,
+        .opcode = XCB_TEST_GET_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_test_get_version_cookie_t xcb_ret;
+    xcb_test_get_version_request_t xcb_out;
+
+    xcb_out.major_version = major_version;
+    xcb_out.pad0 = 0;
+    xcb_out.minor_version = minor_version;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_test_get_version_reply_t *
+xcb_test_get_version_reply (xcb_connection_t               *c,
+                            xcb_test_get_version_cookie_t   cookie  /**< */,
+                            xcb_generic_error_t           **e)
+{
+    return (xcb_test_get_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_test_compare_cursor_cookie_t
+xcb_test_compare_cursor (xcb_connection_t *c,
+                         xcb_window_t      window,
+                         xcb_cursor_t      cursor)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_test_id,
+        .opcode = XCB_TEST_COMPARE_CURSOR,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_test_compare_cursor_cookie_t xcb_ret;
+    xcb_test_compare_cursor_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.cursor = cursor;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_test_compare_cursor_cookie_t
+xcb_test_compare_cursor_unchecked (xcb_connection_t *c,
+                                   xcb_window_t      window,
+                                   xcb_cursor_t      cursor)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_test_id,
+        .opcode = XCB_TEST_COMPARE_CURSOR,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_test_compare_cursor_cookie_t xcb_ret;
+    xcb_test_compare_cursor_request_t xcb_out;
+
+    xcb_out.window = window;
+    xcb_out.cursor = cursor;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_test_compare_cursor_reply_t *
+xcb_test_compare_cursor_reply (xcb_connection_t                  *c,
+                               xcb_test_compare_cursor_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_test_compare_cursor_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_test_fake_input_checked (xcb_connection_t *c,
+                             uint8_t           type,
+                             uint8_t           detail,
+                             uint32_t          time,
+                             xcb_window_t      root,
+                             int16_t           rootX,
+                             int16_t           rootY,
+                             uint8_t           deviceid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_test_id,
+        .opcode = XCB_TEST_FAKE_INPUT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_test_fake_input_request_t xcb_out;
+
+    xcb_out.type = type;
+    xcb_out.detail = detail;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.time = time;
+    xcb_out.root = root;
+    memset(xcb_out.pad1, 0, 8);
+    xcb_out.rootX = rootX;
+    xcb_out.rootY = rootY;
+    memset(xcb_out.pad2, 0, 7);
+    xcb_out.deviceid = deviceid;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_test_fake_input (xcb_connection_t *c,
+                     uint8_t           type,
+                     uint8_t           detail,
+                     uint32_t          time,
+                     xcb_window_t      root,
+                     int16_t           rootX,
+                     int16_t           rootY,
+                     uint8_t           deviceid)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_test_id,
+        .opcode = XCB_TEST_FAKE_INPUT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_test_fake_input_request_t xcb_out;
+
+    xcb_out.type = type;
+    xcb_out.detail = detail;
+    memset(xcb_out.pad0, 0, 2);
+    xcb_out.time = time;
+    xcb_out.root = root;
+    memset(xcb_out.pad1, 0, 8);
+    xcb_out.rootX = rootX;
+    xcb_out.rootY = rootY;
+    memset(xcb_out.pad2, 0, 7);
+    xcb_out.deviceid = deviceid;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_test_grab_control_checked (xcb_connection_t *c,
+                               uint8_t           impervious)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_test_id,
+        .opcode = XCB_TEST_GRAB_CONTROL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_test_grab_control_request_t xcb_out;
+
+    xcb_out.impervious = impervious;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_test_grab_control (xcb_connection_t *c,
+                       uint8_t           impervious)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_test_id,
+        .opcode = XCB_TEST_GRAB_CONTROL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_test_grab_control_request_t xcb_out;
+
+    xcb_out.impervious = impervious;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
diff --git a/depends/libxcb/src/xv.c b/depends/libxcb/src/xv.c
new file mode 100644
index 0000000..8213803
--- /dev/null
+++ b/depends/libxcb/src/xv.c
@@ -0,0 +1,2371 @@
+/*
+ * This file generated automatically from xv.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "xv.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xproto.h"
+#include "shm.h"
+
+xcb_extension_t xcb_xv_id = { "XVideo", 0 };
+
+void
+xcb_xv_port_next (xcb_xv_port_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xv_port_t);
+}
+
+xcb_generic_iterator_t
+xcb_xv_port_end (xcb_xv_port_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xv_encoding_next (xcb_xv_encoding_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xv_encoding_t);
+}
+
+xcb_generic_iterator_t
+xcb_xv_encoding_end (xcb_xv_encoding_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xv_rational_next (xcb_xv_rational_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xv_rational_t);
+}
+
+xcb_generic_iterator_t
+xcb_xv_rational_end (xcb_xv_rational_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xv_format_next (xcb_xv_format_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xv_format_t);
+}
+
+xcb_generic_iterator_t
+xcb_xv_format_end (xcb_xv_format_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+int
+xcb_xv_adaptor_info_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xv_adaptor_info_t *_aux = (xcb_xv_adaptor_info_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xv_adaptor_info_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->name_size * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* formats */
+    xcb_block_len += _aux->num_formats * sizeof(xcb_xv_format_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xv_format_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+char *
+xcb_xv_adaptor_info_name (const xcb_xv_adaptor_info_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_xv_adaptor_info_name_length (const xcb_xv_adaptor_info_t *R)
+{
+    return R->name_size;
+}
+
+xcb_generic_iterator_t
+xcb_xv_adaptor_info_name_end (const xcb_xv_adaptor_info_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->name_size);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xv_format_t *
+xcb_xv_adaptor_info_formats (const xcb_xv_adaptor_info_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_xv_adaptor_info_name_end(R);
+    return (xcb_xv_format_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)) + 0);
+}
+
+int
+xcb_xv_adaptor_info_formats_length (const xcb_xv_adaptor_info_t *R)
+{
+    return R->num_formats;
+}
+
+xcb_xv_format_iterator_t
+xcb_xv_adaptor_info_formats_iterator (const xcb_xv_adaptor_info_t *R)
+{
+    xcb_xv_format_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_xv_adaptor_info_name_end(R);
+    i.data = (xcb_xv_format_t *) ((char *) prev.data + ((-prev.index) & (4 - 1)));
+    i.rem = R->num_formats;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_xv_adaptor_info_next (xcb_xv_adaptor_info_iterator_t *i)
+{
+    xcb_xv_adaptor_info_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_xv_adaptor_info_t *)(((char *)R) + xcb_xv_adaptor_info_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_xv_adaptor_info_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_xv_adaptor_info_end (xcb_xv_adaptor_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_xv_adaptor_info_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_xv_encoding_info_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xv_encoding_info_t *_aux = (xcb_xv_encoding_info_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xv_encoding_info_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->name_size * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+char *
+xcb_xv_encoding_info_name (const xcb_xv_encoding_info_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_xv_encoding_info_name_length (const xcb_xv_encoding_info_t *R)
+{
+    return R->name_size;
+}
+
+xcb_generic_iterator_t
+xcb_xv_encoding_info_name_end (const xcb_xv_encoding_info_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->name_size);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_xv_encoding_info_next (xcb_xv_encoding_info_iterator_t *i)
+{
+    xcb_xv_encoding_info_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_xv_encoding_info_t *)(((char *)R) + xcb_xv_encoding_info_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_xv_encoding_info_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_xv_encoding_info_end (xcb_xv_encoding_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_xv_encoding_info_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_xv_image_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xv_image_t *_aux = (xcb_xv_image_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xv_image_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* pitches */
+    xcb_block_len += _aux->num_planes * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* offsets */
+    xcb_block_len += _aux->num_planes * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += _aux->data_size * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+uint32_t *
+xcb_xv_image_pitches (const xcb_xv_image_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_xv_image_pitches_length (const xcb_xv_image_t *R)
+{
+    return R->num_planes;
+}
+
+xcb_generic_iterator_t
+xcb_xv_image_pitches_end (const xcb_xv_image_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->num_planes);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint32_t *
+xcb_xv_image_offsets (const xcb_xv_image_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_xv_image_pitches_end(R);
+    return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0);
+}
+
+int
+xcb_xv_image_offsets_length (const xcb_xv_image_t *R)
+{
+    return R->num_planes;
+}
+
+xcb_generic_iterator_t
+xcb_xv_image_offsets_end (const xcb_xv_image_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_xv_image_pitches_end(R);
+    i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->num_planes);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint8_t *
+xcb_xv_image_data (const xcb_xv_image_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_xv_image_offsets_end(R);
+    return (uint8_t *) ((char *) prev.data + XCB_TYPE_PAD(uint8_t, prev.index) + 0);
+}
+
+int
+xcb_xv_image_data_length (const xcb_xv_image_t *R)
+{
+    return R->data_size;
+}
+
+xcb_generic_iterator_t
+xcb_xv_image_data_end (const xcb_xv_image_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_xv_image_offsets_end(R);
+    i.data = ((uint8_t *) ((char*) prev.data + XCB_TYPE_PAD(uint8_t, prev.index))) + (R->data_size);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_xv_image_next (xcb_xv_image_iterator_t *i)
+{
+    xcb_xv_image_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_xv_image_t *)(((char *)R) + xcb_xv_image_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_xv_image_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_xv_image_end (xcb_xv_image_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_xv_image_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+int
+xcb_xv_attribute_info_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xv_attribute_info_t *_aux = (xcb_xv_attribute_info_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xv_attribute_info_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* name */
+    xcb_block_len += _aux->size * sizeof(char);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(char);
+    xcb_align_to = 4;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+char *
+xcb_xv_attribute_info_name (const xcb_xv_attribute_info_t *R)
+{
+    return (char *) (R + 1);
+}
+
+int
+xcb_xv_attribute_info_name_length (const xcb_xv_attribute_info_t *R)
+{
+    return R->size;
+}
+
+xcb_generic_iterator_t
+xcb_xv_attribute_info_name_end (const xcb_xv_attribute_info_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((char *) (R + 1)) + (R->size);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+void
+xcb_xv_attribute_info_next (xcb_xv_attribute_info_iterator_t *i)
+{
+    xcb_xv_attribute_info_t *R = i->data;
+    xcb_generic_iterator_t child;
+    child.data = (xcb_xv_attribute_info_t *)(((char *)R) + xcb_xv_attribute_info_sizeof(R));
+    i->index = (char *) child.data - (char *) i->data;
+    --i->rem;
+    i->data = (xcb_xv_attribute_info_t *) child.data;
+}
+
+xcb_generic_iterator_t
+xcb_xv_attribute_info_end (xcb_xv_attribute_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    while(i.rem > 0)
+        xcb_xv_attribute_info_next(&i);
+    ret.data = i.data;
+    ret.rem = i.rem;
+    ret.index = i.index;
+    return ret;
+}
+
+void
+xcb_xv_image_format_info_next (xcb_xv_image_format_info_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xv_image_format_info_t);
+}
+
+xcb_generic_iterator_t
+xcb_xv_image_format_info_end (xcb_xv_image_format_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+xcb_xv_query_extension_cookie_t
+xcb_xv_query_extension (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_QUERY_EXTENSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xv_query_extension_cookie_t xcb_ret;
+    xcb_xv_query_extension_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xv_query_extension_cookie_t
+xcb_xv_query_extension_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_QUERY_EXTENSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xv_query_extension_cookie_t xcb_ret;
+    xcb_xv_query_extension_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xv_query_extension_reply_t *
+xcb_xv_query_extension_reply (xcb_connection_t                 *c,
+                              xcb_xv_query_extension_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_xv_query_extension_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xv_query_adaptors_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xv_query_adaptors_reply_t *_aux = (xcb_xv_query_adaptors_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_xv_query_adaptors_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* info */
+    for(i=0; i<_aux->num_adaptors; i++) {
+        xcb_tmp_len = xcb_xv_adaptor_info_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_xv_adaptor_info_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xv_query_adaptors_cookie_t
+xcb_xv_query_adaptors (xcb_connection_t *c,
+                       xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_QUERY_ADAPTORS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xv_query_adaptors_cookie_t xcb_ret;
+    xcb_xv_query_adaptors_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xv_query_adaptors_cookie_t
+xcb_xv_query_adaptors_unchecked (xcb_connection_t *c,
+                                 xcb_window_t      window)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_QUERY_ADAPTORS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xv_query_adaptors_cookie_t xcb_ret;
+    xcb_xv_query_adaptors_request_t xcb_out;
+
+    xcb_out.window = window;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_xv_query_adaptors_info_length (const xcb_xv_query_adaptors_reply_t *R)
+{
+    return R->num_adaptors;
+}
+
+xcb_xv_adaptor_info_iterator_t
+xcb_xv_query_adaptors_info_iterator (const xcb_xv_query_adaptors_reply_t *R)
+{
+    xcb_xv_adaptor_info_iterator_t i;
+    i.data = (xcb_xv_adaptor_info_t *) (R + 1);
+    i.rem = R->num_adaptors;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xv_query_adaptors_reply_t *
+xcb_xv_query_adaptors_reply (xcb_connection_t                *c,
+                             xcb_xv_query_adaptors_cookie_t   cookie  /**< */,
+                             xcb_generic_error_t            **e)
+{
+    return (xcb_xv_query_adaptors_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xv_query_encodings_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xv_query_encodings_reply_t *_aux = (xcb_xv_query_encodings_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_xv_query_encodings_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* info */
+    for(i=0; i<_aux->num_encodings; i++) {
+        xcb_tmp_len = xcb_xv_encoding_info_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_xv_encoding_info_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xv_query_encodings_cookie_t
+xcb_xv_query_encodings (xcb_connection_t *c,
+                        xcb_xv_port_t     port)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_QUERY_ENCODINGS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xv_query_encodings_cookie_t xcb_ret;
+    xcb_xv_query_encodings_request_t xcb_out;
+
+    xcb_out.port = port;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xv_query_encodings_cookie_t
+xcb_xv_query_encodings_unchecked (xcb_connection_t *c,
+                                  xcb_xv_port_t     port)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_QUERY_ENCODINGS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xv_query_encodings_cookie_t xcb_ret;
+    xcb_xv_query_encodings_request_t xcb_out;
+
+    xcb_out.port = port;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_xv_query_encodings_info_length (const xcb_xv_query_encodings_reply_t *R)
+{
+    return R->num_encodings;
+}
+
+xcb_xv_encoding_info_iterator_t
+xcb_xv_query_encodings_info_iterator (const xcb_xv_query_encodings_reply_t *R)
+{
+    xcb_xv_encoding_info_iterator_t i;
+    i.data = (xcb_xv_encoding_info_t *) (R + 1);
+    i.rem = R->num_encodings;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xv_query_encodings_reply_t *
+xcb_xv_query_encodings_reply (xcb_connection_t                 *c,
+                              xcb_xv_query_encodings_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_xv_query_encodings_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_xv_grab_port_cookie_t
+xcb_xv_grab_port (xcb_connection_t *c,
+                  xcb_xv_port_t     port,
+                  xcb_timestamp_t   time)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_GRAB_PORT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xv_grab_port_cookie_t xcb_ret;
+    xcb_xv_grab_port_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.time = time;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xv_grab_port_cookie_t
+xcb_xv_grab_port_unchecked (xcb_connection_t *c,
+                            xcb_xv_port_t     port,
+                            xcb_timestamp_t   time)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_GRAB_PORT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xv_grab_port_cookie_t xcb_ret;
+    xcb_xv_grab_port_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.time = time;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xv_grab_port_reply_t *
+xcb_xv_grab_port_reply (xcb_connection_t           *c,
+                        xcb_xv_grab_port_cookie_t   cookie  /**< */,
+                        xcb_generic_error_t       **e)
+{
+    return (xcb_xv_grab_port_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_xv_ungrab_port_checked (xcb_connection_t *c,
+                            xcb_xv_port_t     port,
+                            xcb_timestamp_t   time)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_UNGRAB_PORT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_ungrab_port_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.time = time;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xv_ungrab_port (xcb_connection_t *c,
+                    xcb_xv_port_t     port,
+                    xcb_timestamp_t   time)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_UNGRAB_PORT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_ungrab_port_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.time = time;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xv_put_video_checked (xcb_connection_t *c,
+                          xcb_xv_port_t     port,
+                          xcb_drawable_t    drawable,
+                          xcb_gcontext_t    gc,
+                          int16_t           vid_x,
+                          int16_t           vid_y,
+                          uint16_t          vid_w,
+                          uint16_t          vid_h,
+                          int16_t           drw_x,
+                          int16_t           drw_y,
+                          uint16_t          drw_w,
+                          uint16_t          drw_h)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_PUT_VIDEO,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_put_video_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.vid_x = vid_x;
+    xcb_out.vid_y = vid_y;
+    xcb_out.vid_w = vid_w;
+    xcb_out.vid_h = vid_h;
+    xcb_out.drw_x = drw_x;
+    xcb_out.drw_y = drw_y;
+    xcb_out.drw_w = drw_w;
+    xcb_out.drw_h = drw_h;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xv_put_video (xcb_connection_t *c,
+                  xcb_xv_port_t     port,
+                  xcb_drawable_t    drawable,
+                  xcb_gcontext_t    gc,
+                  int16_t           vid_x,
+                  int16_t           vid_y,
+                  uint16_t          vid_w,
+                  uint16_t          vid_h,
+                  int16_t           drw_x,
+                  int16_t           drw_y,
+                  uint16_t          drw_w,
+                  uint16_t          drw_h)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_PUT_VIDEO,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_put_video_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.vid_x = vid_x;
+    xcb_out.vid_y = vid_y;
+    xcb_out.vid_w = vid_w;
+    xcb_out.vid_h = vid_h;
+    xcb_out.drw_x = drw_x;
+    xcb_out.drw_y = drw_y;
+    xcb_out.drw_w = drw_w;
+    xcb_out.drw_h = drw_h;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xv_put_still_checked (xcb_connection_t *c,
+                          xcb_xv_port_t     port,
+                          xcb_drawable_t    drawable,
+                          xcb_gcontext_t    gc,
+                          int16_t           vid_x,
+                          int16_t           vid_y,
+                          uint16_t          vid_w,
+                          uint16_t          vid_h,
+                          int16_t           drw_x,
+                          int16_t           drw_y,
+                          uint16_t          drw_w,
+                          uint16_t          drw_h)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_PUT_STILL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_put_still_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.vid_x = vid_x;
+    xcb_out.vid_y = vid_y;
+    xcb_out.vid_w = vid_w;
+    xcb_out.vid_h = vid_h;
+    xcb_out.drw_x = drw_x;
+    xcb_out.drw_y = drw_y;
+    xcb_out.drw_w = drw_w;
+    xcb_out.drw_h = drw_h;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xv_put_still (xcb_connection_t *c,
+                  xcb_xv_port_t     port,
+                  xcb_drawable_t    drawable,
+                  xcb_gcontext_t    gc,
+                  int16_t           vid_x,
+                  int16_t           vid_y,
+                  uint16_t          vid_w,
+                  uint16_t          vid_h,
+                  int16_t           drw_x,
+                  int16_t           drw_y,
+                  uint16_t          drw_w,
+                  uint16_t          drw_h)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_PUT_STILL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_put_still_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.vid_x = vid_x;
+    xcb_out.vid_y = vid_y;
+    xcb_out.vid_w = vid_w;
+    xcb_out.vid_h = vid_h;
+    xcb_out.drw_x = drw_x;
+    xcb_out.drw_y = drw_y;
+    xcb_out.drw_w = drw_w;
+    xcb_out.drw_h = drw_h;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xv_get_video_checked (xcb_connection_t *c,
+                          xcb_xv_port_t     port,
+                          xcb_drawable_t    drawable,
+                          xcb_gcontext_t    gc,
+                          int16_t           vid_x,
+                          int16_t           vid_y,
+                          uint16_t          vid_w,
+                          uint16_t          vid_h,
+                          int16_t           drw_x,
+                          int16_t           drw_y,
+                          uint16_t          drw_w,
+                          uint16_t          drw_h)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_GET_VIDEO,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_get_video_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.vid_x = vid_x;
+    xcb_out.vid_y = vid_y;
+    xcb_out.vid_w = vid_w;
+    xcb_out.vid_h = vid_h;
+    xcb_out.drw_x = drw_x;
+    xcb_out.drw_y = drw_y;
+    xcb_out.drw_w = drw_w;
+    xcb_out.drw_h = drw_h;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xv_get_video (xcb_connection_t *c,
+                  xcb_xv_port_t     port,
+                  xcb_drawable_t    drawable,
+                  xcb_gcontext_t    gc,
+                  int16_t           vid_x,
+                  int16_t           vid_y,
+                  uint16_t          vid_w,
+                  uint16_t          vid_h,
+                  int16_t           drw_x,
+                  int16_t           drw_y,
+                  uint16_t          drw_w,
+                  uint16_t          drw_h)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_GET_VIDEO,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_get_video_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.vid_x = vid_x;
+    xcb_out.vid_y = vid_y;
+    xcb_out.vid_w = vid_w;
+    xcb_out.vid_h = vid_h;
+    xcb_out.drw_x = drw_x;
+    xcb_out.drw_y = drw_y;
+    xcb_out.drw_w = drw_w;
+    xcb_out.drw_h = drw_h;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xv_get_still_checked (xcb_connection_t *c,
+                          xcb_xv_port_t     port,
+                          xcb_drawable_t    drawable,
+                          xcb_gcontext_t    gc,
+                          int16_t           vid_x,
+                          int16_t           vid_y,
+                          uint16_t          vid_w,
+                          uint16_t          vid_h,
+                          int16_t           drw_x,
+                          int16_t           drw_y,
+                          uint16_t          drw_w,
+                          uint16_t          drw_h)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_GET_STILL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_get_still_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.vid_x = vid_x;
+    xcb_out.vid_y = vid_y;
+    xcb_out.vid_w = vid_w;
+    xcb_out.vid_h = vid_h;
+    xcb_out.drw_x = drw_x;
+    xcb_out.drw_y = drw_y;
+    xcb_out.drw_w = drw_w;
+    xcb_out.drw_h = drw_h;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xv_get_still (xcb_connection_t *c,
+                  xcb_xv_port_t     port,
+                  xcb_drawable_t    drawable,
+                  xcb_gcontext_t    gc,
+                  int16_t           vid_x,
+                  int16_t           vid_y,
+                  uint16_t          vid_w,
+                  uint16_t          vid_h,
+                  int16_t           drw_x,
+                  int16_t           drw_y,
+                  uint16_t          drw_w,
+                  uint16_t          drw_h)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_GET_STILL,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_get_still_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.vid_x = vid_x;
+    xcb_out.vid_y = vid_y;
+    xcb_out.vid_w = vid_w;
+    xcb_out.vid_h = vid_h;
+    xcb_out.drw_x = drw_x;
+    xcb_out.drw_y = drw_y;
+    xcb_out.drw_w = drw_w;
+    xcb_out.drw_h = drw_h;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xv_stop_video_checked (xcb_connection_t *c,
+                           xcb_xv_port_t     port,
+                           xcb_drawable_t    drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_STOP_VIDEO,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_stop_video_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xv_stop_video (xcb_connection_t *c,
+                   xcb_xv_port_t     port,
+                   xcb_drawable_t    drawable)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_STOP_VIDEO,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_stop_video_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.drawable = drawable;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xv_select_video_notify_checked (xcb_connection_t *c,
+                                    xcb_drawable_t    drawable,
+                                    uint8_t           onoff)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_SELECT_VIDEO_NOTIFY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_select_video_notify_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.onoff = onoff;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xv_select_video_notify (xcb_connection_t *c,
+                            xcb_drawable_t    drawable,
+                            uint8_t           onoff)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_SELECT_VIDEO_NOTIFY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_select_video_notify_request_t xcb_out;
+
+    xcb_out.drawable = drawable;
+    xcb_out.onoff = onoff;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xv_select_port_notify_checked (xcb_connection_t *c,
+                                   xcb_xv_port_t     port,
+                                   uint8_t           onoff)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_SELECT_PORT_NOTIFY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_select_port_notify_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.onoff = onoff;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xv_select_port_notify (xcb_connection_t *c,
+                           xcb_xv_port_t     port,
+                           uint8_t           onoff)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_SELECT_PORT_NOTIFY,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_select_port_notify_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.onoff = onoff;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xv_query_best_size_cookie_t
+xcb_xv_query_best_size (xcb_connection_t *c,
+                        xcb_xv_port_t     port,
+                        uint16_t          vid_w,
+                        uint16_t          vid_h,
+                        uint16_t          drw_w,
+                        uint16_t          drw_h,
+                        uint8_t           motion)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_QUERY_BEST_SIZE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xv_query_best_size_cookie_t xcb_ret;
+    xcb_xv_query_best_size_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.vid_w = vid_w;
+    xcb_out.vid_h = vid_h;
+    xcb_out.drw_w = drw_w;
+    xcb_out.drw_h = drw_h;
+    xcb_out.motion = motion;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xv_query_best_size_cookie_t
+xcb_xv_query_best_size_unchecked (xcb_connection_t *c,
+                                  xcb_xv_port_t     port,
+                                  uint16_t          vid_w,
+                                  uint16_t          vid_h,
+                                  uint16_t          drw_w,
+                                  uint16_t          drw_h,
+                                  uint8_t           motion)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_QUERY_BEST_SIZE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xv_query_best_size_cookie_t xcb_ret;
+    xcb_xv_query_best_size_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.vid_w = vid_w;
+    xcb_out.vid_h = vid_h;
+    xcb_out.drw_w = drw_w;
+    xcb_out.drw_h = drw_h;
+    xcb_out.motion = motion;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xv_query_best_size_reply_t *
+xcb_xv_query_best_size_reply (xcb_connection_t                 *c,
+                              xcb_xv_query_best_size_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_xv_query_best_size_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_xv_set_port_attribute_checked (xcb_connection_t *c,
+                                   xcb_xv_port_t     port,
+                                   xcb_atom_t        attribute,
+                                   int32_t           value)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_SET_PORT_ATTRIBUTE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_set_port_attribute_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.attribute = attribute;
+    xcb_out.value = value;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xv_set_port_attribute (xcb_connection_t *c,
+                           xcb_xv_port_t     port,
+                           xcb_atom_t        attribute,
+                           int32_t           value)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_SET_PORT_ATTRIBUTE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_set_port_attribute_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.attribute = attribute;
+    xcb_out.value = value;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xv_get_port_attribute_cookie_t
+xcb_xv_get_port_attribute (xcb_connection_t *c,
+                           xcb_xv_port_t     port,
+                           xcb_atom_t        attribute)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_GET_PORT_ATTRIBUTE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xv_get_port_attribute_cookie_t xcb_ret;
+    xcb_xv_get_port_attribute_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.attribute = attribute;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xv_get_port_attribute_cookie_t
+xcb_xv_get_port_attribute_unchecked (xcb_connection_t *c,
+                                     xcb_xv_port_t     port,
+                                     xcb_atom_t        attribute)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_GET_PORT_ATTRIBUTE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xv_get_port_attribute_cookie_t xcb_ret;
+    xcb_xv_get_port_attribute_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.attribute = attribute;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xv_get_port_attribute_reply_t *
+xcb_xv_get_port_attribute_reply (xcb_connection_t                    *c,
+                                 xcb_xv_get_port_attribute_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e)
+{
+    return (xcb_xv_get_port_attribute_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xv_query_port_attributes_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xv_query_port_attributes_reply_t *_aux = (xcb_xv_query_port_attributes_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+    unsigned int i;
+    unsigned int xcb_tmp_len;
+
+    xcb_block_len += sizeof(xcb_xv_query_port_attributes_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* attributes */
+    for(i=0; i<_aux->num_attributes; i++) {
+        xcb_tmp_len = xcb_xv_attribute_info_sizeof(xcb_tmp);
+        xcb_block_len += xcb_tmp_len;
+        xcb_tmp += xcb_tmp_len;
+    }
+    xcb_align_to = ALIGNOF(xcb_xv_attribute_info_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xv_query_port_attributes_cookie_t
+xcb_xv_query_port_attributes (xcb_connection_t *c,
+                              xcb_xv_port_t     port)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_QUERY_PORT_ATTRIBUTES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xv_query_port_attributes_cookie_t xcb_ret;
+    xcb_xv_query_port_attributes_request_t xcb_out;
+
+    xcb_out.port = port;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xv_query_port_attributes_cookie_t
+xcb_xv_query_port_attributes_unchecked (xcb_connection_t *c,
+                                        xcb_xv_port_t     port)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_QUERY_PORT_ATTRIBUTES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xv_query_port_attributes_cookie_t xcb_ret;
+    xcb_xv_query_port_attributes_request_t xcb_out;
+
+    xcb_out.port = port;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_xv_query_port_attributes_attributes_length (const xcb_xv_query_port_attributes_reply_t *R)
+{
+    return R->num_attributes;
+}
+
+xcb_xv_attribute_info_iterator_t
+xcb_xv_query_port_attributes_attributes_iterator (const xcb_xv_query_port_attributes_reply_t *R)
+{
+    xcb_xv_attribute_info_iterator_t i;
+    i.data = (xcb_xv_attribute_info_t *) (R + 1);
+    i.rem = R->num_attributes;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xv_query_port_attributes_reply_t *
+xcb_xv_query_port_attributes_reply (xcb_connection_t                       *c,
+                                    xcb_xv_query_port_attributes_cookie_t   cookie  /**< */,
+                                    xcb_generic_error_t                   **e)
+{
+    return (xcb_xv_query_port_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xv_list_image_formats_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xv_list_image_formats_reply_t *_aux = (xcb_xv_list_image_formats_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xv_list_image_formats_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* format */
+    xcb_block_len += _aux->num_formats * sizeof(xcb_xv_image_format_info_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xv_image_format_info_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xv_list_image_formats_cookie_t
+xcb_xv_list_image_formats (xcb_connection_t *c,
+                           xcb_xv_port_t     port)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_LIST_IMAGE_FORMATS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xv_list_image_formats_cookie_t xcb_ret;
+    xcb_xv_list_image_formats_request_t xcb_out;
+
+    xcb_out.port = port;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xv_list_image_formats_cookie_t
+xcb_xv_list_image_formats_unchecked (xcb_connection_t *c,
+                                     xcb_xv_port_t     port)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_LIST_IMAGE_FORMATS,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xv_list_image_formats_cookie_t xcb_ret;
+    xcb_xv_list_image_formats_request_t xcb_out;
+
+    xcb_out.port = port;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xv_image_format_info_t *
+xcb_xv_list_image_formats_format (const xcb_xv_list_image_formats_reply_t *R)
+{
+    return (xcb_xv_image_format_info_t *) (R + 1);
+}
+
+int
+xcb_xv_list_image_formats_format_length (const xcb_xv_list_image_formats_reply_t *R)
+{
+    return R->num_formats;
+}
+
+xcb_xv_image_format_info_iterator_t
+xcb_xv_list_image_formats_format_iterator (const xcb_xv_list_image_formats_reply_t *R)
+{
+    xcb_xv_image_format_info_iterator_t i;
+    i.data = (xcb_xv_image_format_info_t *) (R + 1);
+    i.rem = R->num_formats;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xv_list_image_formats_reply_t *
+xcb_xv_list_image_formats_reply (xcb_connection_t                    *c,
+                                 xcb_xv_list_image_formats_cookie_t   cookie  /**< */,
+                                 xcb_generic_error_t                **e)
+{
+    return (xcb_xv_list_image_formats_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xv_query_image_attributes_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xv_query_image_attributes_reply_t *_aux = (xcb_xv_query_image_attributes_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xv_query_image_attributes_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* pitches */
+    xcb_block_len += _aux->num_planes * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+    /* offsets */
+    xcb_block_len += _aux->num_planes * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xv_query_image_attributes_cookie_t
+xcb_xv_query_image_attributes (xcb_connection_t *c,
+                               xcb_xv_port_t     port,
+                               uint32_t          id,
+                               uint16_t          width,
+                               uint16_t          height)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_QUERY_IMAGE_ATTRIBUTES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xv_query_image_attributes_cookie_t xcb_ret;
+    xcb_xv_query_image_attributes_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.id = id;
+    xcb_out.width = width;
+    xcb_out.height = height;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xv_query_image_attributes_cookie_t
+xcb_xv_query_image_attributes_unchecked (xcb_connection_t *c,
+                                         xcb_xv_port_t     port,
+                                         uint32_t          id,
+                                         uint16_t          width,
+                                         uint16_t          height)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_QUERY_IMAGE_ATTRIBUTES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xv_query_image_attributes_cookie_t xcb_ret;
+    xcb_xv_query_image_attributes_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.id = id;
+    xcb_out.width = width;
+    xcb_out.height = height;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_xv_query_image_attributes_pitches (const xcb_xv_query_image_attributes_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_xv_query_image_attributes_pitches_length (const xcb_xv_query_image_attributes_reply_t *R)
+{
+    return R->num_planes;
+}
+
+xcb_generic_iterator_t
+xcb_xv_query_image_attributes_pitches_end (const xcb_xv_query_image_attributes_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->num_planes);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+uint32_t *
+xcb_xv_query_image_attributes_offsets (const xcb_xv_query_image_attributes_reply_t *R)
+{
+    xcb_generic_iterator_t prev = xcb_xv_query_image_attributes_pitches_end(R);
+    return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0);
+}
+
+int
+xcb_xv_query_image_attributes_offsets_length (const xcb_xv_query_image_attributes_reply_t *R)
+{
+    return R->num_planes;
+}
+
+xcb_generic_iterator_t
+xcb_xv_query_image_attributes_offsets_end (const xcb_xv_query_image_attributes_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    xcb_generic_iterator_t prev = xcb_xv_query_image_attributes_pitches_end(R);
+    i.data = ((uint32_t *) ((char*) prev.data + XCB_TYPE_PAD(uint32_t, prev.index))) + (R->num_planes);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xv_query_image_attributes_reply_t *
+xcb_xv_query_image_attributes_reply (xcb_connection_t                        *c,
+                                     xcb_xv_query_image_attributes_cookie_t   cookie  /**< */,
+                                     xcb_generic_error_t                    **e)
+{
+    return (xcb_xv_query_image_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xv_put_image_sizeof (const void  *_buffer,
+                         uint32_t     data_len)
+{
+    char *xcb_tmp = (char *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xv_put_image_request_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* data */
+    xcb_block_len += data_len * sizeof(uint8_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint8_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_void_cookie_t
+xcb_xv_put_image_checked (xcb_connection_t *c,
+                          xcb_xv_port_t     port,
+                          xcb_drawable_t    drawable,
+                          xcb_gcontext_t    gc,
+                          uint32_t          id,
+                          int16_t           src_x,
+                          int16_t           src_y,
+                          uint16_t          src_w,
+                          uint16_t          src_h,
+                          int16_t           drw_x,
+                          int16_t           drw_y,
+                          uint16_t          drw_w,
+                          uint16_t          drw_h,
+                          uint16_t          width,
+                          uint16_t          height,
+                          uint32_t          data_len,
+                          const uint8_t    *data)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_PUT_IMAGE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_put_image_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.id = id;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+    xcb_out.src_w = src_w;
+    xcb_out.src_h = src_h;
+    xcb_out.drw_x = drw_x;
+    xcb_out.drw_y = drw_y;
+    xcb_out.drw_w = drw_w;
+    xcb_out.drw_h = drw_h;
+    xcb_out.width = width;
+    xcb_out.height = height;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t data */
+    xcb_parts[4].iov_base = (char *) data;
+    xcb_parts[4].iov_len = data_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xv_put_image (xcb_connection_t *c,
+                  xcb_xv_port_t     port,
+                  xcb_drawable_t    drawable,
+                  xcb_gcontext_t    gc,
+                  uint32_t          id,
+                  int16_t           src_x,
+                  int16_t           src_y,
+                  uint16_t          src_w,
+                  uint16_t          src_h,
+                  int16_t           drw_x,
+                  int16_t           drw_y,
+                  uint16_t          drw_w,
+                  uint16_t          drw_h,
+                  uint16_t          width,
+                  uint16_t          height,
+                  uint32_t          data_len,
+                  const uint8_t    *data)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 4,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_PUT_IMAGE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[6];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_put_image_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.id = id;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+    xcb_out.src_w = src_w;
+    xcb_out.src_h = src_h;
+    xcb_out.drw_x = drw_x;
+    xcb_out.drw_y = drw_y;
+    xcb_out.drw_w = drw_w;
+    xcb_out.drw_h = drw_h;
+    xcb_out.width = width;
+    xcb_out.height = height;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+    /* uint8_t data */
+    xcb_parts[4].iov_base = (char *) data;
+    xcb_parts[4].iov_len = data_len * sizeof(uint8_t);
+    xcb_parts[5].iov_base = 0;
+    xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint8_t *
+xcb_xv_put_image_data (const xcb_xv_put_image_request_t *R)
+{
+    return (uint8_t *) (R + 1);
+}
+
+int
+xcb_xv_put_image_data_length (const xcb_xv_put_image_request_t *R)
+{
+    return (((R->length * 4) - sizeof(xcb_xv_put_image_request_t))/sizeof(uint8_t));
+}
+
+xcb_generic_iterator_t
+xcb_xv_put_image_data_end (const xcb_xv_put_image_request_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint8_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_xv_put_image_request_t))/sizeof(uint8_t)));
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_void_cookie_t
+xcb_xv_shm_put_image_checked (xcb_connection_t *c,
+                              xcb_xv_port_t     port,
+                              xcb_drawable_t    drawable,
+                              xcb_gcontext_t    gc,
+                              xcb_shm_seg_t     shmseg,
+                              uint32_t          id,
+                              uint32_t          offset,
+                              int16_t           src_x,
+                              int16_t           src_y,
+                              uint16_t          src_w,
+                              uint16_t          src_h,
+                              int16_t           drw_x,
+                              int16_t           drw_y,
+                              uint16_t          drw_w,
+                              uint16_t          drw_h,
+                              uint16_t          width,
+                              uint16_t          height,
+                              uint8_t           send_event)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_SHM_PUT_IMAGE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_shm_put_image_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.shmseg = shmseg;
+    xcb_out.id = id;
+    xcb_out.offset = offset;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+    xcb_out.src_w = src_w;
+    xcb_out.src_h = src_h;
+    xcb_out.drw_x = drw_x;
+    xcb_out.drw_y = drw_y;
+    xcb_out.drw_w = drw_w;
+    xcb_out.drw_h = drw_h;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.send_event = send_event;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xv_shm_put_image (xcb_connection_t *c,
+                      xcb_xv_port_t     port,
+                      xcb_drawable_t    drawable,
+                      xcb_gcontext_t    gc,
+                      xcb_shm_seg_t     shmseg,
+                      uint32_t          id,
+                      uint32_t          offset,
+                      int16_t           src_x,
+                      int16_t           src_y,
+                      uint16_t          src_w,
+                      uint16_t          src_h,
+                      int16_t           drw_x,
+                      int16_t           drw_y,
+                      uint16_t          drw_w,
+                      uint16_t          drw_h,
+                      uint16_t          width,
+                      uint16_t          height,
+                      uint8_t           send_event)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xv_id,
+        .opcode = XCB_XV_SHM_PUT_IMAGE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xv_shm_put_image_request_t xcb_out;
+
+    xcb_out.port = port;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.shmseg = shmseg;
+    xcb_out.id = id;
+    xcb_out.offset = offset;
+    xcb_out.src_x = src_x;
+    xcb_out.src_y = src_y;
+    xcb_out.src_w = src_w;
+    xcb_out.src_h = src_h;
+    xcb_out.drw_x = drw_x;
+    xcb_out.drw_y = drw_y;
+    xcb_out.drw_w = drw_w;
+    xcb_out.drw_h = drw_h;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.send_event = send_event;
+    memset(xcb_out.pad0, 0, 3);
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
diff --git a/depends/libxcb/src/xvmc.c b/depends/libxcb/src/xvmc.c
new file mode 100644
index 0000000..d0f6923
--- /dev/null
+++ b/depends/libxcb/src/xvmc.c
@@ -0,0 +1,913 @@
+/*
+ * This file generated automatically from xvmc.xml by c_client.py.
+ * Edit at your peril.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stddef.h>  /* for offsetof() */
+#include "xcbext.h"
+#include "xvmc.h"
+
+#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)
+#include "xv.h"
+
+xcb_extension_t xcb_xvmc_id = { "XVideo-MotionCompensation", 0 };
+
+void
+xcb_xvmc_context_next (xcb_xvmc_context_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xvmc_context_t);
+}
+
+xcb_generic_iterator_t
+xcb_xvmc_context_end (xcb_xvmc_context_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xvmc_surface_next (xcb_xvmc_surface_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xvmc_surface_t);
+}
+
+xcb_generic_iterator_t
+xcb_xvmc_surface_end (xcb_xvmc_surface_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xvmc_subpicture_next (xcb_xvmc_subpicture_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xvmc_subpicture_t);
+}
+
+xcb_generic_iterator_t
+xcb_xvmc_subpicture_end (xcb_xvmc_subpicture_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+void
+xcb_xvmc_surface_info_next (xcb_xvmc_surface_info_iterator_t *i)
+{
+    --i->rem;
+    ++i->data;
+    i->index += sizeof(xcb_xvmc_surface_info_t);
+}
+
+xcb_generic_iterator_t
+xcb_xvmc_surface_info_end (xcb_xvmc_surface_info_iterator_t i)
+{
+    xcb_generic_iterator_t ret;
+    ret.data = i.data + i.rem;
+    ret.index = i.index + ((char *) ret.data - (char *) i.data);
+    ret.rem = 0;
+    return ret;
+}
+
+xcb_xvmc_query_version_cookie_t
+xcb_xvmc_query_version (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xvmc_id,
+        .opcode = XCB_XVMC_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xvmc_query_version_cookie_t xcb_ret;
+    xcb_xvmc_query_version_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xvmc_query_version_cookie_t
+xcb_xvmc_query_version_unchecked (xcb_connection_t *c)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xvmc_id,
+        .opcode = XCB_XVMC_QUERY_VERSION,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xvmc_query_version_cookie_t xcb_ret;
+    xcb_xvmc_query_version_request_t xcb_out;
+
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xvmc_query_version_reply_t *
+xcb_xvmc_query_version_reply (xcb_connection_t                 *c,
+                              xcb_xvmc_query_version_cookie_t   cookie  /**< */,
+                              xcb_generic_error_t             **e)
+{
+    return (xcb_xvmc_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xvmc_list_surface_types_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xvmc_list_surface_types_reply_t *_aux = (xcb_xvmc_list_surface_types_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xvmc_list_surface_types_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* surfaces */
+    xcb_block_len += _aux->num * sizeof(xcb_xvmc_surface_info_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xvmc_surface_info_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xvmc_list_surface_types_cookie_t
+xcb_xvmc_list_surface_types (xcb_connection_t *c,
+                             xcb_xv_port_t     port_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xvmc_id,
+        .opcode = XCB_XVMC_LIST_SURFACE_TYPES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xvmc_list_surface_types_cookie_t xcb_ret;
+    xcb_xvmc_list_surface_types_request_t xcb_out;
+
+    xcb_out.port_id = port_id;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xvmc_list_surface_types_cookie_t
+xcb_xvmc_list_surface_types_unchecked (xcb_connection_t *c,
+                                       xcb_xv_port_t     port_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xvmc_id,
+        .opcode = XCB_XVMC_LIST_SURFACE_TYPES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xvmc_list_surface_types_cookie_t xcb_ret;
+    xcb_xvmc_list_surface_types_request_t xcb_out;
+
+    xcb_out.port_id = port_id;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xvmc_surface_info_t *
+xcb_xvmc_list_surface_types_surfaces (const xcb_xvmc_list_surface_types_reply_t *R)
+{
+    return (xcb_xvmc_surface_info_t *) (R + 1);
+}
+
+int
+xcb_xvmc_list_surface_types_surfaces_length (const xcb_xvmc_list_surface_types_reply_t *R)
+{
+    return R->num;
+}
+
+xcb_xvmc_surface_info_iterator_t
+xcb_xvmc_list_surface_types_surfaces_iterator (const xcb_xvmc_list_surface_types_reply_t *R)
+{
+    xcb_xvmc_surface_info_iterator_t i;
+    i.data = (xcb_xvmc_surface_info_t *) (R + 1);
+    i.rem = R->num;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xvmc_list_surface_types_reply_t *
+xcb_xvmc_list_surface_types_reply (xcb_connection_t                      *c,
+                                   xcb_xvmc_list_surface_types_cookie_t   cookie  /**< */,
+                                   xcb_generic_error_t                  **e)
+{
+    return (xcb_xvmc_list_surface_types_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+int
+xcb_xvmc_create_context_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xvmc_create_context_reply_t *_aux = (xcb_xvmc_create_context_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xvmc_create_context_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* priv_data */
+    xcb_block_len += _aux->length * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xvmc_create_context_cookie_t
+xcb_xvmc_create_context (xcb_connection_t   *c,
+                         xcb_xvmc_context_t  context_id,
+                         xcb_xv_port_t       port_id,
+                         xcb_xvmc_surface_t  surface_id,
+                         uint16_t            width,
+                         uint16_t            height,
+                         uint32_t            flags)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xvmc_id,
+        .opcode = XCB_XVMC_CREATE_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xvmc_create_context_cookie_t xcb_ret;
+    xcb_xvmc_create_context_request_t xcb_out;
+
+    xcb_out.context_id = context_id;
+    xcb_out.port_id = port_id;
+    xcb_out.surface_id = surface_id;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.flags = flags;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xvmc_create_context_cookie_t
+xcb_xvmc_create_context_unchecked (xcb_connection_t   *c,
+                                   xcb_xvmc_context_t  context_id,
+                                   xcb_xv_port_t       port_id,
+                                   xcb_xvmc_surface_t  surface_id,
+                                   uint16_t            width,
+                                   uint16_t            height,
+                                   uint32_t            flags)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xvmc_id,
+        .opcode = XCB_XVMC_CREATE_CONTEXT,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xvmc_create_context_cookie_t xcb_ret;
+    xcb_xvmc_create_context_request_t xcb_out;
+
+    xcb_out.context_id = context_id;
+    xcb_out.port_id = port_id;
+    xcb_out.surface_id = surface_id;
+    xcb_out.width = width;
+    xcb_out.height = height;
+    xcb_out.flags = flags;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_xvmc_create_context_priv_data (const xcb_xvmc_create_context_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_xvmc_create_context_priv_data_length (const xcb_xvmc_create_context_reply_t *R)
+{
+    return R->length;
+}
+
+xcb_generic_iterator_t
+xcb_xvmc_create_context_priv_data_end (const xcb_xvmc_create_context_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->length);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xvmc_create_context_reply_t *
+xcb_xvmc_create_context_reply (xcb_connection_t                  *c,
+                               xcb_xvmc_create_context_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_xvmc_create_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_xvmc_destroy_context_checked (xcb_connection_t   *c,
+                                  xcb_xvmc_context_t  context_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xvmc_id,
+        .opcode = XCB_XVMC_DESTROY_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xvmc_destroy_context_request_t xcb_out;
+
+    xcb_out.context_id = context_id;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xvmc_destroy_context (xcb_connection_t   *c,
+                          xcb_xvmc_context_t  context_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xvmc_id,
+        .opcode = XCB_XVMC_DESTROY_CONTEXT,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xvmc_destroy_context_request_t xcb_out;
+
+    xcb_out.context_id = context_id;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_xvmc_create_surface_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xvmc_create_surface_reply_t *_aux = (xcb_xvmc_create_surface_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xvmc_create_surface_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* priv_data */
+    xcb_block_len += _aux->length * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xvmc_create_surface_cookie_t
+xcb_xvmc_create_surface (xcb_connection_t   *c,
+                         xcb_xvmc_surface_t  surface_id,
+                         xcb_xvmc_context_t  context_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xvmc_id,
+        .opcode = XCB_XVMC_CREATE_SURFACE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xvmc_create_surface_cookie_t xcb_ret;
+    xcb_xvmc_create_surface_request_t xcb_out;
+
+    xcb_out.surface_id = surface_id;
+    xcb_out.context_id = context_id;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xvmc_create_surface_cookie_t
+xcb_xvmc_create_surface_unchecked (xcb_connection_t   *c,
+                                   xcb_xvmc_surface_t  surface_id,
+                                   xcb_xvmc_context_t  context_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xvmc_id,
+        .opcode = XCB_XVMC_CREATE_SURFACE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xvmc_create_surface_cookie_t xcb_ret;
+    xcb_xvmc_create_surface_request_t xcb_out;
+
+    xcb_out.surface_id = surface_id;
+    xcb_out.context_id = context_id;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_xvmc_create_surface_priv_data (const xcb_xvmc_create_surface_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_xvmc_create_surface_priv_data_length (const xcb_xvmc_create_surface_reply_t *R)
+{
+    return R->length;
+}
+
+xcb_generic_iterator_t
+xcb_xvmc_create_surface_priv_data_end (const xcb_xvmc_create_surface_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->length);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xvmc_create_surface_reply_t *
+xcb_xvmc_create_surface_reply (xcb_connection_t                  *c,
+                               xcb_xvmc_create_surface_cookie_t   cookie  /**< */,
+                               xcb_generic_error_t              **e)
+{
+    return (xcb_xvmc_create_surface_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_xvmc_destroy_surface_checked (xcb_connection_t   *c,
+                                  xcb_xvmc_surface_t  surface_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xvmc_id,
+        .opcode = XCB_XVMC_DESTROY_SURFACE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xvmc_destroy_surface_request_t xcb_out;
+
+    xcb_out.surface_id = surface_id;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xvmc_destroy_surface (xcb_connection_t   *c,
+                          xcb_xvmc_surface_t  surface_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xvmc_id,
+        .opcode = XCB_XVMC_DESTROY_SURFACE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xvmc_destroy_surface_request_t xcb_out;
+
+    xcb_out.surface_id = surface_id;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_xvmc_create_subpicture_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xvmc_create_subpicture_reply_t *_aux = (xcb_xvmc_create_subpicture_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xvmc_create_subpicture_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* priv_data */
+    xcb_block_len += _aux->length * sizeof(uint32_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(uint32_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xvmc_create_subpicture_cookie_t
+xcb_xvmc_create_subpicture (xcb_connection_t      *c,
+                            xcb_xvmc_subpicture_t  subpicture_id,
+                            xcb_xvmc_context_t     context,
+                            uint32_t               xvimage_id,
+                            uint16_t               width,
+                            uint16_t               height)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xvmc_id,
+        .opcode = XCB_XVMC_CREATE_SUBPICTURE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xvmc_create_subpicture_cookie_t xcb_ret;
+    xcb_xvmc_create_subpicture_request_t xcb_out;
+
+    xcb_out.subpicture_id = subpicture_id;
+    xcb_out.context = context;
+    xcb_out.xvimage_id = xvimage_id;
+    xcb_out.width = width;
+    xcb_out.height = height;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xvmc_create_subpicture_cookie_t
+xcb_xvmc_create_subpicture_unchecked (xcb_connection_t      *c,
+                                      xcb_xvmc_subpicture_t  subpicture_id,
+                                      xcb_xvmc_context_t     context,
+                                      uint32_t               xvimage_id,
+                                      uint16_t               width,
+                                      uint16_t               height)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xvmc_id,
+        .opcode = XCB_XVMC_CREATE_SUBPICTURE,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xvmc_create_subpicture_cookie_t xcb_ret;
+    xcb_xvmc_create_subpicture_request_t xcb_out;
+
+    xcb_out.subpicture_id = subpicture_id;
+    xcb_out.context = context;
+    xcb_out.xvimage_id = xvimage_id;
+    xcb_out.width = width;
+    xcb_out.height = height;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+uint32_t *
+xcb_xvmc_create_subpicture_priv_data (const xcb_xvmc_create_subpicture_reply_t *R)
+{
+    return (uint32_t *) (R + 1);
+}
+
+int
+xcb_xvmc_create_subpicture_priv_data_length (const xcb_xvmc_create_subpicture_reply_t *R)
+{
+    return R->length;
+}
+
+xcb_generic_iterator_t
+xcb_xvmc_create_subpicture_priv_data_end (const xcb_xvmc_create_subpicture_reply_t *R)
+{
+    xcb_generic_iterator_t i;
+    i.data = ((uint32_t *) (R + 1)) + (R->length);
+    i.rem = 0;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xvmc_create_subpicture_reply_t *
+xcb_xvmc_create_subpicture_reply (xcb_connection_t                     *c,
+                                  xcb_xvmc_create_subpicture_cookie_t   cookie  /**< */,
+                                  xcb_generic_error_t                 **e)
+{
+    return (xcb_xvmc_create_subpicture_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+
+xcb_void_cookie_t
+xcb_xvmc_destroy_subpicture_checked (xcb_connection_t      *c,
+                                     xcb_xvmc_subpicture_t  subpicture_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xvmc_id,
+        .opcode = XCB_XVMC_DESTROY_SUBPICTURE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xvmc_destroy_subpicture_request_t xcb_out;
+
+    xcb_out.subpicture_id = subpicture_id;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_void_cookie_t
+xcb_xvmc_destroy_subpicture (xcb_connection_t      *c,
+                             xcb_xvmc_subpicture_t  subpicture_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xvmc_id,
+        .opcode = XCB_XVMC_DESTROY_SUBPICTURE,
+        .isvoid = 1
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_void_cookie_t xcb_ret;
+    xcb_xvmc_destroy_subpicture_request_t xcb_out;
+
+    xcb_out.subpicture_id = subpicture_id;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+int
+xcb_xvmc_list_subpicture_types_sizeof (const void  *_buffer)
+{
+    char *xcb_tmp = (char *)_buffer;
+    const xcb_xvmc_list_subpicture_types_reply_t *_aux = (xcb_xvmc_list_subpicture_types_reply_t *)_buffer;
+    unsigned int xcb_buffer_len = 0;
+    unsigned int xcb_block_len = 0;
+    unsigned int xcb_pad = 0;
+    unsigned int xcb_align_to = 0;
+
+
+    xcb_block_len += sizeof(xcb_xvmc_list_subpicture_types_reply_t);
+    xcb_tmp += xcb_block_len;
+    xcb_buffer_len += xcb_block_len;
+    xcb_block_len = 0;
+    /* types */
+    xcb_block_len += _aux->num * sizeof(xcb_xv_image_format_info_t);
+    xcb_tmp += xcb_block_len;
+    xcb_align_to = ALIGNOF(xcb_xv_image_format_info_t);
+    /* insert padding */
+    xcb_pad = -xcb_block_len & (xcb_align_to - 1);
+    xcb_buffer_len += xcb_block_len + xcb_pad;
+    if (0 != xcb_pad) {
+        xcb_tmp += xcb_pad;
+        xcb_pad = 0;
+    }
+    xcb_block_len = 0;
+
+    return xcb_buffer_len;
+}
+
+xcb_xvmc_list_subpicture_types_cookie_t
+xcb_xvmc_list_subpicture_types (xcb_connection_t   *c,
+                                xcb_xv_port_t       port_id,
+                                xcb_xvmc_surface_t  surface_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xvmc_id,
+        .opcode = XCB_XVMC_LIST_SUBPICTURE_TYPES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xvmc_list_subpicture_types_cookie_t xcb_ret;
+    xcb_xvmc_list_subpicture_types_request_t xcb_out;
+
+    xcb_out.port_id = port_id;
+    xcb_out.surface_id = surface_id;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xvmc_list_subpicture_types_cookie_t
+xcb_xvmc_list_subpicture_types_unchecked (xcb_connection_t   *c,
+                                          xcb_xv_port_t       port_id,
+                                          xcb_xvmc_surface_t  surface_id)
+{
+    static const xcb_protocol_request_t xcb_req = {
+        .count = 2,
+        .ext = &xcb_xvmc_id,
+        .opcode = XCB_XVMC_LIST_SUBPICTURE_TYPES,
+        .isvoid = 0
+    };
+
+    struct iovec xcb_parts[4];
+    xcb_xvmc_list_subpicture_types_cookie_t xcb_ret;
+    xcb_xvmc_list_subpicture_types_request_t xcb_out;
+
+    xcb_out.port_id = port_id;
+    xcb_out.surface_id = surface_id;
+
+    xcb_parts[2].iov_base = (char *) &xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
+}
+
+xcb_xv_image_format_info_t *
+xcb_xvmc_list_subpicture_types_types (const xcb_xvmc_list_subpicture_types_reply_t *R)
+{
+    return (xcb_xv_image_format_info_t *) (R + 1);
+}
+
+int
+xcb_xvmc_list_subpicture_types_types_length (const xcb_xvmc_list_subpicture_types_reply_t *R)
+{
+    return R->num;
+}
+
+xcb_xv_image_format_info_iterator_t
+xcb_xvmc_list_subpicture_types_types_iterator (const xcb_xvmc_list_subpicture_types_reply_t *R)
+{
+    xcb_xv_image_format_info_iterator_t i;
+    i.data = (xcb_xv_image_format_info_t *) (R + 1);
+    i.rem = R->num;
+    i.index = (char *) i.data - (char *) R;
+    return i;
+}
+
+xcb_xvmc_list_subpicture_types_reply_t *
+xcb_xvmc_list_subpicture_types_reply (xcb_connection_t                         *c,
+                                      xcb_xvmc_list_subpicture_types_cookie_t   cookie  /**< */,
+                                      xcb_generic_error_t                     **e)
+{
+    return (xcb_xvmc_list_subpicture_types_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e);
+}
+