Update bundled libxkbcommon version to 0.4.0

This release comes with important bug fixes. Also we can now
remove the workaround code which was needed for libxkbcommon 0.2.0.

Task-number: QTBUG-31712
Task-number: QTBUG-33732
Task-number: QTBUG-34056

Change-Id: I57caf7f803b9a01a15541a5ad82e464de3b8abbb
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com>
Reviewed-by: Lars Knoll <lars.knoll@digia.com>

54 files changed, 11383 insertions, 9320 deletions

diff --git a/src/3rdparty/xkbcommon.pri b/src/3rdparty/xkbcommon.pri
index 57470c0499..eb34403746 100644
--- a/src/3rdparty/xkbcommon.pri
+++ b/src/3rdparty/xkbcommon.pri
@@ -1,15 +1,20 @@
 QMAKE_CFLAGS += -std=gnu99 -w
-INCLUDEPATH += $$PWD/xkbcommon $$PWD/xkbcommon/src $$PWD/xkbcommon/src/xkbcomp
+INCLUDEPATH += $$PWD/xkbcommon \
+               $$PWD/xkbcommon/xkbcommon \
+               $$PWD/xkbcommon/src \
+               $$PWD/xkbcommon/src/xkbcomp
 
 DEFINES += DFLT_XKB_CONFIG_ROOT='\\"$$QMAKE_XKB_CONFIG_ROOT\\"'
 
-### RMLVO names can be overwritten with environmental variables (See libxkbcommon documentation)
+### RMLVO names can be overwritten with environmental variables (see libxkbcommon documentation)
 DEFINES += DEFAULT_XKB_RULES='\\"evdev\\"'
 DEFINES += DEFAULT_XKB_MODEL='\\"pc105\\"'
 DEFINES += DEFAULT_XKB_LAYOUT='\\"us\\"'
+# Need to rename several files, qmake has problems processing a project when
+# sub-directories contain files with an equal names.
 
-# Need to rename 2 files, qmake has problems processing a project when
-# directories contain files with equal names.
+# libxkbcommon generates some of these files while executing "./autogen.sh"
+# and some while executing "make" (actually YACC)
 SOURCES += \
     $$PWD/xkbcommon/src/atom.c \
     $$PWD/xkbcommon/src/xkb-compat.c \ # renamed: compat.c -> xkb-compat.c
@@ -18,7 +23,10 @@ SOURCES += \
     $$PWD/xkbcommon/src/keysym.c \
     $$PWD/xkbcommon/src/keysym-utf.c \
     $$PWD/xkbcommon/src/state.c \
-    $$PWD/xkbcommon/src/text.c
+    $$PWD/xkbcommon/src/text.c \
+    $$PWD/xkbcommon/src/context-priv.c \
+    $$PWD/xkbcommon/src/keymap-priv.c \
+    $$PWD/xkbcommon/src/utils.c
 
 SOURCES += \
     $$PWD/xkbcommon/src/xkbcomp/action.c \
@@ -29,12 +37,24 @@ SOURCES += \
     $$PWD/xkbcommon/src/xkbcomp/keycodes.c \
     $$PWD/xkbcommon/src/xkbcomp/keymap-dump.c \
     $$PWD/xkbcommon/src/xkbcomp/keymap.c \
-    $$PWD/xkbcommon/src/xkbcomp/parser.c \
+    $$PWD/xkbcommon/src/xkbcomp/keywords.c \
     $$PWD/xkbcommon/src/xkbcomp/rules.c \
     $$PWD/xkbcommon/src/xkbcomp/scanner.c \
     $$PWD/xkbcommon/src/xkbcomp/symbols.c \
     $$PWD/xkbcommon/src/xkbcomp/types.c \
     $$PWD/xkbcommon/src/xkbcomp/vmod.c \
-    $$PWD/xkbcommon/src/xkbcomp/xkbcomp.c
+    $$PWD/xkbcommon/src/xkbcomp/xkbcomp.c \
+    $$PWD/xkbcommon/src/xkbcomp/parser.c
+
+!contains(DEFINES, QT_NO_XKB):contains(QT_CONFIG, use-xkbcommon-x11support): {
+    # Build xkbcommon-x11 support library, it depends on -lxcb and -lxcb-xkb, linking is done
+    # in xcb-plugin.pro (linked to system libraries or if Qt was configured with -qt-xcb then
+    # linked to -lxcb-static).
+    INCLUDEPATH += $$PWD/xkbcommon/src/x11
+    SOURCES += \
+        $$PWD/xkbcommon/src/x11/util.c \
+        $$PWD/xkbcommon/src/x11/x11-keymap.c \ # renamed: keymap.c -> x11-keymap.c
+        $$PWD/xkbcommon/src/x11/x11-state.c    # renamed: state.c  -> x11-keymap.c
+}
 
 TR_EXCLUDE += $$PWD/*
diff --git a/src/3rdparty/xkbcommon/NEWS b/src/3rdparty/xkbcommon/NEWS
new file mode 100644
index 0000000000..450b7535ee
--- /dev/null
+++ b/src/3rdparty/xkbcommon/NEWS
@@ -0,0 +1,86 @@
+libxkbcommon 0.4.0
+==================
+
+- Add a new add-on library, xkbcommon-x11, to support creating keymaps
+  with the XKB X11 protocol, by querying the X server directly.
+  See the xkbcommon/xkbcommon-x11.h header file for more details.
+  This library requires libxcb-xkb >= 1.10, and is enabled by default.
+  It can be disabled with the --disable-x11 configure switch.
+  Distributions are encouraged to split the necessary files for this
+  library (libxkbcommon-x11.so, xkbcommon-x11.pc, xkbcommon/xkbcommon-x11.h)
+  to a separate package, such that the main package does not depend on
+  X11 libraries.
+
+- Fix the keysym <-> name lookup table to not require huge amounts of
+  relocations.
+
+- Fix a bug in the keysym <-> name lookup, whereby lookup might fail in
+  some rare cases.
+
+- Reduce memory usage during keymap compilation.
+
+- New API:
+  New keysyms from xproto 7.0.25 (German T3 layout keysyms).
+  XKB_MOD_NAME_NUM for the usual NumLock modifier.
+  xkb_x11_* types and functions, XKB_X11_* constants.
+
+
+libxkbcommon 0.3.2
+==================
+
+- Log messages from the library now look like "xkbcommon: ERROR" by
+  default, instead of xkbcomp-like "Error:   ".
+
+- Apply capitalization transformation on keysyms in
+  xkb_keysym_get_one_sym(), to match the behavior specified in the XKB
+  specification:
+  http://www.x.org/releases/current/doc/kbproto/xkbproto.html#Interpreting_the_Lock_Modifier
+
+- Support byacc for generating the parser, in addition to Bison.
+
+- New API:
+  XKB_KEY_XF86AudioMicMute keysym from xproto 7.0.24.
+  XKB_KEYSYM_NO_FLAGS
+  XKB_CONTEXT_NO_FLAGS
+  XKB_MAP_COMPILE_NO_FLAGS
+
+- Bug fixes.
+
+
+libxkbcommon 0.3.1
+==================
+
+- Replace the flex scanner with a hand-written one. flex is no longer
+  a build requirement.
+
+- New API:
+  xkb_keymap_min_keycode()
+  xkb_keymap_max_keycode()
+  xkb_keymap_key_for_each()
+
+
+libxkbcommon 0.3.0
+==================
+
+- Allow passing NULL to *_unref() functions; do nothing instead of
+  crashing.
+
+- The functions xkb_keymap_num_levels_for_key() and
+  xkb_keymap_get_syms_by_level() now allow out-of-range values for the
+  'layout' parameter. The functions now wrap the value around the number
+  of layouts instead of failing.
+
+- The function xkb_keysym_get_name() now types unicode keysyms in
+  uppercase and 0-padding, to match the format used by XKeysymToString().
+
+- Building Linux-specific tests is no longer attempted on non-Linux
+  environments.
+
+- The function xkb_keymap_new_from_names() now accepts a NULL value for
+  the 'names' parameter, instead of failing. This is equivalent to passing
+  a 'struct xkb_rule_names' with all fields set to NULL.
+
+- New API:
+  xkb_keymap_new_from_buffer()
+
+- Bug fixes.
diff --git a/src/3rdparty/xkbcommon/README b/src/3rdparty/xkbcommon/README
index fa8e94c81c..6b99c46620 100644
--- a/src/3rdparty/xkbcommon/README
+++ b/src/3rdparty/xkbcommon/README
@@ -25,27 +25,17 @@ API
 
 While xkbcommon's API is somewhat derived from the classic XKB API as found
 in <X11/extensions/XKB.h> and friends, it has been substantially reworked to
-expose fewer internal details to clients.  The only supported API is available
-in <xkbcommon/xkbcommon.h>.  Any definition not in this header (including
-accessing internal structures through the old macros previously available)
-should be regarded as an implementation detail and is liable to change at any
-time.
+expose fewer internal details to clients.  The supported API is available
+in the <xkbcommon/xkbcommon-*.h> files. Additional support is provided for
+X11 (XCB) clients, in the xkbcommon-x11 library, <xkbcommon/xkbcommon-x11.h>.
 
-During its early development, xkbcommon does not promise API or ABI stability.
-Regardless, we will attempt to not break ABI during a minor release series,
-so applications written against 0.1.0 should be completely compatible with
-0.1.3, but not necessarily with 0.2.0.  However, new symbols may be introduced
-in any release.  Thus, anyone packaging xkbcommon should make sure any package
-depending on it depends on a release greater than or equal to the version it
-was built against (or earlier, if it doesn't use any newly-introduced
-symbols), but less than the next major release.
-
-xkbcommon 1.x will offer full API and ABI stability for its lifetime, with a
-soname of libxkbcommon.so.1.  Any ABI breaks will wait until xkbcommon 2.0,
-which will be libxkbcommon.so.2.
-
-The xkbcomp command-line tool has also been removed, although this will
-likely reappear in a later release.
+The xkbcommon API and ABI are stable. We will attempt to not break ABI during
+a minor release series, so applications written against 0.1.0 should be
+completely compatible with 0.5.3, but not necessarily with 1.0.0.  However, new
+symbols may be introduced in any release.  Thus, anyone packaging xkbcommon
+should make sure any package depending on it depends on a release greater than
+or equal to the version it was built against (or earlier, if it doesn't use
+any newly-introduced symbols), but less than the next major release.
 
 
 Relation to X11
@@ -101,19 +91,24 @@ Development
 An extremely rudimentary homepage can be found at:
     http://xkbcommon.org
 
-xkbcommon is maintained in git at freedesktop.org:
-    git://anongit.freedesktop.org/git/libxkbcommon
+xkbcommon is maintained in git at github.com:
+    https://github.com/xkbcommon/libxkbcommon
 
 Patches are always welcome, and may be sent to either xorg-devel@lists.x.org,
-or wayland-devel@lists.freedesktop.org.  Bugs are tracked in Bugzilla at:
-    http://bugs.freedesktop.org
+or wayland-devel@lists.freedesktop.org.
+
+Bugs are tracked in Bugzilla at:
+    https://bugs.freedesktop.org/describecomponents.cgi?product=libxkbcommon
+Or in github at:
+    https://github.com/xkbcommon/libxkbcommon/issues
 
-The maintainer is Daniel Stone, who can be reached at:
+The maintainers are Daniel Stone and Ran Benita, who can be reached at:
     <daniel@fooishbar.org>
+    <ran234@gmail.com>
 
 
 Credits
 =======
 
 Many thanks are due to Dan Nicholson for his heroic work in getting xkbcommon
-off the ground initially, as well as to Ran Benita for subsequent development.
+off the ground initially.
diff --git a/src/3rdparty/xkbcommon/src/atom.c b/src/3rdparty/xkbcommon/src/atom.c
index a77502336e..044f56681a 100644
--- a/src/3rdparty/xkbcommon/src/atom.c
+++ b/src/3rdparty/xkbcommon/src/atom.c
@@ -74,15 +74,15 @@
 #include "atom.h"
 
 struct atom_node {
-    struct atom_node *left, *right;
+    xkb_atom_t left, right;
     xkb_atom_t atom;
     unsigned int fingerprint;
     char *string;
 };
 
 struct atom_table {
-    struct atom_node *root;
-    darray(struct atom_node *) table;
+    xkb_atom_t root;
+    darray(struct atom_node) table;
 };
 
 struct atom_table *
@@ -95,31 +95,22 @@ atom_table_new(void)
         return NULL;
 
     darray_init(table->table);
-    darray_growalloc(table->table, 100);
-    darray_append(table->table, NULL);
+    /* The original throw-away root is here, at the illegal atom 0. */
+    darray_resize0(table->table, 1);
 
     return table;
 }
 
-static void
-free_atom(struct atom_node *patom)
-{
-    if (!patom)
-        return;
-
-    free_atom(patom->left);
-    free_atom(patom->right);
-    free(patom->string);
-    free(patom);
-}
-
 void
 atom_table_free(struct atom_table *table)
 {
+    struct atom_node *node;
+
     if (!table)
         return;
 
-    free_atom(table->root);
+    darray_foreach(node, table->table)
+        free(node->string);
     darray_free(table->table);
     free(table);
 }
@@ -127,52 +118,42 @@ atom_table_free(struct atom_table *table)
 const char *
 atom_text(struct atom_table *table, xkb_atom_t atom)
 {
-    if (atom >= darray_size(table->table) ||
-        darray_item(table->table, atom) == NULL)
+    if (atom == XKB_ATOM_NONE || atom >= darray_size(table->table))
         return NULL;
 
-    return darray_item(table->table, atom)->string;
-}
-
-char *
-atom_strdup(struct atom_table *table, xkb_atom_t atom)
-{
-    return strdup_safe(atom_text(table, atom));
+    return darray_item(table->table, atom).string;
 }
 
 static bool
-find_node_pointer(struct atom_table *table, const char *string,
-                  struct atom_node ***np_out, unsigned int *fingerprint_out)
+find_atom_pointer(struct atom_table *table, const char *string, size_t len,
+                  xkb_atom_t **atomp_out, unsigned int *fingerprint_out)
 {
-    struct atom_node **np;
-    unsigned i;
-    int comp;
-    unsigned int fp = 0;
-    size_t len;
+    xkb_atom_t *atomp = &table->root;
+    unsigned int fingerprint = 0;
     bool found = false;
 
-    len = strlen(string);
-    np = &table->root;
-    for (i = 0; i < (len + 1) / 2; i++) {
-        fp = fp * 27 + string[i];
-        fp = fp * 27 + string[len - 1 - i];
+    for (size_t i = 0; i < (len + 1) / 2; i++) {
+        fingerprint = fingerprint * 27 + string[i];
+        fingerprint = fingerprint * 27 + string[len - 1 - i];
     }
 
-    while (*np) {
-        if (fp < (*np)->fingerprint) {
-            np = &((*np)->left);
+    while (*atomp != XKB_ATOM_NONE) {
+        struct atom_node *node = &darray_item(table->table, *atomp);
+
+        if (fingerprint < node->fingerprint) {
+            atomp = &node->left;
         }
-        else if (fp > (*np)->fingerprint) {
-            np = &((*np)->right);
+        else if (fingerprint > node->fingerprint) {
+            atomp = &node->right;
         }
         else {
-            /* now start testing the strings */
-            comp = strncmp(string, (*np)->string, len);
-            if (comp < 0 || (comp == 0 && len < strlen((*np)->string))) {
-                np = &((*np)->left);
+            /* Now start testing the strings. */
+            const int cmp = strncmp(string, node->string, len);
+            if (cmp < 0 || (cmp == 0 && len < strlen(node->string))) {
+                atomp = &node->left;
             }
-            else if (comp > 0) {
-                np = &((*np)->right);
+            else if (cmp > 0) {
+                atomp = &node->right;
             }
             else {
                 found = true;
@@ -181,68 +162,64 @@ find_node_pointer(struct atom_table *table, const char *string,
         }
     }
 
-    *fingerprint_out = fp;
-    *np_out = np;
+    if (fingerprint_out)
+        *fingerprint_out = fingerprint;
+    if (atomp_out)
+        *atomp_out = atomp;
     return found;
 }
 
 xkb_atom_t
-atom_lookup(struct atom_table *table, const char *string)
+atom_lookup(struct atom_table *table, const char *string, size_t len)
 {
-    struct atom_node **np;
-    unsigned int fp;
+    xkb_atom_t *atomp;
 
     if (!string)
         return XKB_ATOM_NONE;
 
-    if (!find_node_pointer(table, string, &np, &fp))
+    if (!find_atom_pointer(table, string, len, &atomp, NULL))
         return XKB_ATOM_NONE;
 
-    return (*np)->atom;
+    return *atomp;
 }
 
 /*
  * If steal is true, we do not strdup @string; therefore it must be
- * dynamically allocated, not be free'd by the caller and not be used
- * afterwards. Use to avoid some redundant allocations.
+ * dynamically allocated, NUL-terminated, not be free'd by the caller
+ * and not be used afterwards. Use to avoid some redundant allocations.
  */
 xkb_atom_t
-atom_intern(struct atom_table *table, const char *string,
+atom_intern(struct atom_table *table, const char *string, size_t len,
             bool steal)
 {
-    struct atom_node **np;
-    struct atom_node *nd;
-    unsigned int fp;
+    xkb_atom_t *atomp;
+    struct atom_node node;
+    unsigned int fingerprint;
 
     if (!string)
         return XKB_ATOM_NONE;
 
-    if (find_node_pointer(table, string, &np, &fp)) {
+    if (find_atom_pointer(table, string, len, &atomp, &fingerprint)) {
         if (steal)
             free(UNCONSTIFY(string));
-        return (*np)->atom;
+        return *atomp;
     }
 
-    nd = malloc(sizeof(*nd));
-    if (!nd)
-        return XKB_ATOM_NONE;
-
     if (steal) {
-        nd->string = UNCONSTIFY(string);
+        node.string = UNCONSTIFY(string);
     }
     else {
-        nd->string = strdup(string);
-        if (!nd->string) {
-            free(nd);
+        node.string = strndup(string, len);
+        if (!node.string)
             return XKB_ATOM_NONE;
-        }
     }
 
-    *np = nd;
-    nd->left = nd->right = NULL;
-    nd->fingerprint = fp;
-    nd->atom = darray_size(table->table);
-    darray_append(table->table, nd);
+    node.left = node.right = XKB_ATOM_NONE;
+    node.fingerprint = fingerprint;
+    node.atom = darray_size(table->table);
+    /* Do this before the append, as it may realloc and change the offsets. */
+    *atomp = node.atom;
+    darray_append(table->table, node);
 
-    return nd->atom;
+    return node.atom;
 }
diff --git a/src/3rdparty/xkbcommon/src/atom.h b/src/3rdparty/xkbcommon/src/atom.h
index f1abf1b72f..1bf8e49b8e 100644
--- a/src/3rdparty/xkbcommon/src/atom.h
+++ b/src/3rdparty/xkbcommon/src/atom.h
@@ -37,15 +37,12 @@ void
 atom_table_free(struct atom_table *table);
 
 xkb_atom_t
-atom_lookup(struct atom_table *table, const char *string);
+atom_lookup(struct atom_table *table, const char *string, size_t len);
 
 xkb_atom_t
-atom_intern(struct atom_table *table, const char *string,
+atom_intern(struct atom_table *table, const char *string, size_t len,
             bool steal);
 
-char *
-atom_strdup(struct atom_table *table, xkb_atom_t atom);
-
 const char *
 atom_text(struct atom_table *table, xkb_atom_t atom);
 
diff --git a/src/3rdparty/xkbcommon/src/context-priv.c b/src/3rdparty/xkbcommon/src/context-priv.c
new file mode 100644
index 0000000000..4d7b2ed110
--- /dev/null
+++ b/src/3rdparty/xkbcommon/src/context-priv.c
@@ -0,0 +1,171 @@
+/*
+ * Copyright © 2012 Intel Corporation
+ * Copyright © 2012 Ran Benita
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Author: Daniel Stone <daniel@fooishbar.org>
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <unistd.h>
+
+#include "xkbcommon/xkbcommon.h"
+#include "utils.h"
+#include "context.h"
+
+unsigned int
+xkb_context_num_failed_include_paths(struct xkb_context *ctx)
+{
+    return darray_size(ctx->failed_includes);
+}
+
+const char *
+xkb_context_failed_include_path_get(struct xkb_context *ctx,
+                                    unsigned int idx)
+{
+    if (idx >= xkb_context_num_failed_include_paths(ctx))
+        return NULL;
+
+    return darray_item(ctx->failed_includes, idx);
+}
+
+xkb_atom_t
+xkb_atom_lookup(struct xkb_context *ctx, const char *string)
+{
+    return atom_lookup(ctx->atom_table, string, strlen(string));
+}
+
+xkb_atom_t
+xkb_atom_intern(struct xkb_context *ctx, const char *string, size_t len)
+{
+    return atom_intern(ctx->atom_table, string, len, false);
+}
+
+xkb_atom_t
+xkb_atom_steal(struct xkb_context *ctx, char *string)
+{
+    return atom_intern(ctx->atom_table, string, strlen(string), true);
+}
+
+const char *
+xkb_atom_text(struct xkb_context *ctx, xkb_atom_t atom)
+{
+    return atom_text(ctx->atom_table, atom);
+}
+
+void
+xkb_log(struct xkb_context *ctx, enum xkb_log_level level, int verbosity,
+        const char *fmt, ...)
+{
+    va_list args;
+
+    if (ctx->log_level < level || ctx->log_verbosity < verbosity)
+        return;
+
+    va_start(args, fmt);
+    ctx->log_fn(ctx, level, fmt, args);
+    va_end(args);
+}
+
+char *
+xkb_context_get_buffer(struct xkb_context *ctx, size_t size)
+{
+    char *rtrn;
+
+    if (size >= sizeof(ctx->text_buffer))
+        return NULL;
+
+    if (sizeof(ctx->text_buffer) - ctx->text_next <= size)
+        ctx->text_next = 0;
+
+    rtrn = &ctx->text_buffer[ctx->text_next];
+    ctx->text_next += size;
+
+    return rtrn;
+}
+
+#ifndef DEFAULT_XKB_VARIANT
+#define DEFAULT_XKB_VARIANT NULL
+#endif
+
+#ifndef DEFAULT_XKB_OPTIONS
+#define DEFAULT_XKB_OPTIONS NULL
+#endif
+
+const char *
+xkb_context_get_default_rules(struct xkb_context *ctx)
+{
+    const char *env = NULL;
+
+    if (ctx->use_environment_names)
+        env = getenv("XKB_DEFAULT_RULES");
+
+    return env ? env : DEFAULT_XKB_RULES;
+}
+
+const char *
+xkb_context_get_default_model(struct xkb_context *ctx)
+{
+    const char *env = NULL;
+
+    if (ctx->use_environment_names)
+        env = getenv("XKB_DEFAULT_MODEL");
+
+    return env ? env : DEFAULT_XKB_MODEL;
+}
+
+const char *
+xkb_context_get_default_layout(struct xkb_context *ctx)
+{
+    const char *env = NULL;
+
+    if (ctx->use_environment_names)
+        env = getenv("XKB_DEFAULT_LAYOUT");
+
+    return env ? env : DEFAULT_XKB_LAYOUT;
+}
+
+const char *
+xkb_context_get_default_variant(struct xkb_context *ctx)
+{
+    const char *env = NULL;
+    const char *layout = getenv("XKB_DEFAULT_VARIANT");
+
+    /* We don't want to inherit the variant if they haven't also set a
+     * layout, since they're so closely paired. */
+    if (layout && ctx->use_environment_names)
+        env = getenv("XKB_DEFAULT_VARIANT");
+
+    return env ? env : DEFAULT_XKB_VARIANT;
+}
+
+const char *
+xkb_context_get_default_options(struct xkb_context *ctx)
+{
+    const char *env = NULL;
+
+    if (ctx->use_environment_names)
+        env = getenv("XKB_DEFAULT_OPTIONS");
+
+    return env ? env : DEFAULT_XKB_OPTIONS;
+}
diff --git a/src/3rdparty/xkbcommon/src/context.c b/src/3rdparty/xkbcommon/src/context.c
index 8d56487004..e64b91542f 100644
--- a/src/3rdparty/xkbcommon/src/context.c
+++ b/src/3rdparty/xkbcommon/src/context.c
@@ -26,7 +26,6 @@
 
 #include <sys/types.h>
 #include <sys/stat.h>
-#include <ctype.h>
 #include <errno.h>
 #include <unistd.h>
 
@@ -34,30 +33,6 @@
 #include "utils.h"
 #include "context.h"
 
-struct xkb_context {
-    int refcnt;
-
-    ATTR_PRINTF(3, 0) void (*log_fn)(struct xkb_context *ctx,
-                                     enum xkb_log_level level,
-                                     const char *fmt, va_list args);
-    enum xkb_log_level log_level;
-    int log_verbosity;
-    void *user_data;
-
-    struct xkb_rule_names names_dflt;
-
-    darray(char *) includes;
-    darray(char *) failed_includes;
-
-    struct atom_table *atom_table;
-
-    /* Buffer for the *Text() functions. */
-    char text_buffer[2048];
-    size_t text_next;
-
-    unsigned int use_environment_names : 1;
-};
-
 /**
  * Append one directory to the context's include path.
  */
@@ -155,12 +130,6 @@ xkb_context_num_include_paths(struct xkb_context *ctx)
     return darray_size(ctx->includes);
 }
 
-unsigned int
-xkb_context_num_failed_include_paths(struct xkb_context *ctx)
-{
-    return darray_size(ctx->failed_includes);
-}
-
 /**
  * Returns the given entry in the context's include path, or NULL if an
  * invalid index is passed.
@@ -174,16 +143,6 @@ xkb_context_include_path_get(struct xkb_context *ctx, unsigned int idx)
     return darray_item(ctx->includes, idx);
 }
 
-const char *
-xkb_context_failed_include_path_get(struct xkb_context *ctx,
-                                    unsigned int idx)
-{
-    if (idx >= xkb_context_num_failed_include_paths(ctx))
-        return NULL;
-
-    return darray_item(ctx->failed_includes, idx);
-}
-
 /**
  * Take a new reference on the context.
  */
@@ -214,15 +173,15 @@ log_level_to_prefix(enum xkb_log_level level)
 {
     switch (level) {
     case XKB_LOG_LEVEL_DEBUG:
-        return "Debug:";
+        return "xkbcommon: DEBUG: ";
     case XKB_LOG_LEVEL_INFO:
-        return "Info:";
+        return "xkbcommon: INFO: ";
     case XKB_LOG_LEVEL_WARNING:
-        return "Warning:";
+        return "xkbcommon: WARNING: ";
     case XKB_LOG_LEVEL_ERROR:
-        return "Error:";
+        return "xkbcommon: ERROR: ";
     case XKB_LOG_LEVEL_CRITICAL:
-        return "Critical:";
+        return "xkbcommon: CRITICAL: ";
     default:
         return NULL;
     }
@@ -235,7 +194,7 @@ default_log_fn(struct xkb_context *ctx, enum xkb_log_level level,
     const char *prefix = log_level_to_prefix(level);
 
     if (prefix)
-        fprintf(stderr, "%-10s", prefix);
+        fprintf(stderr, "%s", prefix);
     vfprintf(stderr, fmt, args);
 }
 
@@ -246,7 +205,7 @@ log_level(const char *level) {
 
     errno = 0;
     lvl = strtol(level, &endptr, 10);
-    if (errno == 0 && (endptr[0] == '\0' || isspace(endptr[0])))
+    if (errno == 0 && (endptr[0] == '\0' || is_space(endptr[0])))
         return lvl;
     if (istreq_prefix("crit", level))
         return XKB_LOG_LEVEL_CRITICAL;
@@ -275,14 +234,6 @@ log_verbosity(const char *verbosity) {
     return 0;
 }
 
-#ifndef DEFAULT_XKB_VARIANT
-#define DEFAULT_XKB_VARIANT NULL
-#endif
-
-#ifndef DEFAULT_XKB_OPTIONS
-#define DEFAULT_XKB_OPTIONS NULL
-#endif
-
 /**
  * Create a new context.
  */
@@ -328,47 +279,6 @@ xkb_context_new(enum xkb_context_flags flags)
     return ctx;
 }
 
-xkb_atom_t
-xkb_atom_lookup(struct xkb_context *ctx, const char *string)
-{
-    return atom_lookup(ctx->atom_table, string);
-}
-
-xkb_atom_t
-xkb_atom_intern(struct xkb_context *ctx, const char *string)
-{
-    return atom_intern(ctx->atom_table, string, false);
-}
-
-xkb_atom_t
-xkb_atom_steal(struct xkb_context *ctx, char *string)
-{
-    return atom_intern(ctx->atom_table, string, true);
-}
-
-char *
-xkb_atom_strdup(struct xkb_context *ctx, xkb_atom_t atom)
-{
-    return atom_strdup(ctx->atom_table, atom);
-}
-
-const char *
-xkb_atom_text(struct xkb_context *ctx, xkb_atom_t atom)
-{
-    return atom_text(ctx->atom_table, atom);
-}
-
-void
-xkb_log(struct xkb_context *ctx, enum xkb_log_level level,
-        const char *fmt, ...)
-{
-    va_list args;
-
-    va_start(args, fmt);
-    ctx->log_fn(ctx, level, fmt, args);
-    va_end(args);
-}
-
 XKB_EXPORT void
 xkb_context_set_log_fn(struct xkb_context *ctx,
                        void (*log_fn)(struct xkb_context *ctx,
@@ -415,78 +325,3 @@ xkb_context_set_user_data(struct xkb_context *ctx, void *user_data)
 {
     ctx->user_data = user_data;
 }
-
-char *
-xkb_context_get_buffer(struct xkb_context *ctx, size_t size)
-{
-    char *rtrn;
-
-    if (size >= sizeof(ctx->text_buffer))
-        return NULL;
-
-    if (sizeof(ctx->text_buffer) - ctx->text_next <= size)
-        ctx->text_next = 0;
-
-    rtrn = &ctx->text_buffer[ctx->text_next];
-    ctx->text_next += size;
-
-    return rtrn;
-}
-
-const char *
-xkb_context_get_default_rules(struct xkb_context *ctx)
-{
-    const char *env = NULL;
-
-    if (ctx->use_environment_names)
-        env = getenv("XKB_DEFAULT_RULES");
-
-    return env ? env : DEFAULT_XKB_RULES;
-}
-
-const char *
-xkb_context_get_default_model(struct xkb_context *ctx)
-{
-    const char *env = NULL;
-
-    if (ctx->use_environment_names)
-        env = getenv("XKB_DEFAULT_MODEL");
-
-    return env ? env : DEFAULT_XKB_MODEL;
-}
-
-const char *
-xkb_context_get_default_layout(struct xkb_context *ctx)
-{
-    const char *env = NULL;
-
-    if (ctx->use_environment_names)
-        env = getenv("XKB_DEFAULT_LAYOUT");
-
-    return env ? env : DEFAULT_XKB_LAYOUT;
-}
-
-const char *
-xkb_context_get_default_variant(struct xkb_context *ctx)
-{
-    const char *env = NULL;
-    const char *layout = getenv("XKB_DEFAULT_VARIANT");
-
-    /* We don't want to inherit the variant if they haven't also set a
-     * layout, since they're so closely paired. */
-    if (layout && ctx->use_environment_names)
-        env = getenv("XKB_DEFAULT_VARIANT");
-
-    return env ? env : DEFAULT_XKB_VARIANT;
-}
-
-const char *
-xkb_context_get_default_options(struct xkb_context *ctx)
-{
-    const char *env = NULL;
-
-    if (ctx->use_environment_names)
-        env = getenv("XKB_DEFAULT_OPTIONS");
-
-    return env ? env : DEFAULT_XKB_OPTIONS;
-}
diff --git a/src/3rdparty/xkbcommon/src/context.h b/src/3rdparty/xkbcommon/src/context.h
index 7c061a086f..486f4085a6 100644
--- a/src/3rdparty/xkbcommon/src/context.h
+++ b/src/3rdparty/xkbcommon/src/context.h
@@ -28,6 +28,30 @@
 
 #include "atom.h"
 
+struct xkb_context {
+    int refcnt;
+
+    ATTR_PRINTF(3, 0) void (*log_fn)(struct xkb_context *ctx,
+                                     enum xkb_log_level level,
+                                     const char *fmt, va_list args);
+    enum xkb_log_level log_level;
+    int log_verbosity;
+    void *user_data;
+
+    struct xkb_rule_names names_dflt;
+
+    darray(char *) includes;
+    darray(char *) failed_includes;
+
+    struct atom_table *atom_table;
+
+    /* Buffer for the *Text() functions. */
+    char text_buffer[2048];
+    size_t text_next;
+
+    unsigned int use_environment_names : 1;
+};
+
 unsigned int
 xkb_context_num_failed_include_paths(struct xkb_context *ctx);
 
@@ -43,40 +67,30 @@ xkb_atom_t
 xkb_atom_lookup(struct xkb_context *ctx, const char *string);
 
 xkb_atom_t
-xkb_atom_intern(struct xkb_context *ctx, const char *string);
+xkb_atom_intern(struct xkb_context *ctx, const char *string, size_t len);
+
+#define xkb_atom_intern_literal(ctx, literal) \
+    xkb_atom_intern((ctx), (literal), sizeof(literal) - 1)
 
 /**
- * If @string is dynamically allocated, free'd immediately after
- * being interned, and not used afterwards, use this function
+ * If @string is dynamically allocated, NUL-terminated, free'd immediately
+ * after being interned, and not used afterwards, use this function
  * instead of xkb_atom_intern to avoid some unnecessary allocations.
  * The caller should not use or free the passed in string afterwards.
  */
 xkb_atom_t
 xkb_atom_steal(struct xkb_context *ctx, char *string);
 
-char *
-xkb_atom_strdup(struct xkb_context *ctx, xkb_atom_t atom);
-
 const char *
 xkb_atom_text(struct xkb_context *ctx, xkb_atom_t atom);
 
 char *
 xkb_context_get_buffer(struct xkb_context *ctx, size_t size);
 
-ATTR_PRINTF(3, 4) void
-xkb_log(struct xkb_context *ctx, enum xkb_log_level level,
+ATTR_PRINTF(4, 5) void
+xkb_log(struct xkb_context *ctx, enum xkb_log_level level, int verbosity,
         const char *fmt, ...);
 
-#define xkb_log_cond_level(ctx, level, ...) do { \
-    if (xkb_context_get_log_level(ctx) >= (level)) \
-    xkb_log((ctx), (level), __VA_ARGS__); \
-} while (0)
-
-#define xkb_log_cond_verbosity(ctx, level, vrb, ...) do { \
-    if (xkb_context_get_log_verbosity(ctx) >= (vrb)) \
-    xkb_log_cond_level((ctx), (level), __VA_ARGS__); \
-} while (0)
-
 const char *
 xkb_context_get_default_rules(struct xkb_context *ctx);
 
@@ -99,17 +113,17 @@ xkb_context_get_default_options(struct xkb_context *ctx);
  * result in an error, though.
  */
 #define log_dbg(ctx, ...) \
-    xkb_log_cond_level((ctx), XKB_LOG_LEVEL_DEBUG, __VA_ARGS__)
+    xkb_log((ctx), XKB_LOG_LEVEL_DEBUG, 0, __VA_ARGS__)
 #define log_info(ctx, ...) \
-    xkb_log_cond_level((ctx), XKB_LOG_LEVEL_INFO, __VA_ARGS__)
+    xkb_log((ctx), XKB_LOG_LEVEL_INFO, 0, __VA_ARGS__)
 #define log_warn(ctx, ...) \
-    xkb_log_cond_level((ctx), XKB_LOG_LEVEL_WARNING, __VA_ARGS__)
+    xkb_log((ctx), XKB_LOG_LEVEL_WARNING, 0,  __VA_ARGS__)
 #define log_err(ctx, ...) \
-    xkb_log_cond_level((ctx), XKB_LOG_LEVEL_ERROR, __VA_ARGS__)
+    xkb_log((ctx), XKB_LOG_LEVEL_ERROR, 0,  __VA_ARGS__)
 #define log_wsgo(ctx, ...) \
-    xkb_log_cond_level((ctx), XKB_LOG_LEVEL_CRITICAL, __VA_ARGS__)
+    xkb_log((ctx), XKB_LOG_LEVEL_CRITICAL, 0, __VA_ARGS__)
 #define log_vrb(ctx, vrb, ...) \
-    xkb_log_cond_verbosity((ctx), XKB_LOG_LEVEL_WARNING, (vrb), __VA_ARGS__)
+    xkb_log((ctx), XKB_LOG_LEVEL_WARNING, (vrb), __VA_ARGS__)
 
 /*
  * Variants which are prefixed by the name of the function they're
diff --git a/src/3rdparty/xkbcommon/src/keymap-priv.c b/src/3rdparty/xkbcommon/src/keymap-priv.c
new file mode 100644
index 0000000000..9f42040828
--- /dev/null
+++ b/src/3rdparty/xkbcommon/src/keymap-priv.c
@@ -0,0 +1,121 @@
+/**
+ * Copyright © 2012 Intel Corporation
+ * Copyright © 2012 Ran Benita <ran234@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Author: Daniel Stone <daniel@fooishbar.org>
+ */
+
+#include "keymap.h"
+
+static void
+update_builtin_keymap_fields(struct xkb_keymap *keymap)
+{
+    struct xkb_context *ctx = keymap->ctx;
+
+    /*
+     * Add predefined (AKA real, core, X11) modifiers.
+     * The order is important!
+     */
+    darray_appends_t(keymap->mods, struct xkb_mod,
+        { .name = xkb_atom_intern_literal(ctx, "Shift"),   .type = MOD_REAL },
+        { .name = xkb_atom_intern_literal(ctx, "Lock"),    .type = MOD_REAL },
+        { .name = xkb_atom_intern_literal(ctx, "Control"), .type = MOD_REAL },
+        { .name = xkb_atom_intern_literal(ctx, "Mod1"),    .type = MOD_REAL },
+        { .name = xkb_atom_intern_literal(ctx, "Mod2"),    .type = MOD_REAL },
+        { .name = xkb_atom_intern_literal(ctx, "Mod3"),    .type = MOD_REAL },
+        { .name = xkb_atom_intern_literal(ctx, "Mod4"),    .type = MOD_REAL },
+        { .name = xkb_atom_intern_literal(ctx, "Mod5"),    .type = MOD_REAL });
+}
+
+struct xkb_keymap *
+xkb_keymap_new(struct xkb_context *ctx,
+               enum xkb_keymap_format format,
+               enum xkb_keymap_compile_flags flags)
+{
+    struct xkb_keymap *keymap;
+
+    keymap = calloc(1, sizeof(*keymap));
+    if (!keymap)
+        return NULL;
+
+    keymap->refcnt = 1;
+    keymap->ctx = xkb_context_ref(ctx);
+
+    keymap->format = format;
+    keymap->flags = flags;
+
+    update_builtin_keymap_fields(keymap);
+
+    return keymap;
+}
+
+struct xkb_key *
+XkbKeyByName(struct xkb_keymap *keymap, xkb_atom_t name, bool use_aliases)
+{
+    struct xkb_key *key;
+
+    xkb_foreach_key(key, keymap)
+        if (key->name == name)
+            return key;
+
+    if (use_aliases) {
+        xkb_atom_t new_name = XkbResolveKeyAlias(keymap, name);
+        if (new_name != XKB_ATOM_NONE)
+            return XkbKeyByName(keymap, new_name, false);
+    }
+
+    return NULL;
+}
+
+xkb_atom_t
+XkbResolveKeyAlias(struct xkb_keymap *keymap, xkb_atom_t name)
+{
+    for (unsigned i = 0; i < keymap->num_key_aliases; i++)
+        if (keymap->key_aliases[i].alias == name)
+            return keymap->key_aliases[i].real;
+
+    return XKB_ATOM_NONE;
+}
+
+void
+XkbEscapeMapName(char *name)
+{
+    /*
+     * All latin-1 alphanumerics, plus parens, slash, minus, underscore and
+     * wildcards.
+     */
+    static const unsigned char legal[] = {
+        0x00, 0x00, 0x00, 0x00, 0x00, 0xa7, 0xff, 0x83,
+        0xfe, 0xff, 0xff, 0x87, 0xfe, 0xff, 0xff, 0x07,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff
+    };
+
+    if (!name)
+        return;
+
+    while (*name) {
+        if (!(legal[*name / 8] & (1 << (*name % 8))))
+            *name = '_';
+        name++;
+    }
+}
diff --git a/src/3rdparty/xkbcommon/src/keymap.h b/src/3rdparty/xkbcommon/src/keymap.h
index c6b884d6bc..5f514ec779 100644
--- a/src/3rdparty/xkbcommon/src/keymap.h
+++ b/src/3rdparty/xkbcommon/src/keymap.h
@@ -133,7 +133,6 @@ enum xkb_action_type {
     ACTION_TYPE_SWITCH_VT,
     ACTION_TYPE_CTRL_SET,
     ACTION_TYPE_CTRL_LOCK,
-    ACTION_TYPE_KEY_REDIRECT,
     ACTION_TYPE_PRIVATE,
     _ACTION_TYPE_NUM_ENTRIES
 };
@@ -213,16 +212,6 @@ struct xkb_switch_screen_action {
     int8_t screen;
 };
 
-struct xkb_redirect_key_action {
-    enum xkb_action_type type;
-    enum xkb_action_flags flags;
-    xkb_keycode_t new_kc;
-    uint8_t mods_mask;
-    uint8_t mods;
-    uint16_t vmods_mask;
-    uint16_t vmods;
-};
-
 struct xkb_pointer_action {
     enum xkb_action_type type;
     enum xkb_action_flags flags;
@@ -250,7 +239,6 @@ union xkb_action {
     struct xkb_controls_action ctrls;
     struct xkb_pointer_default_action dflt;
     struct xkb_switch_screen_action screen;
-    struct xkb_redirect_key_action redirect;    /* XXX wholly unnecessary? */
     struct xkb_pointer_action ptr;
     struct xkb_pointer_button_action btn;
     struct xkb_private_action priv;
@@ -313,8 +301,8 @@ struct xkb_controls {
 
 /* Such an awkward name.  Oh well. */
 enum xkb_range_exceed_type {
+    RANGE_WRAP = 0,
     RANGE_SATURATE,
-    RANGE_WRAP,
     RANGE_REDIRECT,
 };
 
@@ -386,7 +374,8 @@ struct xkb_keymap {
     struct xkb_key_type *types;
     unsigned int num_types;
 
-    darray(struct xkb_sym_interpret) sym_interprets;
+    unsigned int num_sym_interprets;
+    struct xkb_sym_interpret *sym_interprets;
 
     darray(struct xkb_mod) mods;
 
@@ -423,12 +412,20 @@ XkbKeyGroupWidth(const struct xkb_key *key, xkb_layout_index_t layout)
     return key->groups[layout].type->num_levels;
 }
 
+struct xkb_keymap *
+xkb_keymap_new(struct xkb_context *ctx,
+               enum xkb_keymap_format format,
+               enum xkb_keymap_compile_flags flags);
+
 struct xkb_key *
 XkbKeyByName(struct xkb_keymap *keymap, xkb_atom_t name, bool use_aliases);
 
 xkb_atom_t
 XkbResolveKeyAlias(struct xkb_keymap *keymap, xkb_atom_t name);
 
+void
+XkbEscapeMapName(char *name);
+
 xkb_layout_index_t
 wrap_group_into_range(int32_t group,
                       xkb_layout_index_t num_groups,
@@ -439,9 +436,7 @@ struct xkb_keymap_format_ops {
     bool (*keymap_new_from_names)(struct xkb_keymap *keymap,
                                   const struct xkb_rule_names *names);
     bool (*keymap_new_from_string)(struct xkb_keymap *keymap,
-                                   const char *string);
-    bool (*keymap_new_from_buffer)(struct xkb_keymap *keymap,
-                                   const char *buffer, size_t length);
+                                   const char *string, size_t length);
     bool (*keymap_new_from_file)(struct xkb_keymap *keymap, FILE *file);
     char *(*keymap_get_as_string)(struct xkb_keymap *keymap);
 };
diff --git a/src/3rdparty/xkbcommon/src/keysym-utf.c b/src/3rdparty/xkbcommon/src/keysym-utf.c
index 5484a8311d..129da15cf8 100644
--- a/src/3rdparty/xkbcommon/src/keysym-utf.c
+++ b/src/3rdparty/xkbcommon/src/keysym-utf.c
@@ -838,20 +838,19 @@ static const struct codepair keysymtab[] = {
 static uint32_t
 bin_search(const struct codepair *table, size_t length, xkb_keysym_t keysym)
 {
-    int min = 0;
-    int max = length;
-    int mid;
+    int first = 0;
+    int last = length;
 
     if (keysym < table[0].keysym  || keysym > table[length].keysym)
         return 0;
 
     /* binary search in table */
-    while (max >= min) {
-        mid = (min + max) / 2;
+    while (last >= first) {
+        int mid = (first + last) / 2;
         if (table[mid].keysym < keysym)
-            min = mid + 1;
+            first = mid + 1;
         else if (table[mid].keysym > keysym)
-            max = mid - 1;
+            last = mid - 1;
         else /* found it */
             return table[mid].ucs;
     }
diff --git a/src/3rdparty/xkbcommon/src/keysym.c b/src/3rdparty/xkbcommon/src/keysym.c
index 1e92a4ac9f..f52d751973 100644
--- a/src/3rdparty/xkbcommon/src/keysym.c
+++ b/src/3rdparty/xkbcommon/src/keysym.c
@@ -53,24 +53,31 @@
 #include "keysym.h"
 #include "ks_tables.h"
 
+static inline const char *
+get_name(const struct name_keysym *entry)
+{
+    return keysym_names + entry->offset;
+}
+
 static int
 compare_by_keysym(const void *a, const void *b)
 {
-    const struct name_keysym *key = a, *entry = b;
-    return key->keysym - (int32_t)entry->keysym;
+    const xkb_keysym_t *key = a;
+    const struct name_keysym *entry = b;
+    return *key - (int32_t) entry->keysym;
 }
 
 static int
 compare_by_name(const void *a, const void *b)
 {
-    const struct name_keysym *key = a, *entry = b;
-    return strcasecmp(key->name, entry->name);
+    const char *key = a;
+    const struct name_keysym *entry = b;
+    return strcasecmp(key, get_name(entry));
 }
 
 XKB_EXPORT int
 xkb_keysym_get_name(xkb_keysym_t ks, char *buffer, size_t size)
 {
-    const struct name_keysym search = { .name = NULL, .keysym = ks };
     const struct name_keysym *entry;
 
     if ((ks & ((unsigned long) ~0x1fffffff)) != 0) {
@@ -78,12 +85,12 @@ xkb_keysym_get_name(xkb_keysym_t ks, char *buffer, size_t size)
         return -1;
     }
 
-    entry = bsearch(&search, keysym_to_name,
+    entry = bsearch(&ks, keysym_to_name,
                     ARRAY_SIZE(keysym_to_name),
                     sizeof(*keysym_to_name),
                     compare_by_keysym);
     if (entry)
-        return snprintf(buffer, size, "%s", entry->name);
+        return snprintf(buffer, size, "%s", get_name(entry));
 
     /* Unnamed Unicode codepoint. */
     if (ks >= 0x01000100 && ks <= 0x0110ffff) {
@@ -119,25 +126,25 @@ find_sym(const struct name_keysym *entry, const char *name, bool icase)
     if (!entry)
         return NULL;
 
-    if (!icase && strcmp(entry->name, name) == 0)
+    if (!icase && strcmp(get_name(entry), name) == 0)
         return entry;
     if (icase && xkb_keysym_is_lower(entry->keysym))
         return entry;
 
     for (iter = entry - 1; iter >= name_to_keysym; --iter) {
-        if (!icase && strcmp(iter->name, name) == 0)
+        if (!icase && strcmp(get_name(iter), name) == 0)
             return iter;
-        if (strcasecmp(iter->name, entry->name) != 0)
+        if (strcasecmp(get_name(iter), get_name(entry)) != 0)
             break;
         if (icase && xkb_keysym_is_lower(iter->keysym))
             return iter;
     }
 
     last = name_to_keysym + len;
-    for (iter = entry + 1; iter < last; --iter) {
-        if (!icase && strcmp(iter->name, name) == 0)
+    for (iter = entry + 1; iter < last; ++iter) {
+        if (!icase && strcmp(get_name(iter), name) == 0)
             return iter;
-        if (strcasecmp(iter->name, entry->name) != 0)
+        if (strcasecmp(get_name(iter), get_name(entry)) != 0)
             break;
         if (icase && xkb_keysym_is_lower(iter->keysym))
             return iter;
@@ -151,7 +158,6 @@ find_sym(const struct name_keysym *entry, const char *name, bool icase)
 XKB_EXPORT xkb_keysym_t
 xkb_keysym_from_name(const char *s, enum xkb_keysym_flags flags)
 {
-    const struct name_keysym search = { .name = s, .keysym = 0 };
     const struct name_keysym *entry;
     char *tmp;
     xkb_keysym_t val;
@@ -160,7 +166,7 @@ xkb_keysym_from_name(const char *s, enum xkb_keysym_flags flags)
     if (flags & ~XKB_KEYSYM_CASE_INSENSITIVE)
         return XKB_KEY_NoSymbol;
 
-    entry = bsearch(&search, name_to_keysym,
+    entry = bsearch(s, name_to_keysym,
                     ARRAY_SIZE(name_to_keysym),
                     sizeof(*name_to_keysym),
                     compare_by_name);
@@ -242,6 +248,26 @@ xkb_keysym_is_upper(xkb_keysym_t ks)
     return (ks == upper ? true : false);
 }
 
+xkb_keysym_t
+xkb_keysym_to_lower(xkb_keysym_t ks)
+{
+    xkb_keysym_t lower, upper;
+
+    XConvertCase(ks, &lower, &upper);
+
+    return lower;
+}
+
+xkb_keysym_t
+xkb_keysym_to_upper(xkb_keysym_t ks)
+{
+    xkb_keysym_t lower, upper;
+
+    XConvertCase(ks, &lower, &upper);
+
+    return upper;
+}
+
 /*
  * The following is copied verbatim from libX11:src/KeyBind.c, commit
  * d45b3fc19fbe95c41afc4e51d768df6d42332010, with the following changes:
diff --git a/src/3rdparty/xkbcommon/src/keysym.h b/src/3rdparty/xkbcommon/src/keysym.h
index 6f2280bfd4..e9374dc492 100644
--- a/src/3rdparty/xkbcommon/src/keysym.h
+++ b/src/3rdparty/xkbcommon/src/keysym.h
@@ -59,4 +59,10 @@ xkb_keysym_is_upper(xkb_keysym_t keysym);
 bool
 xkb_keysym_is_keypad(xkb_keysym_t keysym);
 
+xkb_keysym_t
+xkb_keysym_to_upper(xkb_keysym_t ks);
+
+xkb_keysym_t
+xkb_keysym_to_lower(xkb_keysym_t ks);
+
 #endif
diff --git a/src/3rdparty/xkbcommon/src/ks_tables.h b/src/3rdparty/xkbcommon/src/ks_tables.h
index a7e2b4705f..1010b694e4 100644
--- a/src/3rdparty/xkbcommon/src/ks_tables.h
+++ b/src/3rdparty/xkbcommon/src/ks_tables.h
@@ -1,4681 +1,7104 @@
-/* This file is autogenerated from Makefile.am; please do not commit directly. */
+
+/**
+ * This file comes from libxkbcommon and was generated by makekeys.py
+ * You can always fetch the latest version from:
+ * https://raw.github.com/xkbcommon/libxkbcommon/master/src/ks_tables.h
+ */
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Woverlength-strings"
+static const char *keysym_names =
+    "0\0"
+    "1\0"
+    "2\0"
+    "3\0"
+    "3270_AltCursor\0"
+    "3270_Attn\0"
+    "3270_BackTab\0"
+    "3270_ChangeScreen\0"
+    "3270_Copy\0"
+    "3270_CursorBlink\0"
+    "3270_CursorSelect\0"
+    "3270_DeleteWord\0"
+    "3270_Duplicate\0"
+    "3270_Enter\0"
+    "3270_EraseEOF\0"
+    "3270_EraseInput\0"
+    "3270_ExSelect\0"
+    "3270_FieldMark\0"
+    "3270_Ident\0"
+    "3270_Jump\0"
+    "3270_KeyClick\0"
+    "3270_Left2\0"
+    "3270_PA1\0"
+    "3270_PA2\0"
+    "3270_PA3\0"
+    "3270_Play\0"
+    "3270_PrintScreen\0"
+    "3270_Quit\0"
+    "3270_Record\0"
+    "3270_Reset\0"
+    "3270_Right2\0"
+    "3270_Rule\0"
+    "3270_Setup\0"
+    "3270_Test\0"
+    "4\0"
+    "5\0"
+    "6\0"
+    "7\0"
+    "8\0"
+    "9\0"
+    "A\0"
+    "a\0"
+    "Aacute\0"
+    "aacute\0"
+    "Abelowdot\0"
+    "abelowdot\0"
+    "abovedot\0"
+    "Abreve\0"
+    "abreve\0"
+    "Abreveacute\0"
+    "abreveacute\0"
+    "Abrevebelowdot\0"
+    "abrevebelowdot\0"
+    "Abrevegrave\0"
+    "abrevegrave\0"
+    "Abrevehook\0"
+    "abrevehook\0"
+    "Abrevetilde\0"
+    "abrevetilde\0"
+    "AccessX_Enable\0"
+    "AccessX_Feedback_Enable\0"
+    "Acircumflex\0"
+    "acircumflex\0"
+    "Acircumflexacute\0"
+    "acircumflexacute\0"
+    "Acircumflexbelowdot\0"
+    "acircumflexbelowdot\0"
+    "Acircumflexgrave\0"
+    "acircumflexgrave\0"
+    "Acircumflexhook\0"
+    "acircumflexhook\0"
+    "Acircumflextilde\0"
+    "acircumflextilde\0"
+    "acute\0"
+    "Adiaeresis\0"
+    "adiaeresis\0"
+    "AE\0"
+    "ae\0"
+    "Agrave\0"
+    "agrave\0"
+    "Ahook\0"
+    "ahook\0"
+    "Alt_L\0"
+    "Alt_R\0"
+    "Amacron\0"
+    "amacron\0"
+    "ampersand\0"
+    "Aogonek\0"
+    "aogonek\0"
+    "apostrophe\0"
+    "approxeq\0"
+    "approximate\0"
+    "Arabic_0\0"
+    "Arabic_1\0"
+    "Arabic_2\0"
+    "Arabic_3\0"
+    "Arabic_4\0"
+    "Arabic_5\0"
+    "Arabic_6\0"
+    "Arabic_7\0"
+    "Arabic_8\0"
+    "Arabic_9\0"
+    "Arabic_ain\0"
+    "Arabic_alef\0"
+    "Arabic_alefmaksura\0"
+    "Arabic_beh\0"
+    "Arabic_comma\0"
+    "Arabic_dad\0"
+    "Arabic_dal\0"
+    "Arabic_damma\0"
+    "Arabic_dammatan\0"
+    "Arabic_ddal\0"
+    "Arabic_farsi_yeh\0"
+    "Arabic_fatha\0"
+    "Arabic_fathatan\0"
+    "Arabic_feh\0"
+    "Arabic_fullstop\0"
+    "Arabic_gaf\0"
+    "Arabic_ghain\0"
+    "Arabic_ha\0"
+    "Arabic_hah\0"
+    "Arabic_hamza\0"
+    "Arabic_hamza_above\0"
+    "Arabic_hamza_below\0"
+    "Arabic_hamzaonalef\0"
+    "Arabic_hamzaonwaw\0"
+    "Arabic_hamzaonyeh\0"
+    "Arabic_hamzaunderalef\0"
+    "Arabic_heh\0"
+    "Arabic_heh_doachashmee\0"
+    "Arabic_heh_goal\0"
+    "Arabic_jeem\0"
+    "Arabic_jeh\0"
+    "Arabic_kaf\0"
+    "Arabic_kasra\0"
+    "Arabic_kasratan\0"
+    "Arabic_keheh\0"
+    "Arabic_khah\0"
+    "Arabic_lam\0"
+    "Arabic_madda_above\0"
+    "Arabic_maddaonalef\0"
+    "Arabic_meem\0"
+    "Arabic_noon\0"
+    "Arabic_noon_ghunna\0"
+    "Arabic_peh\0"
+    "Arabic_percent\0"
+    "Arabic_qaf\0"
+    "Arabic_question_mark\0"
+    "Arabic_ra\0"
+    "Arabic_rreh\0"
+    "Arabic_sad\0"
+    "Arabic_seen\0"
+    "Arabic_semicolon\0"
+    "Arabic_shadda\0"
+    "Arabic_sheen\0"
+    "Arabic_sukun\0"
+    "Arabic_superscript_alef\0"
+    "Arabic_switch\0"
+    "Arabic_tah\0"
+    "Arabic_tatweel\0"
+    "Arabic_tcheh\0"
+    "Arabic_teh\0"
+    "Arabic_tehmarbuta\0"
+    "Arabic_thal\0"
+    "Arabic_theh\0"
+    "Arabic_tteh\0"
+    "Arabic_veh\0"
+    "Arabic_waw\0"
+    "Arabic_yeh\0"
+    "Arabic_yeh_baree\0"
+    "Arabic_zah\0"
+    "Arabic_zain\0"
+    "Aring\0"
+    "aring\0"
+    "Armenian_accent\0"
+    "Armenian_amanak\0"
+    "Armenian_apostrophe\0"
+    "Armenian_AT\0"
+    "Armenian_at\0"
+    "Armenian_AYB\0"
+    "Armenian_ayb\0"
+    "Armenian_BEN\0"
+    "Armenian_ben\0"
+    "Armenian_but\0"
+    "Armenian_CHA\0"
+    "Armenian_cha\0"
+    "Armenian_DA\0"
+    "Armenian_da\0"
+    "Armenian_DZA\0"
+    "Armenian_dza\0"
+    "Armenian_E\0"
+    "Armenian_e\0"
+    "Armenian_exclam\0"
+    "Armenian_FE\0"
+    "Armenian_fe\0"
+    "Armenian_full_stop\0"
+    "Armenian_GHAT\0"
+    "Armenian_ghat\0"
+    "Armenian_GIM\0"
+    "Armenian_gim\0"
+    "Armenian_HI\0"
+    "Armenian_hi\0"
+    "Armenian_HO\0"
+    "Armenian_ho\0"
+    "Armenian_hyphen\0"
+    "Armenian_INI\0"
+    "Armenian_ini\0"
+    "Armenian_JE\0"
+    "Armenian_je\0"
+    "Armenian_KE\0"
+    "Armenian_ke\0"
+    "Armenian_KEN\0"
+    "Armenian_ken\0"
+    "Armenian_KHE\0"
+    "Armenian_khe\0"
+    "Armenian_ligature_ew\0"
+    "Armenian_LYUN\0"
+    "Armenian_lyun\0"
+    "Armenian_MEN\0"
+    "Armenian_men\0"
+    "Armenian_NU\0"
+    "Armenian_nu\0"
+    "Armenian_O\0"
+    "Armenian_o\0"
+    "Armenian_paruyk\0"
+    "Armenian_PE\0"
+    "Armenian_pe\0"
+    "Armenian_PYUR\0"
+    "Armenian_pyur\0"
+    "Armenian_question\0"
+    "Armenian_RA\0"
+    "Armenian_ra\0"
+    "Armenian_RE\0"
+    "Armenian_re\0"
+    "Armenian_SE\0"
+    "Armenian_se\0"
+    "Armenian_separation_mark\0"
+    "Armenian_SHA\0"
+    "Armenian_sha\0"
+    "Armenian_shesht\0"
+    "Armenian_TCHE\0"
+    "Armenian_tche\0"
+    "Armenian_TO\0"
+    "Armenian_to\0"
+    "Armenian_TSA\0"
+    "Armenian_tsa\0"
+    "Armenian_TSO\0"
+    "Armenian_tso\0"
+    "Armenian_TYUN\0"
+    "Armenian_tyun\0"
+    "Armenian_verjaket\0"
+    "Armenian_VEV\0"
+    "Armenian_vev\0"
+    "Armenian_VO\0"
+    "Armenian_vo\0"
+    "Armenian_VYUN\0"
+    "Armenian_vyun\0"
+    "Armenian_YECH\0"
+    "Armenian_yech\0"
+    "Armenian_yentamna\0"
+    "Armenian_ZA\0"
+    "Armenian_za\0"
+    "Armenian_ZHE\0"
+    "Armenian_zhe\0"
+    "asciicircum\0"
+    "asciitilde\0"
+    "asterisk\0"
+    "at\0"
+    "Atilde\0"
+    "atilde\0"
+    "AudibleBell_Enable\0"
+    "B\0"
+    "b\0"
+    "Babovedot\0"
+    "babovedot\0"
+    "backslash\0"
+    "BackSpace\0"
+    "BackTab\0"
+    "ballotcross\0"
+    "bar\0"
+    "because\0"
+    "Begin\0"
+    "blank\0"
+    "block\0"
+    "botintegral\0"
+    "botleftparens\0"
+    "botleftsqbracket\0"
+    "botleftsummation\0"
+    "botrightparens\0"
+    "botrightsqbracket\0"
+    "botrightsummation\0"
+    "bott\0"
+    "botvertsummationconnector\0"
+    "BounceKeys_Enable\0"
+    "braceleft\0"
+    "braceright\0"
+    "bracketleft\0"
+    "bracketright\0"
+    "braille_blank\0"
+    "braille_dot_1\0"
+    "braille_dot_10\0"
+    "braille_dot_2\0"
+    "braille_dot_3\0"
+    "braille_dot_4\0"
+    "braille_dot_5\0"
+    "braille_dot_6\0"
+    "braille_dot_7\0"
+    "braille_dot_8\0"
+    "braille_dot_9\0"
+    "braille_dots_1\0"
+    "braille_dots_12\0"
+    "braille_dots_123\0"
+    "braille_dots_1234\0"
+    "braille_dots_12345\0"
+    "braille_dots_123456\0"
+    "braille_dots_1234567\0"
+    "braille_dots_12345678\0"
+    "braille_dots_1234568\0"
+    "braille_dots_123457\0"
+    "braille_dots_1234578\0"
+    "braille_dots_123458\0"
+    "braille_dots_12346\0"
+    "braille_dots_123467\0"
+    "braille_dots_1234678\0"
+    "braille_dots_123468\0"
+    "braille_dots_12347\0"
+    "braille_dots_123478\0"
+    "braille_dots_12348\0"
+    "braille_dots_1235\0"
+    "braille_dots_12356\0"
+    "braille_dots_123567\0"
+    "braille_dots_1235678\0"
+    "braille_dots_123568\0"
+    "braille_dots_12357\0"
+    "braille_dots_123578\0"
+    "braille_dots_12358\0"
+    "braille_dots_1236\0"
+    "braille_dots_12367\0"
+    "braille_dots_123678\0"
+    "braille_dots_12368\0"
+    "braille_dots_1237\0"
+    "braille_dots_12378\0"
+    "braille_dots_1238\0"
+    "braille_dots_124\0"
+    "braille_dots_1245\0"
+    "braille_dots_12456\0"
+    "braille_dots_124567\0"
+    "braille_dots_1245678\0"
+    "braille_dots_124568\0"
+    "braille_dots_12457\0"
+    "braille_dots_124578\0"
+    "braille_dots_12458\0"
+    "braille_dots_1246\0"
+    "braille_dots_12467\0"
+    "braille_dots_124678\0"
+    "braille_dots_12468\0"
+    "braille_dots_1247\0"
+    "braille_dots_12478\0"
+    "braille_dots_1248\0"
+    "braille_dots_125\0"
+    "braille_dots_1256\0"
+    "braille_dots_12567\0"
+    "braille_dots_125678\0"
+    "braille_dots_12568\0"
+    "braille_dots_1257\0"
+    "braille_dots_12578\0"
+    "braille_dots_1258\0"
+    "braille_dots_126\0"
+    "braille_dots_1267\0"
+    "braille_dots_12678\0"
+    "braille_dots_1268\0"
+    "braille_dots_127\0"
+    "braille_dots_1278\0"
+    "braille_dots_128\0"
+    "braille_dots_13\0"
+    "braille_dots_134\0"
+    "braille_dots_1345\0"
+    "braille_dots_13456\0"
+    "braille_dots_134567\0"
+    "braille_dots_1345678\0"
+    "braille_dots_134568\0"
+    "braille_dots_13457\0"
+    "braille_dots_134578\0"
+    "braille_dots_13458\0"
+    "braille_dots_1346\0"
+    "braille_dots_13467\0"
+    "braille_dots_134678\0"
+    "braille_dots_13468\0"
+    "braille_dots_1347\0"
+    "braille_dots_13478\0"
+    "braille_dots_1348\0"
+    "braille_dots_135\0"
+    "braille_dots_1356\0"
+    "braille_dots_13567\0"
+    "braille_dots_135678\0"
+    "braille_dots_13568\0"
+    "braille_dots_1357\0"
+    "braille_dots_13578\0"
+    "braille_dots_1358\0"
+    "braille_dots_136\0"
+    "braille_dots_1367\0"
+    "braille_dots_13678\0"
+    "braille_dots_1368\0"
+    "braille_dots_137\0"
+    "braille_dots_1378\0"
+    "braille_dots_138\0"
+    "braille_dots_14\0"
+    "braille_dots_145\0"
+    "braille_dots_1456\0"
+    "braille_dots_14567\0"
+    "braille_dots_145678\0"
+    "braille_dots_14568\0"
+    "braille_dots_1457\0"
+    "braille_dots_14578\0"
+    "braille_dots_1458\0"
+    "braille_dots_146\0"
+    "braille_dots_1467\0"
+    "braille_dots_14678\0"
+    "braille_dots_1468\0"
+    "braille_dots_147\0"
+    "braille_dots_1478\0"
+    "braille_dots_148\0"
+    "braille_dots_15\0"
+    "braille_dots_156\0"
+    "braille_dots_1567\0"
+    "braille_dots_15678\0"
+    "braille_dots_1568\0"
+    "braille_dots_157\0"
+    "braille_dots_1578\0"
+    "braille_dots_158\0"
+    "braille_dots_16\0"
+    "braille_dots_167\0"
+    "braille_dots_1678\0"
+    "braille_dots_168\0"
+    "braille_dots_17\0"
+    "braille_dots_178\0"
+    "braille_dots_18\0"
+    "braille_dots_2\0"
+    "braille_dots_23\0"
+    "braille_dots_234\0"
+    "braille_dots_2345\0"
+    "braille_dots_23456\0"
+    "braille_dots_234567\0"
+    "braille_dots_2345678\0"
+    "braille_dots_234568\0"
+    "braille_dots_23457\0"
+    "braille_dots_234578\0"
+    "braille_dots_23458\0"
+    "braille_dots_2346\0"
+    "braille_dots_23467\0"
+    "braille_dots_234678\0"
+    "braille_dots_23468\0"
+    "braille_dots_2347\0"
+    "braille_dots_23478\0"
+    "braille_dots_2348\0"
+    "braille_dots_235\0"
+    "braille_dots_2356\0"
+    "braille_dots_23567\0"
+    "braille_dots_235678\0"
+    "braille_dots_23568\0"
+    "braille_dots_2357\0"
+    "braille_dots_23578\0"
+    "braille_dots_2358\0"
+    "braille_dots_236\0"
+    "braille_dots_2367\0"
+    "braille_dots_23678\0"
+    "braille_dots_2368\0"
+    "braille_dots_237\0"
+    "braille_dots_2378\0"
+    "braille_dots_238\0"
+    "braille_dots_24\0"
+    "braille_dots_245\0"
+    "braille_dots_2456\0"
+    "braille_dots_24567\0"
+    "braille_dots_245678\0"
+    "braille_dots_24568\0"
+    "braille_dots_2457\0"
+    "braille_dots_24578\0"
+    "braille_dots_2458\0"
+    "braille_dots_246\0"
+    "braille_dots_2467\0"
+    "braille_dots_24678\0"
+    "braille_dots_2468\0"
+    "braille_dots_247\0"
+    "braille_dots_2478\0"
+    "braille_dots_248\0"
+    "braille_dots_25\0"
+    "braille_dots_256\0"
+    "braille_dots_2567\0"
+    "braille_dots_25678\0"
+    "braille_dots_2568\0"
+    "braille_dots_257\0"
+    "braille_dots_2578\0"
+    "braille_dots_258\0"
+    "braille_dots_26\0"
+    "braille_dots_267\0"
+    "braille_dots_2678\0"
+    "braille_dots_268\0"
+    "braille_dots_27\0"
+    "braille_dots_278\0"
+    "braille_dots_28\0"
+    "braille_dots_3\0"
+    "braille_dots_34\0"
+    "braille_dots_345\0"
+    "braille_dots_3456\0"
+    "braille_dots_34567\0"
+    "braille_dots_345678\0"
+    "braille_dots_34568\0"
+    "braille_dots_3457\0"
+    "braille_dots_34578\0"
+    "braille_dots_3458\0"
+    "braille_dots_346\0"
+    "braille_dots_3467\0"
+    "braille_dots_34678\0"
+    "braille_dots_3468\0"
+    "braille_dots_347\0"
+    "braille_dots_3478\0"
+    "braille_dots_348\0"
+    "braille_dots_35\0"
+    "braille_dots_356\0"
+    "braille_dots_3567\0"
+    "braille_dots_35678\0"
+    "braille_dots_3568\0"
+    "braille_dots_357\0"
+    "braille_dots_3578\0"
+    "braille_dots_358\0"
+    "braille_dots_36\0"
+    "braille_dots_367\0"
+    "braille_dots_3678\0"
+    "braille_dots_368\0"
+    "braille_dots_37\0"
+    "braille_dots_378\0"
+    "braille_dots_38\0"
+    "braille_dots_4\0"
+    "braille_dots_45\0"
+    "braille_dots_456\0"
+    "braille_dots_4567\0"
+    "braille_dots_45678\0"
+    "braille_dots_4568\0"
+    "braille_dots_457\0"
+    "braille_dots_4578\0"
+    "braille_dots_458\0"
+    "braille_dots_46\0"
+    "braille_dots_467\0"
+    "braille_dots_4678\0"
+    "braille_dots_468\0"
+    "braille_dots_47\0"
+    "braille_dots_478\0"
+    "braille_dots_48\0"
+    "braille_dots_5\0"
+    "braille_dots_56\0"
+    "braille_dots_567\0"
+    "braille_dots_5678\0"
+    "braille_dots_568\0"
+    "braille_dots_57\0"
+    "braille_dots_578\0"
+    "braille_dots_58\0"
+    "braille_dots_6\0"
+    "braille_dots_67\0"
+    "braille_dots_678\0"
+    "braille_dots_68\0"
+    "braille_dots_7\0"
+    "braille_dots_78\0"
+    "braille_dots_8\0"
+    "Break\0"
+    "breve\0"
+    "brokenbar\0"
+    "Byelorussian_shortu\0"
+    "Byelorussian_SHORTU\0"
+    "C\0"
+    "c\0"
+    "c_h\0"
+    "C_h\0"
+    "C_H\0"
+    "Cabovedot\0"
+    "cabovedot\0"
+    "Cacute\0"
+    "cacute\0"
+    "Cancel\0"
+    "Caps_Lock\0"
+    "careof\0"
+    "caret\0"
+    "caron\0"
+    "Ccaron\0"
+    "ccaron\0"
+    "Ccedilla\0"
+    "ccedilla\0"
+    "Ccircumflex\0"
+    "ccircumflex\0"
+    "cedilla\0"
+    "cent\0"
+    "ch\0"
+    "Ch\0"
+    "CH\0"
+    "checkerboard\0"
+    "checkmark\0"
+    "circle\0"
+    "Clear\0"
+    "ClearLine\0"
+    "club\0"
+    "Codeinput\0"
+    "colon\0"
+    "ColonSign\0"
+    "comma\0"
+    "containsas\0"
+    "Control_L\0"
+    "Control_R\0"
+    "copyright\0"
+    "cr\0"
+    "crossinglines\0"
+    "CruzeiroSign\0"
+    "cuberoot\0"
+    "currency\0"
+    "cursor\0"
+    "Cyrillic_a\0"
+    "Cyrillic_A\0"
+    "Cyrillic_be\0"
+    "Cyrillic_BE\0"
+    "Cyrillic_che\0"
+    "Cyrillic_CHE\0"
+    "Cyrillic_CHE_descender\0"
+    "Cyrillic_che_descender\0"
+    "Cyrillic_CHE_vertstroke\0"
+    "Cyrillic_che_vertstroke\0"
+    "Cyrillic_de\0"
+    "Cyrillic_DE\0"
+    "Cyrillic_dzhe\0"
+    "Cyrillic_DZHE\0"
+    "Cyrillic_e\0"
+    "Cyrillic_E\0"
+    "Cyrillic_ef\0"
+    "Cyrillic_EF\0"
+    "Cyrillic_el\0"
+    "Cyrillic_EL\0"
+    "Cyrillic_em\0"
+    "Cyrillic_EM\0"
+    "Cyrillic_en\0"
+    "Cyrillic_EN\0"
+    "Cyrillic_EN_descender\0"
+    "Cyrillic_en_descender\0"
+    "Cyrillic_er\0"
+    "Cyrillic_ER\0"
+    "Cyrillic_es\0"
+    "Cyrillic_ES\0"
+    "Cyrillic_ghe\0"
+    "Cyrillic_GHE\0"
+    "Cyrillic_GHE_bar\0"
+    "Cyrillic_ghe_bar\0"
+    "Cyrillic_ha\0"
+    "Cyrillic_HA\0"
+    "Cyrillic_HA_descender\0"
+    "Cyrillic_ha_descender\0"
+    "Cyrillic_hardsign\0"
+    "Cyrillic_HARDSIGN\0"
+    "Cyrillic_i\0"
+    "Cyrillic_I\0"
+    "Cyrillic_I_macron\0"
+    "Cyrillic_i_macron\0"
+    "Cyrillic_ie\0"
+    "Cyrillic_IE\0"
+    "Cyrillic_io\0"
+    "Cyrillic_IO\0"
+    "Cyrillic_je\0"
+    "Cyrillic_JE\0"
+    "Cyrillic_ka\0"
+    "Cyrillic_KA\0"
+    "Cyrillic_KA_descender\0"
+    "Cyrillic_ka_descender\0"
+    "Cyrillic_KA_vertstroke\0"
+    "Cyrillic_ka_vertstroke\0"
+    "Cyrillic_lje\0"
+    "Cyrillic_LJE\0"
+    "Cyrillic_nje\0"
+    "Cyrillic_NJE\0"
+    "Cyrillic_o\0"
+    "Cyrillic_O\0"
+    "Cyrillic_O_bar\0"
+    "Cyrillic_o_bar\0"
+    "Cyrillic_pe\0"
+    "Cyrillic_PE\0"
+    "Cyrillic_SCHWA\0"
+    "Cyrillic_schwa\0"
+    "Cyrillic_sha\0"
+    "Cyrillic_SHA\0"
+    "Cyrillic_shcha\0"
+    "Cyrillic_SHCHA\0"
+    "Cyrillic_SHHA\0"
+    "Cyrillic_shha\0"
+    "Cyrillic_shorti\0"
+    "Cyrillic_SHORTI\0"
+    "Cyrillic_softsign\0"
+    "Cyrillic_SOFTSIGN\0"
+    "Cyrillic_te\0"
+    "Cyrillic_TE\0"
+    "Cyrillic_tse\0"
+    "Cyrillic_TSE\0"
+    "Cyrillic_u\0"
+    "Cyrillic_U\0"
+    "Cyrillic_U_macron\0"
+    "Cyrillic_u_macron\0"
+    "Cyrillic_U_straight\0"
+    "Cyrillic_u_straight\0"
+    "Cyrillic_U_straight_bar\0"
+    "Cyrillic_u_straight_bar\0"
+    "Cyrillic_ve\0"
+    "Cyrillic_VE\0"
+    "Cyrillic_ya\0"
+    "Cyrillic_YA\0"
+    "Cyrillic_yeru\0"
+    "Cyrillic_YERU\0"
+    "Cyrillic_yu\0"
+    "Cyrillic_YU\0"
+    "Cyrillic_ze\0"
+    "Cyrillic_ZE\0"
+    "Cyrillic_zhe\0"
+    "Cyrillic_ZHE\0"
+    "Cyrillic_ZHE_descender\0"
+    "Cyrillic_zhe_descender\0"
+    "D\0"
+    "d\0"
+    "Dabovedot\0"
+    "dabovedot\0"
+    "Dacute_accent\0"
+    "dagger\0"
+    "Dcaron\0"
+    "dcaron\0"
+    "Dcedilla_accent\0"
+    "Dcircumflex_accent\0"
+    "Ddiaeresis\0"
+    "dead_a\0"
+    "dead_A\0"
+    "dead_abovecomma\0"
+    "dead_abovedot\0"
+    "dead_abovereversedcomma\0"
+    "dead_abovering\0"
+    "dead_aboveverticalline\0"
+    "dead_acute\0"
+    "dead_belowbreve\0"
+    "dead_belowcircumflex\0"
+    "dead_belowcomma\0"
+    "dead_belowdiaeresis\0"
+    "dead_belowdot\0"
+    "dead_belowmacron\0"
+    "dead_belowring\0"
+    "dead_belowtilde\0"
+    "dead_belowverticalline\0"
+    "dead_breve\0"
+    "dead_capital_schwa\0"
+    "dead_caron\0"
+    "dead_cedilla\0"
+    "dead_circumflex\0"
+    "dead_currency\0"
+    "dead_dasia\0"
+    "dead_diaeresis\0"
+    "dead_doubleacute\0"
+    "dead_doublegrave\0"
+    "dead_e\0"
+    "dead_E\0"
+    "dead_grave\0"
+    "dead_greek\0"
+    "dead_hook\0"
+    "dead_horn\0"
+    "dead_i\0"
+    "dead_I\0"
+    "dead_invertedbreve\0"
+    "dead_iota\0"
+    "dead_longsolidusoverlay\0"
+    "dead_lowline\0"
+    "dead_macron\0"
+    "dead_o\0"
+    "dead_O\0"
+    "dead_ogonek\0"
+    "dead_perispomeni\0"
+    "dead_psili\0"
+    "dead_semivoiced_sound\0"
+    "dead_small_schwa\0"
+    "dead_stroke\0"
+    "dead_tilde\0"
+    "dead_u\0"
+    "dead_U\0"
+    "dead_voiced_sound\0"
+    "decimalpoint\0"
+    "degree\0"
+    "Delete\0"
+    "DeleteChar\0"
+    "DeleteLine\0"
+    "Dgrave_accent\0"
+    "diaeresis\0"
+    "diamond\0"
+    "digitspace\0"
+    "dintegral\0"
+    "division\0"
+    "dollar\0"
+    "DongSign\0"
+    "doubbaselinedot\0"
+    "doubleacute\0"
+    "doubledagger\0"
+    "doublelowquotemark\0"
+    "Down\0"
+    "downarrow\0"
+    "downcaret\0"
+    "downshoe\0"
+    "downstile\0"
+    "downtack\0"
+    "DRemove\0"
+    "Dring_accent\0"
+    "Dstroke\0"
+    "dstroke\0"
+    "Dtilde\0"
+    "E\0"
+    "e\0"
+    "Eabovedot\0"
+    "eabovedot\0"
+    "Eacute\0"
+    "eacute\0"
+    "Ebelowdot\0"
+    "ebelowdot\0"
+    "Ecaron\0"
+    "ecaron\0"
+    "Ecircumflex\0"
+    "ecircumflex\0"
+    "Ecircumflexacute\0"
+    "ecircumflexacute\0"
+    "Ecircumflexbelowdot\0"
+    "ecircumflexbelowdot\0"
+    "Ecircumflexgrave\0"
+    "ecircumflexgrave\0"
+    "Ecircumflexhook\0"
+    "ecircumflexhook\0"
+    "Ecircumflextilde\0"
+    "ecircumflextilde\0"
+    "EcuSign\0"
+    "Ediaeresis\0"
+    "ediaeresis\0"
+    "Egrave\0"
+    "egrave\0"
+    "Ehook\0"
+    "ehook\0"
+    "eightsubscript\0"
+    "eightsuperior\0"
+    "Eisu_Shift\0"
+    "Eisu_toggle\0"
+    "elementof\0"
+    "ellipsis\0"
+    "em3space\0"
+    "em4space\0"
+    "Emacron\0"
+    "emacron\0"
+    "emdash\0"
+    "emfilledcircle\0"
+    "emfilledrect\0"
+    "emopencircle\0"
+    "emopenrectangle\0"
+    "emptyset\0"
+    "emspace\0"
+    "End\0"
+    "endash\0"
+    "enfilledcircbullet\0"
+    "enfilledsqbullet\0"
+    "ENG\0"
+    "eng\0"
+    "enopencircbullet\0"
+    "enopensquarebullet\0"
+    "enspace\0"
+    "Eogonek\0"
+    "eogonek\0"
+    "equal\0"
+    "Escape\0"
+    "ETH\0"
+    "Eth\0"
+    "eth\0"
+    "Etilde\0"
+    "etilde\0"
+    "EuroSign\0"
+    "exclam\0"
+    "exclamdown\0"
+    "Execute\0"
+    "Ext16bit_L\0"
+    "Ext16bit_R\0"
+    "EZH\0"
+    "ezh\0"
+    "F\0"
+    "f\0"
+    "F1\0"
+    "F10\0"
+    "F11\0"
+    "F12\0"
+    "F13\0"
+    "F14\0"
+    "F15\0"
+    "F16\0"
+    "F17\0"
+    "F18\0"
+    "F19\0"
+    "F2\0"
+    "F20\0"
+    "F21\0"
+    "F22\0"
+    "F23\0"
+    "F24\0"
+    "F25\0"
+    "F26\0"
+    "F27\0"
+    "F28\0"
+    "F29\0"
+    "F3\0"
+    "F30\0"
+    "F31\0"
+    "F32\0"
+    "F33\0"
+    "F34\0"
+    "F35\0"
+    "F4\0"
+    "F5\0"
+    "F6\0"
+    "F7\0"
+    "F8\0"
+    "F9\0"
+    "Fabovedot\0"
+    "fabovedot\0"
+    "Farsi_0\0"
+    "Farsi_1\0"
+    "Farsi_2\0"
+    "Farsi_3\0"
+    "Farsi_4\0"
+    "Farsi_5\0"
+    "Farsi_6\0"
+    "Farsi_7\0"
+    "Farsi_8\0"
+    "Farsi_9\0"
+    "Farsi_yeh\0"
+    "femalesymbol\0"
+    "ff\0"
+    "FFrancSign\0"
+    "figdash\0"
+    "filledlefttribullet\0"
+    "filledrectbullet\0"
+    "filledrighttribullet\0"
+    "filledtribulletdown\0"
+    "filledtribulletup\0"
+    "Find\0"
+    "First_Virtual_Screen\0"
+    "fiveeighths\0"
+    "fivesixths\0"
+    "fivesubscript\0"
+    "fivesuperior\0"
+    "fourfifths\0"
+    "foursubscript\0"
+    "foursuperior\0"
+    "fourthroot\0"
+    "function\0"
+    "G\0"
+    "g\0"
+    "Gabovedot\0"
+    "gabovedot\0"
+    "Gbreve\0"
+    "gbreve\0"
+    "Gcaron\0"
+    "gcaron\0"
+    "Gcedilla\0"
+    "gcedilla\0"
+    "Gcircumflex\0"
+    "gcircumflex\0"
+    "Georgian_an\0"
+    "Georgian_ban\0"
+    "Georgian_can\0"
+    "Georgian_char\0"
+    "Georgian_chin\0"
+    "Georgian_cil\0"
+    "Georgian_don\0"
+    "Georgian_en\0"
+    "Georgian_fi\0"
+    "Georgian_gan\0"
+    "Georgian_ghan\0"
+    "Georgian_hae\0"
+    "Georgian_har\0"
+    "Georgian_he\0"
+    "Georgian_hie\0"
+    "Georgian_hoe\0"
+    "Georgian_in\0"
+    "Georgian_jhan\0"
+    "Georgian_jil\0"
+    "Georgian_kan\0"
+    "Georgian_khar\0"
+    "Georgian_las\0"
+    "Georgian_man\0"
+    "Georgian_nar\0"
+    "Georgian_on\0"
+    "Georgian_par\0"
+    "Georgian_phar\0"
+    "Georgian_qar\0"
+    "Georgian_rae\0"
+    "Georgian_san\0"
+    "Georgian_shin\0"
+    "Georgian_tan\0"
+    "Georgian_tar\0"
+    "Georgian_un\0"
+    "Georgian_vin\0"
+    "Georgian_we\0"
+    "Georgian_xan\0"
+    "Georgian_zen\0"
+    "Georgian_zhar\0"
+    "grave\0"
+    "greater\0"
+    "greaterthanequal\0"
+    "Greek_accentdieresis\0"
+    "Greek_ALPHA\0"
+    "Greek_alpha\0"
+    "Greek_ALPHAaccent\0"
+    "Greek_alphaaccent\0"
+    "Greek_BETA\0"
+    "Greek_beta\0"
+    "Greek_CHI\0"
+    "Greek_chi\0"
+    "Greek_DELTA\0"
+    "Greek_delta\0"
+    "Greek_EPSILON\0"
+    "Greek_epsilon\0"
+    "Greek_EPSILONaccent\0"
+    "Greek_epsilonaccent\0"
+    "Greek_ETA\0"
+    "Greek_eta\0"
+    "Greek_ETAaccent\0"
+    "Greek_etaaccent\0"
+    "Greek_finalsmallsigma\0"
+    "Greek_GAMMA\0"
+    "Greek_gamma\0"
+    "Greek_horizbar\0"
+    "Greek_IOTA\0"
+    "Greek_iota\0"
+    "Greek_IOTAaccent\0"
+    "Greek_iotaaccent\0"
+    "Greek_iotaaccentdieresis\0"
+    "Greek_IOTAdiaeresis\0"
+    "Greek_IOTAdieresis\0"
+    "Greek_iotadieresis\0"
+    "Greek_KAPPA\0"
+    "Greek_kappa\0"
+    "Greek_LAMBDA\0"
+    "Greek_lambda\0"
+    "Greek_LAMDA\0"
+    "Greek_lamda\0"
+    "Greek_MU\0"
+    "Greek_mu\0"
+    "Greek_NU\0"
+    "Greek_nu\0"
+    "Greek_OMEGA\0"
+    "Greek_omega\0"
+    "Greek_OMEGAaccent\0"
+    "Greek_omegaaccent\0"
+    "Greek_OMICRON\0"
+    "Greek_omicron\0"
+    "Greek_OMICRONaccent\0"
+    "Greek_omicronaccent\0"
+    "Greek_PHI\0"
+    "Greek_phi\0"
+    "Greek_PI\0"
+    "Greek_pi\0"
+    "Greek_PSI\0"
+    "Greek_psi\0"
+    "Greek_RHO\0"
+    "Greek_rho\0"
+    "Greek_SIGMA\0"
+    "Greek_sigma\0"
+    "Greek_switch\0"
+    "Greek_TAU\0"
+    "Greek_tau\0"
+    "Greek_THETA\0"
+    "Greek_theta\0"
+    "Greek_UPSILON\0"
+    "Greek_upsilon\0"
+    "Greek_UPSILONaccent\0"
+    "Greek_upsilonaccent\0"
+    "Greek_upsilonaccentdieresis\0"
+    "Greek_UPSILONdieresis\0"
+    "Greek_upsilondieresis\0"
+    "Greek_XI\0"
+    "Greek_xi\0"
+    "Greek_ZETA\0"
+    "Greek_zeta\0"
+    "guilder\0"
+    "guillemotleft\0"
+    "guillemotright\0"
+    "H\0"
+    "h\0"
+    "hairspace\0"
+    "Hangul\0"
+    "Hangul_A\0"
+    "Hangul_AE\0"
+    "Hangul_AraeA\0"
+    "Hangul_AraeAE\0"
+    "Hangul_Banja\0"
+    "Hangul_Cieuc\0"
+    "Hangul_Codeinput\0"
+    "Hangul_Dikeud\0"
+    "Hangul_E\0"
+    "Hangul_End\0"
+    "Hangul_EO\0"
+    "Hangul_EU\0"
+    "Hangul_Hanja\0"
+    "Hangul_Hieuh\0"
+    "Hangul_I\0"
+    "Hangul_Ieung\0"
+    "Hangul_J_Cieuc\0"
+    "Hangul_J_Dikeud\0"
+    "Hangul_J_Hieuh\0"
+    "Hangul_J_Ieung\0"
+    "Hangul_J_Jieuj\0"
+    "Hangul_J_Khieuq\0"
+    "Hangul_J_Kiyeog\0"
+    "Hangul_J_KiyeogSios\0"
+    "Hangul_J_KkogjiDalrinIeung\0"
+    "Hangul_J_Mieum\0"
+    "Hangul_J_Nieun\0"
+    "Hangul_J_NieunHieuh\0"
+    "Hangul_J_NieunJieuj\0"
+    "Hangul_J_PanSios\0"
+    "Hangul_J_Phieuf\0"
+    "Hangul_J_Pieub\0"
+    "Hangul_J_PieubSios\0"
+    "Hangul_J_Rieul\0"
+    "Hangul_J_RieulHieuh\0"
+    "Hangul_J_RieulKiyeog\0"
+    "Hangul_J_RieulMieum\0"
+    "Hangul_J_RieulPhieuf\0"
+    "Hangul_J_RieulPieub\0"
+    "Hangul_J_RieulSios\0"
+    "Hangul_J_RieulTieut\0"
+    "Hangul_J_Sios\0"
+    "Hangul_J_SsangKiyeog\0"
+    "Hangul_J_SsangSios\0"
+    "Hangul_J_Tieut\0"
+    "Hangul_J_YeorinHieuh\0"
+    "Hangul_Jamo\0"
+    "Hangul_Jeonja\0"
+    "Hangul_Jieuj\0"
+    "Hangul_Khieuq\0"
+    "Hangul_Kiyeog\0"
+    "Hangul_KiyeogSios\0"
+    "Hangul_KkogjiDalrinIeung\0"
+    "Hangul_Mieum\0"
+    "Hangul_MultipleCandidate\0"
+    "Hangul_Nieun\0"
+    "Hangul_NieunHieuh\0"
+    "Hangul_NieunJieuj\0"
+    "Hangul_O\0"
+    "Hangul_OE\0"
+    "Hangul_PanSios\0"
+    "Hangul_Phieuf\0"
+    "Hangul_Pieub\0"
+    "Hangul_PieubSios\0"
+    "Hangul_PostHanja\0"
+    "Hangul_PreHanja\0"
+    "Hangul_PreviousCandidate\0"
+    "Hangul_Rieul\0"
+    "Hangul_RieulHieuh\0"
+    "Hangul_RieulKiyeog\0"
+    "Hangul_RieulMieum\0"
+    "Hangul_RieulPhieuf\0"
+    "Hangul_RieulPieub\0"
+    "Hangul_RieulSios\0"
+    "Hangul_RieulTieut\0"
+    "Hangul_RieulYeorinHieuh\0"
+    "Hangul_Romaja\0"
+    "Hangul_SingleCandidate\0"
+    "Hangul_Sios\0"
+    "Hangul_Special\0"
+    "Hangul_SsangDikeud\0"
+    "Hangul_SsangJieuj\0"
+    "Hangul_SsangKiyeog\0"
+    "Hangul_SsangPieub\0"
+    "Hangul_SsangSios\0"
+    "Hangul_Start\0"
+    "Hangul_SunkyeongeumMieum\0"
+    "Hangul_SunkyeongeumPhieuf\0"
+    "Hangul_SunkyeongeumPieub\0"
+    "Hangul_switch\0"
+    "Hangul_Tieut\0"
+    "Hangul_U\0"
+    "Hangul_WA\0"
+    "Hangul_WAE\0"
+    "Hangul_WE\0"
+    "Hangul_WEO\0"
+    "Hangul_WI\0"
+    "Hangul_YA\0"
+    "Hangul_YAE\0"
+    "Hangul_YE\0"
+    "Hangul_YEO\0"
+    "Hangul_YeorinHieuh\0"
+    "Hangul_YI\0"
+    "Hangul_YO\0"
+    "Hangul_YU\0"
+    "Hankaku\0"
+    "Hcircumflex\0"
+    "hcircumflex\0"
+    "heart\0"
+    "hebrew_aleph\0"
+    "hebrew_ayin\0"
+    "hebrew_bet\0"
+    "hebrew_beth\0"
+    "hebrew_chet\0"
+    "hebrew_dalet\0"
+    "hebrew_daleth\0"
+    "hebrew_doublelowline\0"
+    "hebrew_finalkaph\0"
+    "hebrew_finalmem\0"
+    "hebrew_finalnun\0"
+    "hebrew_finalpe\0"
+    "hebrew_finalzade\0"
+    "hebrew_finalzadi\0"
+    "hebrew_gimel\0"
+    "hebrew_gimmel\0"
+    "hebrew_he\0"
+    "hebrew_het\0"
+    "hebrew_kaph\0"
+    "hebrew_kuf\0"
+    "hebrew_lamed\0"
+    "hebrew_mem\0"
+    "hebrew_nun\0"
+    "hebrew_pe\0"
+    "hebrew_qoph\0"
+    "hebrew_resh\0"
+    "hebrew_samech\0"
+    "hebrew_samekh\0"
+    "hebrew_shin\0"
+    "Hebrew_switch\0"
+    "hebrew_taf\0"
+    "hebrew_taw\0"
+    "hebrew_tet\0"
+    "hebrew_teth\0"
+    "hebrew_waw\0"
+    "hebrew_yod\0"
+    "hebrew_zade\0"
+    "hebrew_zadi\0"
+    "hebrew_zain\0"
+    "hebrew_zayin\0"
+    "Help\0"
+    "Henkan\0"
+    "Henkan_Mode\0"
+    "hexagram\0"
+    "Hiragana\0"
+    "Hiragana_Katakana\0"
+    "Home\0"
+    "horizconnector\0"
+    "horizlinescan1\0"
+    "horizlinescan3\0"
+    "horizlinescan5\0"
+    "horizlinescan7\0"
+    "horizlinescan9\0"
+    "hpBackTab\0"
+    "hpblock\0"
+    "hpClearLine\0"
+    "hpDeleteChar\0"
+    "hpDeleteLine\0"
+    "hpguilder\0"
+    "hpInsertChar\0"
+    "hpInsertLine\0"
+    "hpIO\0"
+    "hpKP_BackTab\0"
+    "hplira\0"
+    "hplongminus\0"
+    "hpModelock1\0"
+    "hpModelock2\0"
+    "hpmute_acute\0"
+    "hpmute_asciicircum\0"
+    "hpmute_asciitilde\0"
+    "hpmute_diaeresis\0"
+    "hpmute_grave\0"
+    "hpReset\0"
+    "hpSystem\0"
+    "hpUser\0"
+    "hpYdiaeresis\0"
+    "Hstroke\0"
+    "hstroke\0"
+    "ht\0"
+    "Hyper_L\0"
+    "Hyper_R\0"
+    "hyphen\0"
+    "I\0"
+    "i\0"
+    "Iabovedot\0"
+    "Iacute\0"
+    "iacute\0"
+    "Ibelowdot\0"
+    "ibelowdot\0"
+    "Ibreve\0"
+    "ibreve\0"
+    "Icircumflex\0"
+    "icircumflex\0"
+    "identical\0"
+    "Idiaeresis\0"
+    "idiaeresis\0"
+    "idotless\0"
+    "ifonlyif\0"
+    "Igrave\0"
+    "igrave\0"
+    "Ihook\0"
+    "ihook\0"
+    "Imacron\0"
+    "imacron\0"
+    "implies\0"
+    "includedin\0"
+    "includes\0"
+    "infinity\0"
+    "Insert\0"
+    "InsertChar\0"
+    "InsertLine\0"
+    "integral\0"
+    "intersection\0"
+    "IO\0"
+    "Iogonek\0"
+    "iogonek\0"
+    "ISO_Center_Object\0"
+    "ISO_Continuous_Underline\0"
+    "ISO_Discontinuous_Underline\0"
+    "ISO_Emphasize\0"
+    "ISO_Enter\0"
+    "ISO_Fast_Cursor_Down\0"
+    "ISO_Fast_Cursor_Left\0"
+    "ISO_Fast_Cursor_Right\0"
+    "ISO_Fast_Cursor_Up\0"
+    "ISO_First_Group\0"
+    "ISO_First_Group_Lock\0"
+    "ISO_Group_Latch\0"
+    "ISO_Group_Lock\0"
+    "ISO_Group_Shift\0"
+    "ISO_Last_Group\0"
+    "ISO_Last_Group_Lock\0"
+    "ISO_Left_Tab\0"
+    "ISO_Level2_Latch\0"
+    "ISO_Level3_Latch\0"
+    "ISO_Level3_Lock\0"
+    "ISO_Level3_Shift\0"
+    "ISO_Level5_Latch\0"
+    "ISO_Level5_Lock\0"
+    "ISO_Level5_Shift\0"
+    "ISO_Lock\0"
+    "ISO_Move_Line_Down\0"
+    "ISO_Move_Line_Up\0"
+    "ISO_Next_Group\0"
+    "ISO_Next_Group_Lock\0"
+    "ISO_Partial_Line_Down\0"
+    "ISO_Partial_Line_Up\0"
+    "ISO_Partial_Space_Left\0"
+    "ISO_Partial_Space_Right\0"
+    "ISO_Prev_Group\0"
+    "ISO_Prev_Group_Lock\0"
+    "ISO_Release_Both_Margins\0"
+    "ISO_Release_Margin_Left\0"
+    "ISO_Release_Margin_Right\0"
+    "ISO_Set_Margin_Left\0"
+    "ISO_Set_Margin_Right\0"
+    "Itilde\0"
+    "itilde\0"
+    "J\0"
+    "j\0"
+    "Jcircumflex\0"
+    "jcircumflex\0"
+    "jot\0"
+    "K\0"
+    "k\0"
+    "kana_a\0"
+    "kana_A\0"
+    "kana_CHI\0"
+    "kana_closingbracket\0"
+    "kana_comma\0"
+    "kana_conjunctive\0"
+    "kana_e\0"
+    "kana_E\0"
+    "kana_FU\0"
+    "kana_fullstop\0"
+    "kana_HA\0"
+    "kana_HE\0"
+    "kana_HI\0"
+    "kana_HO\0"
+    "kana_HU\0"
+    "kana_i\0"
+    "kana_I\0"
+    "kana_KA\0"
+    "kana_KE\0"
+    "kana_KI\0"
+    "kana_KO\0"
+    "kana_KU\0"
+    "Kana_Lock\0"
+    "kana_MA\0"
+    "kana_ME\0"
+    "kana_MI\0"
+    "kana_middledot\0"
+    "kana_MO\0"
+    "kana_MU\0"
+    "kana_N\0"
+    "kana_NA\0"
+    "kana_NE\0"
+    "kana_NI\0"
+    "kana_NO\0"
+    "kana_NU\0"
+    "kana_o\0"
+    "kana_O\0"
+    "kana_openingbracket\0"
+    "kana_RA\0"
+    "kana_RE\0"
+    "kana_RI\0"
+    "kana_RO\0"
+    "kana_RU\0"
+    "kana_SA\0"
+    "kana_SE\0"
+    "kana_SHI\0"
+    "Kana_Shift\0"
+    "kana_SO\0"
+    "kana_SU\0"
+    "kana_switch\0"
+    "kana_TA\0"
+    "kana_TE\0"
+    "kana_TI\0"
+    "kana_TO\0"
+    "kana_tsu\0"
+    "kana_TSU\0"
+    "kana_tu\0"
+    "kana_TU\0"
+    "kana_u\0"
+    "kana_U\0"
+    "kana_WA\0"
+    "kana_WO\0"
+    "kana_ya\0"
+    "kana_YA\0"
+    "kana_yo\0"
+    "kana_YO\0"
+    "kana_yu\0"
+    "kana_YU\0"
+    "Kanji\0"
+    "Kanji_Bangou\0"
+    "kappa\0"
+    "Katakana\0"
+    "Kcedilla\0"
+    "kcedilla\0"
+    "Korean_Won\0"
+    "KP_0\0"
+    "KP_1\0"
+    "KP_2\0"
+    "KP_3\0"
+    "KP_4\0"
+    "KP_5\0"
+    "KP_6\0"
+    "KP_7\0"
+    "KP_8\0"
+    "KP_9\0"
+    "KP_Add\0"
+    "KP_BackTab\0"
+    "KP_Begin\0"
+    "KP_Decimal\0"
+    "KP_Delete\0"
+    "KP_Divide\0"
+    "KP_Down\0"
+    "KP_End\0"
+    "KP_Enter\0"
+    "KP_Equal\0"
+    "KP_F1\0"
+    "KP_F2\0"
+    "KP_F3\0"
+    "KP_F4\0"
+    "KP_Home\0"
+    "KP_Insert\0"
+    "KP_Left\0"
+    "KP_Multiply\0"
+    "KP_Next\0"
+    "KP_Page_Down\0"
+    "KP_Page_Up\0"
+    "KP_Prior\0"
+    "KP_Right\0"
+    "KP_Separator\0"
+    "KP_Space\0"
+    "KP_Subtract\0"
+    "KP_Tab\0"
+    "KP_Up\0"
+    "kra\0"
+    "L\0"
+    "l\0"
+    "L1\0"
+    "L10\0"
+    "L2\0"
+    "L3\0"
+    "L4\0"
+    "L5\0"
+    "L6\0"
+    "L7\0"
+    "L8\0"
+    "L9\0"
+    "Lacute\0"
+    "lacute\0"
+    "Last_Virtual_Screen\0"
+    "latincross\0"
+    "Lbelowdot\0"
+    "lbelowdot\0"
+    "Lcaron\0"
+    "lcaron\0"
+    "Lcedilla\0"
+    "lcedilla\0"
+    "Left\0"
+    "leftanglebracket\0"
+    "leftarrow\0"
+    "leftcaret\0"
+    "leftdoublequotemark\0"
+    "leftmiddlecurlybrace\0"
+    "leftopentriangle\0"
+    "leftpointer\0"
+    "leftradical\0"
+    "leftshoe\0"
+    "leftsinglequotemark\0"
+    "leftt\0"
+    "lefttack\0"
+    "less\0"
+    "lessthanequal\0"
+    "lf\0"
+    "Linefeed\0"
+    "lira\0"
+    "LiraSign\0"
+    "logicaland\0"
+    "logicalor\0"
+    "longminus\0"
+    "lowleftcorner\0"
+    "lowrightcorner\0"
+    "Lstroke\0"
+    "lstroke\0"
+    "M\0"
+    "m\0"
+    "Mabovedot\0"
+    "mabovedot\0"
+    "Macedonia_dse\0"
+    "Macedonia_DSE\0"
+    "Macedonia_gje\0"
+    "Macedonia_GJE\0"
+    "Macedonia_kje\0"
+    "Macedonia_KJE\0"
+    "macron\0"
+    "Mae_Koho\0"
+    "malesymbol\0"
+    "maltesecross\0"
+    "marker\0"
+    "masculine\0"
+    "Massyo\0"
+    "Menu\0"
+    "Meta_L\0"
+    "Meta_R\0"
+    "MillSign\0"
+    "minus\0"
+    "minutes\0"
+    "Mode_switch\0"
+    "MouseKeys_Accel_Enable\0"
+    "MouseKeys_Enable\0"
+    "mu\0"
+    "Muhenkan\0"
+    "Multi_key\0"
+    "MultipleCandidate\0"
+    "multiply\0"
+    "musicalflat\0"
+    "musicalsharp\0"
+    "mute_acute\0"
+    "mute_asciicircum\0"
+    "mute_asciitilde\0"
+    "mute_diaeresis\0"
+    "mute_grave\0"
+    "N\0"
+    "n\0"
+    "nabla\0"
+    "Nacute\0"
+    "nacute\0"
+    "NairaSign\0"
+    "Ncaron\0"
+    "ncaron\0"
+    "Ncedilla\0"
+    "ncedilla\0"
+    "NewSheqelSign\0"
+    "Next\0"
+    "Next_Virtual_Screen\0"
+    "ninesubscript\0"
+    "ninesuperior\0"
+    "nl\0"
+    "nobreakspace\0"
+    "NoSymbol\0"
+    "notapproxeq\0"
+    "notelementof\0"
+    "notequal\0"
+    "notidentical\0"
+    "notsign\0"
+    "Ntilde\0"
+    "ntilde\0"
+    "Num_Lock\0"
+    "numbersign\0"
+    "numerosign\0"
+    "O\0"
+    "o\0"
+    "Oacute\0"
+    "oacute\0"
+    "Obarred\0"
+    "obarred\0"
+    "Obelowdot\0"
+    "obelowdot\0"
+    "Ocaron\0"
+    "ocaron\0"
+    "Ocircumflex\0"
+    "ocircumflex\0"
+    "Ocircumflexacute\0"
+    "ocircumflexacute\0"
+    "Ocircumflexbelowdot\0"
+    "ocircumflexbelowdot\0"
+    "Ocircumflexgrave\0"
+    "ocircumflexgrave\0"
+    "Ocircumflexhook\0"
+    "ocircumflexhook\0"
+    "Ocircumflextilde\0"
+    "ocircumflextilde\0"
+    "Odiaeresis\0"
+    "odiaeresis\0"
+    "Odoubleacute\0"
+    "odoubleacute\0"
+    "OE\0"
+    "oe\0"
+    "ogonek\0"
+    "Ograve\0"
+    "ograve\0"
+    "Ohook\0"
+    "ohook\0"
+    "Ohorn\0"
+    "ohorn\0"
+    "Ohornacute\0"
+    "ohornacute\0"
+    "Ohornbelowdot\0"
+    "ohornbelowdot\0"
+    "Ohorngrave\0"
+    "ohorngrave\0"
+    "Ohornhook\0"
+    "ohornhook\0"
+    "Ohorntilde\0"
+    "ohorntilde\0"
+    "Omacron\0"
+    "omacron\0"
+    "oneeighth\0"
+    "onefifth\0"
+    "onehalf\0"
+    "onequarter\0"
+    "onesixth\0"
+    "onesubscript\0"
+    "onesuperior\0"
+    "onethird\0"
+    "Ooblique\0"
+    "ooblique\0"
+    "openrectbullet\0"
+    "openstar\0"
+    "opentribulletdown\0"
+    "opentribulletup\0"
+    "ordfeminine\0"
+    "osfActivate\0"
+    "osfAddMode\0"
+    "osfBackSpace\0"
+    "osfBackTab\0"
+    "osfBeginData\0"
+    "osfBeginLine\0"
+    "osfCancel\0"
+    "osfClear\0"
+    "osfCopy\0"
+    "osfCut\0"
+    "osfDelete\0"
+    "osfDeselectAll\0"
+    "osfDown\0"
+    "osfEndData\0"
+    "osfEndLine\0"
+    "osfEscape\0"
+    "osfExtend\0"
+    "osfHelp\0"
+    "osfInsert\0"
+    "osfLeft\0"
+    "osfMenu\0"
+    "osfMenuBar\0"
+    "osfNextField\0"
+    "osfNextMenu\0"
+    "osfPageDown\0"
+    "osfPageLeft\0"
+    "osfPageRight\0"
+    "osfPageUp\0"
+    "osfPaste\0"
+    "osfPrevField\0"
+    "osfPrevMenu\0"
+    "osfPrimaryPaste\0"
+    "osfQuickPaste\0"
+    "osfReselect\0"
+    "osfRestore\0"
+    "osfRight\0"
+    "osfSelect\0"
+    "osfSelectAll\0"
+    "osfUndo\0"
+    "osfUp\0"
+    "Oslash\0"
+    "oslash\0"
+    "Otilde\0"
+    "otilde\0"
+    "overbar\0"
+    "Overlay1_Enable\0"
+    "Overlay2_Enable\0"
+    "overline\0"
+    "P\0"
+    "p\0"
+    "Pabovedot\0"
+    "pabovedot\0"
+    "Page_Down\0"
+    "Page_Up\0"
+    "paragraph\0"
+    "parenleft\0"
+    "parenright\0"
+    "partdifferential\0"
+    "partialderivative\0"
+    "Pause\0"
+    "percent\0"
+    "period\0"
+    "periodcentered\0"
+    "permille\0"
+    "PesetaSign\0"
+    "phonographcopyright\0"
+    "plus\0"
+    "plusminus\0"
+    "Pointer_Accelerate\0"
+    "Pointer_Button1\0"
+    "Pointer_Button2\0"
+    "Pointer_Button3\0"
+    "Pointer_Button4\0"
+    "Pointer_Button5\0"
+    "Pointer_Button_Dflt\0"
+    "Pointer_DblClick1\0"
+    "Pointer_DblClick2\0"
+    "Pointer_DblClick3\0"
+    "Pointer_DblClick4\0"
+    "Pointer_DblClick5\0"
+    "Pointer_DblClick_Dflt\0"
+    "Pointer_DfltBtnNext\0"
+    "Pointer_DfltBtnPrev\0"
+    "Pointer_Down\0"
+    "Pointer_DownLeft\0"
+    "Pointer_DownRight\0"
+    "Pointer_Drag1\0"
+    "Pointer_Drag2\0"
+    "Pointer_Drag3\0"
+    "Pointer_Drag4\0"
+    "Pointer_Drag5\0"
+    "Pointer_Drag_Dflt\0"
+    "Pointer_EnableKeys\0"
+    "Pointer_Left\0"
+    "Pointer_Right\0"
+    "Pointer_Up\0"
+    "Pointer_UpLeft\0"
+    "Pointer_UpRight\0"
+    "prescription\0"
+    "Prev_Virtual_Screen\0"
+    "PreviousCandidate\0"
+    "Print\0"
+    "Prior\0"
+    "prolongedsound\0"
+    "punctspace\0"
+    "Q\0"
+    "q\0"
+    "quad\0"
+    "question\0"
+    "questiondown\0"
+    "quotedbl\0"
+    "quoteleft\0"
+    "quoteright\0"
+    "R\0"
+    "r\0"
+    "R1\0"
+    "R10\0"
+    "R11\0"
+    "R12\0"
+    "R13\0"
+    "R14\0"
+    "R15\0"
+    "R2\0"
+    "R3\0"
+    "R4\0"
+    "R5\0"
+    "R6\0"
+    "R7\0"
+    "R8\0"
+    "R9\0"
+    "Racute\0"
+    "racute\0"
+    "radical\0"
+    "Rcaron\0"
+    "rcaron\0"
+    "Rcedilla\0"
+    "rcedilla\0"
+    "Redo\0"
+    "registered\0"
+    "RepeatKeys_Enable\0"
+    "Reset\0"
+    "Return\0"
+    "Right\0"
+    "rightanglebracket\0"
+    "rightarrow\0"
+    "rightcaret\0"
+    "rightdoublequotemark\0"
+    "rightmiddlecurlybrace\0"
+    "rightmiddlesummation\0"
+    "rightopentriangle\0"
+    "rightpointer\0"
+    "rightshoe\0"
+    "rightsinglequotemark\0"
+    "rightt\0"
+    "righttack\0"
+    "Romaji\0"
+    "RupeeSign\0"
+    "S\0"
+    "s\0"
+    "Sabovedot\0"
+    "sabovedot\0"
+    "Sacute\0"
+    "sacute\0"
+    "Scaron\0"
+    "scaron\0"
+    "Scedilla\0"
+    "scedilla\0"
+    "SCHWA\0"
+    "schwa\0"
+    "Scircumflex\0"
+    "scircumflex\0"
+    "script_switch\0"
+    "Scroll_Lock\0"
+    "seconds\0"
+    "section\0"
+    "Select\0"
+    "semicolon\0"
+    "semivoicedsound\0"
+    "Serbian_dje\0"
+    "Serbian_DJE\0"
+    "Serbian_dze\0"
+    "Serbian_DZE\0"
+    "Serbian_je\0"
+    "Serbian_JE\0"
+    "Serbian_lje\0"
+    "Serbian_LJE\0"
+    "Serbian_nje\0"
+    "Serbian_NJE\0"
+    "Serbian_tshe\0"
+    "Serbian_TSHE\0"
+    "seveneighths\0"
+    "sevensubscript\0"
+    "sevensuperior\0"
+    "Shift_L\0"
+    "Shift_Lock\0"
+    "Shift_R\0"
+    "signaturemark\0"
+    "signifblank\0"
+    "similarequal\0"
+    "SingleCandidate\0"
+    "singlelowquotemark\0"
+    "Sinh_a\0"
+    "Sinh_aa\0"
+    "Sinh_aa2\0"
+    "Sinh_ae\0"
+    "Sinh_ae2\0"
+    "Sinh_aee\0"
+    "Sinh_aee2\0"
+    "Sinh_ai\0"
+    "Sinh_ai2\0"
+    "Sinh_al\0"
+    "Sinh_au\0"
+    "Sinh_au2\0"
+    "Sinh_ba\0"
+    "Sinh_bha\0"
+    "Sinh_ca\0"
+    "Sinh_cha\0"
+    "Sinh_dda\0"
+    "Sinh_ddha\0"
+    "Sinh_dha\0"
+    "Sinh_dhha\0"
+    "Sinh_e\0"
+    "Sinh_e2\0"
+    "Sinh_ee\0"
+    "Sinh_ee2\0"
+    "Sinh_fa\0"
+    "Sinh_ga\0"
+    "Sinh_gha\0"
+    "Sinh_h2\0"
+    "Sinh_ha\0"
+    "Sinh_i\0"
+    "Sinh_i2\0"
+    "Sinh_ii\0"
+    "Sinh_ii2\0"
+    "Sinh_ja\0"
+    "Sinh_jha\0"
+    "Sinh_jnya\0"
+    "Sinh_ka\0"
+    "Sinh_kha\0"
+    "Sinh_kunddaliya\0"
+    "Sinh_la\0"
+    "Sinh_lla\0"
+    "Sinh_lu\0"
+    "Sinh_lu2\0"
+    "Sinh_luu\0"
+    "Sinh_luu2\0"
+    "Sinh_ma\0"
+    "Sinh_mba\0"
+    "Sinh_na\0"
+    "Sinh_ndda\0"
+    "Sinh_ndha\0"
+    "Sinh_ng\0"
+    "Sinh_ng2\0"
+    "Sinh_nga\0"
+    "Sinh_nja\0"
+    "Sinh_nna\0"
+    "Sinh_nya\0"
+    "Sinh_o\0"
+    "Sinh_o2\0"
+    "Sinh_oo\0"
+    "Sinh_oo2\0"
+    "Sinh_pa\0"
+    "Sinh_pha\0"
+    "Sinh_ra\0"
+    "Sinh_ri\0"
+    "Sinh_rii\0"
+    "Sinh_ru2\0"
+    "Sinh_ruu2\0"
+    "Sinh_sa\0"
+    "Sinh_sha\0"
+    "Sinh_ssha\0"
+    "Sinh_tha\0"
+    "Sinh_thha\0"
+    "Sinh_tta\0"
+    "Sinh_ttha\0"
+    "Sinh_u\0"
+    "Sinh_u2\0"
+    "Sinh_uu\0"
+    "Sinh_uu2\0"
+    "Sinh_va\0"
+    "Sinh_ya\0"
+    "sixsubscript\0"
+    "sixsuperior\0"
+    "slash\0"
+    "SlowKeys_Enable\0"
+    "soliddiamond\0"
+    "space\0"
+    "squareroot\0"
+    "ssharp\0"
+    "sterling\0"
+    "StickyKeys_Enable\0"
+    "stricteq\0"
+    "SunAgain\0"
+    "SunAltGraph\0"
+    "SunAudioLowerVolume\0"
+    "SunAudioMute\0"
+    "SunAudioRaiseVolume\0"
+    "SunCompose\0"
+    "SunCopy\0"
+    "SunCut\0"
+    "SunF36\0"
+    "SunF37\0"
+    "SunFA_Acute\0"
+    "SunFA_Cedilla\0"
+    "SunFA_Circum\0"
+    "SunFA_Diaeresis\0"
+    "SunFA_Grave\0"
+    "SunFA_Tilde\0"
+    "SunFind\0"
+    "SunFront\0"
+    "SunOpen\0"
+    "SunPageDown\0"
+    "SunPageUp\0"
+    "SunPaste\0"
+    "SunPowerSwitch\0"
+    "SunPowerSwitchShift\0"
+    "SunPrint_Screen\0"
+    "SunProps\0"
+    "SunStop\0"
+    "SunSys_Req\0"
+    "SunUndo\0"
+    "SunVideoDegauss\0"
+    "SunVideoLowerBrightness\0"
+    "SunVideoRaiseBrightness\0"
+    "Super_L\0"
+    "Super_R\0"
+    "Sys_Req\0"
+    "System\0"
+    "T\0"
+    "t\0"
+    "Tab\0"
+    "Tabovedot\0"
+    "tabovedot\0"
+    "Tcaron\0"
+    "tcaron\0"
+    "Tcedilla\0"
+    "tcedilla\0"
+    "telephone\0"
+    "telephonerecorder\0"
+    "Terminate_Server\0"
+    "Thai_baht\0"
+    "Thai_bobaimai\0"
+    "Thai_chochan\0"
+    "Thai_chochang\0"
+    "Thai_choching\0"
+    "Thai_chochoe\0"
+    "Thai_dochada\0"
+    "Thai_dodek\0"
+    "Thai_fofa\0"
+    "Thai_fofan\0"
+    "Thai_hohip\0"
+    "Thai_honokhuk\0"
+    "Thai_khokhai\0"
+    "Thai_khokhon\0"
+    "Thai_khokhuat\0"
+    "Thai_khokhwai\0"
+    "Thai_khorakhang\0"
+    "Thai_kokai\0"
+    "Thai_lakkhangyao\0"
+    "Thai_lekchet\0"
+    "Thai_lekha\0"
+    "Thai_lekhok\0"
+    "Thai_lekkao\0"
+    "Thai_leknung\0"
+    "Thai_lekpaet\0"
+    "Thai_leksam\0"
+    "Thai_leksi\0"
+    "Thai_leksong\0"
+    "Thai_leksun\0"
+    "Thai_lochula\0"
+    "Thai_loling\0"
+    "Thai_lu\0"
+    "Thai_maichattawa\0"
+    "Thai_maiek\0"
+    "Thai_maihanakat\0"
+    "Thai_maihanakat_maitho\0"
+    "Thai_maitaikhu\0"
+    "Thai_maitho\0"
+    "Thai_maitri\0"
+    "Thai_maiyamok\0"
+    "Thai_moma\0"
+    "Thai_ngongu\0"
+    "Thai_nikhahit\0"
+    "Thai_nonen\0"
+    "Thai_nonu\0"
+    "Thai_oang\0"
+    "Thai_paiyannoi\0"
+    "Thai_phinthu\0"
+    "Thai_phophan\0"
+    "Thai_phophung\0"
+    "Thai_phosamphao\0"
+    "Thai_popla\0"
+    "Thai_rorua\0"
+    "Thai_ru\0"
+    "Thai_saraa\0"
+    "Thai_saraaa\0"
+    "Thai_saraae\0"
+    "Thai_saraaimaimalai\0"
+    "Thai_saraaimaimuan\0"
+    "Thai_saraam\0"
+    "Thai_sarae\0"
+    "Thai_sarai\0"
+    "Thai_saraii\0"
+    "Thai_sarao\0"
+    "Thai_sarau\0"
+    "Thai_saraue\0"
+    "Thai_sarauee\0"
+    "Thai_sarauu\0"
+    "Thai_sorusi\0"
+    "Thai_sosala\0"
+    "Thai_soso\0"
+    "Thai_sosua\0"
+    "Thai_thanthakhat\0"
+    "Thai_thonangmontho\0"
+    "Thai_thophuthao\0"
+    "Thai_thothahan\0"
+    "Thai_thothan\0"
+    "Thai_thothong\0"
+    "Thai_thothung\0"
+    "Thai_topatak\0"
+    "Thai_totao\0"
+    "Thai_wowaen\0"
+    "Thai_yoyak\0"
+    "Thai_yoying\0"
+    "therefore\0"
+    "thinspace\0"
+    "THORN\0"
+    "Thorn\0"
+    "thorn\0"
+    "threeeighths\0"
+    "threefifths\0"
+    "threequarters\0"
+    "threesubscript\0"
+    "threesuperior\0"
+    "tintegral\0"
+    "topintegral\0"
+    "topleftparens\0"
+    "topleftradical\0"
+    "topleftsqbracket\0"
+    "topleftsummation\0"
+    "toprightparens\0"
+    "toprightsqbracket\0"
+    "toprightsummation\0"
+    "topt\0"
+    "topvertsummationconnector\0"
+    "Touroku\0"
+    "trademark\0"
+    "trademarkincircle\0"
+    "Tslash\0"
+    "tslash\0"
+    "twofifths\0"
+    "twosubscript\0"
+    "twosuperior\0"
+    "twothirds\0"
+    "U\0"
+    "u\0"
+    "Uacute\0"
+    "uacute\0"
+    "Ubelowdot\0"
+    "ubelowdot\0"
+    "Ubreve\0"
+    "ubreve\0"
+    "Ucircumflex\0"
+    "ucircumflex\0"
+    "Udiaeresis\0"
+    "udiaeresis\0"
+    "Udoubleacute\0"
+    "udoubleacute\0"
+    "Ugrave\0"
+    "ugrave\0"
+    "Uhook\0"
+    "uhook\0"
+    "Uhorn\0"
+    "uhorn\0"
+    "Uhornacute\0"
+    "uhornacute\0"
+    "Uhornbelowdot\0"
+    "uhornbelowdot\0"
+    "Uhorngrave\0"
+    "uhorngrave\0"
+    "Uhornhook\0"
+    "uhornhook\0"
+    "Uhorntilde\0"
+    "uhorntilde\0"
+    "Ukrainian_ghe_with_upturn\0"
+    "Ukrainian_GHE_WITH_UPTURN\0"
+    "Ukrainian_i\0"
+    "Ukrainian_I\0"
+    "Ukrainian_ie\0"
+    "Ukrainian_IE\0"
+    "Ukrainian_yi\0"
+    "Ukrainian_YI\0"
+    "Ukranian_i\0"
+    "Ukranian_I\0"
+    "Ukranian_je\0"
+    "Ukranian_JE\0"
+    "Ukranian_yi\0"
+    "Ukranian_YI\0"
+    "Umacron\0"
+    "umacron\0"
+    "underbar\0"
+    "underscore\0"
+    "Undo\0"
+    "union\0"
+    "Uogonek\0"
+    "uogonek\0"
+    "Up\0"
+    "uparrow\0"
+    "upcaret\0"
+    "upleftcorner\0"
+    "uprightcorner\0"
+    "upshoe\0"
+    "upstile\0"
+    "uptack\0"
+    "Uring\0"
+    "uring\0"
+    "User\0"
+    "Utilde\0"
+    "utilde\0"
+    "V\0"
+    "v\0"
+    "variation\0"
+    "vertbar\0"
+    "vertconnector\0"
+    "voicedsound\0"
+    "VoidSymbol\0"
+    "vt\0"
+    "W\0"
+    "w\0"
+    "Wacute\0"
+    "wacute\0"
+    "Wcircumflex\0"
+    "wcircumflex\0"
+    "Wdiaeresis\0"
+    "wdiaeresis\0"
+    "Wgrave\0"
+    "wgrave\0"
+    "WonSign\0"
+    "X\0"
+    "x\0"
+    "Xabovedot\0"
+    "xabovedot\0"
+    "XF86AddFavorite\0"
+    "XF86ApplicationLeft\0"
+    "XF86ApplicationRight\0"
+    "XF86AudioCycleTrack\0"
+    "XF86AudioForward\0"
+    "XF86AudioLowerVolume\0"
+    "XF86AudioMedia\0"
+    "XF86AudioMicMute\0"
+    "XF86AudioMute\0"
+    "XF86AudioNext\0"
+    "XF86AudioPause\0"
+    "XF86AudioPlay\0"
+    "XF86AudioPrev\0"
+    "XF86AudioRaiseVolume\0"
+    "XF86AudioRandomPlay\0"
+    "XF86AudioRecord\0"
+    "XF86AudioRepeat\0"
+    "XF86AudioRewind\0"
+    "XF86AudioStop\0"
+    "XF86Away\0"
+    "XF86Back\0"
+    "XF86BackForward\0"
+    "XF86Battery\0"
+    "XF86Blue\0"
+    "XF86Bluetooth\0"
+    "XF86Book\0"
+    "XF86BrightnessAdjust\0"
+    "XF86Calculater\0"
+    "XF86Calculator\0"
+    "XF86Calendar\0"
+    "XF86CD\0"
+    "XF86Clear\0"
+    "XF86ClearGrab\0"
+    "XF86Close\0"
+    "XF86Community\0"
+    "XF86ContrastAdjust\0"
+    "XF86Copy\0"
+    "XF86Cut\0"
+    "XF86CycleAngle\0"
+    "XF86Display\0"
+    "XF86Documents\0"
+    "XF86DOS\0"
+    "XF86Eject\0"
+    "XF86Excel\0"
+    "XF86Explorer\0"
+    "XF86Favorites\0"
+    "XF86Finance\0"
+    "XF86Forward\0"
+    "XF86FrameBack\0"
+    "XF86FrameForward\0"
+    "XF86Game\0"
+    "XF86Go\0"
+    "XF86Green\0"
+    "XF86Hibernate\0"
+    "XF86History\0"
+    "XF86HomePage\0"
+    "XF86HotLinks\0"
+    "XF86iTouch\0"
+    "XF86KbdBrightnessDown\0"
+    "XF86KbdBrightnessUp\0"
+    "XF86KbdLightOnOff\0"
+    "XF86Launch0\0"
+    "XF86Launch1\0"
+    "XF86Launch2\0"
+    "XF86Launch3\0"
+    "XF86Launch4\0"
+    "XF86Launch5\0"
+    "XF86Launch6\0"
+    "XF86Launch7\0"
+    "XF86Launch8\0"
+    "XF86Launch9\0"
+    "XF86LaunchA\0"
+    "XF86LaunchB\0"
+    "XF86LaunchC\0"
+    "XF86LaunchD\0"
+    "XF86LaunchE\0"
+    "XF86LaunchF\0"
+    "XF86LightBulb\0"
+    "XF86LogGrabInfo\0"
+    "XF86LogOff\0"
+    "XF86LogWindowTree\0"
+    "XF86Mail\0"
+    "XF86MailForward\0"
+    "XF86Market\0"
+    "XF86Meeting\0"
+    "XF86Memo\0"
+    "XF86MenuKB\0"
+    "XF86MenuPB\0"
+    "XF86Messenger\0"
+    "XF86ModeLock\0"
+    "XF86MonBrightnessDown\0"
+    "XF86MonBrightnessUp\0"
+    "XF86Music\0"
+    "XF86MyComputer\0"
+    "XF86MySites\0"
+    "XF86New\0"
+    "XF86News\0"
+    "XF86Next_VMode\0"
+    "XF86OfficeHome\0"
+    "XF86Open\0"
+    "XF86OpenURL\0"
+    "XF86Option\0"
+    "XF86Paste\0"
+    "XF86Phone\0"
+    "XF86Pictures\0"
+    "XF86PowerDown\0"
+    "XF86PowerOff\0"
+    "XF86Prev_VMode\0"
+    "XF86Q\0"
+    "XF86Red\0"
+    "XF86Refresh\0"
+    "XF86Reload\0"
+    "XF86Reply\0"
+    "XF86RockerDown\0"
+    "XF86RockerEnter\0"
+    "XF86RockerUp\0"
+    "XF86RotateWindows\0"
+    "XF86RotationKB\0"
+    "XF86RotationPB\0"
+    "XF86Save\0"
+    "XF86ScreenSaver\0"
+    "XF86ScrollClick\0"
+    "XF86ScrollDown\0"
+    "XF86ScrollUp\0"
+    "XF86Search\0"
+    "XF86Select\0"
+    "XF86Send\0"
+    "XF86Shop\0"
+    "XF86Sleep\0"
+    "XF86Spell\0"
+    "XF86SplitScreen\0"
+    "XF86Standby\0"
+    "XF86Start\0"
+    "XF86Stop\0"
+    "XF86Subtitle\0"
+    "XF86Support\0"
+    "XF86Suspend\0"
+    "XF86Switch_VT_1\0"
+    "XF86Switch_VT_10\0"
+    "XF86Switch_VT_11\0"
+    "XF86Switch_VT_12\0"
+    "XF86Switch_VT_2\0"
+    "XF86Switch_VT_3\0"
+    "XF86Switch_VT_4\0"
+    "XF86Switch_VT_5\0"
+    "XF86Switch_VT_6\0"
+    "XF86Switch_VT_7\0"
+    "XF86Switch_VT_8\0"
+    "XF86Switch_VT_9\0"
+    "XF86TaskPane\0"
+    "XF86Terminal\0"
+    "XF86Time\0"
+    "XF86ToDoList\0"
+    "XF86Tools\0"
+    "XF86TopMenu\0"
+    "XF86TouchpadOff\0"
+    "XF86TouchpadOn\0"
+    "XF86TouchpadToggle\0"
+    "XF86Travel\0"
+    "XF86Ungrab\0"
+    "XF86User1KB\0"
+    "XF86User2KB\0"
+    "XF86UserPB\0"
+    "XF86UWB\0"
+    "XF86VendorHome\0"
+    "XF86Video\0"
+    "XF86View\0"
+    "XF86WakeUp\0"
+    "XF86WebCam\0"
+    "XF86WheelButton\0"
+    "XF86WLAN\0"
+    "XF86Word\0"
+    "XF86WWW\0"
+    "XF86Xfer\0"
+    "XF86Yellow\0"
+    "XF86ZoomIn\0"
+    "XF86ZoomOut\0"
+    "Y\0"
+    "y\0"
+    "Yacute\0"
+    "yacute\0"
+    "Ybelowdot\0"
+    "ybelowdot\0"
+    "Ycircumflex\0"
+    "ycircumflex\0"
+    "ydiaeresis\0"
+    "Ydiaeresis\0"
+    "yen\0"
+    "Ygrave\0"
+    "ygrave\0"
+    "Yhook\0"
+    "yhook\0"
+    "Ytilde\0"
+    "ytilde\0"
+    "Z\0"
+    "z\0"
+    "Zabovedot\0"
+    "zabovedot\0"
+    "Zacute\0"
+    "zacute\0"
+    "Zcaron\0"
+    "zcaron\0"
+    "Zen_Koho\0"
+    "Zenkaku\0"
+    "Zenkaku_Hankaku\0"
+    "zerosubscript\0"
+    "zerosuperior\0"
+    "Zstroke\0"
+    "zstroke\0"
+;
+#pragma GCC diagnostic pop
 
 struct name_keysym {
-    const char *name;
     xkb_keysym_t keysym;
+    uint32_t offset;
 };
 
 static const struct name_keysym name_to_keysym[] = {
-    { "0", XKB_KEY_0 },
-    { "1", XKB_KEY_1 },
-    { "2", XKB_KEY_2 },
-    { "3", XKB_KEY_3 },
-    { "3270_AltCursor", XKB_KEY_3270_AltCursor },
-    { "3270_Attn", XKB_KEY_3270_Attn },
-    { "3270_BackTab", XKB_KEY_3270_BackTab },
-    { "3270_ChangeScreen", XKB_KEY_3270_ChangeScreen },
-    { "3270_Copy", XKB_KEY_3270_Copy },
-    { "3270_CursorBlink", XKB_KEY_3270_CursorBlink },
-    { "3270_CursorSelect", XKB_KEY_3270_CursorSelect },
-    { "3270_DeleteWord", XKB_KEY_3270_DeleteWord },
-    { "3270_Duplicate", XKB_KEY_3270_Duplicate },
-    { "3270_Enter", XKB_KEY_3270_Enter },
-    { "3270_EraseEOF", XKB_KEY_3270_EraseEOF },
-    { "3270_EraseInput", XKB_KEY_3270_EraseInput },
-    { "3270_ExSelect", XKB_KEY_3270_ExSelect },
-    { "3270_FieldMark", XKB_KEY_3270_FieldMark },
-    { "3270_Ident", XKB_KEY_3270_Ident },
-    { "3270_Jump", XKB_KEY_3270_Jump },
-    { "3270_KeyClick", XKB_KEY_3270_KeyClick },
-    { "3270_Left2", XKB_KEY_3270_Left2 },
-    { "3270_PA1", XKB_KEY_3270_PA1 },
-    { "3270_PA2", XKB_KEY_3270_PA2 },
-    { "3270_PA3", XKB_KEY_3270_PA3 },
-    { "3270_Play", XKB_KEY_3270_Play },
-    { "3270_PrintScreen", XKB_KEY_3270_PrintScreen },
-    { "3270_Quit", XKB_KEY_3270_Quit },
-    { "3270_Record", XKB_KEY_3270_Record },
-    { "3270_Reset", XKB_KEY_3270_Reset },
-    { "3270_Right2", XKB_KEY_3270_Right2 },
-    { "3270_Rule", XKB_KEY_3270_Rule },
-    { "3270_Setup", XKB_KEY_3270_Setup },
-    { "3270_Test", XKB_KEY_3270_Test },
-    { "4", XKB_KEY_4 },
-    { "5", XKB_KEY_5 },
-    { "6", XKB_KEY_6 },
-    { "7", XKB_KEY_7 },
-    { "8", XKB_KEY_8 },
-    { "9", XKB_KEY_9 },
-    { "A", XKB_KEY_A },
-    { "a", XKB_KEY_a },
-    { "Aacute", XKB_KEY_Aacute },
-    { "aacute", XKB_KEY_aacute },
-    { "Abelowdot", XKB_KEY_Abelowdot },
-    { "abelowdot", XKB_KEY_abelowdot },
-    { "abovedot", XKB_KEY_abovedot },
-    { "Abreve", XKB_KEY_Abreve },
-    { "abreve", XKB_KEY_abreve },
-    { "Abreveacute", XKB_KEY_Abreveacute },
-    { "abreveacute", XKB_KEY_abreveacute },
-    { "Abrevebelowdot", XKB_KEY_Abrevebelowdot },
-    { "abrevebelowdot", XKB_KEY_abrevebelowdot },
-    { "Abrevegrave", XKB_KEY_Abrevegrave },
-    { "abrevegrave", XKB_KEY_abrevegrave },
-    { "Abrevehook", XKB_KEY_Abrevehook },
-    { "abrevehook", XKB_KEY_abrevehook },
-    { "Abrevetilde", XKB_KEY_Abrevetilde },
-    { "abrevetilde", XKB_KEY_abrevetilde },
-    { "AccessX_Enable", XKB_KEY_AccessX_Enable },
-    { "AccessX_Feedback_Enable", XKB_KEY_AccessX_Feedback_Enable },
-    { "Acircumflex", XKB_KEY_Acircumflex },
-    { "acircumflex", XKB_KEY_acircumflex },
-    { "Acircumflexacute", XKB_KEY_Acircumflexacute },
-    { "acircumflexacute", XKB_KEY_acircumflexacute },
-    { "Acircumflexbelowdot", XKB_KEY_Acircumflexbelowdot },
-    { "acircumflexbelowdot", XKB_KEY_acircumflexbelowdot },
-    { "Acircumflexgrave", XKB_KEY_Acircumflexgrave },
-    { "acircumflexgrave", XKB_KEY_acircumflexgrave },
-    { "Acircumflexhook", XKB_KEY_Acircumflexhook },
-    { "acircumflexhook", XKB_KEY_acircumflexhook },
-    { "Acircumflextilde", XKB_KEY_Acircumflextilde },
-    { "acircumflextilde", XKB_KEY_acircumflextilde },
-    { "acute", XKB_KEY_acute },
-    { "Adiaeresis", XKB_KEY_Adiaeresis },
-    { "adiaeresis", XKB_KEY_adiaeresis },
-    { "AE", XKB_KEY_AE },
-    { "ae", XKB_KEY_ae },
-    { "Agrave", XKB_KEY_Agrave },
-    { "agrave", XKB_KEY_agrave },
-    { "Ahook", XKB_KEY_Ahook },
-    { "ahook", XKB_KEY_ahook },
-    { "Alt_L", XKB_KEY_Alt_L },
-    { "Alt_R", XKB_KEY_Alt_R },
-    { "Amacron", XKB_KEY_Amacron },
-    { "amacron", XKB_KEY_amacron },
-    { "ampersand", XKB_KEY_ampersand },
-    { "Aogonek", XKB_KEY_Aogonek },
-    { "aogonek", XKB_KEY_aogonek },
-    { "apostrophe", XKB_KEY_apostrophe },
-    { "approxeq", XKB_KEY_approxeq },
-    { "approximate", XKB_KEY_approximate },
-    { "Arabic_0", XKB_KEY_Arabic_0 },
-    { "Arabic_1", XKB_KEY_Arabic_1 },
-    { "Arabic_2", XKB_KEY_Arabic_2 },
-    { "Arabic_3", XKB_KEY_Arabic_3 },
-    { "Arabic_4", XKB_KEY_Arabic_4 },
-    { "Arabic_5", XKB_KEY_Arabic_5 },
-    { "Arabic_6", XKB_KEY_Arabic_6 },
-    { "Arabic_7", XKB_KEY_Arabic_7 },
-    { "Arabic_8", XKB_KEY_Arabic_8 },
-    { "Arabic_9", XKB_KEY_Arabic_9 },
-    { "Arabic_ain", XKB_KEY_Arabic_ain },
-    { "Arabic_alef", XKB_KEY_Arabic_alef },
-    { "Arabic_alefmaksura", XKB_KEY_Arabic_alefmaksura },
-    { "Arabic_beh", XKB_KEY_Arabic_beh },
-    { "Arabic_comma", XKB_KEY_Arabic_comma },
-    { "Arabic_dad", XKB_KEY_Arabic_dad },
-    { "Arabic_dal", XKB_KEY_Arabic_dal },
-    { "Arabic_damma", XKB_KEY_Arabic_damma },
-    { "Arabic_dammatan", XKB_KEY_Arabic_dammatan },
-    { "Arabic_ddal", XKB_KEY_Arabic_ddal },
-    { "Arabic_farsi_yeh", XKB_KEY_Arabic_farsi_yeh },
-    { "Arabic_fatha", XKB_KEY_Arabic_fatha },
-    { "Arabic_fathatan", XKB_KEY_Arabic_fathatan },
-    { "Arabic_feh", XKB_KEY_Arabic_feh },
-    { "Arabic_fullstop", XKB_KEY_Arabic_fullstop },
-    { "Arabic_gaf", XKB_KEY_Arabic_gaf },
-    { "Arabic_ghain", XKB_KEY_Arabic_ghain },
-    { "Arabic_ha", XKB_KEY_Arabic_ha },
-    { "Arabic_hah", XKB_KEY_Arabic_hah },
-    { "Arabic_hamza", XKB_KEY_Arabic_hamza },
-    { "Arabic_hamza_above", XKB_KEY_Arabic_hamza_above },
-    { "Arabic_hamza_below", XKB_KEY_Arabic_hamza_below },
-    { "Arabic_hamzaonalef", XKB_KEY_Arabic_hamzaonalef },
-    { "Arabic_hamzaonwaw", XKB_KEY_Arabic_hamzaonwaw },
-    { "Arabic_hamzaonyeh", XKB_KEY_Arabic_hamzaonyeh },
-    { "Arabic_hamzaunderalef", XKB_KEY_Arabic_hamzaunderalef },
-    { "Arabic_heh", XKB_KEY_Arabic_heh },
-    { "Arabic_heh_doachashmee", XKB_KEY_Arabic_heh_doachashmee },
-    { "Arabic_heh_goal", XKB_KEY_Arabic_heh_goal },
-    { "Arabic_jeem", XKB_KEY_Arabic_jeem },
-    { "Arabic_jeh", XKB_KEY_Arabic_jeh },
-    { "Arabic_kaf", XKB_KEY_Arabic_kaf },
-    { "Arabic_kasra", XKB_KEY_Arabic_kasra },
-    { "Arabic_kasratan", XKB_KEY_Arabic_kasratan },
-    { "Arabic_keheh", XKB_KEY_Arabic_keheh },
-    { "Arabic_khah", XKB_KEY_Arabic_khah },
-    { "Arabic_lam", XKB_KEY_Arabic_lam },
-    { "Arabic_madda_above", XKB_KEY_Arabic_madda_above },
-    { "Arabic_maddaonalef", XKB_KEY_Arabic_maddaonalef },
-    { "Arabic_meem", XKB_KEY_Arabic_meem },
-    { "Arabic_noon", XKB_KEY_Arabic_noon },
-    { "Arabic_noon_ghunna", XKB_KEY_Arabic_noon_ghunna },
-    { "Arabic_peh", XKB_KEY_Arabic_peh },
-    { "Arabic_percent", XKB_KEY_Arabic_percent },
-    { "Arabic_qaf", XKB_KEY_Arabic_qaf },
-    { "Arabic_question_mark", XKB_KEY_Arabic_question_mark },
-    { "Arabic_ra", XKB_KEY_Arabic_ra },
-    { "Arabic_rreh", XKB_KEY_Arabic_rreh },
-    { "Arabic_sad", XKB_KEY_Arabic_sad },
-    { "Arabic_seen", XKB_KEY_Arabic_seen },
-    { "Arabic_semicolon", XKB_KEY_Arabic_semicolon },
-    { "Arabic_shadda", XKB_KEY_Arabic_shadda },
-    { "Arabic_sheen", XKB_KEY_Arabic_sheen },
-    { "Arabic_sukun", XKB_KEY_Arabic_sukun },
-    { "Arabic_superscript_alef", XKB_KEY_Arabic_superscript_alef },
-    { "Arabic_switch", XKB_KEY_Arabic_switch },
-    { "Arabic_tah", XKB_KEY_Arabic_tah },
-    { "Arabic_tatweel", XKB_KEY_Arabic_tatweel },
-    { "Arabic_tcheh", XKB_KEY_Arabic_tcheh },
-    { "Arabic_teh", XKB_KEY_Arabic_teh },
-    { "Arabic_tehmarbuta", XKB_KEY_Arabic_tehmarbuta },
-    { "Arabic_thal", XKB_KEY_Arabic_thal },
-    { "Arabic_theh", XKB_KEY_Arabic_theh },
-    { "Arabic_tteh", XKB_KEY_Arabic_tteh },
-    { "Arabic_veh", XKB_KEY_Arabic_veh },
-    { "Arabic_waw", XKB_KEY_Arabic_waw },
-    { "Arabic_yeh", XKB_KEY_Arabic_yeh },
-    { "Arabic_yeh_baree", XKB_KEY_Arabic_yeh_baree },
-    { "Arabic_zah", XKB_KEY_Arabic_zah },
-    { "Arabic_zain", XKB_KEY_Arabic_zain },
-    { "Aring", XKB_KEY_Aring },
-    { "aring", XKB_KEY_aring },
-    { "Armenian_accent", XKB_KEY_Armenian_accent },
-    { "Armenian_amanak", XKB_KEY_Armenian_amanak },
-    { "Armenian_apostrophe", XKB_KEY_Armenian_apostrophe },
-    { "Armenian_AT", XKB_KEY_Armenian_AT },
-    { "Armenian_at", XKB_KEY_Armenian_at },
-    { "Armenian_AYB", XKB_KEY_Armenian_AYB },
-    { "Armenian_ayb", XKB_KEY_Armenian_ayb },
-    { "Armenian_BEN", XKB_KEY_Armenian_BEN },
-    { "Armenian_ben", XKB_KEY_Armenian_ben },
-    { "Armenian_but", XKB_KEY_Armenian_but },
-    { "Armenian_CHA", XKB_KEY_Armenian_CHA },
-    { "Armenian_cha", XKB_KEY_Armenian_cha },
-    { "Armenian_DA", XKB_KEY_Armenian_DA },
-    { "Armenian_da", XKB_KEY_Armenian_da },
-    { "Armenian_DZA", XKB_KEY_Armenian_DZA },
-    { "Armenian_dza", XKB_KEY_Armenian_dza },
-    { "Armenian_E", XKB_KEY_Armenian_E },
-    { "Armenian_e", XKB_KEY_Armenian_e },
-    { "Armenian_exclam", XKB_KEY_Armenian_exclam },
-    { "Armenian_FE", XKB_KEY_Armenian_FE },
-    { "Armenian_fe", XKB_KEY_Armenian_fe },
-    { "Armenian_full_stop", XKB_KEY_Armenian_full_stop },
-    { "Armenian_GHAT", XKB_KEY_Armenian_GHAT },
-    { "Armenian_ghat", XKB_KEY_Armenian_ghat },
-    { "Armenian_GIM", XKB_KEY_Armenian_GIM },
-    { "Armenian_gim", XKB_KEY_Armenian_gim },
-    { "Armenian_HI", XKB_KEY_Armenian_HI },
-    { "Armenian_hi", XKB_KEY_Armenian_hi },
-    { "Armenian_HO", XKB_KEY_Armenian_HO },
-    { "Armenian_ho", XKB_KEY_Armenian_ho },
-    { "Armenian_hyphen", XKB_KEY_Armenian_hyphen },
-    { "Armenian_INI", XKB_KEY_Armenian_INI },
-    { "Armenian_ini", XKB_KEY_Armenian_ini },
-    { "Armenian_JE", XKB_KEY_Armenian_JE },
-    { "Armenian_je", XKB_KEY_Armenian_je },
-    { "Armenian_KE", XKB_KEY_Armenian_KE },
-    { "Armenian_ke", XKB_KEY_Armenian_ke },
-    { "Armenian_KEN", XKB_KEY_Armenian_KEN },
-    { "Armenian_ken", XKB_KEY_Armenian_ken },
-    { "Armenian_KHE", XKB_KEY_Armenian_KHE },
-    { "Armenian_khe", XKB_KEY_Armenian_khe },
-    { "Armenian_ligature_ew", XKB_KEY_Armenian_ligature_ew },
-    { "Armenian_LYUN", XKB_KEY_Armenian_LYUN },
-    { "Armenian_lyun", XKB_KEY_Armenian_lyun },
-    { "Armenian_MEN", XKB_KEY_Armenian_MEN },
-    { "Armenian_men", XKB_KEY_Armenian_men },
-    { "Armenian_NU", XKB_KEY_Armenian_NU },
-    { "Armenian_nu", XKB_KEY_Armenian_nu },
-    { "Armenian_O", XKB_KEY_Armenian_O },
-    { "Armenian_o", XKB_KEY_Armenian_o },
-    { "Armenian_paruyk", XKB_KEY_Armenian_paruyk },
-    { "Armenian_PE", XKB_KEY_Armenian_PE },
-    { "Armenian_pe", XKB_KEY_Armenian_pe },
-    { "Armenian_PYUR", XKB_KEY_Armenian_PYUR },
-    { "Armenian_pyur", XKB_KEY_Armenian_pyur },
-    { "Armenian_question", XKB_KEY_Armenian_question },
-    { "Armenian_RA", XKB_KEY_Armenian_RA },
-    { "Armenian_ra", XKB_KEY_Armenian_ra },
-    { "Armenian_RE", XKB_KEY_Armenian_RE },
-    { "Armenian_re", XKB_KEY_Armenian_re },
-    { "Armenian_SE", XKB_KEY_Armenian_SE },
-    { "Armenian_se", XKB_KEY_Armenian_se },
-    { "Armenian_separation_mark", XKB_KEY_Armenian_separation_mark },
-    { "Armenian_SHA", XKB_KEY_Armenian_SHA },
-    { "Armenian_sha", XKB_KEY_Armenian_sha },
-    { "Armenian_shesht", XKB_KEY_Armenian_shesht },
-    { "Armenian_TCHE", XKB_KEY_Armenian_TCHE },
-    { "Armenian_tche", XKB_KEY_Armenian_tche },
-    { "Armenian_TO", XKB_KEY_Armenian_TO },
-    { "Armenian_to", XKB_KEY_Armenian_to },
-    { "Armenian_TSA", XKB_KEY_Armenian_TSA },
-    { "Armenian_tsa", XKB_KEY_Armenian_tsa },
-    { "Armenian_TSO", XKB_KEY_Armenian_TSO },
-    { "Armenian_tso", XKB_KEY_Armenian_tso },
-    { "Armenian_TYUN", XKB_KEY_Armenian_TYUN },
-    { "Armenian_tyun", XKB_KEY_Armenian_tyun },
-    { "Armenian_verjaket", XKB_KEY_Armenian_verjaket },
-    { "Armenian_VEV", XKB_KEY_Armenian_VEV },
-    { "Armenian_vev", XKB_KEY_Armenian_vev },
-    { "Armenian_VO", XKB_KEY_Armenian_VO },
-    { "Armenian_vo", XKB_KEY_Armenian_vo },
-    { "Armenian_VYUN", XKB_KEY_Armenian_VYUN },
-    { "Armenian_vyun", XKB_KEY_Armenian_vyun },
-    { "Armenian_YECH", XKB_KEY_Armenian_YECH },
-    { "Armenian_yech", XKB_KEY_Armenian_yech },
-    { "Armenian_yentamna", XKB_KEY_Armenian_yentamna },
-    { "Armenian_ZA", XKB_KEY_Armenian_ZA },
-    { "Armenian_za", XKB_KEY_Armenian_za },
-    { "Armenian_ZHE", XKB_KEY_Armenian_ZHE },
-    { "Armenian_zhe", XKB_KEY_Armenian_zhe },
-    { "asciicircum", XKB_KEY_asciicircum },
-    { "asciitilde", XKB_KEY_asciitilde },
-    { "asterisk", XKB_KEY_asterisk },
-    { "at", XKB_KEY_at },
-    { "Atilde", XKB_KEY_Atilde },
-    { "atilde", XKB_KEY_atilde },
-    { "AudibleBell_Enable", XKB_KEY_AudibleBell_Enable },
-    { "B", XKB_KEY_B },
-    { "b", XKB_KEY_b },
-    { "Babovedot", XKB_KEY_Babovedot },
-    { "babovedot", XKB_KEY_babovedot },
-    { "backslash", XKB_KEY_backslash },
-    { "BackSpace", XKB_KEY_BackSpace },
-    { "BackTab", XKB_KEY_BackTab },
-    { "ballotcross", XKB_KEY_ballotcross },
-    { "bar", XKB_KEY_bar },
-    { "because", XKB_KEY_because },
-    { "Begin", XKB_KEY_Begin },
-    { "blank", XKB_KEY_blank },
-    { "block", XKB_KEY_block },
-    { "botintegral", XKB_KEY_botintegral },
-    { "botleftparens", XKB_KEY_botleftparens },
-    { "botleftsqbracket", XKB_KEY_botleftsqbracket },
-    { "botleftsummation", XKB_KEY_botleftsummation },
-    { "botrightparens", XKB_KEY_botrightparens },
-    { "botrightsqbracket", XKB_KEY_botrightsqbracket },
-    { "botrightsummation", XKB_KEY_botrightsummation },
-    { "bott", XKB_KEY_bott },
-    { "botvertsummationconnector", XKB_KEY_botvertsummationconnector },
-    { "BounceKeys_Enable", XKB_KEY_BounceKeys_Enable },
-    { "braceleft", XKB_KEY_braceleft },
-    { "braceright", XKB_KEY_braceright },
-    { "bracketleft", XKB_KEY_bracketleft },
-    { "bracketright", XKB_KEY_bracketright },
-    { "braille_blank", XKB_KEY_braille_blank },
-    { "braille_dot_1", XKB_KEY_braille_dot_1 },
-    { "braille_dot_10", XKB_KEY_braille_dot_10 },
-    { "braille_dot_2", XKB_KEY_braille_dot_2 },
-    { "braille_dot_3", XKB_KEY_braille_dot_3 },
-    { "braille_dot_4", XKB_KEY_braille_dot_4 },
-    { "braille_dot_5", XKB_KEY_braille_dot_5 },
-    { "braille_dot_6", XKB_KEY_braille_dot_6 },
-    { "braille_dot_7", XKB_KEY_braille_dot_7 },
-    { "braille_dot_8", XKB_KEY_braille_dot_8 },
-    { "braille_dot_9", XKB_KEY_braille_dot_9 },
-    { "braille_dots_1", XKB_KEY_braille_dots_1 },
-    { "braille_dots_12", XKB_KEY_braille_dots_12 },
-    { "braille_dots_123", XKB_KEY_braille_dots_123 },
-    { "braille_dots_1234", XKB_KEY_braille_dots_1234 },
-    { "braille_dots_12345", XKB_KEY_braille_dots_12345 },
-    { "braille_dots_123456", XKB_KEY_braille_dots_123456 },
-    { "braille_dots_1234567", XKB_KEY_braille_dots_1234567 },
-    { "braille_dots_12345678", XKB_KEY_braille_dots_12345678 },
-    { "braille_dots_1234568", XKB_KEY_braille_dots_1234568 },
-    { "braille_dots_123457", XKB_KEY_braille_dots_123457 },
-    { "braille_dots_1234578", XKB_KEY_braille_dots_1234578 },
-    { "braille_dots_123458", XKB_KEY_braille_dots_123458 },
-    { "braille_dots_12346", XKB_KEY_braille_dots_12346 },
-    { "braille_dots_123467", XKB_KEY_braille_dots_123467 },
-    { "braille_dots_1234678", XKB_KEY_braille_dots_1234678 },
-    { "braille_dots_123468", XKB_KEY_braille_dots_123468 },
-    { "braille_dots_12347", XKB_KEY_braille_dots_12347 },
-    { "braille_dots_123478", XKB_KEY_braille_dots_123478 },
-    { "braille_dots_12348", XKB_KEY_braille_dots_12348 },
-    { "braille_dots_1235", XKB_KEY_braille_dots_1235 },
-    { "braille_dots_12356", XKB_KEY_braille_dots_12356 },
-    { "braille_dots_123567", XKB_KEY_braille_dots_123567 },
-    { "braille_dots_1235678", XKB_KEY_braille_dots_1235678 },
-    { "braille_dots_123568", XKB_KEY_braille_dots_123568 },
-    { "braille_dots_12357", XKB_KEY_braille_dots_12357 },
-    { "braille_dots_123578", XKB_KEY_braille_dots_123578 },
-    { "braille_dots_12358", XKB_KEY_braille_dots_12358 },
-    { "braille_dots_1236", XKB_KEY_braille_dots_1236 },
-    { "braille_dots_12367", XKB_KEY_braille_dots_12367 },
-    { "braille_dots_123678", XKB_KEY_braille_dots_123678 },
-    { "braille_dots_12368", XKB_KEY_braille_dots_12368 },
-    { "braille_dots_1237", XKB_KEY_braille_dots_1237 },
-    { "braille_dots_12378", XKB_KEY_braille_dots_12378 },
-    { "braille_dots_1238", XKB_KEY_braille_dots_1238 },
-    { "braille_dots_124", XKB_KEY_braille_dots_124 },
-    { "braille_dots_1245", XKB_KEY_braille_dots_1245 },
-    { "braille_dots_12456", XKB_KEY_braille_dots_12456 },
-    { "braille_dots_124567", XKB_KEY_braille_dots_124567 },
-    { "braille_dots_1245678", XKB_KEY_braille_dots_1245678 },
-    { "braille_dots_124568", XKB_KEY_braille_dots_124568 },
-    { "braille_dots_12457", XKB_KEY_braille_dots_12457 },
-    { "braille_dots_124578", XKB_KEY_braille_dots_124578 },
-    { "braille_dots_12458", XKB_KEY_braille_dots_12458 },
-    { "braille_dots_1246", XKB_KEY_braille_dots_1246 },
-    { "braille_dots_12467", XKB_KEY_braille_dots_12467 },
-    { "braille_dots_124678", XKB_KEY_braille_dots_124678 },
-    { "braille_dots_12468", XKB_KEY_braille_dots_12468 },
-    { "braille_dots_1247", XKB_KEY_braille_dots_1247 },
-    { "braille_dots_12478", XKB_KEY_braille_dots_12478 },
-    { "braille_dots_1248", XKB_KEY_braille_dots_1248 },
-    { "braille_dots_125", XKB_KEY_braille_dots_125 },
-    { "braille_dots_1256", XKB_KEY_braille_dots_1256 },
-    { "braille_dots_12567", XKB_KEY_braille_dots_12567 },
-    { "braille_dots_125678", XKB_KEY_braille_dots_125678 },
-    { "braille_dots_12568", XKB_KEY_braille_dots_12568 },
-    { "braille_dots_1257", XKB_KEY_braille_dots_1257 },
-    { "braille_dots_12578", XKB_KEY_braille_dots_12578 },
-    { "braille_dots_1258", XKB_KEY_braille_dots_1258 },
-    { "braille_dots_126", XKB_KEY_braille_dots_126 },
-    { "braille_dots_1267", XKB_KEY_braille_dots_1267 },
-    { "braille_dots_12678", XKB_KEY_braille_dots_12678 },
-    { "braille_dots_1268", XKB_KEY_braille_dots_1268 },
-    { "braille_dots_127", XKB_KEY_braille_dots_127 },
-    { "braille_dots_1278", XKB_KEY_braille_dots_1278 },
-    { "braille_dots_128", XKB_KEY_braille_dots_128 },
-    { "braille_dots_13", XKB_KEY_braille_dots_13 },
-    { "braille_dots_134", XKB_KEY_braille_dots_134 },
-    { "braille_dots_1345", XKB_KEY_braille_dots_1345 },
-    { "braille_dots_13456", XKB_KEY_braille_dots_13456 },
-    { "braille_dots_134567", XKB_KEY_braille_dots_134567 },
-    { "braille_dots_1345678", XKB_KEY_braille_dots_1345678 },
-    { "braille_dots_134568", XKB_KEY_braille_dots_134568 },
-    { "braille_dots_13457", XKB_KEY_braille_dots_13457 },
-    { "braille_dots_134578", XKB_KEY_braille_dots_134578 },
-    { "braille_dots_13458", XKB_KEY_braille_dots_13458 },
-    { "braille_dots_1346", XKB_KEY_braille_dots_1346 },
-    { "braille_dots_13467", XKB_KEY_braille_dots_13467 },
-    { "braille_dots_134678", XKB_KEY_braille_dots_134678 },
-    { "braille_dots_13468", XKB_KEY_braille_dots_13468 },
-    { "braille_dots_1347", XKB_KEY_braille_dots_1347 },
-    { "braille_dots_13478", XKB_KEY_braille_dots_13478 },
-    { "braille_dots_1348", XKB_KEY_braille_dots_1348 },
-    { "braille_dots_135", XKB_KEY_braille_dots_135 },
-    { "braille_dots_1356", XKB_KEY_braille_dots_1356 },
-    { "braille_dots_13567", XKB_KEY_braille_dots_13567 },
-    { "braille_dots_135678", XKB_KEY_braille_dots_135678 },
-    { "braille_dots_13568", XKB_KEY_braille_dots_13568 },
-    { "braille_dots_1357", XKB_KEY_braille_dots_1357 },
-    { "braille_dots_13578", XKB_KEY_braille_dots_13578 },
-    { "braille_dots_1358", XKB_KEY_braille_dots_1358 },
-    { "braille_dots_136", XKB_KEY_braille_dots_136 },
-    { "braille_dots_1367", XKB_KEY_braille_dots_1367 },
-    { "braille_dots_13678", XKB_KEY_braille_dots_13678 },
-    { "braille_dots_1368", XKB_KEY_braille_dots_1368 },
-    { "braille_dots_137", XKB_KEY_braille_dots_137 },
-    { "braille_dots_1378", XKB_KEY_braille_dots_1378 },
-    { "braille_dots_138", XKB_KEY_braille_dots_138 },
-    { "braille_dots_14", XKB_KEY_braille_dots_14 },
-    { "braille_dots_145", XKB_KEY_braille_dots_145 },
-    { "braille_dots_1456", XKB_KEY_braille_dots_1456 },
-    { "braille_dots_14567", XKB_KEY_braille_dots_14567 },
-    { "braille_dots_145678", XKB_KEY_braille_dots_145678 },
-    { "braille_dots_14568", XKB_KEY_braille_dots_14568 },
-    { "braille_dots_1457", XKB_KEY_braille_dots_1457 },
-    { "braille_dots_14578", XKB_KEY_braille_dots_14578 },
-    { "braille_dots_1458", XKB_KEY_braille_dots_1458 },
-    { "braille_dots_146", XKB_KEY_braille_dots_146 },
-    { "braille_dots_1467", XKB_KEY_braille_dots_1467 },
-    { "braille_dots_14678", XKB_KEY_braille_dots_14678 },
-    { "braille_dots_1468", XKB_KEY_braille_dots_1468 },
-    { "braille_dots_147", XKB_KEY_braille_dots_147 },
-    { "braille_dots_1478", XKB_KEY_braille_dots_1478 },
-    { "braille_dots_148", XKB_KEY_braille_dots_148 },
-    { "braille_dots_15", XKB_KEY_braille_dots_15 },
-    { "braille_dots_156", XKB_KEY_braille_dots_156 },
-    { "braille_dots_1567", XKB_KEY_braille_dots_1567 },
-    { "braille_dots_15678", XKB_KEY_braille_dots_15678 },
-    { "braille_dots_1568", XKB_KEY_braille_dots_1568 },
-    { "braille_dots_157", XKB_KEY_braille_dots_157 },
-    { "braille_dots_1578", XKB_KEY_braille_dots_1578 },
-    { "braille_dots_158", XKB_KEY_braille_dots_158 },
-    { "braille_dots_16", XKB_KEY_braille_dots_16 },
-    { "braille_dots_167", XKB_KEY_braille_dots_167 },
-    { "braille_dots_1678", XKB_KEY_braille_dots_1678 },
-    { "braille_dots_168", XKB_KEY_braille_dots_168 },
-    { "braille_dots_17", XKB_KEY_braille_dots_17 },
-    { "braille_dots_178", XKB_KEY_braille_dots_178 },
-    { "braille_dots_18", XKB_KEY_braille_dots_18 },
-    { "braille_dots_2", XKB_KEY_braille_dots_2 },
-    { "braille_dots_23", XKB_KEY_braille_dots_23 },
-    { "braille_dots_234", XKB_KEY_braille_dots_234 },
-    { "braille_dots_2345", XKB_KEY_braille_dots_2345 },
-    { "braille_dots_23456", XKB_KEY_braille_dots_23456 },
-    { "braille_dots_234567", XKB_KEY_braille_dots_234567 },
-    { "braille_dots_2345678", XKB_KEY_braille_dots_2345678 },
-    { "braille_dots_234568", XKB_KEY_braille_dots_234568 },
-    { "braille_dots_23457", XKB_KEY_braille_dots_23457 },
-    { "braille_dots_234578", XKB_KEY_braille_dots_234578 },
-    { "braille_dots_23458", XKB_KEY_braille_dots_23458 },
-    { "braille_dots_2346", XKB_KEY_braille_dots_2346 },
-    { "braille_dots_23467", XKB_KEY_braille_dots_23467 },
-    { "braille_dots_234678", XKB_KEY_braille_dots_234678 },
-    { "braille_dots_23468", XKB_KEY_braille_dots_23468 },
-    { "braille_dots_2347", XKB_KEY_braille_dots_2347 },
-    { "braille_dots_23478", XKB_KEY_braille_dots_23478 },
-    { "braille_dots_2348", XKB_KEY_braille_dots_2348 },
-    { "braille_dots_235", XKB_KEY_braille_dots_235 },
-    { "braille_dots_2356", XKB_KEY_braille_dots_2356 },
-    { "braille_dots_23567", XKB_KEY_braille_dots_23567 },
-    { "braille_dots_235678", XKB_KEY_braille_dots_235678 },
-    { "braille_dots_23568", XKB_KEY_braille_dots_23568 },
-    { "braille_dots_2357", XKB_KEY_braille_dots_2357 },
-    { "braille_dots_23578", XKB_KEY_braille_dots_23578 },
-    { "braille_dots_2358", XKB_KEY_braille_dots_2358 },
-    { "braille_dots_236", XKB_KEY_braille_dots_236 },
-    { "braille_dots_2367", XKB_KEY_braille_dots_2367 },
-    { "braille_dots_23678", XKB_KEY_braille_dots_23678 },
-    { "braille_dots_2368", XKB_KEY_braille_dots_2368 },
-    { "braille_dots_237", XKB_KEY_braille_dots_237 },
-    { "braille_dots_2378", XKB_KEY_braille_dots_2378 },
-    { "braille_dots_238", XKB_KEY_braille_dots_238 },
-    { "braille_dots_24", XKB_KEY_braille_dots_24 },
-    { "braille_dots_245", XKB_KEY_braille_dots_245 },
-    { "braille_dots_2456", XKB_KEY_braille_dots_2456 },
-    { "braille_dots_24567", XKB_KEY_braille_dots_24567 },
-    { "braille_dots_245678", XKB_KEY_braille_dots_245678 },
-    { "braille_dots_24568", XKB_KEY_braille_dots_24568 },
-    { "braille_dots_2457", XKB_KEY_braille_dots_2457 },
-    { "braille_dots_24578", XKB_KEY_braille_dots_24578 },
-    { "braille_dots_2458", XKB_KEY_braille_dots_2458 },
-    { "braille_dots_246", XKB_KEY_braille_dots_246 },
-    { "braille_dots_2467", XKB_KEY_braille_dots_2467 },
-    { "braille_dots_24678", XKB_KEY_braille_dots_24678 },
-    { "braille_dots_2468", XKB_KEY_braille_dots_2468 },
-    { "braille_dots_247", XKB_KEY_braille_dots_247 },
-    { "braille_dots_2478", XKB_KEY_braille_dots_2478 },
-    { "braille_dots_248", XKB_KEY_braille_dots_248 },
-    { "braille_dots_25", XKB_KEY_braille_dots_25 },
-    { "braille_dots_256", XKB_KEY_braille_dots_256 },
-    { "braille_dots_2567", XKB_KEY_braille_dots_2567 },
-    { "braille_dots_25678", XKB_KEY_braille_dots_25678 },
-    { "braille_dots_2568", XKB_KEY_braille_dots_2568 },
-    { "braille_dots_257", XKB_KEY_braille_dots_257 },
-    { "braille_dots_2578", XKB_KEY_braille_dots_2578 },
-    { "braille_dots_258", XKB_KEY_braille_dots_258 },
-    { "braille_dots_26", XKB_KEY_braille_dots_26 },
-    { "braille_dots_267", XKB_KEY_braille_dots_267 },
-    { "braille_dots_2678", XKB_KEY_braille_dots_2678 },
-    { "braille_dots_268", XKB_KEY_braille_dots_268 },
-    { "braille_dots_27", XKB_KEY_braille_dots_27 },
-    { "braille_dots_278", XKB_KEY_braille_dots_278 },
-    { "braille_dots_28", XKB_KEY_braille_dots_28 },
-    { "braille_dots_3", XKB_KEY_braille_dots_3 },
-    { "braille_dots_34", XKB_KEY_braille_dots_34 },
-    { "braille_dots_345", XKB_KEY_braille_dots_345 },
-    { "braille_dots_3456", XKB_KEY_braille_dots_3456 },
-    { "braille_dots_34567", XKB_KEY_braille_dots_34567 },
-    { "braille_dots_345678", XKB_KEY_braille_dots_345678 },
-    { "braille_dots_34568", XKB_KEY_braille_dots_34568 },
-    { "braille_dots_3457", XKB_KEY_braille_dots_3457 },
-    { "braille_dots_34578", XKB_KEY_braille_dots_34578 },
-    { "braille_dots_3458", XKB_KEY_braille_dots_3458 },
-    { "braille_dots_346", XKB_KEY_braille_dots_346 },
-    { "braille_dots_3467", XKB_KEY_braille_dots_3467 },
-    { "braille_dots_34678", XKB_KEY_braille_dots_34678 },
-    { "braille_dots_3468", XKB_KEY_braille_dots_3468 },
-    { "braille_dots_347", XKB_KEY_braille_dots_347 },
-    { "braille_dots_3478", XKB_KEY_braille_dots_3478 },
-    { "braille_dots_348", XKB_KEY_braille_dots_348 },
-    { "braille_dots_35", XKB_KEY_braille_dots_35 },
-    { "braille_dots_356", XKB_KEY_braille_dots_356 },
-    { "braille_dots_3567", XKB_KEY_braille_dots_3567 },
-    { "braille_dots_35678", XKB_KEY_braille_dots_35678 },
-    { "braille_dots_3568", XKB_KEY_braille_dots_3568 },
-    { "braille_dots_357", XKB_KEY_braille_dots_357 },
-    { "braille_dots_3578", XKB_KEY_braille_dots_3578 },
-    { "braille_dots_358", XKB_KEY_braille_dots_358 },
-    { "braille_dots_36", XKB_KEY_braille_dots_36 },
-    { "braille_dots_367", XKB_KEY_braille_dots_367 },
-    { "braille_dots_3678", XKB_KEY_braille_dots_3678 },
-    { "braille_dots_368", XKB_KEY_braille_dots_368 },
-    { "braille_dots_37", XKB_KEY_braille_dots_37 },
-    { "braille_dots_378", XKB_KEY_braille_dots_378 },
-    { "braille_dots_38", XKB_KEY_braille_dots_38 },
-    { "braille_dots_4", XKB_KEY_braille_dots_4 },
-    { "braille_dots_45", XKB_KEY_braille_dots_45 },
-    { "braille_dots_456", XKB_KEY_braille_dots_456 },
-    { "braille_dots_4567", XKB_KEY_braille_dots_4567 },
-    { "braille_dots_45678", XKB_KEY_braille_dots_45678 },
-    { "braille_dots_4568", XKB_KEY_braille_dots_4568 },
-    { "braille_dots_457", XKB_KEY_braille_dots_457 },
-    { "braille_dots_4578", XKB_KEY_braille_dots_4578 },
-    { "braille_dots_458", XKB_KEY_braille_dots_458 },
-    { "braille_dots_46", XKB_KEY_braille_dots_46 },
-    { "braille_dots_467", XKB_KEY_braille_dots_467 },
-    { "braille_dots_4678", XKB_KEY_braille_dots_4678 },
-    { "braille_dots_468", XKB_KEY_braille_dots_468 },
-    { "braille_dots_47", XKB_KEY_braille_dots_47 },
-    { "braille_dots_478", XKB_KEY_braille_dots_478 },
-    { "braille_dots_48", XKB_KEY_braille_dots_48 },
-    { "braille_dots_5", XKB_KEY_braille_dots_5 },
-    { "braille_dots_56", XKB_KEY_braille_dots_56 },
-    { "braille_dots_567", XKB_KEY_braille_dots_567 },
-    { "braille_dots_5678", XKB_KEY_braille_dots_5678 },
-    { "braille_dots_568", XKB_KEY_braille_dots_568 },
-    { "braille_dots_57", XKB_KEY_braille_dots_57 },
-    { "braille_dots_578", XKB_KEY_braille_dots_578 },
-    { "braille_dots_58", XKB_KEY_braille_dots_58 },
-    { "braille_dots_6", XKB_KEY_braille_dots_6 },
-    { "braille_dots_67", XKB_KEY_braille_dots_67 },
-    { "braille_dots_678", XKB_KEY_braille_dots_678 },
-    { "braille_dots_68", XKB_KEY_braille_dots_68 },
-    { "braille_dots_7", XKB_KEY_braille_dots_7 },
-    { "braille_dots_78", XKB_KEY_braille_dots_78 },
-    { "braille_dots_8", XKB_KEY_braille_dots_8 },
-    { "Break", XKB_KEY_Break },
-    { "breve", XKB_KEY_breve },
-    { "brokenbar", XKB_KEY_brokenbar },
-    { "Byelorussian_shortu", XKB_KEY_Byelorussian_shortu },
-    { "Byelorussian_SHORTU", XKB_KEY_Byelorussian_SHORTU },
-    { "C", XKB_KEY_C },
-    { "c", XKB_KEY_c },
-    { "c_h", XKB_KEY_c_h },
-    { "C_h", XKB_KEY_C_h },
-    { "C_H", XKB_KEY_C_H },
-    { "Cabovedot", XKB_KEY_Cabovedot },
-    { "cabovedot", XKB_KEY_cabovedot },
-    { "Cacute", XKB_KEY_Cacute },
-    { "cacute", XKB_KEY_cacute },
-    { "Cancel", XKB_KEY_Cancel },
-    { "Caps_Lock", XKB_KEY_Caps_Lock },
-    { "careof", XKB_KEY_careof },
-    { "caret", XKB_KEY_caret },
-    { "caron", XKB_KEY_caron },
-    { "Ccaron", XKB_KEY_Ccaron },
-    { "ccaron", XKB_KEY_ccaron },
-    { "Ccedilla", XKB_KEY_Ccedilla },
-    { "ccedilla", XKB_KEY_ccedilla },
-    { "Ccircumflex", XKB_KEY_Ccircumflex },
-    { "ccircumflex", XKB_KEY_ccircumflex },
-    { "cedilla", XKB_KEY_cedilla },
-    { "cent", XKB_KEY_cent },
-    { "ch", XKB_KEY_ch },
-    { "Ch", XKB_KEY_Ch },
-    { "CH", XKB_KEY_CH },
-    { "checkerboard", XKB_KEY_checkerboard },
-    { "checkmark", XKB_KEY_checkmark },
-    { "circle", XKB_KEY_circle },
-    { "Clear", XKB_KEY_Clear },
-    { "ClearLine", XKB_KEY_ClearLine },
-    { "club", XKB_KEY_club },
-    { "Codeinput", XKB_KEY_Codeinput },
-    { "colon", XKB_KEY_colon },
-    { "ColonSign", XKB_KEY_ColonSign },
-    { "comma", XKB_KEY_comma },
-    { "containsas", XKB_KEY_containsas },
-    { "Control_L", XKB_KEY_Control_L },
-    { "Control_R", XKB_KEY_Control_R },
-    { "copyright", XKB_KEY_copyright },
-    { "cr", XKB_KEY_cr },
-    { "crossinglines", XKB_KEY_crossinglines },
-    { "CruzeiroSign", XKB_KEY_CruzeiroSign },
-    { "cuberoot", XKB_KEY_cuberoot },
-    { "currency", XKB_KEY_currency },
-    { "cursor", XKB_KEY_cursor },
-    { "Cyrillic_a", XKB_KEY_Cyrillic_a },
-    { "Cyrillic_A", XKB_KEY_Cyrillic_A },
-    { "Cyrillic_be", XKB_KEY_Cyrillic_be },
-    { "Cyrillic_BE", XKB_KEY_Cyrillic_BE },
-    { "Cyrillic_che", XKB_KEY_Cyrillic_che },
-    { "Cyrillic_CHE", XKB_KEY_Cyrillic_CHE },
-    { "Cyrillic_CHE_descender", XKB_KEY_Cyrillic_CHE_descender },
-    { "Cyrillic_che_descender", XKB_KEY_Cyrillic_che_descender },
-    { "Cyrillic_CHE_vertstroke", XKB_KEY_Cyrillic_CHE_vertstroke },
-    { "Cyrillic_che_vertstroke", XKB_KEY_Cyrillic_che_vertstroke },
-    { "Cyrillic_de", XKB_KEY_Cyrillic_de },
-    { "Cyrillic_DE", XKB_KEY_Cyrillic_DE },
-    { "Cyrillic_dzhe", XKB_KEY_Cyrillic_dzhe },
-    { "Cyrillic_DZHE", XKB_KEY_Cyrillic_DZHE },
-    { "Cyrillic_e", XKB_KEY_Cyrillic_e },
-    { "Cyrillic_E", XKB_KEY_Cyrillic_E },
-    { "Cyrillic_ef", XKB_KEY_Cyrillic_ef },
-    { "Cyrillic_EF", XKB_KEY_Cyrillic_EF },
-    { "Cyrillic_el", XKB_KEY_Cyrillic_el },
-    { "Cyrillic_EL", XKB_KEY_Cyrillic_EL },
-    { "Cyrillic_em", XKB_KEY_Cyrillic_em },
-    { "Cyrillic_EM", XKB_KEY_Cyrillic_EM },
-    { "Cyrillic_en", XKB_KEY_Cyrillic_en },
-    { "Cyrillic_EN", XKB_KEY_Cyrillic_EN },
-    { "Cyrillic_EN_descender", XKB_KEY_Cyrillic_EN_descender },
-    { "Cyrillic_en_descender", XKB_KEY_Cyrillic_en_descender },
-    { "Cyrillic_er", XKB_KEY_Cyrillic_er },
-    { "Cyrillic_ER", XKB_KEY_Cyrillic_ER },
-    { "Cyrillic_es", XKB_KEY_Cyrillic_es },
-    { "Cyrillic_ES", XKB_KEY_Cyrillic_ES },
-    { "Cyrillic_ghe", XKB_KEY_Cyrillic_ghe },
-    { "Cyrillic_GHE", XKB_KEY_Cyrillic_GHE },
-    { "Cyrillic_GHE_bar", XKB_KEY_Cyrillic_GHE_bar },
-    { "Cyrillic_ghe_bar", XKB_KEY_Cyrillic_ghe_bar },
-    { "Cyrillic_ha", XKB_KEY_Cyrillic_ha },
-    { "Cyrillic_HA", XKB_KEY_Cyrillic_HA },
-    { "Cyrillic_HA_descender", XKB_KEY_Cyrillic_HA_descender },
-    { "Cyrillic_ha_descender", XKB_KEY_Cyrillic_ha_descender },
-    { "Cyrillic_hardsign", XKB_KEY_Cyrillic_hardsign },
-    { "Cyrillic_HARDSIGN", XKB_KEY_Cyrillic_HARDSIGN },
-    { "Cyrillic_i", XKB_KEY_Cyrillic_i },
-    { "Cyrillic_I", XKB_KEY_Cyrillic_I },
-    { "Cyrillic_I_macron", XKB_KEY_Cyrillic_I_macron },
-    { "Cyrillic_i_macron", XKB_KEY_Cyrillic_i_macron },
-    { "Cyrillic_ie", XKB_KEY_Cyrillic_ie },
-    { "Cyrillic_IE", XKB_KEY_Cyrillic_IE },
-    { "Cyrillic_io", XKB_KEY_Cyrillic_io },
-    { "Cyrillic_IO", XKB_KEY_Cyrillic_IO },
-    { "Cyrillic_je", XKB_KEY_Cyrillic_je },
-    { "Cyrillic_JE", XKB_KEY_Cyrillic_JE },
-    { "Cyrillic_ka", XKB_KEY_Cyrillic_ka },
-    { "Cyrillic_KA", XKB_KEY_Cyrillic_KA },
-    { "Cyrillic_KA_descender", XKB_KEY_Cyrillic_KA_descender },
-    { "Cyrillic_ka_descender", XKB_KEY_Cyrillic_ka_descender },
-    { "Cyrillic_KA_vertstroke", XKB_KEY_Cyrillic_KA_vertstroke },
-    { "Cyrillic_ka_vertstroke", XKB_KEY_Cyrillic_ka_vertstroke },
-    { "Cyrillic_lje", XKB_KEY_Cyrillic_lje },
-    { "Cyrillic_LJE", XKB_KEY_Cyrillic_LJE },
-    { "Cyrillic_nje", XKB_KEY_Cyrillic_nje },
-    { "Cyrillic_NJE", XKB_KEY_Cyrillic_NJE },
-    { "Cyrillic_o", XKB_KEY_Cyrillic_o },
-    { "Cyrillic_O", XKB_KEY_Cyrillic_O },
-    { "Cyrillic_O_bar", XKB_KEY_Cyrillic_O_bar },
-    { "Cyrillic_o_bar", XKB_KEY_Cyrillic_o_bar },
-    { "Cyrillic_pe", XKB_KEY_Cyrillic_pe },
-    { "Cyrillic_PE", XKB_KEY_Cyrillic_PE },
-    { "Cyrillic_SCHWA", XKB_KEY_Cyrillic_SCHWA },
-    { "Cyrillic_schwa", XKB_KEY_Cyrillic_schwa },
-    { "Cyrillic_sha", XKB_KEY_Cyrillic_sha },
-    { "Cyrillic_SHA", XKB_KEY_Cyrillic_SHA },
-    { "Cyrillic_shcha", XKB_KEY_Cyrillic_shcha },
-    { "Cyrillic_SHCHA", XKB_KEY_Cyrillic_SHCHA },
-    { "Cyrillic_SHHA", XKB_KEY_Cyrillic_SHHA },
-    { "Cyrillic_shha", XKB_KEY_Cyrillic_shha },
-    { "Cyrillic_shorti", XKB_KEY_Cyrillic_shorti },
-    { "Cyrillic_SHORTI", XKB_KEY_Cyrillic_SHORTI },
-    { "Cyrillic_softsign", XKB_KEY_Cyrillic_softsign },
-    { "Cyrillic_SOFTSIGN", XKB_KEY_Cyrillic_SOFTSIGN },
-    { "Cyrillic_te", XKB_KEY_Cyrillic_te },
-    { "Cyrillic_TE", XKB_KEY_Cyrillic_TE },
-    { "Cyrillic_tse", XKB_KEY_Cyrillic_tse },
-    { "Cyrillic_TSE", XKB_KEY_Cyrillic_TSE },
-    { "Cyrillic_u", XKB_KEY_Cyrillic_u },
-    { "Cyrillic_U", XKB_KEY_Cyrillic_U },
-    { "Cyrillic_U_macron", XKB_KEY_Cyrillic_U_macron },
-    { "Cyrillic_u_macron", XKB_KEY_Cyrillic_u_macron },
-    { "Cyrillic_U_straight", XKB_KEY_Cyrillic_U_straight },
-    { "Cyrillic_u_straight", XKB_KEY_Cyrillic_u_straight },
-    { "Cyrillic_U_straight_bar", XKB_KEY_Cyrillic_U_straight_bar },
-    { "Cyrillic_u_straight_bar", XKB_KEY_Cyrillic_u_straight_bar },
-    { "Cyrillic_ve", XKB_KEY_Cyrillic_ve },
-    { "Cyrillic_VE", XKB_KEY_Cyrillic_VE },
-    { "Cyrillic_ya", XKB_KEY_Cyrillic_ya },
-    { "Cyrillic_YA", XKB_KEY_Cyrillic_YA },
-    { "Cyrillic_yeru", XKB_KEY_Cyrillic_yeru },
-    { "Cyrillic_YERU", XKB_KEY_Cyrillic_YERU },
-    { "Cyrillic_yu", XKB_KEY_Cyrillic_yu },
-    { "Cyrillic_YU", XKB_KEY_Cyrillic_YU },
-    { "Cyrillic_ze", XKB_KEY_Cyrillic_ze },
-    { "Cyrillic_ZE", XKB_KEY_Cyrillic_ZE },
-    { "Cyrillic_zhe", XKB_KEY_Cyrillic_zhe },
-    { "Cyrillic_ZHE", XKB_KEY_Cyrillic_ZHE },
-    { "Cyrillic_ZHE_descender", XKB_KEY_Cyrillic_ZHE_descender },
-    { "Cyrillic_zhe_descender", XKB_KEY_Cyrillic_zhe_descender },
-    { "D", XKB_KEY_D },
-    { "d", XKB_KEY_d },
-    { "Dabovedot", XKB_KEY_Dabovedot },
-    { "dabovedot", XKB_KEY_dabovedot },
-    { "Dacute_accent", XKB_KEY_Dacute_accent },
-    { "dagger", XKB_KEY_dagger },
-    { "Dcaron", XKB_KEY_Dcaron },
-    { "dcaron", XKB_KEY_dcaron },
-    { "Dcedilla_accent", XKB_KEY_Dcedilla_accent },
-    { "Dcircumflex_accent", XKB_KEY_Dcircumflex_accent },
-    { "Ddiaeresis", XKB_KEY_Ddiaeresis },
-    { "dead_a", XKB_KEY_dead_a },
-    { "dead_A", XKB_KEY_dead_A },
-    { "dead_abovecomma", XKB_KEY_dead_abovecomma },
-    { "dead_abovedot", XKB_KEY_dead_abovedot },
-    { "dead_abovereversedcomma", XKB_KEY_dead_abovereversedcomma },
-    { "dead_abovering", XKB_KEY_dead_abovering },
-    { "dead_acute", XKB_KEY_dead_acute },
-    { "dead_belowbreve", XKB_KEY_dead_belowbreve },
-    { "dead_belowcircumflex", XKB_KEY_dead_belowcircumflex },
-    { "dead_belowcomma", XKB_KEY_dead_belowcomma },
-    { "dead_belowdiaeresis", XKB_KEY_dead_belowdiaeresis },
-    { "dead_belowdot", XKB_KEY_dead_belowdot },
-    { "dead_belowmacron", XKB_KEY_dead_belowmacron },
-    { "dead_belowring", XKB_KEY_dead_belowring },
-    { "dead_belowtilde", XKB_KEY_dead_belowtilde },
-    { "dead_breve", XKB_KEY_dead_breve },
-    { "dead_capital_schwa", XKB_KEY_dead_capital_schwa },
-    { "dead_caron", XKB_KEY_dead_caron },
-    { "dead_cedilla", XKB_KEY_dead_cedilla },
-    { "dead_circumflex", XKB_KEY_dead_circumflex },
-    { "dead_currency", XKB_KEY_dead_currency },
-    { "dead_dasia", XKB_KEY_dead_dasia },
-    { "dead_diaeresis", XKB_KEY_dead_diaeresis },
-    { "dead_doubleacute", XKB_KEY_dead_doubleacute },
-    { "dead_doublegrave", XKB_KEY_dead_doublegrave },
-    { "dead_e", XKB_KEY_dead_e },
-    { "dead_E", XKB_KEY_dead_E },
-    { "dead_grave", XKB_KEY_dead_grave },
-    { "dead_greek", XKB_KEY_dead_greek },
-    { "dead_hook", XKB_KEY_dead_hook },
-    { "dead_horn", XKB_KEY_dead_horn },
-    { "dead_i", XKB_KEY_dead_i },
-    { "dead_I", XKB_KEY_dead_I },
-    { "dead_invertedbreve", XKB_KEY_dead_invertedbreve },
-    { "dead_iota", XKB_KEY_dead_iota },
-    { "dead_macron", XKB_KEY_dead_macron },
-    { "dead_o", XKB_KEY_dead_o },
-    { "dead_O", XKB_KEY_dead_O },
-    { "dead_ogonek", XKB_KEY_dead_ogonek },
-    { "dead_perispomeni", XKB_KEY_dead_perispomeni },
-    { "dead_psili", XKB_KEY_dead_psili },
-    { "dead_semivoiced_sound", XKB_KEY_dead_semivoiced_sound },
-    { "dead_small_schwa", XKB_KEY_dead_small_schwa },
-    { "dead_stroke", XKB_KEY_dead_stroke },
-    { "dead_tilde", XKB_KEY_dead_tilde },
-    { "dead_u", XKB_KEY_dead_u },
-    { "dead_U", XKB_KEY_dead_U },
-    { "dead_voiced_sound", XKB_KEY_dead_voiced_sound },
-    { "decimalpoint", XKB_KEY_decimalpoint },
-    { "degree", XKB_KEY_degree },
-    { "Delete", XKB_KEY_Delete },
-    { "DeleteChar", XKB_KEY_DeleteChar },
-    { "DeleteLine", XKB_KEY_DeleteLine },
-    { "Dgrave_accent", XKB_KEY_Dgrave_accent },
-    { "diaeresis", XKB_KEY_diaeresis },
-    { "diamond", XKB_KEY_diamond },
-    { "digitspace", XKB_KEY_digitspace },
-    { "dintegral", XKB_KEY_dintegral },
-    { "division", XKB_KEY_division },
-    { "dollar", XKB_KEY_dollar },
-    { "DongSign", XKB_KEY_DongSign },
-    { "doubbaselinedot", XKB_KEY_doubbaselinedot },
-    { "doubleacute", XKB_KEY_doubleacute },
-    { "doubledagger", XKB_KEY_doubledagger },
-    { "doublelowquotemark", XKB_KEY_doublelowquotemark },
-    { "Down", XKB_KEY_Down },
-    { "downarrow", XKB_KEY_downarrow },
-    { "downcaret", XKB_KEY_downcaret },
-    { "downshoe", XKB_KEY_downshoe },
-    { "downstile", XKB_KEY_downstile },
-    { "downtack", XKB_KEY_downtack },
-    { "DRemove", XKB_KEY_DRemove },
-    { "Dring_accent", XKB_KEY_Dring_accent },
-    { "Dstroke", XKB_KEY_Dstroke },
-    { "dstroke", XKB_KEY_dstroke },
-    { "Dtilde", XKB_KEY_Dtilde },
-    { "E", XKB_KEY_E },
-    { "e", XKB_KEY_e },
-    { "Eabovedot", XKB_KEY_Eabovedot },
-    { "eabovedot", XKB_KEY_eabovedot },
-    { "Eacute", XKB_KEY_Eacute },
-    { "eacute", XKB_KEY_eacute },
-    { "Ebelowdot", XKB_KEY_Ebelowdot },
-    { "ebelowdot", XKB_KEY_ebelowdot },
-    { "Ecaron", XKB_KEY_Ecaron },
-    { "ecaron", XKB_KEY_ecaron },
-    { "Ecircumflex", XKB_KEY_Ecircumflex },
-    { "ecircumflex", XKB_KEY_ecircumflex },
-    { "Ecircumflexacute", XKB_KEY_Ecircumflexacute },
-    { "ecircumflexacute", XKB_KEY_ecircumflexacute },
-    { "Ecircumflexbelowdot", XKB_KEY_Ecircumflexbelowdot },
-    { "ecircumflexbelowdot", XKB_KEY_ecircumflexbelowdot },
-    { "Ecircumflexgrave", XKB_KEY_Ecircumflexgrave },
-    { "ecircumflexgrave", XKB_KEY_ecircumflexgrave },
-    { "Ecircumflexhook", XKB_KEY_Ecircumflexhook },
-    { "ecircumflexhook", XKB_KEY_ecircumflexhook },
-    { "Ecircumflextilde", XKB_KEY_Ecircumflextilde },
-    { "ecircumflextilde", XKB_KEY_ecircumflextilde },
-    { "EcuSign", XKB_KEY_EcuSign },
-    { "Ediaeresis", XKB_KEY_Ediaeresis },
-    { "ediaeresis", XKB_KEY_ediaeresis },
-    { "Egrave", XKB_KEY_Egrave },
-    { "egrave", XKB_KEY_egrave },
-    { "Ehook", XKB_KEY_Ehook },
-    { "ehook", XKB_KEY_ehook },
-    { "eightsubscript", XKB_KEY_eightsubscript },
-    { "eightsuperior", XKB_KEY_eightsuperior },
-    { "Eisu_Shift", XKB_KEY_Eisu_Shift },
-    { "Eisu_toggle", XKB_KEY_Eisu_toggle },
-    { "elementof", XKB_KEY_elementof },
-    { "ellipsis", XKB_KEY_ellipsis },
-    { "em3space", XKB_KEY_em3space },
-    { "em4space", XKB_KEY_em4space },
-    { "Emacron", XKB_KEY_Emacron },
-    { "emacron", XKB_KEY_emacron },
-    { "emdash", XKB_KEY_emdash },
-    { "emfilledcircle", XKB_KEY_emfilledcircle },
-    { "emfilledrect", XKB_KEY_emfilledrect },
-    { "emopencircle", XKB_KEY_emopencircle },
-    { "emopenrectangle", XKB_KEY_emopenrectangle },
-    { "emptyset", XKB_KEY_emptyset },
-    { "emspace", XKB_KEY_emspace },
-    { "End", XKB_KEY_End },
-    { "endash", XKB_KEY_endash },
-    { "enfilledcircbullet", XKB_KEY_enfilledcircbullet },
-    { "enfilledsqbullet", XKB_KEY_enfilledsqbullet },
-    { "ENG", XKB_KEY_ENG },
-    { "eng", XKB_KEY_eng },
-    { "enopencircbullet", XKB_KEY_enopencircbullet },
-    { "enopensquarebullet", XKB_KEY_enopensquarebullet },
-    { "enspace", XKB_KEY_enspace },
-    { "Eogonek", XKB_KEY_Eogonek },
-    { "eogonek", XKB_KEY_eogonek },
-    { "equal", XKB_KEY_equal },
-    { "Escape", XKB_KEY_Escape },
-    { "ETH", XKB_KEY_ETH },
-    { "Eth", XKB_KEY_Eth },
-    { "eth", XKB_KEY_eth },
-    { "Etilde", XKB_KEY_Etilde },
-    { "etilde", XKB_KEY_etilde },
-    { "EuroSign", XKB_KEY_EuroSign },
-    { "exclam", XKB_KEY_exclam },
-    { "exclamdown", XKB_KEY_exclamdown },
-    { "Execute", XKB_KEY_Execute },
-    { "Ext16bit_L", XKB_KEY_Ext16bit_L },
-    { "Ext16bit_R", XKB_KEY_Ext16bit_R },
-    { "EZH", XKB_KEY_EZH },
-    { "ezh", XKB_KEY_ezh },
-    { "F", XKB_KEY_F },
-    { "f", XKB_KEY_f },
-    { "F1", XKB_KEY_F1 },
-    { "F10", XKB_KEY_F10 },
-    { "F11", XKB_KEY_F11 },
-    { "F12", XKB_KEY_F12 },
-    { "F13", XKB_KEY_F13 },
-    { "F14", XKB_KEY_F14 },
-    { "F15", XKB_KEY_F15 },
-    { "F16", XKB_KEY_F16 },
-    { "F17", XKB_KEY_F17 },
-    { "F18", XKB_KEY_F18 },
-    { "F19", XKB_KEY_F19 },
-    { "F2", XKB_KEY_F2 },
-    { "F20", XKB_KEY_F20 },
-    { "F21", XKB_KEY_F21 },
-    { "F22", XKB_KEY_F22 },
-    { "F23", XKB_KEY_F23 },
-    { "F24", XKB_KEY_F24 },
-    { "F25", XKB_KEY_F25 },
-    { "F26", XKB_KEY_F26 },
-    { "F27", XKB_KEY_F27 },
-    { "F28", XKB_KEY_F28 },
-    { "F29", XKB_KEY_F29 },
-    { "F3", XKB_KEY_F3 },
-    { "F30", XKB_KEY_F30 },
-    { "F31", XKB_KEY_F31 },
-    { "F32", XKB_KEY_F32 },
-    { "F33", XKB_KEY_F33 },
-    { "F34", XKB_KEY_F34 },
-    { "F35", XKB_KEY_F35 },
-    { "F4", XKB_KEY_F4 },
-    { "F5", XKB_KEY_F5 },
-    { "F6", XKB_KEY_F6 },
-    { "F7", XKB_KEY_F7 },
-    { "F8", XKB_KEY_F8 },
-    { "F9", XKB_KEY_F9 },
-    { "Fabovedot", XKB_KEY_Fabovedot },
-    { "fabovedot", XKB_KEY_fabovedot },
-    { "Farsi_0", XKB_KEY_Farsi_0 },
-    { "Farsi_1", XKB_KEY_Farsi_1 },
-    { "Farsi_2", XKB_KEY_Farsi_2 },
-    { "Farsi_3", XKB_KEY_Farsi_3 },
-    { "Farsi_4", XKB_KEY_Farsi_4 },
-    { "Farsi_5", XKB_KEY_Farsi_5 },
-    { "Farsi_6", XKB_KEY_Farsi_6 },
-    { "Farsi_7", XKB_KEY_Farsi_7 },
-    { "Farsi_8", XKB_KEY_Farsi_8 },
-    { "Farsi_9", XKB_KEY_Farsi_9 },
-    { "Farsi_yeh", XKB_KEY_Farsi_yeh },
-    { "femalesymbol", XKB_KEY_femalesymbol },
-    { "ff", XKB_KEY_ff },
-    { "FFrancSign", XKB_KEY_FFrancSign },
-    { "figdash", XKB_KEY_figdash },
-    { "filledlefttribullet", XKB_KEY_filledlefttribullet },
-    { "filledrectbullet", XKB_KEY_filledrectbullet },
-    { "filledrighttribullet", XKB_KEY_filledrighttribullet },
-    { "filledtribulletdown", XKB_KEY_filledtribulletdown },
-    { "filledtribulletup", XKB_KEY_filledtribulletup },
-    { "Find", XKB_KEY_Find },
-    { "First_Virtual_Screen", XKB_KEY_First_Virtual_Screen },
-    { "fiveeighths", XKB_KEY_fiveeighths },
-    { "fivesixths", XKB_KEY_fivesixths },
-    { "fivesubscript", XKB_KEY_fivesubscript },
-    { "fivesuperior", XKB_KEY_fivesuperior },
-    { "fourfifths", XKB_KEY_fourfifths },
-    { "foursubscript", XKB_KEY_foursubscript },
-    { "foursuperior", XKB_KEY_foursuperior },
-    { "fourthroot", XKB_KEY_fourthroot },
-    { "function", XKB_KEY_function },
-    { "G", XKB_KEY_G },
-    { "g", XKB_KEY_g },
-    { "Gabovedot", XKB_KEY_Gabovedot },
-    { "gabovedot", XKB_KEY_gabovedot },
-    { "Gbreve", XKB_KEY_Gbreve },
-    { "gbreve", XKB_KEY_gbreve },
-    { "Gcaron", XKB_KEY_Gcaron },
-    { "gcaron", XKB_KEY_gcaron },
-    { "Gcedilla", XKB_KEY_Gcedilla },
-    { "gcedilla", XKB_KEY_gcedilla },
-    { "Gcircumflex", XKB_KEY_Gcircumflex },
-    { "gcircumflex", XKB_KEY_gcircumflex },
-    { "Georgian_an", XKB_KEY_Georgian_an },
-    { "Georgian_ban", XKB_KEY_Georgian_ban },
-    { "Georgian_can", XKB_KEY_Georgian_can },
-    { "Georgian_char", XKB_KEY_Georgian_char },
-    { "Georgian_chin", XKB_KEY_Georgian_chin },
-    { "Georgian_cil", XKB_KEY_Georgian_cil },
-    { "Georgian_don", XKB_KEY_Georgian_don },
-    { "Georgian_en", XKB_KEY_Georgian_en },
-    { "Georgian_fi", XKB_KEY_Georgian_fi },
-    { "Georgian_gan", XKB_KEY_Georgian_gan },
-    { "Georgian_ghan", XKB_KEY_Georgian_ghan },
-    { "Georgian_hae", XKB_KEY_Georgian_hae },
-    { "Georgian_har", XKB_KEY_Georgian_har },
-    { "Georgian_he", XKB_KEY_Georgian_he },
-    { "Georgian_hie", XKB_KEY_Georgian_hie },
-    { "Georgian_hoe", XKB_KEY_Georgian_hoe },
-    { "Georgian_in", XKB_KEY_Georgian_in },
-    { "Georgian_jhan", XKB_KEY_Georgian_jhan },
-    { "Georgian_jil", XKB_KEY_Georgian_jil },
-    { "Georgian_kan", XKB_KEY_Georgian_kan },
-    { "Georgian_khar", XKB_KEY_Georgian_khar },
-    { "Georgian_las", XKB_KEY_Georgian_las },
-    { "Georgian_man", XKB_KEY_Georgian_man },
-    { "Georgian_nar", XKB_KEY_Georgian_nar },
-    { "Georgian_on", XKB_KEY_Georgian_on },
-    { "Georgian_par", XKB_KEY_Georgian_par },
-    { "Georgian_phar", XKB_KEY_Georgian_phar },
-    { "Georgian_qar", XKB_KEY_Georgian_qar },
-    { "Georgian_rae", XKB_KEY_Georgian_rae },
-    { "Georgian_san", XKB_KEY_Georgian_san },
-    { "Georgian_shin", XKB_KEY_Georgian_shin },
-    { "Georgian_tan", XKB_KEY_Georgian_tan },
-    { "Georgian_tar", XKB_KEY_Georgian_tar },
-    { "Georgian_un", XKB_KEY_Georgian_un },
-    { "Georgian_vin", XKB_KEY_Georgian_vin },
-    { "Georgian_we", XKB_KEY_Georgian_we },
-    { "Georgian_xan", XKB_KEY_Georgian_xan },
-    { "Georgian_zen", XKB_KEY_Georgian_zen },
-    { "Georgian_zhar", XKB_KEY_Georgian_zhar },
-    { "grave", XKB_KEY_grave },
-    { "greater", XKB_KEY_greater },
-    { "greaterthanequal", XKB_KEY_greaterthanequal },
-    { "Greek_accentdieresis", XKB_KEY_Greek_accentdieresis },
-    { "Greek_ALPHA", XKB_KEY_Greek_ALPHA },
-    { "Greek_alpha", XKB_KEY_Greek_alpha },
-    { "Greek_ALPHAaccent", XKB_KEY_Greek_ALPHAaccent },
-    { "Greek_alphaaccent", XKB_KEY_Greek_alphaaccent },
-    { "Greek_BETA", XKB_KEY_Greek_BETA },
-    { "Greek_beta", XKB_KEY_Greek_beta },
-    { "Greek_CHI", XKB_KEY_Greek_CHI },
-    { "Greek_chi", XKB_KEY_Greek_chi },
-    { "Greek_DELTA", XKB_KEY_Greek_DELTA },
-    { "Greek_delta", XKB_KEY_Greek_delta },
-    { "Greek_EPSILON", XKB_KEY_Greek_EPSILON },
-    { "Greek_epsilon", XKB_KEY_Greek_epsilon },
-    { "Greek_EPSILONaccent", XKB_KEY_Greek_EPSILONaccent },
-    { "Greek_epsilonaccent", XKB_KEY_Greek_epsilonaccent },
-    { "Greek_ETA", XKB_KEY_Greek_ETA },
-    { "Greek_eta", XKB_KEY_Greek_eta },
-    { "Greek_ETAaccent", XKB_KEY_Greek_ETAaccent },
-    { "Greek_etaaccent", XKB_KEY_Greek_etaaccent },
-    { "Greek_finalsmallsigma", XKB_KEY_Greek_finalsmallsigma },
-    { "Greek_GAMMA", XKB_KEY_Greek_GAMMA },
-    { "Greek_gamma", XKB_KEY_Greek_gamma },
-    { "Greek_horizbar", XKB_KEY_Greek_horizbar },
-    { "Greek_IOTA", XKB_KEY_Greek_IOTA },
-    { "Greek_iota", XKB_KEY_Greek_iota },
-    { "Greek_IOTAaccent", XKB_KEY_Greek_IOTAaccent },
-    { "Greek_iotaaccent", XKB_KEY_Greek_iotaaccent },
-    { "Greek_iotaaccentdieresis", XKB_KEY_Greek_iotaaccentdieresis },
-    { "Greek_IOTAdiaeresis", XKB_KEY_Greek_IOTAdiaeresis },
-    { "Greek_IOTAdieresis", XKB_KEY_Greek_IOTAdieresis },
-    { "Greek_iotadieresis", XKB_KEY_Greek_iotadieresis },
-    { "Greek_KAPPA", XKB_KEY_Greek_KAPPA },
-    { "Greek_kappa", XKB_KEY_Greek_kappa },
-    { "Greek_LAMBDA", XKB_KEY_Greek_LAMBDA },
-    { "Greek_lambda", XKB_KEY_Greek_lambda },
-    { "Greek_LAMDA", XKB_KEY_Greek_LAMDA },
-    { "Greek_lamda", XKB_KEY_Greek_lamda },
-    { "Greek_MU", XKB_KEY_Greek_MU },
-    { "Greek_mu", XKB_KEY_Greek_mu },
-    { "Greek_NU", XKB_KEY_Greek_NU },
-    { "Greek_nu", XKB_KEY_Greek_nu },
-    { "Greek_OMEGA", XKB_KEY_Greek_OMEGA },
-    { "Greek_omega", XKB_KEY_Greek_omega },
-    { "Greek_OMEGAaccent", XKB_KEY_Greek_OMEGAaccent },
-    { "Greek_omegaaccent", XKB_KEY_Greek_omegaaccent },
-    { "Greek_OMICRON", XKB_KEY_Greek_OMICRON },
-    { "Greek_omicron", XKB_KEY_Greek_omicron },
-    { "Greek_OMICRONaccent", XKB_KEY_Greek_OMICRONaccent },
-    { "Greek_omicronaccent", XKB_KEY_Greek_omicronaccent },
-    { "Greek_PHI", XKB_KEY_Greek_PHI },
-    { "Greek_phi", XKB_KEY_Greek_phi },
-    { "Greek_PI", XKB_KEY_Greek_PI },
-    { "Greek_pi", XKB_KEY_Greek_pi },
-    { "Greek_PSI", XKB_KEY_Greek_PSI },
-    { "Greek_psi", XKB_KEY_Greek_psi },
-    { "Greek_RHO", XKB_KEY_Greek_RHO },
-    { "Greek_rho", XKB_KEY_Greek_rho },
-    { "Greek_SIGMA", XKB_KEY_Greek_SIGMA },
-    { "Greek_sigma", XKB_KEY_Greek_sigma },
-    { "Greek_switch", XKB_KEY_Greek_switch },
-    { "Greek_TAU", XKB_KEY_Greek_TAU },
-    { "Greek_tau", XKB_KEY_Greek_tau },
-    { "Greek_THETA", XKB_KEY_Greek_THETA },
-    { "Greek_theta", XKB_KEY_Greek_theta },
-    { "Greek_UPSILON", XKB_KEY_Greek_UPSILON },
-    { "Greek_upsilon", XKB_KEY_Greek_upsilon },
-    { "Greek_UPSILONaccent", XKB_KEY_Greek_UPSILONaccent },
-    { "Greek_upsilonaccent", XKB_KEY_Greek_upsilonaccent },
-    { "Greek_upsilonaccentdieresis", XKB_KEY_Greek_upsilonaccentdieresis },
-    { "Greek_UPSILONdieresis", XKB_KEY_Greek_UPSILONdieresis },
-    { "Greek_upsilondieresis", XKB_KEY_Greek_upsilondieresis },
-    { "Greek_XI", XKB_KEY_Greek_XI },
-    { "Greek_xi", XKB_KEY_Greek_xi },
-    { "Greek_ZETA", XKB_KEY_Greek_ZETA },
-    { "Greek_zeta", XKB_KEY_Greek_zeta },
-    { "guilder", XKB_KEY_guilder },
-    { "guillemotleft", XKB_KEY_guillemotleft },
-    { "guillemotright", XKB_KEY_guillemotright },
-    { "H", XKB_KEY_H },
-    { "h", XKB_KEY_h },
-    { "hairspace", XKB_KEY_hairspace },
-    { "Hangul", XKB_KEY_Hangul },
-    { "Hangul_A", XKB_KEY_Hangul_A },
-    { "Hangul_AE", XKB_KEY_Hangul_AE },
-    { "Hangul_AraeA", XKB_KEY_Hangul_AraeA },
-    { "Hangul_AraeAE", XKB_KEY_Hangul_AraeAE },
-    { "Hangul_Banja", XKB_KEY_Hangul_Banja },
-    { "Hangul_Cieuc", XKB_KEY_Hangul_Cieuc },
-    { "Hangul_Codeinput", XKB_KEY_Hangul_Codeinput },
-    { "Hangul_Dikeud", XKB_KEY_Hangul_Dikeud },
-    { "Hangul_E", XKB_KEY_Hangul_E },
-    { "Hangul_End", XKB_KEY_Hangul_End },
-    { "Hangul_EO", XKB_KEY_Hangul_EO },
-    { "Hangul_EU", XKB_KEY_Hangul_EU },
-    { "Hangul_Hanja", XKB_KEY_Hangul_Hanja },
-    { "Hangul_Hieuh", XKB_KEY_Hangul_Hieuh },
-    { "Hangul_I", XKB_KEY_Hangul_I },
-    { "Hangul_Ieung", XKB_KEY_Hangul_Ieung },
-    { "Hangul_J_Cieuc", XKB_KEY_Hangul_J_Cieuc },
-    { "Hangul_J_Dikeud", XKB_KEY_Hangul_J_Dikeud },
-    { "Hangul_J_Hieuh", XKB_KEY_Hangul_J_Hieuh },
-    { "Hangul_J_Ieung", XKB_KEY_Hangul_J_Ieung },
-    { "Hangul_J_Jieuj", XKB_KEY_Hangul_J_Jieuj },
-    { "Hangul_J_Khieuq", XKB_KEY_Hangul_J_Khieuq },
-    { "Hangul_J_Kiyeog", XKB_KEY_Hangul_J_Kiyeog },
-    { "Hangul_J_KiyeogSios", XKB_KEY_Hangul_J_KiyeogSios },
-    { "Hangul_J_KkogjiDalrinIeung", XKB_KEY_Hangul_J_KkogjiDalrinIeung },
-    { "Hangul_J_Mieum", XKB_KEY_Hangul_J_Mieum },
-    { "Hangul_J_Nieun", XKB_KEY_Hangul_J_Nieun },
-    { "Hangul_J_NieunHieuh", XKB_KEY_Hangul_J_NieunHieuh },
-    { "Hangul_J_NieunJieuj", XKB_KEY_Hangul_J_NieunJieuj },
-    { "Hangul_J_PanSios", XKB_KEY_Hangul_J_PanSios },
-    { "Hangul_J_Phieuf", XKB_KEY_Hangul_J_Phieuf },
-    { "Hangul_J_Pieub", XKB_KEY_Hangul_J_Pieub },
-    { "Hangul_J_PieubSios", XKB_KEY_Hangul_J_PieubSios },
-    { "Hangul_J_Rieul", XKB_KEY_Hangul_J_Rieul },
-    { "Hangul_J_RieulHieuh", XKB_KEY_Hangul_J_RieulHieuh },
-    { "Hangul_J_RieulKiyeog", XKB_KEY_Hangul_J_RieulKiyeog },
-    { "Hangul_J_RieulMieum", XKB_KEY_Hangul_J_RieulMieum },
-    { "Hangul_J_RieulPhieuf", XKB_KEY_Hangul_J_RieulPhieuf },
-    { "Hangul_J_RieulPieub", XKB_KEY_Hangul_J_RieulPieub },
-    { "Hangul_J_RieulSios", XKB_KEY_Hangul_J_RieulSios },
-    { "Hangul_J_RieulTieut", XKB_KEY_Hangul_J_RieulTieut },
-    { "Hangul_J_Sios", XKB_KEY_Hangul_J_Sios },
-    { "Hangul_J_SsangKiyeog", XKB_KEY_Hangul_J_SsangKiyeog },
-    { "Hangul_J_SsangSios", XKB_KEY_Hangul_J_SsangSios },
-    { "Hangul_J_Tieut", XKB_KEY_Hangul_J_Tieut },
-    { "Hangul_J_YeorinHieuh", XKB_KEY_Hangul_J_YeorinHieuh },
-    { "Hangul_Jamo", XKB_KEY_Hangul_Jamo },
-    { "Hangul_Jeonja", XKB_KEY_Hangul_Jeonja },
-    { "Hangul_Jieuj", XKB_KEY_Hangul_Jieuj },
-    { "Hangul_Khieuq", XKB_KEY_Hangul_Khieuq },
-    { "Hangul_Kiyeog", XKB_KEY_Hangul_Kiyeog },
-    { "Hangul_KiyeogSios", XKB_KEY_Hangul_KiyeogSios },
-    { "Hangul_KkogjiDalrinIeung", XKB_KEY_Hangul_KkogjiDalrinIeung },
-    { "Hangul_Mieum", XKB_KEY_Hangul_Mieum },
-    { "Hangul_MultipleCandidate", XKB_KEY_Hangul_MultipleCandidate },
-    { "Hangul_Nieun", XKB_KEY_Hangul_Nieun },
-    { "Hangul_NieunHieuh", XKB_KEY_Hangul_NieunHieuh },
-    { "Hangul_NieunJieuj", XKB_KEY_Hangul_NieunJieuj },
-    { "Hangul_O", XKB_KEY_Hangul_O },
-    { "Hangul_OE", XKB_KEY_Hangul_OE },
-    { "Hangul_PanSios", XKB_KEY_Hangul_PanSios },
-    { "Hangul_Phieuf", XKB_KEY_Hangul_Phieuf },
-    { "Hangul_Pieub", XKB_KEY_Hangul_Pieub },
-    { "Hangul_PieubSios", XKB_KEY_Hangul_PieubSios },
-    { "Hangul_PostHanja", XKB_KEY_Hangul_PostHanja },
-    { "Hangul_PreHanja", XKB_KEY_Hangul_PreHanja },
-    { "Hangul_PreviousCandidate", XKB_KEY_Hangul_PreviousCandidate },
-    { "Hangul_Rieul", XKB_KEY_Hangul_Rieul },
-    { "Hangul_RieulHieuh", XKB_KEY_Hangul_RieulHieuh },
-    { "Hangul_RieulKiyeog", XKB_KEY_Hangul_RieulKiyeog },
-    { "Hangul_RieulMieum", XKB_KEY_Hangul_RieulMieum },
-    { "Hangul_RieulPhieuf", XKB_KEY_Hangul_RieulPhieuf },
-    { "Hangul_RieulPieub", XKB_KEY_Hangul_RieulPieub },
-    { "Hangul_RieulSios", XKB_KEY_Hangul_RieulSios },
-    { "Hangul_RieulTieut", XKB_KEY_Hangul_RieulTieut },
-    { "Hangul_RieulYeorinHieuh", XKB_KEY_Hangul_RieulYeorinHieuh },
-    { "Hangul_Romaja", XKB_KEY_Hangul_Romaja },
-    { "Hangul_SingleCandidate", XKB_KEY_Hangul_SingleCandidate },
-    { "Hangul_Sios", XKB_KEY_Hangul_Sios },
-    { "Hangul_Special", XKB_KEY_Hangul_Special },
-    { "Hangul_SsangDikeud", XKB_KEY_Hangul_SsangDikeud },
-    { "Hangul_SsangJieuj", XKB_KEY_Hangul_SsangJieuj },
-    { "Hangul_SsangKiyeog", XKB_KEY_Hangul_SsangKiyeog },
-    { "Hangul_SsangPieub", XKB_KEY_Hangul_SsangPieub },
-    { "Hangul_SsangSios", XKB_KEY_Hangul_SsangSios },
-    { "Hangul_Start", XKB_KEY_Hangul_Start },
-    { "Hangul_SunkyeongeumMieum", XKB_KEY_Hangul_SunkyeongeumMieum },
-    { "Hangul_SunkyeongeumPhieuf", XKB_KEY_Hangul_SunkyeongeumPhieuf },
-    { "Hangul_SunkyeongeumPieub", XKB_KEY_Hangul_SunkyeongeumPieub },
-    { "Hangul_switch", XKB_KEY_Hangul_switch },
-    { "Hangul_Tieut", XKB_KEY_Hangul_Tieut },
-    { "Hangul_U", XKB_KEY_Hangul_U },
-    { "Hangul_WA", XKB_KEY_Hangul_WA },
-    { "Hangul_WAE", XKB_KEY_Hangul_WAE },
-    { "Hangul_WE", XKB_KEY_Hangul_WE },
-    { "Hangul_WEO", XKB_KEY_Hangul_WEO },
-    { "Hangul_WI", XKB_KEY_Hangul_WI },
-    { "Hangul_YA", XKB_KEY_Hangul_YA },
-    { "Hangul_YAE", XKB_KEY_Hangul_YAE },
-    { "Hangul_YE", XKB_KEY_Hangul_YE },
-    { "Hangul_YEO", XKB_KEY_Hangul_YEO },
-    { "Hangul_YeorinHieuh", XKB_KEY_Hangul_YeorinHieuh },
-    { "Hangul_YI", XKB_KEY_Hangul_YI },
-    { "Hangul_YO", XKB_KEY_Hangul_YO },
-    { "Hangul_YU", XKB_KEY_Hangul_YU },
-    { "Hankaku", XKB_KEY_Hankaku },
-    { "Hcircumflex", XKB_KEY_Hcircumflex },
-    { "hcircumflex", XKB_KEY_hcircumflex },
-    { "heart", XKB_KEY_heart },
-    { "hebrew_aleph", XKB_KEY_hebrew_aleph },
-    { "hebrew_ayin", XKB_KEY_hebrew_ayin },
-    { "hebrew_bet", XKB_KEY_hebrew_bet },
-    { "hebrew_beth", XKB_KEY_hebrew_beth },
-    { "hebrew_chet", XKB_KEY_hebrew_chet },
-    { "hebrew_dalet", XKB_KEY_hebrew_dalet },
-    { "hebrew_daleth", XKB_KEY_hebrew_daleth },
-    { "hebrew_doublelowline", XKB_KEY_hebrew_doublelowline },
-    { "hebrew_finalkaph", XKB_KEY_hebrew_finalkaph },
-    { "hebrew_finalmem", XKB_KEY_hebrew_finalmem },
-    { "hebrew_finalnun", XKB_KEY_hebrew_finalnun },
-    { "hebrew_finalpe", XKB_KEY_hebrew_finalpe },
-    { "hebrew_finalzade", XKB_KEY_hebrew_finalzade },
-    { "hebrew_finalzadi", XKB_KEY_hebrew_finalzadi },
-    { "hebrew_gimel", XKB_KEY_hebrew_gimel },
-    { "hebrew_gimmel", XKB_KEY_hebrew_gimmel },
-    { "hebrew_he", XKB_KEY_hebrew_he },
-    { "hebrew_het", XKB_KEY_hebrew_het },
-    { "hebrew_kaph", XKB_KEY_hebrew_kaph },
-    { "hebrew_kuf", XKB_KEY_hebrew_kuf },
-    { "hebrew_lamed", XKB_KEY_hebrew_lamed },
-    { "hebrew_mem", XKB_KEY_hebrew_mem },
-    { "hebrew_nun", XKB_KEY_hebrew_nun },
-    { "hebrew_pe", XKB_KEY_hebrew_pe },
-    { "hebrew_qoph", XKB_KEY_hebrew_qoph },
-    { "hebrew_resh", XKB_KEY_hebrew_resh },
-    { "hebrew_samech", XKB_KEY_hebrew_samech },
-    { "hebrew_samekh", XKB_KEY_hebrew_samekh },
-    { "hebrew_shin", XKB_KEY_hebrew_shin },
-    { "Hebrew_switch", XKB_KEY_Hebrew_switch },
-    { "hebrew_taf", XKB_KEY_hebrew_taf },
-    { "hebrew_taw", XKB_KEY_hebrew_taw },
-    { "hebrew_tet", XKB_KEY_hebrew_tet },
-    { "hebrew_teth", XKB_KEY_hebrew_teth },
-    { "hebrew_waw", XKB_KEY_hebrew_waw },
-    { "hebrew_yod", XKB_KEY_hebrew_yod },
-    { "hebrew_zade", XKB_KEY_hebrew_zade },
-    { "hebrew_zadi", XKB_KEY_hebrew_zadi },
-    { "hebrew_zain", XKB_KEY_hebrew_zain },
-    { "hebrew_zayin", XKB_KEY_hebrew_zayin },
-    { "Help", XKB_KEY_Help },
-    { "Henkan", XKB_KEY_Henkan },
-    { "Henkan_Mode", XKB_KEY_Henkan_Mode },
-    { "hexagram", XKB_KEY_hexagram },
-    { "Hiragana", XKB_KEY_Hiragana },
-    { "Hiragana_Katakana", XKB_KEY_Hiragana_Katakana },
-    { "Home", XKB_KEY_Home },
-    { "horizconnector", XKB_KEY_horizconnector },
-    { "horizlinescan1", XKB_KEY_horizlinescan1 },
-    { "horizlinescan3", XKB_KEY_horizlinescan3 },
-    { "horizlinescan5", XKB_KEY_horizlinescan5 },
-    { "horizlinescan7", XKB_KEY_horizlinescan7 },
-    { "horizlinescan9", XKB_KEY_horizlinescan9 },
-    { "hpBackTab", XKB_KEY_hpBackTab },
-    { "hpblock", XKB_KEY_hpblock },
-    { "hpClearLine", XKB_KEY_hpClearLine },
-    { "hpDeleteChar", XKB_KEY_hpDeleteChar },
-    { "hpDeleteLine", XKB_KEY_hpDeleteLine },
-    { "hpguilder", XKB_KEY_hpguilder },
-    { "hpInsertChar", XKB_KEY_hpInsertChar },
-    { "hpInsertLine", XKB_KEY_hpInsertLine },
-    { "hpIO", XKB_KEY_hpIO },
-    { "hpKP_BackTab", XKB_KEY_hpKP_BackTab },
-    { "hplira", XKB_KEY_hplira },
-    { "hplongminus", XKB_KEY_hplongminus },
-    { "hpModelock1", XKB_KEY_hpModelock1 },
-    { "hpModelock2", XKB_KEY_hpModelock2 },
-    { "hpmute_acute", XKB_KEY_hpmute_acute },
-    { "hpmute_asciicircum", XKB_KEY_hpmute_asciicircum },
-    { "hpmute_asciitilde", XKB_KEY_hpmute_asciitilde },
-    { "hpmute_diaeresis", XKB_KEY_hpmute_diaeresis },
-    { "hpmute_grave", XKB_KEY_hpmute_grave },
-    { "hpReset", XKB_KEY_hpReset },
-    { "hpSystem", XKB_KEY_hpSystem },
-    { "hpUser", XKB_KEY_hpUser },
-    { "hpYdiaeresis", XKB_KEY_hpYdiaeresis },
-    { "Hstroke", XKB_KEY_Hstroke },
-    { "hstroke", XKB_KEY_hstroke },
-    { "ht", XKB_KEY_ht },
-    { "Hyper_L", XKB_KEY_Hyper_L },
-    { "Hyper_R", XKB_KEY_Hyper_R },
-    { "hyphen", XKB_KEY_hyphen },
-    { "I", XKB_KEY_I },
-    { "i", XKB_KEY_i },
-    { "Iabovedot", XKB_KEY_Iabovedot },
-    { "Iacute", XKB_KEY_Iacute },
-    { "iacute", XKB_KEY_iacute },
-    { "Ibelowdot", XKB_KEY_Ibelowdot },
-    { "ibelowdot", XKB_KEY_ibelowdot },
-    { "Ibreve", XKB_KEY_Ibreve },
-    { "ibreve", XKB_KEY_ibreve },
-    { "Icircumflex", XKB_KEY_Icircumflex },
-    { "icircumflex", XKB_KEY_icircumflex },
-    { "identical", XKB_KEY_identical },
-    { "Idiaeresis", XKB_KEY_Idiaeresis },
-    { "idiaeresis", XKB_KEY_idiaeresis },
-    { "idotless", XKB_KEY_idotless },
-    { "ifonlyif", XKB_KEY_ifonlyif },
-    { "Igrave", XKB_KEY_Igrave },
-    { "igrave", XKB_KEY_igrave },
-    { "Ihook", XKB_KEY_Ihook },
-    { "ihook", XKB_KEY_ihook },
-    { "Imacron", XKB_KEY_Imacron },
-    { "imacron", XKB_KEY_imacron },
-    { "implies", XKB_KEY_implies },
-    { "includedin", XKB_KEY_includedin },
-    { "includes", XKB_KEY_includes },
-    { "infinity", XKB_KEY_infinity },
-    { "Insert", XKB_KEY_Insert },
-    { "InsertChar", XKB_KEY_InsertChar },
-    { "InsertLine", XKB_KEY_InsertLine },
-    { "integral", XKB_KEY_integral },
-    { "intersection", XKB_KEY_intersection },
-    { "IO", XKB_KEY_IO },
-    { "Iogonek", XKB_KEY_Iogonek },
-    { "iogonek", XKB_KEY_iogonek },
-    { "ISO_Center_Object", XKB_KEY_ISO_Center_Object },
-    { "ISO_Continuous_Underline", XKB_KEY_ISO_Continuous_Underline },
-    { "ISO_Discontinuous_Underline", XKB_KEY_ISO_Discontinuous_Underline },
-    { "ISO_Emphasize", XKB_KEY_ISO_Emphasize },
-    { "ISO_Enter", XKB_KEY_ISO_Enter },
-    { "ISO_Fast_Cursor_Down", XKB_KEY_ISO_Fast_Cursor_Down },
-    { "ISO_Fast_Cursor_Left", XKB_KEY_ISO_Fast_Cursor_Left },
-    { "ISO_Fast_Cursor_Right", XKB_KEY_ISO_Fast_Cursor_Right },
-    { "ISO_Fast_Cursor_Up", XKB_KEY_ISO_Fast_Cursor_Up },
-    { "ISO_First_Group", XKB_KEY_ISO_First_Group },
-    { "ISO_First_Group_Lock", XKB_KEY_ISO_First_Group_Lock },
-    { "ISO_Group_Latch", XKB_KEY_ISO_Group_Latch },
-    { "ISO_Group_Lock", XKB_KEY_ISO_Group_Lock },
-    { "ISO_Group_Shift", XKB_KEY_ISO_Group_Shift },
-    { "ISO_Last_Group", XKB_KEY_ISO_Last_Group },
-    { "ISO_Last_Group_Lock", XKB_KEY_ISO_Last_Group_Lock },
-    { "ISO_Left_Tab", XKB_KEY_ISO_Left_Tab },
-    { "ISO_Level2_Latch", XKB_KEY_ISO_Level2_Latch },
-    { "ISO_Level3_Latch", XKB_KEY_ISO_Level3_Latch },
-    { "ISO_Level3_Lock", XKB_KEY_ISO_Level3_Lock },
-    { "ISO_Level3_Shift", XKB_KEY_ISO_Level3_Shift },
-    { "ISO_Level5_Latch", XKB_KEY_ISO_Level5_Latch },
-    { "ISO_Level5_Lock", XKB_KEY_ISO_Level5_Lock },
-    { "ISO_Level5_Shift", XKB_KEY_ISO_Level5_Shift },
-    { "ISO_Lock", XKB_KEY_ISO_Lock },
-    { "ISO_Move_Line_Down", XKB_KEY_ISO_Move_Line_Down },
-    { "ISO_Move_Line_Up", XKB_KEY_ISO_Move_Line_Up },
-    { "ISO_Next_Group", XKB_KEY_ISO_Next_Group },
-    { "ISO_Next_Group_Lock", XKB_KEY_ISO_Next_Group_Lock },
-    { "ISO_Partial_Line_Down", XKB_KEY_ISO_Partial_Line_Down },
-    { "ISO_Partial_Line_Up", XKB_KEY_ISO_Partial_Line_Up },
-    { "ISO_Partial_Space_Left", XKB_KEY_ISO_Partial_Space_Left },
-    { "ISO_Partial_Space_Right", XKB_KEY_ISO_Partial_Space_Right },
-    { "ISO_Prev_Group", XKB_KEY_ISO_Prev_Group },
-    { "ISO_Prev_Group_Lock", XKB_KEY_ISO_Prev_Group_Lock },
-    { "ISO_Release_Both_Margins", XKB_KEY_ISO_Release_Both_Margins },
-    { "ISO_Release_Margin_Left", XKB_KEY_ISO_Release_Margin_Left },
-    { "ISO_Release_Margin_Right", XKB_KEY_ISO_Release_Margin_Right },
-    { "ISO_Set_Margin_Left", XKB_KEY_ISO_Set_Margin_Left },
-    { "ISO_Set_Margin_Right", XKB_KEY_ISO_Set_Margin_Right },
-    { "Itilde", XKB_KEY_Itilde },
-    { "itilde", XKB_KEY_itilde },
-    { "J", XKB_KEY_J },
-    { "j", XKB_KEY_j },
-    { "Jcircumflex", XKB_KEY_Jcircumflex },
-    { "jcircumflex", XKB_KEY_jcircumflex },
-    { "jot", XKB_KEY_jot },
-    { "K", XKB_KEY_K },
-    { "k", XKB_KEY_k },
-    { "kana_a", XKB_KEY_kana_a },
-    { "kana_A", XKB_KEY_kana_A },
-    { "kana_CHI", XKB_KEY_kana_CHI },
-    { "kana_closingbracket", XKB_KEY_kana_closingbracket },
-    { "kana_comma", XKB_KEY_kana_comma },
-    { "kana_conjunctive", XKB_KEY_kana_conjunctive },
-    { "kana_e", XKB_KEY_kana_e },
-    { "kana_E", XKB_KEY_kana_E },
-    { "kana_FU", XKB_KEY_kana_FU },
-    { "kana_fullstop", XKB_KEY_kana_fullstop },
-    { "kana_HA", XKB_KEY_kana_HA },
-    { "kana_HE", XKB_KEY_kana_HE },
-    { "kana_HI", XKB_KEY_kana_HI },
-    { "kana_HO", XKB_KEY_kana_HO },
-    { "kana_HU", XKB_KEY_kana_HU },
-    { "kana_i", XKB_KEY_kana_i },
-    { "kana_I", XKB_KEY_kana_I },
-    { "kana_KA", XKB_KEY_kana_KA },
-    { "kana_KE", XKB_KEY_kana_KE },
-    { "kana_KI", XKB_KEY_kana_KI },
-    { "kana_KO", XKB_KEY_kana_KO },
-    { "kana_KU", XKB_KEY_kana_KU },
-    { "Kana_Lock", XKB_KEY_Kana_Lock },
-    { "kana_MA", XKB_KEY_kana_MA },
-    { "kana_ME", XKB_KEY_kana_ME },
-    { "kana_MI", XKB_KEY_kana_MI },
-    { "kana_middledot", XKB_KEY_kana_middledot },
-    { "kana_MO", XKB_KEY_kana_MO },
-    { "kana_MU", XKB_KEY_kana_MU },
-    { "kana_N", XKB_KEY_kana_N },
-    { "kana_NA", XKB_KEY_kana_NA },
-    { "kana_NE", XKB_KEY_kana_NE },
-    { "kana_NI", XKB_KEY_kana_NI },
-    { "kana_NO", XKB_KEY_kana_NO },
-    { "kana_NU", XKB_KEY_kana_NU },
-    { "kana_o", XKB_KEY_kana_o },
-    { "kana_O", XKB_KEY_kana_O },
-    { "kana_openingbracket", XKB_KEY_kana_openingbracket },
-    { "kana_RA", XKB_KEY_kana_RA },
-    { "kana_RE", XKB_KEY_kana_RE },
-    { "kana_RI", XKB_KEY_kana_RI },
-    { "kana_RO", XKB_KEY_kana_RO },
-    { "kana_RU", XKB_KEY_kana_RU },
-    { "kana_SA", XKB_KEY_kana_SA },
-    { "kana_SE", XKB_KEY_kana_SE },
-    { "kana_SHI", XKB_KEY_kana_SHI },
-    { "Kana_Shift", XKB_KEY_Kana_Shift },
-    { "kana_SO", XKB_KEY_kana_SO },
-    { "kana_SU", XKB_KEY_kana_SU },
-    { "kana_switch", XKB_KEY_kana_switch },
-    { "kana_TA", XKB_KEY_kana_TA },
-    { "kana_TE", XKB_KEY_kana_TE },
-    { "kana_TI", XKB_KEY_kana_TI },
-    { "kana_TO", XKB_KEY_kana_TO },
-    { "kana_tsu", XKB_KEY_kana_tsu },
-    { "kana_TSU", XKB_KEY_kana_TSU },
-    { "kana_tu", XKB_KEY_kana_tu },
-    { "kana_TU", XKB_KEY_kana_TU },
-    { "kana_u", XKB_KEY_kana_u },
-    { "kana_U", XKB_KEY_kana_U },
-    { "kana_WA", XKB_KEY_kana_WA },
-    { "kana_WO", XKB_KEY_kana_WO },
-    { "kana_ya", XKB_KEY_kana_ya },
-    { "kana_YA", XKB_KEY_kana_YA },
-    { "kana_yo", XKB_KEY_kana_yo },
-    { "kana_YO", XKB_KEY_kana_YO },
-    { "kana_yu", XKB_KEY_kana_yu },
-    { "kana_YU", XKB_KEY_kana_YU },
-    { "Kanji", XKB_KEY_Kanji },
-    { "Kanji_Bangou", XKB_KEY_Kanji_Bangou },
-    { "kappa", XKB_KEY_kappa },
-    { "Katakana", XKB_KEY_Katakana },
-    { "Kcedilla", XKB_KEY_Kcedilla },
-    { "kcedilla", XKB_KEY_kcedilla },
-    { "Korean_Won", XKB_KEY_Korean_Won },
-    { "KP_0", XKB_KEY_KP_0 },
-    { "KP_1", XKB_KEY_KP_1 },
-    { "KP_2", XKB_KEY_KP_2 },
-    { "KP_3", XKB_KEY_KP_3 },
-    { "KP_4", XKB_KEY_KP_4 },
-    { "KP_5", XKB_KEY_KP_5 },
-    { "KP_6", XKB_KEY_KP_6 },
-    { "KP_7", XKB_KEY_KP_7 },
-    { "KP_8", XKB_KEY_KP_8 },
-    { "KP_9", XKB_KEY_KP_9 },
-    { "KP_Add", XKB_KEY_KP_Add },
-    { "KP_BackTab", XKB_KEY_KP_BackTab },
-    { "KP_Begin", XKB_KEY_KP_Begin },
-    { "KP_Decimal", XKB_KEY_KP_Decimal },
-    { "KP_Delete", XKB_KEY_KP_Delete },
-    { "KP_Divide", XKB_KEY_KP_Divide },
-    { "KP_Down", XKB_KEY_KP_Down },
-    { "KP_End", XKB_KEY_KP_End },
-    { "KP_Enter", XKB_KEY_KP_Enter },
-    { "KP_Equal", XKB_KEY_KP_Equal },
-    { "KP_F1", XKB_KEY_KP_F1 },
-    { "KP_F2", XKB_KEY_KP_F2 },
-    { "KP_F3", XKB_KEY_KP_F3 },
-    { "KP_F4", XKB_KEY_KP_F4 },
-    { "KP_Home", XKB_KEY_KP_Home },
-    { "KP_Insert", XKB_KEY_KP_Insert },
-    { "KP_Left", XKB_KEY_KP_Left },
-    { "KP_Multiply", XKB_KEY_KP_Multiply },
-    { "KP_Next", XKB_KEY_KP_Next },
-    { "KP_Page_Down", XKB_KEY_KP_Page_Down },
-    { "KP_Page_Up", XKB_KEY_KP_Page_Up },
-    { "KP_Prior", XKB_KEY_KP_Prior },
-    { "KP_Right", XKB_KEY_KP_Right },
-    { "KP_Separator", XKB_KEY_KP_Separator },
-    { "KP_Space", XKB_KEY_KP_Space },
-    { "KP_Subtract", XKB_KEY_KP_Subtract },
-    { "KP_Tab", XKB_KEY_KP_Tab },
-    { "KP_Up", XKB_KEY_KP_Up },
-    { "kra", XKB_KEY_kra },
-    { "L", XKB_KEY_L },
-    { "l", XKB_KEY_l },
-    { "L1", XKB_KEY_L1 },
-    { "L10", XKB_KEY_L10 },
-    { "L2", XKB_KEY_L2 },
-    { "L3", XKB_KEY_L3 },
-    { "L4", XKB_KEY_L4 },
-    { "L5", XKB_KEY_L5 },
-    { "L6", XKB_KEY_L6 },
-    { "L7", XKB_KEY_L7 },
-    { "L8", XKB_KEY_L8 },
-    { "L9", XKB_KEY_L9 },
-    { "Lacute", XKB_KEY_Lacute },
-    { "lacute", XKB_KEY_lacute },
-    { "Last_Virtual_Screen", XKB_KEY_Last_Virtual_Screen },
-    { "latincross", XKB_KEY_latincross },
-    { "Lbelowdot", XKB_KEY_Lbelowdot },
-    { "lbelowdot", XKB_KEY_lbelowdot },
-    { "Lcaron", XKB_KEY_Lcaron },
-    { "lcaron", XKB_KEY_lcaron },
-    { "Lcedilla", XKB_KEY_Lcedilla },
-    { "lcedilla", XKB_KEY_lcedilla },
-    { "Left", XKB_KEY_Left },
-    { "leftanglebracket", XKB_KEY_leftanglebracket },
-    { "leftarrow", XKB_KEY_leftarrow },
-    { "leftcaret", XKB_KEY_leftcaret },
-    { "leftdoublequotemark", XKB_KEY_leftdoublequotemark },
-    { "leftmiddlecurlybrace", XKB_KEY_leftmiddlecurlybrace },
-    { "leftopentriangle", XKB_KEY_leftopentriangle },
-    { "leftpointer", XKB_KEY_leftpointer },
-    { "leftradical", XKB_KEY_leftradical },
-    { "leftshoe", XKB_KEY_leftshoe },
-    { "leftsinglequotemark", XKB_KEY_leftsinglequotemark },
-    { "leftt", XKB_KEY_leftt },
-    { "lefttack", XKB_KEY_lefttack },
-    { "less", XKB_KEY_less },
-    { "lessthanequal", XKB_KEY_lessthanequal },
-    { "lf", XKB_KEY_lf },
-    { "Linefeed", XKB_KEY_Linefeed },
-    { "lira", XKB_KEY_lira },
-    { "LiraSign", XKB_KEY_LiraSign },
-    { "logicaland", XKB_KEY_logicaland },
-    { "logicalor", XKB_KEY_logicalor },
-    { "longminus", XKB_KEY_longminus },
-    { "lowleftcorner", XKB_KEY_lowleftcorner },
-    { "lowrightcorner", XKB_KEY_lowrightcorner },
-    { "Lstroke", XKB_KEY_Lstroke },
-    { "lstroke", XKB_KEY_lstroke },
-    { "M", XKB_KEY_M },
-    { "m", XKB_KEY_m },
-    { "Mabovedot", XKB_KEY_Mabovedot },
-    { "mabovedot", XKB_KEY_mabovedot },
-    { "Macedonia_dse", XKB_KEY_Macedonia_dse },
-    { "Macedonia_DSE", XKB_KEY_Macedonia_DSE },
-    { "Macedonia_gje", XKB_KEY_Macedonia_gje },
-    { "Macedonia_GJE", XKB_KEY_Macedonia_GJE },
-    { "Macedonia_kje", XKB_KEY_Macedonia_kje },
-    { "Macedonia_KJE", XKB_KEY_Macedonia_KJE },
-    { "macron", XKB_KEY_macron },
-    { "Mae_Koho", XKB_KEY_Mae_Koho },
-    { "malesymbol", XKB_KEY_malesymbol },
-    { "maltesecross", XKB_KEY_maltesecross },
-    { "marker", XKB_KEY_marker },
-    { "masculine", XKB_KEY_masculine },
-    { "Massyo", XKB_KEY_Massyo },
-    { "Menu", XKB_KEY_Menu },
-    { "Meta_L", XKB_KEY_Meta_L },
-    { "Meta_R", XKB_KEY_Meta_R },
-    { "MillSign", XKB_KEY_MillSign },
-    { "minus", XKB_KEY_minus },
-    { "minutes", XKB_KEY_minutes },
-    { "Mode_switch", XKB_KEY_Mode_switch },
-    { "MouseKeys_Accel_Enable", XKB_KEY_MouseKeys_Accel_Enable },
-    { "MouseKeys_Enable", XKB_KEY_MouseKeys_Enable },
-    { "mu", XKB_KEY_mu },
-    { "Muhenkan", XKB_KEY_Muhenkan },
-    { "Multi_key", XKB_KEY_Multi_key },
-    { "MultipleCandidate", XKB_KEY_MultipleCandidate },
-    { "multiply", XKB_KEY_multiply },
-    { "musicalflat", XKB_KEY_musicalflat },
-    { "musicalsharp", XKB_KEY_musicalsharp },
-    { "mute_acute", XKB_KEY_mute_acute },
-    { "mute_asciicircum", XKB_KEY_mute_asciicircum },
-    { "mute_asciitilde", XKB_KEY_mute_asciitilde },
-    { "mute_diaeresis", XKB_KEY_mute_diaeresis },
-    { "mute_grave", XKB_KEY_mute_grave },
-    { "N", XKB_KEY_N },
-    { "n", XKB_KEY_n },
-    { "nabla", XKB_KEY_nabla },
-    { "Nacute", XKB_KEY_Nacute },
-    { "nacute", XKB_KEY_nacute },
-    { "NairaSign", XKB_KEY_NairaSign },
-    { "Ncaron", XKB_KEY_Ncaron },
-    { "ncaron", XKB_KEY_ncaron },
-    { "Ncedilla", XKB_KEY_Ncedilla },
-    { "ncedilla", XKB_KEY_ncedilla },
-    { "NewSheqelSign", XKB_KEY_NewSheqelSign },
-    { "Next", XKB_KEY_Next },
-    { "Next_Virtual_Screen", XKB_KEY_Next_Virtual_Screen },
-    { "ninesubscript", XKB_KEY_ninesubscript },
-    { "ninesuperior", XKB_KEY_ninesuperior },
-    { "nl", XKB_KEY_nl },
-    { "nobreakspace", XKB_KEY_nobreakspace },
-    { "NoSymbol", XKB_KEY_NoSymbol },
-    { "notapproxeq", XKB_KEY_notapproxeq },
-    { "notelementof", XKB_KEY_notelementof },
-    { "notequal", XKB_KEY_notequal },
-    { "notidentical", XKB_KEY_notidentical },
-    { "notsign", XKB_KEY_notsign },
-    { "Ntilde", XKB_KEY_Ntilde },
-    { "ntilde", XKB_KEY_ntilde },
-    { "Num_Lock", XKB_KEY_Num_Lock },
-    { "numbersign", XKB_KEY_numbersign },
-    { "numerosign", XKB_KEY_numerosign },
-    { "O", XKB_KEY_O },
-    { "o", XKB_KEY_o },
-    { "Oacute", XKB_KEY_Oacute },
-    { "oacute", XKB_KEY_oacute },
-    { "Obarred", XKB_KEY_Obarred },
-    { "obarred", XKB_KEY_obarred },
-    { "Obelowdot", XKB_KEY_Obelowdot },
-    { "obelowdot", XKB_KEY_obelowdot },
-    { "Ocaron", XKB_KEY_Ocaron },
-    { "ocaron", XKB_KEY_ocaron },
-    { "Ocircumflex", XKB_KEY_Ocircumflex },
-    { "ocircumflex", XKB_KEY_ocircumflex },
-    { "Ocircumflexacute", XKB_KEY_Ocircumflexacute },
-    { "ocircumflexacute", XKB_KEY_ocircumflexacute },
-    { "Ocircumflexbelowdot", XKB_KEY_Ocircumflexbelowdot },
-    { "ocircumflexbelowdot", XKB_KEY_ocircumflexbelowdot },
-    { "Ocircumflexgrave", XKB_KEY_Ocircumflexgrave },
-    { "ocircumflexgrave", XKB_KEY_ocircumflexgrave },
-    { "Ocircumflexhook", XKB_KEY_Ocircumflexhook },
-    { "ocircumflexhook", XKB_KEY_ocircumflexhook },
-    { "Ocircumflextilde", XKB_KEY_Ocircumflextilde },
-    { "ocircumflextilde", XKB_KEY_ocircumflextilde },
-    { "Odiaeresis", XKB_KEY_Odiaeresis },
-    { "odiaeresis", XKB_KEY_odiaeresis },
-    { "Odoubleacute", XKB_KEY_Odoubleacute },
-    { "odoubleacute", XKB_KEY_odoubleacute },
-    { "OE", XKB_KEY_OE },
-    { "oe", XKB_KEY_oe },
-    { "ogonek", XKB_KEY_ogonek },
-    { "Ograve", XKB_KEY_Ograve },
-    { "ograve", XKB_KEY_ograve },
-    { "Ohook", XKB_KEY_Ohook },
-    { "ohook", XKB_KEY_ohook },
-    { "Ohorn", XKB_KEY_Ohorn },
-    { "ohorn", XKB_KEY_ohorn },
-    { "Ohornacute", XKB_KEY_Ohornacute },
-    { "ohornacute", XKB_KEY_ohornacute },
-    { "Ohornbelowdot", XKB_KEY_Ohornbelowdot },
-    { "ohornbelowdot", XKB_KEY_ohornbelowdot },
-    { "Ohorngrave", XKB_KEY_Ohorngrave },
-    { "ohorngrave", XKB_KEY_ohorngrave },
-    { "Ohornhook", XKB_KEY_Ohornhook },
-    { "ohornhook", XKB_KEY_ohornhook },
-    { "Ohorntilde", XKB_KEY_Ohorntilde },
-    { "ohorntilde", XKB_KEY_ohorntilde },
-    { "Omacron", XKB_KEY_Omacron },
-    { "omacron", XKB_KEY_omacron },
-    { "oneeighth", XKB_KEY_oneeighth },
-    { "onefifth", XKB_KEY_onefifth },
-    { "onehalf", XKB_KEY_onehalf },
-    { "onequarter", XKB_KEY_onequarter },
-    { "onesixth", XKB_KEY_onesixth },
-    { "onesubscript", XKB_KEY_onesubscript },
-    { "onesuperior", XKB_KEY_onesuperior },
-    { "onethird", XKB_KEY_onethird },
-    { "Ooblique", XKB_KEY_Ooblique },
-    { "ooblique", XKB_KEY_ooblique },
-    { "openrectbullet", XKB_KEY_openrectbullet },
-    { "openstar", XKB_KEY_openstar },
-    { "opentribulletdown", XKB_KEY_opentribulletdown },
-    { "opentribulletup", XKB_KEY_opentribulletup },
-    { "ordfeminine", XKB_KEY_ordfeminine },
-    { "osfActivate", XKB_KEY_osfActivate },
-    { "osfAddMode", XKB_KEY_osfAddMode },
-    { "osfBackSpace", XKB_KEY_osfBackSpace },
-    { "osfBackTab", XKB_KEY_osfBackTab },
-    { "osfBeginData", XKB_KEY_osfBeginData },
-    { "osfBeginLine", XKB_KEY_osfBeginLine },
-    { "osfCancel", XKB_KEY_osfCancel },
-    { "osfClear", XKB_KEY_osfClear },
-    { "osfCopy", XKB_KEY_osfCopy },
-    { "osfCut", XKB_KEY_osfCut },
-    { "osfDelete", XKB_KEY_osfDelete },
-    { "osfDeselectAll", XKB_KEY_osfDeselectAll },
-    { "osfDown", XKB_KEY_osfDown },
-    { "osfEndData", XKB_KEY_osfEndData },
-    { "osfEndLine", XKB_KEY_osfEndLine },
-    { "osfEscape", XKB_KEY_osfEscape },
-    { "osfExtend", XKB_KEY_osfExtend },
-    { "osfHelp", XKB_KEY_osfHelp },
-    { "osfInsert", XKB_KEY_osfInsert },
-    { "osfLeft", XKB_KEY_osfLeft },
-    { "osfMenu", XKB_KEY_osfMenu },
-    { "osfMenuBar", XKB_KEY_osfMenuBar },
-    { "osfNextField", XKB_KEY_osfNextField },
-    { "osfNextMenu", XKB_KEY_osfNextMenu },
-    { "osfPageDown", XKB_KEY_osfPageDown },
-    { "osfPageLeft", XKB_KEY_osfPageLeft },
-    { "osfPageRight", XKB_KEY_osfPageRight },
-    { "osfPageUp", XKB_KEY_osfPageUp },
-    { "osfPaste", XKB_KEY_osfPaste },
-    { "osfPrevField", XKB_KEY_osfPrevField },
-    { "osfPrevMenu", XKB_KEY_osfPrevMenu },
-    { "osfPrimaryPaste", XKB_KEY_osfPrimaryPaste },
-    { "osfQuickPaste", XKB_KEY_osfQuickPaste },
-    { "osfReselect", XKB_KEY_osfReselect },
-    { "osfRestore", XKB_KEY_osfRestore },
-    { "osfRight", XKB_KEY_osfRight },
-    { "osfSelect", XKB_KEY_osfSelect },
-    { "osfSelectAll", XKB_KEY_osfSelectAll },
-    { "osfUndo", XKB_KEY_osfUndo },
-    { "osfUp", XKB_KEY_osfUp },
-    { "Oslash", XKB_KEY_Oslash },
-    { "oslash", XKB_KEY_oslash },
-    { "Otilde", XKB_KEY_Otilde },
-    { "otilde", XKB_KEY_otilde },
-    { "overbar", XKB_KEY_overbar },
-    { "Overlay1_Enable", XKB_KEY_Overlay1_Enable },
-    { "Overlay2_Enable", XKB_KEY_Overlay2_Enable },
-    { "overline", XKB_KEY_overline },
-    { "P", XKB_KEY_P },
-    { "p", XKB_KEY_p },
-    { "Pabovedot", XKB_KEY_Pabovedot },
-    { "pabovedot", XKB_KEY_pabovedot },
-    { "Page_Down", XKB_KEY_Page_Down },
-    { "Page_Up", XKB_KEY_Page_Up },
-    { "paragraph", XKB_KEY_paragraph },
-    { "parenleft", XKB_KEY_parenleft },
-    { "parenright", XKB_KEY_parenright },
-    { "partdifferential", XKB_KEY_partdifferential },
-    { "partialderivative", XKB_KEY_partialderivative },
-    { "Pause", XKB_KEY_Pause },
-    { "percent", XKB_KEY_percent },
-    { "period", XKB_KEY_period },
-    { "periodcentered", XKB_KEY_periodcentered },
-    { "permille", XKB_KEY_permille },
-    { "PesetaSign", XKB_KEY_PesetaSign },
-    { "phonographcopyright", XKB_KEY_phonographcopyright },
-    { "plus", XKB_KEY_plus },
-    { "plusminus", XKB_KEY_plusminus },
-    { "Pointer_Accelerate", XKB_KEY_Pointer_Accelerate },
-    { "Pointer_Button1", XKB_KEY_Pointer_Button1 },
-    { "Pointer_Button2", XKB_KEY_Pointer_Button2 },
-    { "Pointer_Button3", XKB_KEY_Pointer_Button3 },
-    { "Pointer_Button4", XKB_KEY_Pointer_Button4 },
-    { "Pointer_Button5", XKB_KEY_Pointer_Button5 },
-    { "Pointer_Button_Dflt", XKB_KEY_Pointer_Button_Dflt },
-    { "Pointer_DblClick1", XKB_KEY_Pointer_DblClick1 },
-    { "Pointer_DblClick2", XKB_KEY_Pointer_DblClick2 },
-    { "Pointer_DblClick3", XKB_KEY_Pointer_DblClick3 },
-    { "Pointer_DblClick4", XKB_KEY_Pointer_DblClick4 },
-    { "Pointer_DblClick5", XKB_KEY_Pointer_DblClick5 },
-    { "Pointer_DblClick_Dflt", XKB_KEY_Pointer_DblClick_Dflt },
-    { "Pointer_DfltBtnNext", XKB_KEY_Pointer_DfltBtnNext },
-    { "Pointer_DfltBtnPrev", XKB_KEY_Pointer_DfltBtnPrev },
-    { "Pointer_Down", XKB_KEY_Pointer_Down },
-    { "Pointer_DownLeft", XKB_KEY_Pointer_DownLeft },
-    { "Pointer_DownRight", XKB_KEY_Pointer_DownRight },
-    { "Pointer_Drag1", XKB_KEY_Pointer_Drag1 },
-    { "Pointer_Drag2", XKB_KEY_Pointer_Drag2 },
-    { "Pointer_Drag3", XKB_KEY_Pointer_Drag3 },
-    { "Pointer_Drag4", XKB_KEY_Pointer_Drag4 },
-    { "Pointer_Drag5", XKB_KEY_Pointer_Drag5 },
-    { "Pointer_Drag_Dflt", XKB_KEY_Pointer_Drag_Dflt },
-    { "Pointer_EnableKeys", XKB_KEY_Pointer_EnableKeys },
-    { "Pointer_Left", XKB_KEY_Pointer_Left },
-    { "Pointer_Right", XKB_KEY_Pointer_Right },
-    { "Pointer_Up", XKB_KEY_Pointer_Up },
-    { "Pointer_UpLeft", XKB_KEY_Pointer_UpLeft },
-    { "Pointer_UpRight", XKB_KEY_Pointer_UpRight },
-    { "prescription", XKB_KEY_prescription },
-    { "Prev_Virtual_Screen", XKB_KEY_Prev_Virtual_Screen },
-    { "PreviousCandidate", XKB_KEY_PreviousCandidate },
-    { "Print", XKB_KEY_Print },
-    { "Prior", XKB_KEY_Prior },
-    { "prolongedsound", XKB_KEY_prolongedsound },
-    { "punctspace", XKB_KEY_punctspace },
-    { "Q", XKB_KEY_Q },
-    { "q", XKB_KEY_q },
-    { "quad", XKB_KEY_quad },
-    { "question", XKB_KEY_question },
-    { "questiondown", XKB_KEY_questiondown },
-    { "quotedbl", XKB_KEY_quotedbl },
-    { "quoteleft", XKB_KEY_quoteleft },
-    { "quoteright", XKB_KEY_quoteright },
-    { "R", XKB_KEY_R },
-    { "r", XKB_KEY_r },
-    { "R1", XKB_KEY_R1 },
-    { "R10", XKB_KEY_R10 },
-    { "R11", XKB_KEY_R11 },
-    { "R12", XKB_KEY_R12 },
-    { "R13", XKB_KEY_R13 },
-    { "R14", XKB_KEY_R14 },
-    { "R15", XKB_KEY_R15 },
-    { "R2", XKB_KEY_R2 },
-    { "R3", XKB_KEY_R3 },
-    { "R4", XKB_KEY_R4 },
-    { "R5", XKB_KEY_R5 },
-    { "R6", XKB_KEY_R6 },
-    { "R7", XKB_KEY_R7 },
-    { "R8", XKB_KEY_R8 },
-    { "R9", XKB_KEY_R9 },
-    { "Racute", XKB_KEY_Racute },
-    { "racute", XKB_KEY_racute },
-    { "radical", XKB_KEY_radical },
-    { "Rcaron", XKB_KEY_Rcaron },
-    { "rcaron", XKB_KEY_rcaron },
-    { "Rcedilla", XKB_KEY_Rcedilla },
-    { "rcedilla", XKB_KEY_rcedilla },
-    { "Redo", XKB_KEY_Redo },
-    { "registered", XKB_KEY_registered },
-    { "RepeatKeys_Enable", XKB_KEY_RepeatKeys_Enable },
-    { "Reset", XKB_KEY_Reset },
-    { "Return", XKB_KEY_Return },
-    { "Right", XKB_KEY_Right },
-    { "rightanglebracket", XKB_KEY_rightanglebracket },
-    { "rightarrow", XKB_KEY_rightarrow },
-    { "rightcaret", XKB_KEY_rightcaret },
-    { "rightdoublequotemark", XKB_KEY_rightdoublequotemark },
-    { "rightmiddlecurlybrace", XKB_KEY_rightmiddlecurlybrace },
-    { "rightmiddlesummation", XKB_KEY_rightmiddlesummation },
-    { "rightopentriangle", XKB_KEY_rightopentriangle },
-    { "rightpointer", XKB_KEY_rightpointer },
-    { "rightshoe", XKB_KEY_rightshoe },
-    { "rightsinglequotemark", XKB_KEY_rightsinglequotemark },
-    { "rightt", XKB_KEY_rightt },
-    { "righttack", XKB_KEY_righttack },
-    { "Romaji", XKB_KEY_Romaji },
-    { "RupeeSign", XKB_KEY_RupeeSign },
-    { "S", XKB_KEY_S },
-    { "s", XKB_KEY_s },
-    { "Sabovedot", XKB_KEY_Sabovedot },
-    { "sabovedot", XKB_KEY_sabovedot },
-    { "Sacute", XKB_KEY_Sacute },
-    { "sacute", XKB_KEY_sacute },
-    { "Scaron", XKB_KEY_Scaron },
-    { "scaron", XKB_KEY_scaron },
-    { "Scedilla", XKB_KEY_Scedilla },
-    { "scedilla", XKB_KEY_scedilla },
-    { "SCHWA", XKB_KEY_SCHWA },
-    { "schwa", XKB_KEY_schwa },
-    { "Scircumflex", XKB_KEY_Scircumflex },
-    { "scircumflex", XKB_KEY_scircumflex },
-    { "script_switch", XKB_KEY_script_switch },
-    { "Scroll_Lock", XKB_KEY_Scroll_Lock },
-    { "seconds", XKB_KEY_seconds },
-    { "section", XKB_KEY_section },
-    { "Select", XKB_KEY_Select },
-    { "semicolon", XKB_KEY_semicolon },
-    { "semivoicedsound", XKB_KEY_semivoicedsound },
-    { "Serbian_dje", XKB_KEY_Serbian_dje },
-    { "Serbian_DJE", XKB_KEY_Serbian_DJE },
-    { "Serbian_dze", XKB_KEY_Serbian_dze },
-    { "Serbian_DZE", XKB_KEY_Serbian_DZE },
-    { "Serbian_je", XKB_KEY_Serbian_je },
-    { "Serbian_JE", XKB_KEY_Serbian_JE },
-    { "Serbian_lje", XKB_KEY_Serbian_lje },
-    { "Serbian_LJE", XKB_KEY_Serbian_LJE },
-    { "Serbian_nje", XKB_KEY_Serbian_nje },
-    { "Serbian_NJE", XKB_KEY_Serbian_NJE },
-    { "Serbian_tshe", XKB_KEY_Serbian_tshe },
-    { "Serbian_TSHE", XKB_KEY_Serbian_TSHE },
-    { "seveneighths", XKB_KEY_seveneighths },
-    { "sevensubscript", XKB_KEY_sevensubscript },
-    { "sevensuperior", XKB_KEY_sevensuperior },
-    { "Shift_L", XKB_KEY_Shift_L },
-    { "Shift_Lock", XKB_KEY_Shift_Lock },
-    { "Shift_R", XKB_KEY_Shift_R },
-    { "signaturemark", XKB_KEY_signaturemark },
-    { "signifblank", XKB_KEY_signifblank },
-    { "similarequal", XKB_KEY_similarequal },
-    { "SingleCandidate", XKB_KEY_SingleCandidate },
-    { "singlelowquotemark", XKB_KEY_singlelowquotemark },
-    { "Sinh_a", XKB_KEY_Sinh_a },
-    { "Sinh_aa", XKB_KEY_Sinh_aa },
-    { "Sinh_aa2", XKB_KEY_Sinh_aa2 },
-    { "Sinh_ae", XKB_KEY_Sinh_ae },
-    { "Sinh_ae2", XKB_KEY_Sinh_ae2 },
-    { "Sinh_aee", XKB_KEY_Sinh_aee },
-    { "Sinh_aee2", XKB_KEY_Sinh_aee2 },
-    { "Sinh_ai", XKB_KEY_Sinh_ai },
-    { "Sinh_ai2", XKB_KEY_Sinh_ai2 },
-    { "Sinh_al", XKB_KEY_Sinh_al },
-    { "Sinh_au", XKB_KEY_Sinh_au },
-    { "Sinh_au2", XKB_KEY_Sinh_au2 },
-    { "Sinh_ba", XKB_KEY_Sinh_ba },
-    { "Sinh_bha", XKB_KEY_Sinh_bha },
-    { "Sinh_ca", XKB_KEY_Sinh_ca },
-    { "Sinh_cha", XKB_KEY_Sinh_cha },
-    { "Sinh_dda", XKB_KEY_Sinh_dda },
-    { "Sinh_ddha", XKB_KEY_Sinh_ddha },
-    { "Sinh_dha", XKB_KEY_Sinh_dha },
-    { "Sinh_dhha", XKB_KEY_Sinh_dhha },
-    { "Sinh_e", XKB_KEY_Sinh_e },
-    { "Sinh_e2", XKB_KEY_Sinh_e2 },
-    { "Sinh_ee", XKB_KEY_Sinh_ee },
-    { "Sinh_ee2", XKB_KEY_Sinh_ee2 },
-    { "Sinh_fa", XKB_KEY_Sinh_fa },
-    { "Sinh_ga", XKB_KEY_Sinh_ga },
-    { "Sinh_gha", XKB_KEY_Sinh_gha },
-    { "Sinh_h2", XKB_KEY_Sinh_h2 },
-    { "Sinh_ha", XKB_KEY_Sinh_ha },
-    { "Sinh_i", XKB_KEY_Sinh_i },
-    { "Sinh_i2", XKB_KEY_Sinh_i2 },
-    { "Sinh_ii", XKB_KEY_Sinh_ii },
-    { "Sinh_ii2", XKB_KEY_Sinh_ii2 },
-    { "Sinh_ja", XKB_KEY_Sinh_ja },
-    { "Sinh_jha", XKB_KEY_Sinh_jha },
-    { "Sinh_jnya", XKB_KEY_Sinh_jnya },
-    { "Sinh_ka", XKB_KEY_Sinh_ka },
-    { "Sinh_kha", XKB_KEY_Sinh_kha },
-    { "Sinh_kunddaliya", XKB_KEY_Sinh_kunddaliya },
-    { "Sinh_la", XKB_KEY_Sinh_la },
-    { "Sinh_lla", XKB_KEY_Sinh_lla },
-    { "Sinh_lu", XKB_KEY_Sinh_lu },
-    { "Sinh_lu2", XKB_KEY_Sinh_lu2 },
-    { "Sinh_luu", XKB_KEY_Sinh_luu },
-    { "Sinh_luu2", XKB_KEY_Sinh_luu2 },
-    { "Sinh_ma", XKB_KEY_Sinh_ma },
-    { "Sinh_mba", XKB_KEY_Sinh_mba },
-    { "Sinh_na", XKB_KEY_Sinh_na },
-    { "Sinh_ndda", XKB_KEY_Sinh_ndda },
-    { "Sinh_ndha", XKB_KEY_Sinh_ndha },
-    { "Sinh_ng", XKB_KEY_Sinh_ng },
-    { "Sinh_ng2", XKB_KEY_Sinh_ng2 },
-    { "Sinh_nga", XKB_KEY_Sinh_nga },
-    { "Sinh_nja", XKB_KEY_Sinh_nja },
-    { "Sinh_nna", XKB_KEY_Sinh_nna },
-    { "Sinh_nya", XKB_KEY_Sinh_nya },
-    { "Sinh_o", XKB_KEY_Sinh_o },
-    { "Sinh_o2", XKB_KEY_Sinh_o2 },
-    { "Sinh_oo", XKB_KEY_Sinh_oo },
-    { "Sinh_oo2", XKB_KEY_Sinh_oo2 },
-    { "Sinh_pa", XKB_KEY_Sinh_pa },
-    { "Sinh_pha", XKB_KEY_Sinh_pha },
-    { "Sinh_ra", XKB_KEY_Sinh_ra },
-    { "Sinh_ri", XKB_KEY_Sinh_ri },
-    { "Sinh_rii", XKB_KEY_Sinh_rii },
-    { "Sinh_ru2", XKB_KEY_Sinh_ru2 },
-    { "Sinh_ruu2", XKB_KEY_Sinh_ruu2 },
-    { "Sinh_sa", XKB_KEY_Sinh_sa },
-    { "Sinh_sha", XKB_KEY_Sinh_sha },
-    { "Sinh_ssha", XKB_KEY_Sinh_ssha },
-    { "Sinh_tha", XKB_KEY_Sinh_tha },
-    { "Sinh_thha", XKB_KEY_Sinh_thha },
-    { "Sinh_tta", XKB_KEY_Sinh_tta },
-    { "Sinh_ttha", XKB_KEY_Sinh_ttha },
-    { "Sinh_u", XKB_KEY_Sinh_u },
-    { "Sinh_u2", XKB_KEY_Sinh_u2 },
-    { "Sinh_uu", XKB_KEY_Sinh_uu },
-    { "Sinh_uu2", XKB_KEY_Sinh_uu2 },
-    { "Sinh_va", XKB_KEY_Sinh_va },
-    { "Sinh_ya", XKB_KEY_Sinh_ya },
-    { "sixsubscript", XKB_KEY_sixsubscript },
-    { "sixsuperior", XKB_KEY_sixsuperior },
-    { "slash", XKB_KEY_slash },
-    { "SlowKeys_Enable", XKB_KEY_SlowKeys_Enable },
-    { "soliddiamond", XKB_KEY_soliddiamond },
-    { "space", XKB_KEY_space },
-    { "squareroot", XKB_KEY_squareroot },
-    { "ssharp", XKB_KEY_ssharp },
-    { "sterling", XKB_KEY_sterling },
-    { "StickyKeys_Enable", XKB_KEY_StickyKeys_Enable },
-    { "stricteq", XKB_KEY_stricteq },
-    { "SunAgain", XKB_KEY_SunAgain },
-    { "SunAltGraph", XKB_KEY_SunAltGraph },
-    { "SunAudioLowerVolume", XKB_KEY_SunAudioLowerVolume },
-    { "SunAudioMute", XKB_KEY_SunAudioMute },
-    { "SunAudioRaiseVolume", XKB_KEY_SunAudioRaiseVolume },
-    { "SunCompose", XKB_KEY_SunCompose },
-    { "SunCopy", XKB_KEY_SunCopy },
-    { "SunCut", XKB_KEY_SunCut },
-    { "SunF36", XKB_KEY_SunF36 },
-    { "SunF37", XKB_KEY_SunF37 },
-    { "SunFA_Acute", XKB_KEY_SunFA_Acute },
-    { "SunFA_Cedilla", XKB_KEY_SunFA_Cedilla },
-    { "SunFA_Circum", XKB_KEY_SunFA_Circum },
-    { "SunFA_Diaeresis", XKB_KEY_SunFA_Diaeresis },
-    { "SunFA_Grave", XKB_KEY_SunFA_Grave },
-    { "SunFA_Tilde", XKB_KEY_SunFA_Tilde },
-    { "SunFind", XKB_KEY_SunFind },
-    { "SunFront", XKB_KEY_SunFront },
-    { "SunOpen", XKB_KEY_SunOpen },
-    { "SunPageDown", XKB_KEY_SunPageDown },
-    { "SunPageUp", XKB_KEY_SunPageUp },
-    { "SunPaste", XKB_KEY_SunPaste },
-    { "SunPowerSwitch", XKB_KEY_SunPowerSwitch },
-    { "SunPowerSwitchShift", XKB_KEY_SunPowerSwitchShift },
-    { "SunPrint_Screen", XKB_KEY_SunPrint_Screen },
-    { "SunProps", XKB_KEY_SunProps },
-    { "SunStop", XKB_KEY_SunStop },
-    { "SunSys_Req", XKB_KEY_SunSys_Req },
-    { "SunUndo", XKB_KEY_SunUndo },
-    { "SunVideoDegauss", XKB_KEY_SunVideoDegauss },
-    { "SunVideoLowerBrightness", XKB_KEY_SunVideoLowerBrightness },
-    { "SunVideoRaiseBrightness", XKB_KEY_SunVideoRaiseBrightness },
-    { "Super_L", XKB_KEY_Super_L },
-    { "Super_R", XKB_KEY_Super_R },
-    { "Sys_Req", XKB_KEY_Sys_Req },
-    { "System", XKB_KEY_System },
-    { "T", XKB_KEY_T },
-    { "t", XKB_KEY_t },
-    { "Tab", XKB_KEY_Tab },
-    { "Tabovedot", XKB_KEY_Tabovedot },
-    { "tabovedot", XKB_KEY_tabovedot },
-    { "Tcaron", XKB_KEY_Tcaron },
-    { "tcaron", XKB_KEY_tcaron },
-    { "Tcedilla", XKB_KEY_Tcedilla },
-    { "tcedilla", XKB_KEY_tcedilla },
-    { "telephone", XKB_KEY_telephone },
-    { "telephonerecorder", XKB_KEY_telephonerecorder },
-    { "Terminate_Server", XKB_KEY_Terminate_Server },
-    { "Thai_baht", XKB_KEY_Thai_baht },
-    { "Thai_bobaimai", XKB_KEY_Thai_bobaimai },
-    { "Thai_chochan", XKB_KEY_Thai_chochan },
-    { "Thai_chochang", XKB_KEY_Thai_chochang },
-    { "Thai_choching", XKB_KEY_Thai_choching },
-    { "Thai_chochoe", XKB_KEY_Thai_chochoe },
-    { "Thai_dochada", XKB_KEY_Thai_dochada },
-    { "Thai_dodek", XKB_KEY_Thai_dodek },
-    { "Thai_fofa", XKB_KEY_Thai_fofa },
-    { "Thai_fofan", XKB_KEY_Thai_fofan },
-    { "Thai_hohip", XKB_KEY_Thai_hohip },
-    { "Thai_honokhuk", XKB_KEY_Thai_honokhuk },
-    { "Thai_khokhai", XKB_KEY_Thai_khokhai },
-    { "Thai_khokhon", XKB_KEY_Thai_khokhon },
-    { "Thai_khokhuat", XKB_KEY_Thai_khokhuat },
-    { "Thai_khokhwai", XKB_KEY_Thai_khokhwai },
-    { "Thai_khorakhang", XKB_KEY_Thai_khorakhang },
-    { "Thai_kokai", XKB_KEY_Thai_kokai },
-    { "Thai_lakkhangyao", XKB_KEY_Thai_lakkhangyao },
-    { "Thai_lekchet", XKB_KEY_Thai_lekchet },
-    { "Thai_lekha", XKB_KEY_Thai_lekha },
-    { "Thai_lekhok", XKB_KEY_Thai_lekhok },
-    { "Thai_lekkao", XKB_KEY_Thai_lekkao },
-    { "Thai_leknung", XKB_KEY_Thai_leknung },
-    { "Thai_lekpaet", XKB_KEY_Thai_lekpaet },
-    { "Thai_leksam", XKB_KEY_Thai_leksam },
-    { "Thai_leksi", XKB_KEY_Thai_leksi },
-    { "Thai_leksong", XKB_KEY_Thai_leksong },
-    { "Thai_leksun", XKB_KEY_Thai_leksun },
-    { "Thai_lochula", XKB_KEY_Thai_lochula },
-    { "Thai_loling", XKB_KEY_Thai_loling },
-    { "Thai_lu", XKB_KEY_Thai_lu },
-    { "Thai_maichattawa", XKB_KEY_Thai_maichattawa },
-    { "Thai_maiek", XKB_KEY_Thai_maiek },
-    { "Thai_maihanakat", XKB_KEY_Thai_maihanakat },
-    { "Thai_maihanakat_maitho", XKB_KEY_Thai_maihanakat_maitho },
-    { "Thai_maitaikhu", XKB_KEY_Thai_maitaikhu },
-    { "Thai_maitho", XKB_KEY_Thai_maitho },
-    { "Thai_maitri", XKB_KEY_Thai_maitri },
-    { "Thai_maiyamok", XKB_KEY_Thai_maiyamok },
-    { "Thai_moma", XKB_KEY_Thai_moma },
-    { "Thai_ngongu", XKB_KEY_Thai_ngongu },
-    { "Thai_nikhahit", XKB_KEY_Thai_nikhahit },
-    { "Thai_nonen", XKB_KEY_Thai_nonen },
-    { "Thai_nonu", XKB_KEY_Thai_nonu },
-    { "Thai_oang", XKB_KEY_Thai_oang },
-    { "Thai_paiyannoi", XKB_KEY_Thai_paiyannoi },
-    { "Thai_phinthu", XKB_KEY_Thai_phinthu },
-    { "Thai_phophan", XKB_KEY_Thai_phophan },
-    { "Thai_phophung", XKB_KEY_Thai_phophung },
-    { "Thai_phosamphao", XKB_KEY_Thai_phosamphao },
-    { "Thai_popla", XKB_KEY_Thai_popla },
-    { "Thai_rorua", XKB_KEY_Thai_rorua },
-    { "Thai_ru", XKB_KEY_Thai_ru },
-    { "Thai_saraa", XKB_KEY_Thai_saraa },
-    { "Thai_saraaa", XKB_KEY_Thai_saraaa },
-    { "Thai_saraae", XKB_KEY_Thai_saraae },
-    { "Thai_saraaimaimalai", XKB_KEY_Thai_saraaimaimalai },
-    { "Thai_saraaimaimuan", XKB_KEY_Thai_saraaimaimuan },
-    { "Thai_saraam", XKB_KEY_Thai_saraam },
-    { "Thai_sarae", XKB_KEY_Thai_sarae },
-    { "Thai_sarai", XKB_KEY_Thai_sarai },
-    { "Thai_saraii", XKB_KEY_Thai_saraii },
-    { "Thai_sarao", XKB_KEY_Thai_sarao },
-    { "Thai_sarau", XKB_KEY_Thai_sarau },
-    { "Thai_saraue", XKB_KEY_Thai_saraue },
-    { "Thai_sarauee", XKB_KEY_Thai_sarauee },
-    { "Thai_sarauu", XKB_KEY_Thai_sarauu },
-    { "Thai_sorusi", XKB_KEY_Thai_sorusi },
-    { "Thai_sosala", XKB_KEY_Thai_sosala },
-    { "Thai_soso", XKB_KEY_Thai_soso },
-    { "Thai_sosua", XKB_KEY_Thai_sosua },
-    { "Thai_thanthakhat", XKB_KEY_Thai_thanthakhat },
-    { "Thai_thonangmontho", XKB_KEY_Thai_thonangmontho },
-    { "Thai_thophuthao", XKB_KEY_Thai_thophuthao },
-    { "Thai_thothahan", XKB_KEY_Thai_thothahan },
-    { "Thai_thothan", XKB_KEY_Thai_thothan },
-    { "Thai_thothong", XKB_KEY_Thai_thothong },
-    { "Thai_thothung", XKB_KEY_Thai_thothung },
-    { "Thai_topatak", XKB_KEY_Thai_topatak },
-    { "Thai_totao", XKB_KEY_Thai_totao },
-    { "Thai_wowaen", XKB_KEY_Thai_wowaen },
-    { "Thai_yoyak", XKB_KEY_Thai_yoyak },
-    { "Thai_yoying", XKB_KEY_Thai_yoying },
-    { "therefore", XKB_KEY_therefore },
-    { "thinspace", XKB_KEY_thinspace },
-    { "THORN", XKB_KEY_THORN },
-    { "Thorn", XKB_KEY_Thorn },
-    { "thorn", XKB_KEY_thorn },
-    { "threeeighths", XKB_KEY_threeeighths },
-    { "threefifths", XKB_KEY_threefifths },
-    { "threequarters", XKB_KEY_threequarters },
-    { "threesubscript", XKB_KEY_threesubscript },
-    { "threesuperior", XKB_KEY_threesuperior },
-    { "tintegral", XKB_KEY_tintegral },
-    { "topintegral", XKB_KEY_topintegral },
-    { "topleftparens", XKB_KEY_topleftparens },
-    { "topleftradical", XKB_KEY_topleftradical },
-    { "topleftsqbracket", XKB_KEY_topleftsqbracket },
-    { "topleftsummation", XKB_KEY_topleftsummation },
-    { "toprightparens", XKB_KEY_toprightparens },
-    { "toprightsqbracket", XKB_KEY_toprightsqbracket },
-    { "toprightsummation", XKB_KEY_toprightsummation },
-    { "topt", XKB_KEY_topt },
-    { "topvertsummationconnector", XKB_KEY_topvertsummationconnector },
-    { "Touroku", XKB_KEY_Touroku },
-    { "trademark", XKB_KEY_trademark },
-    { "trademarkincircle", XKB_KEY_trademarkincircle },
-    { "Tslash", XKB_KEY_Tslash },
-    { "tslash", XKB_KEY_tslash },
-    { "twofifths", XKB_KEY_twofifths },
-    { "twosubscript", XKB_KEY_twosubscript },
-    { "twosuperior", XKB_KEY_twosuperior },
-    { "twothirds", XKB_KEY_twothirds },
-    { "U", XKB_KEY_U },
-    { "u", XKB_KEY_u },
-    { "Uacute", XKB_KEY_Uacute },
-    { "uacute", XKB_KEY_uacute },
-    { "Ubelowdot", XKB_KEY_Ubelowdot },
-    { "ubelowdot", XKB_KEY_ubelowdot },
-    { "Ubreve", XKB_KEY_Ubreve },
-    { "ubreve", XKB_KEY_ubreve },
-    { "Ucircumflex", XKB_KEY_Ucircumflex },
-    { "ucircumflex", XKB_KEY_ucircumflex },
-    { "Udiaeresis", XKB_KEY_Udiaeresis },
-    { "udiaeresis", XKB_KEY_udiaeresis },
-    { "Udoubleacute", XKB_KEY_Udoubleacute },
-    { "udoubleacute", XKB_KEY_udoubleacute },
-    { "Ugrave", XKB_KEY_Ugrave },
-    { "ugrave", XKB_KEY_ugrave },
-    { "Uhook", XKB_KEY_Uhook },
-    { "uhook", XKB_KEY_uhook },
-    { "Uhorn", XKB_KEY_Uhorn },
-    { "uhorn", XKB_KEY_uhorn },
-    { "Uhornacute", XKB_KEY_Uhornacute },
-    { "uhornacute", XKB_KEY_uhornacute },
-    { "Uhornbelowdot", XKB_KEY_Uhornbelowdot },
-    { "uhornbelowdot", XKB_KEY_uhornbelowdot },
-    { "Uhorngrave", XKB_KEY_Uhorngrave },
-    { "uhorngrave", XKB_KEY_uhorngrave },
-    { "Uhornhook", XKB_KEY_Uhornhook },
-    { "uhornhook", XKB_KEY_uhornhook },
-    { "Uhorntilde", XKB_KEY_Uhorntilde },
-    { "uhorntilde", XKB_KEY_uhorntilde },
-    { "Ukrainian_ghe_with_upturn", XKB_KEY_Ukrainian_ghe_with_upturn },
-    { "Ukrainian_GHE_WITH_UPTURN", XKB_KEY_Ukrainian_GHE_WITH_UPTURN },
-    { "Ukrainian_i", XKB_KEY_Ukrainian_i },
-    { "Ukrainian_I", XKB_KEY_Ukrainian_I },
-    { "Ukrainian_ie", XKB_KEY_Ukrainian_ie },
-    { "Ukrainian_IE", XKB_KEY_Ukrainian_IE },
-    { "Ukrainian_yi", XKB_KEY_Ukrainian_yi },
-    { "Ukrainian_YI", XKB_KEY_Ukrainian_YI },
-    { "Ukranian_i", XKB_KEY_Ukranian_i },
-    { "Ukranian_I", XKB_KEY_Ukranian_I },
-    { "Ukranian_je", XKB_KEY_Ukranian_je },
-    { "Ukranian_JE", XKB_KEY_Ukranian_JE },
-    { "Ukranian_yi", XKB_KEY_Ukranian_yi },
-    { "Ukranian_YI", XKB_KEY_Ukranian_YI },
-    { "Umacron", XKB_KEY_Umacron },
-    { "umacron", XKB_KEY_umacron },
-    { "underbar", XKB_KEY_underbar },
-    { "underscore", XKB_KEY_underscore },
-    { "Undo", XKB_KEY_Undo },
-    { "union", XKB_KEY_union },
-    { "Uogonek", XKB_KEY_Uogonek },
-    { "uogonek", XKB_KEY_uogonek },
-    { "Up", XKB_KEY_Up },
-    { "uparrow", XKB_KEY_uparrow },
-    { "upcaret", XKB_KEY_upcaret },
-    { "upleftcorner", XKB_KEY_upleftcorner },
-    { "uprightcorner", XKB_KEY_uprightcorner },
-    { "upshoe", XKB_KEY_upshoe },
-    { "upstile", XKB_KEY_upstile },
-    { "uptack", XKB_KEY_uptack },
-    { "Uring", XKB_KEY_Uring },
-    { "uring", XKB_KEY_uring },
-    { "User", XKB_KEY_User },
-    { "Utilde", XKB_KEY_Utilde },
-    { "utilde", XKB_KEY_utilde },
-    { "V", XKB_KEY_V },
-    { "v", XKB_KEY_v },
-    { "variation", XKB_KEY_variation },
-    { "vertbar", XKB_KEY_vertbar },
-    { "vertconnector", XKB_KEY_vertconnector },
-    { "voicedsound", XKB_KEY_voicedsound },
-    { "VoidSymbol", XKB_KEY_VoidSymbol },
-    { "vt", XKB_KEY_vt },
-    { "W", XKB_KEY_W },
-    { "w", XKB_KEY_w },
-    { "Wacute", XKB_KEY_Wacute },
-    { "wacute", XKB_KEY_wacute },
-    { "Wcircumflex", XKB_KEY_Wcircumflex },
-    { "wcircumflex", XKB_KEY_wcircumflex },
-    { "Wdiaeresis", XKB_KEY_Wdiaeresis },
-    { "wdiaeresis", XKB_KEY_wdiaeresis },
-    { "Wgrave", XKB_KEY_Wgrave },
-    { "wgrave", XKB_KEY_wgrave },
-    { "WonSign", XKB_KEY_WonSign },
-    { "X", XKB_KEY_X },
-    { "x", XKB_KEY_x },
-    { "Xabovedot", XKB_KEY_Xabovedot },
-    { "xabovedot", XKB_KEY_xabovedot },
-    { "XF86AddFavorite", XKB_KEY_XF86AddFavorite },
-    { "XF86ApplicationLeft", XKB_KEY_XF86ApplicationLeft },
-    { "XF86ApplicationRight", XKB_KEY_XF86ApplicationRight },
-    { "XF86AudioCycleTrack", XKB_KEY_XF86AudioCycleTrack },
-    { "XF86AudioForward", XKB_KEY_XF86AudioForward },
-    { "XF86AudioLowerVolume", XKB_KEY_XF86AudioLowerVolume },
-    { "XF86AudioMedia", XKB_KEY_XF86AudioMedia },
-    { "XF86AudioMute", XKB_KEY_XF86AudioMute },
-    { "XF86AudioNext", XKB_KEY_XF86AudioNext },
-    { "XF86AudioPause", XKB_KEY_XF86AudioPause },
-    { "XF86AudioPlay", XKB_KEY_XF86AudioPlay },
-    { "XF86AudioPrev", XKB_KEY_XF86AudioPrev },
-    { "XF86AudioRaiseVolume", XKB_KEY_XF86AudioRaiseVolume },
-    { "XF86AudioRandomPlay", XKB_KEY_XF86AudioRandomPlay },
-    { "XF86AudioRecord", XKB_KEY_XF86AudioRecord },
-    { "XF86AudioRepeat", XKB_KEY_XF86AudioRepeat },
-    { "XF86AudioRewind", XKB_KEY_XF86AudioRewind },
-    { "XF86AudioStop", XKB_KEY_XF86AudioStop },
-    { "XF86Away", XKB_KEY_XF86Away },
-    { "XF86Back", XKB_KEY_XF86Back },
-    { "XF86BackForward", XKB_KEY_XF86BackForward },
-    { "XF86Battery", XKB_KEY_XF86Battery },
-    { "XF86Blue", XKB_KEY_XF86Blue },
-    { "XF86Bluetooth", XKB_KEY_XF86Bluetooth },
-    { "XF86Book", XKB_KEY_XF86Book },
-    { "XF86BrightnessAdjust", XKB_KEY_XF86BrightnessAdjust },
-    { "XF86Calculater", XKB_KEY_XF86Calculater },
-    { "XF86Calculator", XKB_KEY_XF86Calculator },
-    { "XF86Calendar", XKB_KEY_XF86Calendar },
-    { "XF86CD", XKB_KEY_XF86CD },
-    { "XF86Clear", XKB_KEY_XF86Clear },
-    { "XF86ClearGrab", XKB_KEY_XF86ClearGrab },
-    { "XF86Close", XKB_KEY_XF86Close },
-    { "XF86Community", XKB_KEY_XF86Community },
-    { "XF86ContrastAdjust", XKB_KEY_XF86ContrastAdjust },
-    { "XF86Copy", XKB_KEY_XF86Copy },
-    { "XF86Cut", XKB_KEY_XF86Cut },
-    { "XF86CycleAngle", XKB_KEY_XF86CycleAngle },
-    { "XF86Display", XKB_KEY_XF86Display },
-    { "XF86Documents", XKB_KEY_XF86Documents },
-    { "XF86DOS", XKB_KEY_XF86DOS },
-    { "XF86Eject", XKB_KEY_XF86Eject },
-    { "XF86Excel", XKB_KEY_XF86Excel },
-    { "XF86Explorer", XKB_KEY_XF86Explorer },
-    { "XF86Favorites", XKB_KEY_XF86Favorites },
-    { "XF86Finance", XKB_KEY_XF86Finance },
-    { "XF86Forward", XKB_KEY_XF86Forward },
-    { "XF86FrameBack", XKB_KEY_XF86FrameBack },
-    { "XF86FrameForward", XKB_KEY_XF86FrameForward },
-    { "XF86Game", XKB_KEY_XF86Game },
-    { "XF86Go", XKB_KEY_XF86Go },
-    { "XF86Green", XKB_KEY_XF86Green },
-    { "XF86Hibernate", XKB_KEY_XF86Hibernate },
-    { "XF86History", XKB_KEY_XF86History },
-    { "XF86HomePage", XKB_KEY_XF86HomePage },
-    { "XF86HotLinks", XKB_KEY_XF86HotLinks },
-    { "XF86iTouch", XKB_KEY_XF86iTouch },
-    { "XF86KbdBrightnessDown", XKB_KEY_XF86KbdBrightnessDown },
-    { "XF86KbdBrightnessUp", XKB_KEY_XF86KbdBrightnessUp },
-    { "XF86KbdLightOnOff", XKB_KEY_XF86KbdLightOnOff },
-    { "XF86Launch0", XKB_KEY_XF86Launch0 },
-    { "XF86Launch1", XKB_KEY_XF86Launch1 },
-    { "XF86Launch2", XKB_KEY_XF86Launch2 },
-    { "XF86Launch3", XKB_KEY_XF86Launch3 },
-    { "XF86Launch4", XKB_KEY_XF86Launch4 },
-    { "XF86Launch5", XKB_KEY_XF86Launch5 },
-    { "XF86Launch6", XKB_KEY_XF86Launch6 },
-    { "XF86Launch7", XKB_KEY_XF86Launch7 },
-    { "XF86Launch8", XKB_KEY_XF86Launch8 },
-    { "XF86Launch9", XKB_KEY_XF86Launch9 },
-    { "XF86LaunchA", XKB_KEY_XF86LaunchA },
-    { "XF86LaunchB", XKB_KEY_XF86LaunchB },
-    { "XF86LaunchC", XKB_KEY_XF86LaunchC },
-    { "XF86LaunchD", XKB_KEY_XF86LaunchD },
-    { "XF86LaunchE", XKB_KEY_XF86LaunchE },
-    { "XF86LaunchF", XKB_KEY_XF86LaunchF },
-    { "XF86LightBulb", XKB_KEY_XF86LightBulb },
-    { "XF86LogGrabInfo", XKB_KEY_XF86LogGrabInfo },
-    { "XF86LogOff", XKB_KEY_XF86LogOff },
-    { "XF86LogWindowTree", XKB_KEY_XF86LogWindowTree },
-    { "XF86Mail", XKB_KEY_XF86Mail },
-    { "XF86MailForward", XKB_KEY_XF86MailForward },
-    { "XF86Market", XKB_KEY_XF86Market },
-    { "XF86Meeting", XKB_KEY_XF86Meeting },
-    { "XF86Memo", XKB_KEY_XF86Memo },
-    { "XF86MenuKB", XKB_KEY_XF86MenuKB },
-    { "XF86MenuPB", XKB_KEY_XF86MenuPB },
-    { "XF86Messenger", XKB_KEY_XF86Messenger },
-    { "XF86ModeLock", XKB_KEY_XF86ModeLock },
-    { "XF86MonBrightnessDown", XKB_KEY_XF86MonBrightnessDown },
-    { "XF86MonBrightnessUp", XKB_KEY_XF86MonBrightnessUp },
-    { "XF86Music", XKB_KEY_XF86Music },
-    { "XF86MyComputer", XKB_KEY_XF86MyComputer },
-    { "XF86MySites", XKB_KEY_XF86MySites },
-    { "XF86New", XKB_KEY_XF86New },
-    { "XF86News", XKB_KEY_XF86News },
-    { "XF86Next_VMode", XKB_KEY_XF86Next_VMode },
-    { "XF86OfficeHome", XKB_KEY_XF86OfficeHome },
-    { "XF86Open", XKB_KEY_XF86Open },
-    { "XF86OpenURL", XKB_KEY_XF86OpenURL },
-    { "XF86Option", XKB_KEY_XF86Option },
-    { "XF86Paste", XKB_KEY_XF86Paste },
-    { "XF86Phone", XKB_KEY_XF86Phone },
-    { "XF86Pictures", XKB_KEY_XF86Pictures },
-    { "XF86PowerDown", XKB_KEY_XF86PowerDown },
-    { "XF86PowerOff", XKB_KEY_XF86PowerOff },
-    { "XF86Prev_VMode", XKB_KEY_XF86Prev_VMode },
-    { "XF86Q", XKB_KEY_XF86Q },
-    { "XF86Red", XKB_KEY_XF86Red },
-    { "XF86Refresh", XKB_KEY_XF86Refresh },
-    { "XF86Reload", XKB_KEY_XF86Reload },
-    { "XF86Reply", XKB_KEY_XF86Reply },
-    { "XF86RockerDown", XKB_KEY_XF86RockerDown },
-    { "XF86RockerEnter", XKB_KEY_XF86RockerEnter },
-    { "XF86RockerUp", XKB_KEY_XF86RockerUp },
-    { "XF86RotateWindows", XKB_KEY_XF86RotateWindows },
-    { "XF86RotationKB", XKB_KEY_XF86RotationKB },
-    { "XF86RotationPB", XKB_KEY_XF86RotationPB },
-    { "XF86Save", XKB_KEY_XF86Save },
-    { "XF86ScreenSaver", XKB_KEY_XF86ScreenSaver },
-    { "XF86ScrollClick", XKB_KEY_XF86ScrollClick },
-    { "XF86ScrollDown", XKB_KEY_XF86ScrollDown },
-    { "XF86ScrollUp", XKB_KEY_XF86ScrollUp },
-    { "XF86Search", XKB_KEY_XF86Search },
-    { "XF86Select", XKB_KEY_XF86Select },
-    { "XF86Send", XKB_KEY_XF86Send },
-    { "XF86Shop", XKB_KEY_XF86Shop },
-    { "XF86Sleep", XKB_KEY_XF86Sleep },
-    { "XF86Spell", XKB_KEY_XF86Spell },
-    { "XF86SplitScreen", XKB_KEY_XF86SplitScreen },
-    { "XF86Standby", XKB_KEY_XF86Standby },
-    { "XF86Start", XKB_KEY_XF86Start },
-    { "XF86Stop", XKB_KEY_XF86Stop },
-    { "XF86Subtitle", XKB_KEY_XF86Subtitle },
-    { "XF86Support", XKB_KEY_XF86Support },
-    { "XF86Suspend", XKB_KEY_XF86Suspend },
-    { "XF86Switch_VT_1", XKB_KEY_XF86Switch_VT_1 },
-    { "XF86Switch_VT_10", XKB_KEY_XF86Switch_VT_10 },
-    { "XF86Switch_VT_11", XKB_KEY_XF86Switch_VT_11 },
-    { "XF86Switch_VT_12", XKB_KEY_XF86Switch_VT_12 },
-    { "XF86Switch_VT_2", XKB_KEY_XF86Switch_VT_2 },
-    { "XF86Switch_VT_3", XKB_KEY_XF86Switch_VT_3 },
-    { "XF86Switch_VT_4", XKB_KEY_XF86Switch_VT_4 },
-    { "XF86Switch_VT_5", XKB_KEY_XF86Switch_VT_5 },
-    { "XF86Switch_VT_6", XKB_KEY_XF86Switch_VT_6 },
-    { "XF86Switch_VT_7", XKB_KEY_XF86Switch_VT_7 },
-    { "XF86Switch_VT_8", XKB_KEY_XF86Switch_VT_8 },
-    { "XF86Switch_VT_9", XKB_KEY_XF86Switch_VT_9 },
-    { "XF86TaskPane", XKB_KEY_XF86TaskPane },
-    { "XF86Terminal", XKB_KEY_XF86Terminal },
-    { "XF86Time", XKB_KEY_XF86Time },
-    { "XF86ToDoList", XKB_KEY_XF86ToDoList },
-    { "XF86Tools", XKB_KEY_XF86Tools },
-    { "XF86TopMenu", XKB_KEY_XF86TopMenu },
-    { "XF86TouchpadOff", XKB_KEY_XF86TouchpadOff },
-    { "XF86TouchpadOn", XKB_KEY_XF86TouchpadOn },
-    { "XF86TouchpadToggle", XKB_KEY_XF86TouchpadToggle },
-    { "XF86Travel", XKB_KEY_XF86Travel },
-    { "XF86Ungrab", XKB_KEY_XF86Ungrab },
-    { "XF86User1KB", XKB_KEY_XF86User1KB },
-    { "XF86User2KB", XKB_KEY_XF86User2KB },
-    { "XF86UserPB", XKB_KEY_XF86UserPB },
-    { "XF86UWB", XKB_KEY_XF86UWB },
-    { "XF86VendorHome", XKB_KEY_XF86VendorHome },
-    { "XF86Video", XKB_KEY_XF86Video },
-    { "XF86View", XKB_KEY_XF86View },
-    { "XF86WakeUp", XKB_KEY_XF86WakeUp },
-    { "XF86WebCam", XKB_KEY_XF86WebCam },
-    { "XF86WheelButton", XKB_KEY_XF86WheelButton },
-    { "XF86WLAN", XKB_KEY_XF86WLAN },
-    { "XF86Word", XKB_KEY_XF86Word },
-    { "XF86WWW", XKB_KEY_XF86WWW },
-    { "XF86Xfer", XKB_KEY_XF86Xfer },
-    { "XF86Yellow", XKB_KEY_XF86Yellow },
-    { "XF86ZoomIn", XKB_KEY_XF86ZoomIn },
-    { "XF86ZoomOut", XKB_KEY_XF86ZoomOut },
-    { "Y", XKB_KEY_Y },
-    { "y", XKB_KEY_y },
-    { "Yacute", XKB_KEY_Yacute },
-    { "yacute", XKB_KEY_yacute },
-    { "Ybelowdot", XKB_KEY_Ybelowdot },
-    { "ybelowdot", XKB_KEY_ybelowdot },
-    { "Ycircumflex", XKB_KEY_Ycircumflex },
-    { "ycircumflex", XKB_KEY_ycircumflex },
-    { "ydiaeresis", XKB_KEY_ydiaeresis },
-    { "Ydiaeresis", XKB_KEY_Ydiaeresis },
-    { "yen", XKB_KEY_yen },
-    { "Ygrave", XKB_KEY_Ygrave },
-    { "ygrave", XKB_KEY_ygrave },
-    { "Yhook", XKB_KEY_Yhook },
-    { "yhook", XKB_KEY_yhook },
-    { "Ytilde", XKB_KEY_Ytilde },
-    { "ytilde", XKB_KEY_ytilde },
-    { "Z", XKB_KEY_Z },
-    { "z", XKB_KEY_z },
-    { "Zabovedot", XKB_KEY_Zabovedot },
-    { "zabovedot", XKB_KEY_zabovedot },
-    { "Zacute", XKB_KEY_Zacute },
-    { "zacute", XKB_KEY_zacute },
-    { "Zcaron", XKB_KEY_Zcaron },
-    { "zcaron", XKB_KEY_zcaron },
-    { "Zen_Koho", XKB_KEY_Zen_Koho },
-    { "Zenkaku", XKB_KEY_Zenkaku },
-    { "Zenkaku_Hankaku", XKB_KEY_Zenkaku_Hankaku },
-    { "zerosubscript", XKB_KEY_zerosubscript },
-    { "zerosuperior", XKB_KEY_zerosuperior },
-    { "Zstroke", XKB_KEY_Zstroke },
-    { "zstroke", XKB_KEY_zstroke },
+    { 0x00000030, 0 }, /* 0 */
+    { 0x00000031, 2 }, /* 1 */
+    { 0x00000032, 4 }, /* 2 */
+    { 0x00000033, 6 }, /* 3 */
+    { 0x0000fd10, 8 }, /* 3270_AltCursor */
+    { 0x0000fd0e, 23 }, /* 3270_Attn */
+    { 0x0000fd05, 33 }, /* 3270_BackTab */
+    { 0x0000fd19, 46 }, /* 3270_ChangeScreen */
+    { 0x0000fd15, 64 }, /* 3270_Copy */
+    { 0x0000fd0f, 74 }, /* 3270_CursorBlink */
+    { 0x0000fd1c, 91 }, /* 3270_CursorSelect */
+    { 0x0000fd1a, 109 }, /* 3270_DeleteWord */
+    { 0x0000fd01, 125 }, /* 3270_Duplicate */
+    { 0x0000fd1e, 140 }, /* 3270_Enter */
+    { 0x0000fd06, 151 }, /* 3270_EraseEOF */
+    { 0x0000fd07, 165 }, /* 3270_EraseInput */
+    { 0x0000fd1b, 181 }, /* 3270_ExSelect */
+    { 0x0000fd02, 195 }, /* 3270_FieldMark */
+    { 0x0000fd13, 210 }, /* 3270_Ident */
+    { 0x0000fd12, 221 }, /* 3270_Jump */
+    { 0x0000fd11, 231 }, /* 3270_KeyClick */
+    { 0x0000fd04, 245 }, /* 3270_Left2 */
+    { 0x0000fd0a, 256 }, /* 3270_PA1 */
+    { 0x0000fd0b, 265 }, /* 3270_PA2 */
+    { 0x0000fd0c, 274 }, /* 3270_PA3 */
+    { 0x0000fd16, 283 }, /* 3270_Play */
+    { 0x0000fd1d, 293 }, /* 3270_PrintScreen */
+    { 0x0000fd09, 310 }, /* 3270_Quit */
+    { 0x0000fd18, 320 }, /* 3270_Record */
+    { 0x0000fd08, 332 }, /* 3270_Reset */
+    { 0x0000fd03, 343 }, /* 3270_Right2 */
+    { 0x0000fd14, 355 }, /* 3270_Rule */
+    { 0x0000fd17, 365 }, /* 3270_Setup */
+    { 0x0000fd0d, 376 }, /* 3270_Test */
+    { 0x00000034, 386 }, /* 4 */
+    { 0x00000035, 388 }, /* 5 */
+    { 0x00000036, 390 }, /* 6 */
+    { 0x00000037, 392 }, /* 7 */
+    { 0x00000038, 394 }, /* 8 */
+    { 0x00000039, 396 }, /* 9 */
+    { 0x00000041, 398 }, /* A */
+    { 0x00000061, 400 }, /* a */
+    { 0x000000c1, 402 }, /* Aacute */
+    { 0x000000e1, 409 }, /* aacute */
+    { 0x01001ea0, 416 }, /* Abelowdot */
+    { 0x01001ea1, 426 }, /* abelowdot */
+    { 0x000001ff, 436 }, /* abovedot */
+    { 0x000001c3, 445 }, /* Abreve */
+    { 0x000001e3, 452 }, /* abreve */
+    { 0x01001eae, 459 }, /* Abreveacute */
+    { 0x01001eaf, 471 }, /* abreveacute */
+    { 0x01001eb6, 483 }, /* Abrevebelowdot */
+    { 0x01001eb7, 498 }, /* abrevebelowdot */
+    { 0x01001eb0, 513 }, /* Abrevegrave */
+    { 0x01001eb1, 525 }, /* abrevegrave */
+    { 0x01001eb2, 537 }, /* Abrevehook */
+    { 0x01001eb3, 548 }, /* abrevehook */
+    { 0x01001eb4, 559 }, /* Abrevetilde */
+    { 0x01001eb5, 571 }, /* abrevetilde */
+    { 0x0000fe70, 583 }, /* AccessX_Enable */
+    { 0x0000fe71, 598 }, /* AccessX_Feedback_Enable */
+    { 0x000000c2, 622 }, /* Acircumflex */
+    { 0x000000e2, 634 }, /* acircumflex */
+    { 0x01001ea4, 646 }, /* Acircumflexacute */
+    { 0x01001ea5, 663 }, /* acircumflexacute */
+    { 0x01001eac, 680 }, /* Acircumflexbelowdot */
+    { 0x01001ead, 700 }, /* acircumflexbelowdot */
+    { 0x01001ea6, 720 }, /* Acircumflexgrave */
+    { 0x01001ea7, 737 }, /* acircumflexgrave */
+    { 0x01001ea8, 754 }, /* Acircumflexhook */
+    { 0x01001ea9, 770 }, /* acircumflexhook */
+    { 0x01001eaa, 786 }, /* Acircumflextilde */
+    { 0x01001eab, 803 }, /* acircumflextilde */
+    { 0x000000b4, 820 }, /* acute */
+    { 0x000000c4, 826 }, /* Adiaeresis */
+    { 0x000000e4, 837 }, /* adiaeresis */
+    { 0x000000c6, 848 }, /* AE */
+    { 0x000000e6, 851 }, /* ae */
+    { 0x000000c0, 854 }, /* Agrave */
+    { 0x000000e0, 861 }, /* agrave */
+    { 0x01001ea2, 868 }, /* Ahook */
+    { 0x01001ea3, 874 }, /* ahook */
+    { 0x0000ffe9, 880 }, /* Alt_L */
+    { 0x0000ffea, 886 }, /* Alt_R */
+    { 0x000003c0, 892 }, /* Amacron */
+    { 0x000003e0, 900 }, /* amacron */
+    { 0x00000026, 908 }, /* ampersand */
+    { 0x000001a1, 918 }, /* Aogonek */
+    { 0x000001b1, 926 }, /* aogonek */
+    { 0x00000027, 934 }, /* apostrophe */
+    { 0x01002248, 945 }, /* approxeq */
+    { 0x000008c8, 954 }, /* approximate */
+    { 0x01000660, 966 }, /* Arabic_0 */
+    { 0x01000661, 975 }, /* Arabic_1 */
+    { 0x01000662, 984 }, /* Arabic_2 */
+    { 0x01000663, 993 }, /* Arabic_3 */
+    { 0x01000664, 1002 }, /* Arabic_4 */
+    { 0x01000665, 1011 }, /* Arabic_5 */
+    { 0x01000666, 1020 }, /* Arabic_6 */
+    { 0x01000667, 1029 }, /* Arabic_7 */
+    { 0x01000668, 1038 }, /* Arabic_8 */
+    { 0x01000669, 1047 }, /* Arabic_9 */
+    { 0x000005d9, 1056 }, /* Arabic_ain */
+    { 0x000005c7, 1067 }, /* Arabic_alef */
+    { 0x000005e9, 1079 }, /* Arabic_alefmaksura */
+    { 0x000005c8, 1098 }, /* Arabic_beh */
+    { 0x000005ac, 1109 }, /* Arabic_comma */
+    { 0x000005d6, 1122 }, /* Arabic_dad */
+    { 0x000005cf, 1133 }, /* Arabic_dal */
+    { 0x000005ef, 1144 }, /* Arabic_damma */
+    { 0x000005ec, 1157 }, /* Arabic_dammatan */
+    { 0x01000688, 1173 }, /* Arabic_ddal */
+    { 0x010006cc, 1185 }, /* Arabic_farsi_yeh */
+    { 0x000005ee, 1202 }, /* Arabic_fatha */
+    { 0x000005eb, 1215 }, /* Arabic_fathatan */
+    { 0x000005e1, 1231 }, /* Arabic_feh */
+    { 0x010006d4, 1242 }, /* Arabic_fullstop */
+    { 0x010006af, 1258 }, /* Arabic_gaf */
+    { 0x000005da, 1269 }, /* Arabic_ghain */
+    { 0x000005e7, 1282 }, /* Arabic_ha */
+    { 0x000005cd, 1292 }, /* Arabic_hah */
+    { 0x000005c1, 1303 }, /* Arabic_hamza */
+    { 0x01000654, 1316 }, /* Arabic_hamza_above */
+    { 0x01000655, 1335 }, /* Arabic_hamza_below */
+    { 0x000005c3, 1354 }, /* Arabic_hamzaonalef */
+    { 0x000005c4, 1373 }, /* Arabic_hamzaonwaw */
+    { 0x000005c6, 1391 }, /* Arabic_hamzaonyeh */
+    { 0x000005c5, 1409 }, /* Arabic_hamzaunderalef */
+    { 0x000005e7, 1431 }, /* Arabic_heh */
+    { 0x010006be, 1442 }, /* Arabic_heh_doachashmee */
+    { 0x010006c1, 1465 }, /* Arabic_heh_goal */
+    { 0x000005cc, 1481 }, /* Arabic_jeem */
+    { 0x01000698, 1493 }, /* Arabic_jeh */
+    { 0x000005e3, 1504 }, /* Arabic_kaf */
+    { 0x000005f0, 1515 }, /* Arabic_kasra */
+    { 0x000005ed, 1528 }, /* Arabic_kasratan */
+    { 0x010006a9, 1544 }, /* Arabic_keheh */
+    { 0x000005ce, 1557 }, /* Arabic_khah */
+    { 0x000005e4, 1569 }, /* Arabic_lam */
+    { 0x01000653, 1580 }, /* Arabic_madda_above */
+    { 0x000005c2, 1599 }, /* Arabic_maddaonalef */
+    { 0x000005e5, 1618 }, /* Arabic_meem */
+    { 0x000005e6, 1630 }, /* Arabic_noon */
+    { 0x010006ba, 1642 }, /* Arabic_noon_ghunna */
+    { 0x0100067e, 1661 }, /* Arabic_peh */
+    { 0x0100066a, 1672 }, /* Arabic_percent */
+    { 0x000005e2, 1687 }, /* Arabic_qaf */
+    { 0x000005bf, 1698 }, /* Arabic_question_mark */
+    { 0x000005d1, 1719 }, /* Arabic_ra */
+    { 0x01000691, 1729 }, /* Arabic_rreh */
+    { 0x000005d5, 1741 }, /* Arabic_sad */
+    { 0x000005d3, 1752 }, /* Arabic_seen */
+    { 0x000005bb, 1764 }, /* Arabic_semicolon */
+    { 0x000005f1, 1781 }, /* Arabic_shadda */
+    { 0x000005d4, 1795 }, /* Arabic_sheen */
+    { 0x000005f2, 1808 }, /* Arabic_sukun */
+    { 0x01000670, 1821 }, /* Arabic_superscript_alef */
+    { 0x0000ff7e, 1845 }, /* Arabic_switch */
+    { 0x000005d7, 1859 }, /* Arabic_tah */
+    { 0x000005e0, 1870 }, /* Arabic_tatweel */
+    { 0x01000686, 1885 }, /* Arabic_tcheh */
+    { 0x000005ca, 1898 }, /* Arabic_teh */
+    { 0x000005c9, 1909 }, /* Arabic_tehmarbuta */
+    { 0x000005d0, 1927 }, /* Arabic_thal */
+    { 0x000005cb, 1939 }, /* Arabic_theh */
+    { 0x01000679, 1951 }, /* Arabic_tteh */
+    { 0x010006a4, 1963 }, /* Arabic_veh */
+    { 0x000005e8, 1974 }, /* Arabic_waw */
+    { 0x000005ea, 1985 }, /* Arabic_yeh */
+    { 0x010006d2, 1996 }, /* Arabic_yeh_baree */
+    { 0x000005d8, 2013 }, /* Arabic_zah */
+    { 0x000005d2, 2024 }, /* Arabic_zain */
+    { 0x000000c5, 2036 }, /* Aring */
+    { 0x000000e5, 2042 }, /* aring */
+    { 0x0100055b, 2048 }, /* Armenian_accent */
+    { 0x0100055c, 2064 }, /* Armenian_amanak */
+    { 0x0100055a, 2080 }, /* Armenian_apostrophe */
+    { 0x01000538, 2100 }, /* Armenian_AT */
+    { 0x01000568, 2112 }, /* Armenian_at */
+    { 0x01000531, 2124 }, /* Armenian_AYB */
+    { 0x01000561, 2137 }, /* Armenian_ayb */
+    { 0x01000532, 2150 }, /* Armenian_BEN */
+    { 0x01000562, 2163 }, /* Armenian_ben */
+    { 0x0100055d, 2176 }, /* Armenian_but */
+    { 0x01000549, 2189 }, /* Armenian_CHA */
+    { 0x01000579, 2202 }, /* Armenian_cha */
+    { 0x01000534, 2215 }, /* Armenian_DA */
+    { 0x01000564, 2227 }, /* Armenian_da */
+    { 0x01000541, 2239 }, /* Armenian_DZA */
+    { 0x01000571, 2252 }, /* Armenian_dza */
+    { 0x01000537, 2265 }, /* Armenian_E */
+    { 0x01000567, 2276 }, /* Armenian_e */
+    { 0x0100055c, 2287 }, /* Armenian_exclam */
+    { 0x01000556, 2303 }, /* Armenian_FE */
+    { 0x01000586, 2315 }, /* Armenian_fe */
+    { 0x01000589, 2327 }, /* Armenian_full_stop */
+    { 0x01000542, 2346 }, /* Armenian_GHAT */
+    { 0x01000572, 2360 }, /* Armenian_ghat */
+    { 0x01000533, 2374 }, /* Armenian_GIM */
+    { 0x01000563, 2387 }, /* Armenian_gim */
+    { 0x01000545, 2400 }, /* Armenian_HI */
+    { 0x01000575, 2412 }, /* Armenian_hi */
+    { 0x01000540, 2424 }, /* Armenian_HO */
+    { 0x01000570, 2436 }, /* Armenian_ho */
+    { 0x0100058a, 2448 }, /* Armenian_hyphen */
+    { 0x0100053b, 2464 }, /* Armenian_INI */
+    { 0x0100056b, 2477 }, /* Armenian_ini */
+    { 0x0100054b, 2490 }, /* Armenian_JE */
+    { 0x0100057b, 2502 }, /* Armenian_je */
+    { 0x01000554, 2514 }, /* Armenian_KE */
+    { 0x01000584, 2526 }, /* Armenian_ke */
+    { 0x0100053f, 2538 }, /* Armenian_KEN */
+    { 0x0100056f, 2551 }, /* Armenian_ken */
+    { 0x0100053d, 2564 }, /* Armenian_KHE */
+    { 0x0100056d, 2577 }, /* Armenian_khe */
+    { 0x01000587, 2590 }, /* Armenian_ligature_ew */
+    { 0x0100053c, 2611 }, /* Armenian_LYUN */
+    { 0x0100056c, 2625 }, /* Armenian_lyun */
+    { 0x01000544, 2639 }, /* Armenian_MEN */
+    { 0x01000574, 2652 }, /* Armenian_men */
+    { 0x01000546, 2665 }, /* Armenian_NU */
+    { 0x01000576, 2677 }, /* Armenian_nu */
+    { 0x01000555, 2689 }, /* Armenian_O */
+    { 0x01000585, 2700 }, /* Armenian_o */
+    { 0x0100055e, 2711 }, /* Armenian_paruyk */
+    { 0x0100054a, 2727 }, /* Armenian_PE */
+    { 0x0100057a, 2739 }, /* Armenian_pe */
+    { 0x01000553, 2751 }, /* Armenian_PYUR */
+    { 0x01000583, 2765 }, /* Armenian_pyur */
+    { 0x0100055e, 2779 }, /* Armenian_question */
+    { 0x0100054c, 2797 }, /* Armenian_RA */
+    { 0x0100057c, 2809 }, /* Armenian_ra */
+    { 0x01000550, 2821 }, /* Armenian_RE */
+    { 0x01000580, 2833 }, /* Armenian_re */
+    { 0x0100054d, 2845 }, /* Armenian_SE */
+    { 0x0100057d, 2857 }, /* Armenian_se */
+    { 0x0100055d, 2869 }, /* Armenian_separation_mark */
+    { 0x01000547, 2894 }, /* Armenian_SHA */
+    { 0x01000577, 2907 }, /* Armenian_sha */
+    { 0x0100055b, 2920 }, /* Armenian_shesht */
+    { 0x01000543, 2936 }, /* Armenian_TCHE */
+    { 0x01000573, 2950 }, /* Armenian_tche */
+    { 0x01000539, 2964 }, /* Armenian_TO */
+    { 0x01000569, 2976 }, /* Armenian_to */
+    { 0x0100053e, 2988 }, /* Armenian_TSA */
+    { 0x0100056e, 3001 }, /* Armenian_tsa */
+    { 0x01000551, 3014 }, /* Armenian_TSO */
+    { 0x01000581, 3027 }, /* Armenian_tso */
+    { 0x0100054f, 3040 }, /* Armenian_TYUN */
+    { 0x0100057f, 3054 }, /* Armenian_tyun */
+    { 0x01000589, 3068 }, /* Armenian_verjaket */
+    { 0x0100054e, 3086 }, /* Armenian_VEV */
+    { 0x0100057e, 3099 }, /* Armenian_vev */
+    { 0x01000548, 3112 }, /* Armenian_VO */
+    { 0x01000578, 3124 }, /* Armenian_vo */
+    { 0x01000552, 3136 }, /* Armenian_VYUN */
+    { 0x01000582, 3150 }, /* Armenian_vyun */
+    { 0x01000535, 3164 }, /* Armenian_YECH */
+    { 0x01000565, 3178 }, /* Armenian_yech */
+    { 0x0100058a, 3192 }, /* Armenian_yentamna */
+    { 0x01000536, 3210 }, /* Armenian_ZA */
+    { 0x01000566, 3222 }, /* Armenian_za */
+    { 0x0100053a, 3234 }, /* Armenian_ZHE */
+    { 0x0100056a, 3247 }, /* Armenian_zhe */
+    { 0x0000005e, 3260 }, /* asciicircum */
+    { 0x0000007e, 3272 }, /* asciitilde */
+    { 0x0000002a, 3283 }, /* asterisk */
+    { 0x00000040, 3292 }, /* at */
+    { 0x000000c3, 3295 }, /* Atilde */
+    { 0x000000e3, 3302 }, /* atilde */
+    { 0x0000fe7a, 3309 }, /* AudibleBell_Enable */
+    { 0x00000042, 3328 }, /* B */
+    { 0x00000062, 3330 }, /* b */
+    { 0x01001e02, 3332 }, /* Babovedot */
+    { 0x01001e03, 3342 }, /* babovedot */
+    { 0x0000005c, 3352 }, /* backslash */
+    { 0x0000ff08, 3362 }, /* BackSpace */
+    { 0x1000ff74, 3372 }, /* BackTab */
+    { 0x00000af4, 3380 }, /* ballotcross */
+    { 0x0000007c, 3392 }, /* bar */
+    { 0x01002235, 3396 }, /* because */
+    { 0x0000ff58, 3404 }, /* Begin */
+    { 0x000009df, 3410 }, /* blank */
+    { 0x100000fc, 3416 }, /* block */
+    { 0x000008a5, 3422 }, /* botintegral */
+    { 0x000008ac, 3434 }, /* botleftparens */
+    { 0x000008a8, 3448 }, /* botleftsqbracket */
+    { 0x000008b2, 3465 }, /* botleftsummation */
+    { 0x000008ae, 3482 }, /* botrightparens */
+    { 0x000008aa, 3497 }, /* botrightsqbracket */
+    { 0x000008b6, 3515 }, /* botrightsummation */
+    { 0x000009f6, 3533 }, /* bott */
+    { 0x000008b4, 3538 }, /* botvertsummationconnector */
+    { 0x0000fe74, 3564 }, /* BounceKeys_Enable */
+    { 0x0000007b, 3582 }, /* braceleft */
+    { 0x0000007d, 3592 }, /* braceright */
+    { 0x0000005b, 3603 }, /* bracketleft */
+    { 0x0000005d, 3615 }, /* bracketright */
+    { 0x01002800, 3628 }, /* braille_blank */
+    { 0x0000fff1, 3642 }, /* braille_dot_1 */
+    { 0x0000fffa, 3656 }, /* braille_dot_10 */
+    { 0x0000fff2, 3671 }, /* braille_dot_2 */
+    { 0x0000fff3, 3685 }, /* braille_dot_3 */
+    { 0x0000fff4, 3699 }, /* braille_dot_4 */
+    { 0x0000fff5, 3713 }, /* braille_dot_5 */
+    { 0x0000fff6, 3727 }, /* braille_dot_6 */
+    { 0x0000fff7, 3741 }, /* braille_dot_7 */
+    { 0x0000fff8, 3755 }, /* braille_dot_8 */
+    { 0x0000fff9, 3769 }, /* braille_dot_9 */
+    { 0x01002801, 3783 }, /* braille_dots_1 */
+    { 0x01002803, 3798 }, /* braille_dots_12 */
+    { 0x01002807, 3814 }, /* braille_dots_123 */
+    { 0x0100280f, 3831 }, /* braille_dots_1234 */
+    { 0x0100281f, 3849 }, /* braille_dots_12345 */
+    { 0x0100283f, 3868 }, /* braille_dots_123456 */
+    { 0x0100287f, 3888 }, /* braille_dots_1234567 */
+    { 0x010028ff, 3909 }, /* braille_dots_12345678 */
+    { 0x010028bf, 3931 }, /* braille_dots_1234568 */
+    { 0x0100285f, 3952 }, /* braille_dots_123457 */
+    { 0x010028df, 3972 }, /* braille_dots_1234578 */
+    { 0x0100289f, 3993 }, /* braille_dots_123458 */
+    { 0x0100282f, 4013 }, /* braille_dots_12346 */
+    { 0x0100286f, 4032 }, /* braille_dots_123467 */
+    { 0x010028ef, 4052 }, /* braille_dots_1234678 */
+    { 0x010028af, 4073 }, /* braille_dots_123468 */
+    { 0x0100284f, 4093 }, /* braille_dots_12347 */
+    { 0x010028cf, 4112 }, /* braille_dots_123478 */
+    { 0x0100288f, 4132 }, /* braille_dots_12348 */
+    { 0x01002817, 4151 }, /* braille_dots_1235 */
+    { 0x01002837, 4169 }, /* braille_dots_12356 */
+    { 0x01002877, 4188 }, /* braille_dots_123567 */
+    { 0x010028f7, 4208 }, /* braille_dots_1235678 */
+    { 0x010028b7, 4229 }, /* braille_dots_123568 */
+    { 0x01002857, 4249 }, /* braille_dots_12357 */
+    { 0x010028d7, 4268 }, /* braille_dots_123578 */
+    { 0x01002897, 4288 }, /* braille_dots_12358 */
+    { 0x01002827, 4307 }, /* braille_dots_1236 */
+    { 0x01002867, 4325 }, /* braille_dots_12367 */
+    { 0x010028e7, 4344 }, /* braille_dots_123678 */
+    { 0x010028a7, 4364 }, /* braille_dots_12368 */
+    { 0x01002847, 4383 }, /* braille_dots_1237 */
+    { 0x010028c7, 4401 }, /* braille_dots_12378 */
+    { 0x01002887, 4420 }, /* braille_dots_1238 */
+    { 0x0100280b, 4438 }, /* braille_dots_124 */
+    { 0x0100281b, 4455 }, /* braille_dots_1245 */
+    { 0x0100283b, 4473 }, /* braille_dots_12456 */
+    { 0x0100287b, 4492 }, /* braille_dots_124567 */
+    { 0x010028fb, 4512 }, /* braille_dots_1245678 */
+    { 0x010028bb, 4533 }, /* braille_dots_124568 */
+    { 0x0100285b, 4553 }, /* braille_dots_12457 */
+    { 0x010028db, 4572 }, /* braille_dots_124578 */
+    { 0x0100289b, 4592 }, /* braille_dots_12458 */
+    { 0x0100282b, 4611 }, /* braille_dots_1246 */
+    { 0x0100286b, 4629 }, /* braille_dots_12467 */
+    { 0x010028eb, 4648 }, /* braille_dots_124678 */
+    { 0x010028ab, 4668 }, /* braille_dots_12468 */
+    { 0x0100284b, 4687 }, /* braille_dots_1247 */
+    { 0x010028cb, 4705 }, /* braille_dots_12478 */
+    { 0x0100288b, 4724 }, /* braille_dots_1248 */
+    { 0x01002813, 4742 }, /* braille_dots_125 */
+    { 0x01002833, 4759 }, /* braille_dots_1256 */
+    { 0x01002873, 4777 }, /* braille_dots_12567 */
+    { 0x010028f3, 4796 }, /* braille_dots_125678 */
+    { 0x010028b3, 4816 }, /* braille_dots_12568 */
+    { 0x01002853, 4835 }, /* braille_dots_1257 */
+    { 0x010028d3, 4853 }, /* braille_dots_12578 */
+    { 0x01002893, 4872 }, /* braille_dots_1258 */
+    { 0x01002823, 4890 }, /* braille_dots_126 */
+    { 0x01002863, 4907 }, /* braille_dots_1267 */
+    { 0x010028e3, 4925 }, /* braille_dots_12678 */
+    { 0x010028a3, 4944 }, /* braille_dots_1268 */
+    { 0x01002843, 4962 }, /* braille_dots_127 */
+    { 0x010028c3, 4979 }, /* braille_dots_1278 */
+    { 0x01002883, 4997 }, /* braille_dots_128 */
+    { 0x01002805, 5014 }, /* braille_dots_13 */
+    { 0x0100280d, 5030 }, /* braille_dots_134 */
+    { 0x0100281d, 5047 }, /* braille_dots_1345 */
+    { 0x0100283d, 5065 }, /* braille_dots_13456 */
+    { 0x0100287d, 5084 }, /* braille_dots_134567 */
+    { 0x010028fd, 5104 }, /* braille_dots_1345678 */
+    { 0x010028bd, 5125 }, /* braille_dots_134568 */
+    { 0x0100285d, 5145 }, /* braille_dots_13457 */
+    { 0x010028dd, 5164 }, /* braille_dots_134578 */
+    { 0x0100289d, 5184 }, /* braille_dots_13458 */
+    { 0x0100282d, 5203 }, /* braille_dots_1346 */
+    { 0x0100286d, 5221 }, /* braille_dots_13467 */
+    { 0x010028ed, 5240 }, /* braille_dots_134678 */
+    { 0x010028ad, 5260 }, /* braille_dots_13468 */
+    { 0x0100284d, 5279 }, /* braille_dots_1347 */
+    { 0x010028cd, 5297 }, /* braille_dots_13478 */
+    { 0x0100288d, 5316 }, /* braille_dots_1348 */
+    { 0x01002815, 5334 }, /* braille_dots_135 */
+    { 0x01002835, 5351 }, /* braille_dots_1356 */
+    { 0x01002875, 5369 }, /* braille_dots_13567 */
+    { 0x010028f5, 5388 }, /* braille_dots_135678 */
+    { 0x010028b5, 5408 }, /* braille_dots_13568 */
+    { 0x01002855, 5427 }, /* braille_dots_1357 */
+    { 0x010028d5, 5445 }, /* braille_dots_13578 */
+    { 0x01002895, 5464 }, /* braille_dots_1358 */
+    { 0x01002825, 5482 }, /* braille_dots_136 */
+    { 0x01002865, 5499 }, /* braille_dots_1367 */
+    { 0x010028e5, 5517 }, /* braille_dots_13678 */
+    { 0x010028a5, 5536 }, /* braille_dots_1368 */
+    { 0x01002845, 5554 }, /* braille_dots_137 */
+    { 0x010028c5, 5571 }, /* braille_dots_1378 */
+    { 0x01002885, 5589 }, /* braille_dots_138 */
+    { 0x01002809, 5606 }, /* braille_dots_14 */
+    { 0x01002819, 5622 }, /* braille_dots_145 */
+    { 0x01002839, 5639 }, /* braille_dots_1456 */
+    { 0x01002879, 5657 }, /* braille_dots_14567 */
+    { 0x010028f9, 5676 }, /* braille_dots_145678 */
+    { 0x010028b9, 5696 }, /* braille_dots_14568 */
+    { 0x01002859, 5715 }, /* braille_dots_1457 */
+    { 0x010028d9, 5733 }, /* braille_dots_14578 */
+    { 0x01002899, 5752 }, /* braille_dots_1458 */
+    { 0x01002829, 5770 }, /* braille_dots_146 */
+    { 0x01002869, 5787 }, /* braille_dots_1467 */
+    { 0x010028e9, 5805 }, /* braille_dots_14678 */
+    { 0x010028a9, 5824 }, /* braille_dots_1468 */
+    { 0x01002849, 5842 }, /* braille_dots_147 */
+    { 0x010028c9, 5859 }, /* braille_dots_1478 */
+    { 0x01002889, 5877 }, /* braille_dots_148 */
+    { 0x01002811, 5894 }, /* braille_dots_15 */
+    { 0x01002831, 5910 }, /* braille_dots_156 */
+    { 0x01002871, 5927 }, /* braille_dots_1567 */
+    { 0x010028f1, 5945 }, /* braille_dots_15678 */
+    { 0x010028b1, 5964 }, /* braille_dots_1568 */
+    { 0x01002851, 5982 }, /* braille_dots_157 */
+    { 0x010028d1, 5999 }, /* braille_dots_1578 */
+    { 0x01002891, 6017 }, /* braille_dots_158 */
+    { 0x01002821, 6034 }, /* braille_dots_16 */
+    { 0x01002861, 6050 }, /* braille_dots_167 */
+    { 0x010028e1, 6067 }, /* braille_dots_1678 */
+    { 0x010028a1, 6085 }, /* braille_dots_168 */
+    { 0x01002841, 6102 }, /* braille_dots_17 */
+    { 0x010028c1, 6118 }, /* braille_dots_178 */
+    { 0x01002881, 6135 }, /* braille_dots_18 */
+    { 0x01002802, 6151 }, /* braille_dots_2 */
+    { 0x01002806, 6166 }, /* braille_dots_23 */
+    { 0x0100280e, 6182 }, /* braille_dots_234 */
+    { 0x0100281e, 6199 }, /* braille_dots_2345 */
+    { 0x0100283e, 6217 }, /* braille_dots_23456 */
+    { 0x0100287e, 6236 }, /* braille_dots_234567 */
+    { 0x010028fe, 6256 }, /* braille_dots_2345678 */
+    { 0x010028be, 6277 }, /* braille_dots_234568 */
+    { 0x0100285e, 6297 }, /* braille_dots_23457 */
+    { 0x010028de, 6316 }, /* braille_dots_234578 */
+    { 0x0100289e, 6336 }, /* braille_dots_23458 */
+    { 0x0100282e, 6355 }, /* braille_dots_2346 */
+    { 0x0100286e, 6373 }, /* braille_dots_23467 */
+    { 0x010028ee, 6392 }, /* braille_dots_234678 */
+    { 0x010028ae, 6412 }, /* braille_dots_23468 */
+    { 0x0100284e, 6431 }, /* braille_dots_2347 */
+    { 0x010028ce, 6449 }, /* braille_dots_23478 */
+    { 0x0100288e, 6468 }, /* braille_dots_2348 */
+    { 0x01002816, 6486 }, /* braille_dots_235 */
+    { 0x01002836, 6503 }, /* braille_dots_2356 */
+    { 0x01002876, 6521 }, /* braille_dots_23567 */
+    { 0x010028f6, 6540 }, /* braille_dots_235678 */
+    { 0x010028b6, 6560 }, /* braille_dots_23568 */
+    { 0x01002856, 6579 }, /* braille_dots_2357 */
+    { 0x010028d6, 6597 }, /* braille_dots_23578 */
+    { 0x01002896, 6616 }, /* braille_dots_2358 */
+    { 0x01002826, 6634 }, /* braille_dots_236 */
+    { 0x01002866, 6651 }, /* braille_dots_2367 */
+    { 0x010028e6, 6669 }, /* braille_dots_23678 */
+    { 0x010028a6, 6688 }, /* braille_dots_2368 */
+    { 0x01002846, 6706 }, /* braille_dots_237 */
+    { 0x010028c6, 6723 }, /* braille_dots_2378 */
+    { 0x01002886, 6741 }, /* braille_dots_238 */
+    { 0x0100280a, 6758 }, /* braille_dots_24 */
+    { 0x0100281a, 6774 }, /* braille_dots_245 */
+    { 0x0100283a, 6791 }, /* braille_dots_2456 */
+    { 0x0100287a, 6809 }, /* braille_dots_24567 */
+    { 0x010028fa, 6828 }, /* braille_dots_245678 */
+    { 0x010028ba, 6848 }, /* braille_dots_24568 */
+    { 0x0100285a, 6867 }, /* braille_dots_2457 */
+    { 0x010028da, 6885 }, /* braille_dots_24578 */
+    { 0x0100289a, 6904 }, /* braille_dots_2458 */
+    { 0x0100282a, 6922 }, /* braille_dots_246 */
+    { 0x0100286a, 6939 }, /* braille_dots_2467 */
+    { 0x010028ea, 6957 }, /* braille_dots_24678 */
+    { 0x010028aa, 6976 }, /* braille_dots_2468 */
+    { 0x0100284a, 6994 }, /* braille_dots_247 */
+    { 0x010028ca, 7011 }, /* braille_dots_2478 */
+    { 0x0100288a, 7029 }, /* braille_dots_248 */
+    { 0x01002812, 7046 }, /* braille_dots_25 */
+    { 0x01002832, 7062 }, /* braille_dots_256 */
+    { 0x01002872, 7079 }, /* braille_dots_2567 */
+    { 0x010028f2, 7097 }, /* braille_dots_25678 */
+    { 0x010028b2, 7116 }, /* braille_dots_2568 */
+    { 0x01002852, 7134 }, /* braille_dots_257 */
+    { 0x010028d2, 7151 }, /* braille_dots_2578 */
+    { 0x01002892, 7169 }, /* braille_dots_258 */
+    { 0x01002822, 7186 }, /* braille_dots_26 */
+    { 0x01002862, 7202 }, /* braille_dots_267 */
+    { 0x010028e2, 7219 }, /* braille_dots_2678 */
+    { 0x010028a2, 7237 }, /* braille_dots_268 */
+    { 0x01002842, 7254 }, /* braille_dots_27 */
+    { 0x010028c2, 7270 }, /* braille_dots_278 */
+    { 0x01002882, 7287 }, /* braille_dots_28 */
+    { 0x01002804, 7303 }, /* braille_dots_3 */
+    { 0x0100280c, 7318 }, /* braille_dots_34 */
+    { 0x0100281c, 7334 }, /* braille_dots_345 */
+    { 0x0100283c, 7351 }, /* braille_dots_3456 */
+    { 0x0100287c, 7369 }, /* braille_dots_34567 */
+    { 0x010028fc, 7388 }, /* braille_dots_345678 */
+    { 0x010028bc, 7408 }, /* braille_dots_34568 */
+    { 0x0100285c, 7427 }, /* braille_dots_3457 */
+    { 0x010028dc, 7445 }, /* braille_dots_34578 */
+    { 0x0100289c, 7464 }, /* braille_dots_3458 */
+    { 0x0100282c, 7482 }, /* braille_dots_346 */
+    { 0x0100286c, 7499 }, /* braille_dots_3467 */
+    { 0x010028ec, 7517 }, /* braille_dots_34678 */
+    { 0x010028ac, 7536 }, /* braille_dots_3468 */
+    { 0x0100284c, 7554 }, /* braille_dots_347 */
+    { 0x010028cc, 7571 }, /* braille_dots_3478 */
+    { 0x0100288c, 7589 }, /* braille_dots_348 */
+    { 0x01002814, 7606 }, /* braille_dots_35 */
+    { 0x01002834, 7622 }, /* braille_dots_356 */
+    { 0x01002874, 7639 }, /* braille_dots_3567 */
+    { 0x010028f4, 7657 }, /* braille_dots_35678 */
+    { 0x010028b4, 7676 }, /* braille_dots_3568 */
+    { 0x01002854, 7694 }, /* braille_dots_357 */
+    { 0x010028d4, 7711 }, /* braille_dots_3578 */
+    { 0x01002894, 7729 }, /* braille_dots_358 */
+    { 0x01002824, 7746 }, /* braille_dots_36 */
+    { 0x01002864, 7762 }, /* braille_dots_367 */
+    { 0x010028e4, 7779 }, /* braille_dots_3678 */
+    { 0x010028a4, 7797 }, /* braille_dots_368 */
+    { 0x01002844, 7814 }, /* braille_dots_37 */
+    { 0x010028c4, 7830 }, /* braille_dots_378 */
+    { 0x01002884, 7847 }, /* braille_dots_38 */
+    { 0x01002808, 7863 }, /* braille_dots_4 */
+    { 0x01002818, 7878 }, /* braille_dots_45 */
+    { 0x01002838, 7894 }, /* braille_dots_456 */
+    { 0x01002878, 7911 }, /* braille_dots_4567 */
+    { 0x010028f8, 7929 }, /* braille_dots_45678 */
+    { 0x010028b8, 7948 }, /* braille_dots_4568 */
+    { 0x01002858, 7966 }, /* braille_dots_457 */
+    { 0x010028d8, 7983 }, /* braille_dots_4578 */
+    { 0x01002898, 8001 }, /* braille_dots_458 */
+    { 0x01002828, 8018 }, /* braille_dots_46 */
+    { 0x01002868, 8034 }, /* braille_dots_467 */
+    { 0x010028e8, 8051 }, /* braille_dots_4678 */
+    { 0x010028a8, 8069 }, /* braille_dots_468 */
+    { 0x01002848, 8086 }, /* braille_dots_47 */
+    { 0x010028c8, 8102 }, /* braille_dots_478 */
+    { 0x01002888, 8119 }, /* braille_dots_48 */
+    { 0x01002810, 8135 }, /* braille_dots_5 */
+    { 0x01002830, 8150 }, /* braille_dots_56 */
+    { 0x01002870, 8166 }, /* braille_dots_567 */
+    { 0x010028f0, 8183 }, /* braille_dots_5678 */
+    { 0x010028b0, 8201 }, /* braille_dots_568 */
+    { 0x01002850, 8218 }, /* braille_dots_57 */
+    { 0x010028d0, 8234 }, /* braille_dots_578 */
+    { 0x01002890, 8251 }, /* braille_dots_58 */
+    { 0x01002820, 8267 }, /* braille_dots_6 */
+    { 0x01002860, 8282 }, /* braille_dots_67 */
+    { 0x010028e0, 8298 }, /* braille_dots_678 */
+    { 0x010028a0, 8315 }, /* braille_dots_68 */
+    { 0x01002840, 8331 }, /* braille_dots_7 */
+    { 0x010028c0, 8346 }, /* braille_dots_78 */
+    { 0x01002880, 8362 }, /* braille_dots_8 */
+    { 0x0000ff6b, 8377 }, /* Break */
+    { 0x000001a2, 8383 }, /* breve */
+    { 0x000000a6, 8389 }, /* brokenbar */
+    { 0x000006ae, 8399 }, /* Byelorussian_shortu */
+    { 0x000006be, 8419 }, /* Byelorussian_SHORTU */
+    { 0x00000043, 8439 }, /* C */
+    { 0x00000063, 8441 }, /* c */
+    { 0x0000fea3, 8443 }, /* c_h */
+    { 0x0000fea4, 8447 }, /* C_h */
+    { 0x0000fea5, 8451 }, /* C_H */
+    { 0x000002c5, 8455 }, /* Cabovedot */
+    { 0x000002e5, 8465 }, /* cabovedot */
+    { 0x000001c6, 8475 }, /* Cacute */
+    { 0x000001e6, 8482 }, /* cacute */
+    { 0x0000ff69, 8489 }, /* Cancel */
+    { 0x0000ffe5, 8496 }, /* Caps_Lock */
+    { 0x00000ab8, 8506 }, /* careof */
+    { 0x00000afc, 8513 }, /* caret */
+    { 0x000001b7, 8519 }, /* caron */
+    { 0x000001c8, 8525 }, /* Ccaron */
+    { 0x000001e8, 8532 }, /* ccaron */
+    { 0x000000c7, 8539 }, /* Ccedilla */
+    { 0x000000e7, 8548 }, /* ccedilla */
+    { 0x000002c6, 8557 }, /* Ccircumflex */
+    { 0x000002e6, 8569 }, /* ccircumflex */
+    { 0x000000b8, 8581 }, /* cedilla */
+    { 0x000000a2, 8589 }, /* cent */
+    { 0x0000fea0, 8594 }, /* ch */
+    { 0x0000fea1, 8597 }, /* Ch */
+    { 0x0000fea2, 8600 }, /* CH */
+    { 0x000009e1, 8603 }, /* checkerboard */
+    { 0x00000af3, 8616 }, /* checkmark */
+    { 0x00000bcf, 8626 }, /* circle */
+    { 0x0000ff0b, 8633 }, /* Clear */
+    { 0x1000ff6f, 8639 }, /* ClearLine */
+    { 0x00000aec, 8649 }, /* club */
+    { 0x0000ff37, 8654 }, /* Codeinput */
+    { 0x0000003a, 8664 }, /* colon */
+    { 0x010020a1, 8670 }, /* ColonSign */
+    { 0x0000002c, 8680 }, /* comma */
+    { 0x0100220b, 8686 }, /* containsas */
+    { 0x0000ffe3, 8697 }, /* Control_L */
+    { 0x0000ffe4, 8707 }, /* Control_R */
+    { 0x000000a9, 8717 }, /* copyright */
+    { 0x000009e4, 8727 }, /* cr */
+    { 0x000009ee, 8730 }, /* crossinglines */
+    { 0x010020a2, 8744 }, /* CruzeiroSign */
+    { 0x0100221b, 8757 }, /* cuberoot */
+    { 0x000000a4, 8766 }, /* currency */
+    { 0x00000aff, 8775 }, /* cursor */
+    { 0x000006c1, 8782 }, /* Cyrillic_a */
+    { 0x000006e1, 8793 }, /* Cyrillic_A */
+    { 0x000006c2, 8804 }, /* Cyrillic_be */
+    { 0x000006e2, 8816 }, /* Cyrillic_BE */
+    { 0x000006de, 8828 }, /* Cyrillic_che */
+    { 0x000006fe, 8841 }, /* Cyrillic_CHE */
+    { 0x010004b6, 8854 }, /* Cyrillic_CHE_descender */
+    { 0x010004b7, 8877 }, /* Cyrillic_che_descender */
+    { 0x010004b8, 8900 }, /* Cyrillic_CHE_vertstroke */
+    { 0x010004b9, 8924 }, /* Cyrillic_che_vertstroke */
+    { 0x000006c4, 8948 }, /* Cyrillic_de */
+    { 0x000006e4, 8960 }, /* Cyrillic_DE */
+    { 0x000006af, 8972 }, /* Cyrillic_dzhe */
+    { 0x000006bf, 8986 }, /* Cyrillic_DZHE */
+    { 0x000006dc, 9000 }, /* Cyrillic_e */
+    { 0x000006fc, 9011 }, /* Cyrillic_E */
+    { 0x000006c6, 9022 }, /* Cyrillic_ef */
+    { 0x000006e6, 9034 }, /* Cyrillic_EF */
+    { 0x000006cc, 9046 }, /* Cyrillic_el */
+    { 0x000006ec, 9058 }, /* Cyrillic_EL */
+    { 0x000006cd, 9070 }, /* Cyrillic_em */
+    { 0x000006ed, 9082 }, /* Cyrillic_EM */
+    { 0x000006ce, 9094 }, /* Cyrillic_en */
+    { 0x000006ee, 9106 }, /* Cyrillic_EN */
+    { 0x010004a2, 9118 }, /* Cyrillic_EN_descender */
+    { 0x010004a3, 9140 }, /* Cyrillic_en_descender */
+    { 0x000006d2, 9162 }, /* Cyrillic_er */
+    { 0x000006f2, 9174 }, /* Cyrillic_ER */
+    { 0x000006d3, 9186 }, /* Cyrillic_es */
+    { 0x000006f3, 9198 }, /* Cyrillic_ES */
+    { 0x000006c7, 9210 }, /* Cyrillic_ghe */
+    { 0x000006e7, 9223 }, /* Cyrillic_GHE */
+    { 0x01000492, 9236 }, /* Cyrillic_GHE_bar */
+    { 0x01000493, 9253 }, /* Cyrillic_ghe_bar */
+    { 0x000006c8, 9270 }, /* Cyrillic_ha */
+    { 0x000006e8, 9282 }, /* Cyrillic_HA */
+    { 0x010004b2, 9294 }, /* Cyrillic_HA_descender */
+    { 0x010004b3, 9316 }, /* Cyrillic_ha_descender */
+    { 0x000006df, 9338 }, /* Cyrillic_hardsign */
+    { 0x000006ff, 9356 }, /* Cyrillic_HARDSIGN */
+    { 0x000006c9, 9374 }, /* Cyrillic_i */
+    { 0x000006e9, 9385 }, /* Cyrillic_I */
+    { 0x010004e2, 9396 }, /* Cyrillic_I_macron */
+    { 0x010004e3, 9414 }, /* Cyrillic_i_macron */
+    { 0x000006c5, 9432 }, /* Cyrillic_ie */
+    { 0x000006e5, 9444 }, /* Cyrillic_IE */
+    { 0x000006a3, 9456 }, /* Cyrillic_io */
+    { 0x000006b3, 9468 }, /* Cyrillic_IO */
+    { 0x000006a8, 9480 }, /* Cyrillic_je */
+    { 0x000006b8, 9492 }, /* Cyrillic_JE */
+    { 0x000006cb, 9504 }, /* Cyrillic_ka */
+    { 0x000006eb, 9516 }, /* Cyrillic_KA */
+    { 0x0100049a, 9528 }, /* Cyrillic_KA_descender */
+    { 0x0100049b, 9550 }, /* Cyrillic_ka_descender */
+    { 0x0100049c, 9572 }, /* Cyrillic_KA_vertstroke */
+    { 0x0100049d, 9595 }, /* Cyrillic_ka_vertstroke */
+    { 0x000006a9, 9618 }, /* Cyrillic_lje */
+    { 0x000006b9, 9631 }, /* Cyrillic_LJE */
+    { 0x000006aa, 9644 }, /* Cyrillic_nje */
+    { 0x000006ba, 9657 }, /* Cyrillic_NJE */
+    { 0x000006cf, 9670 }, /* Cyrillic_o */
+    { 0x000006ef, 9681 }, /* Cyrillic_O */
+    { 0x010004e8, 9692 }, /* Cyrillic_O_bar */
+    { 0x010004e9, 9707 }, /* Cyrillic_o_bar */
+    { 0x000006d0, 9722 }, /* Cyrillic_pe */
+    { 0x000006f0, 9734 }, /* Cyrillic_PE */
+    { 0x010004d8, 9746 }, /* Cyrillic_SCHWA */
+    { 0x010004d9, 9761 }, /* Cyrillic_schwa */
+    { 0x000006db, 9776 }, /* Cyrillic_sha */
+    { 0x000006fb, 9789 }, /* Cyrillic_SHA */
+    { 0x000006dd, 9802 }, /* Cyrillic_shcha */
+    { 0x000006fd, 9817 }, /* Cyrillic_SHCHA */
+    { 0x010004ba, 9832 }, /* Cyrillic_SHHA */
+    { 0x010004bb, 9846 }, /* Cyrillic_shha */
+    { 0x000006ca, 9860 }, /* Cyrillic_shorti */
+    { 0x000006ea, 9876 }, /* Cyrillic_SHORTI */
+    { 0x000006d8, 9892 }, /* Cyrillic_softsign */
+    { 0x000006f8, 9910 }, /* Cyrillic_SOFTSIGN */
+    { 0x000006d4, 9928 }, /* Cyrillic_te */
+    { 0x000006f4, 9940 }, /* Cyrillic_TE */
+    { 0x000006c3, 9952 }, /* Cyrillic_tse */
+    { 0x000006e3, 9965 }, /* Cyrillic_TSE */
+    { 0x000006d5, 9978 }, /* Cyrillic_u */
+    { 0x000006f5, 9989 }, /* Cyrillic_U */
+    { 0x010004ee, 10000 }, /* Cyrillic_U_macron */
+    { 0x010004ef, 10018 }, /* Cyrillic_u_macron */
+    { 0x010004ae, 10036 }, /* Cyrillic_U_straight */
+    { 0x010004af, 10056 }, /* Cyrillic_u_straight */
+    { 0x010004b0, 10076 }, /* Cyrillic_U_straight_bar */
+    { 0x010004b1, 10100 }, /* Cyrillic_u_straight_bar */
+    { 0x000006d7, 10124 }, /* Cyrillic_ve */
+    { 0x000006f7, 10136 }, /* Cyrillic_VE */
+    { 0x000006d1, 10148 }, /* Cyrillic_ya */
+    { 0x000006f1, 10160 }, /* Cyrillic_YA */
+    { 0x000006d9, 10172 }, /* Cyrillic_yeru */
+    { 0x000006f9, 10186 }, /* Cyrillic_YERU */
+    { 0x000006c0, 10200 }, /* Cyrillic_yu */
+    { 0x000006e0, 10212 }, /* Cyrillic_YU */
+    { 0x000006da, 10224 }, /* Cyrillic_ze */
+    { 0x000006fa, 10236 }, /* Cyrillic_ZE */
+    { 0x000006d6, 10248 }, /* Cyrillic_zhe */
+    { 0x000006f6, 10261 }, /* Cyrillic_ZHE */
+    { 0x01000496, 10274 }, /* Cyrillic_ZHE_descender */
+    { 0x01000497, 10297 }, /* Cyrillic_zhe_descender */
+    { 0x00000044, 10320 }, /* D */
+    { 0x00000064, 10322 }, /* d */
+    { 0x01001e0a, 10324 }, /* Dabovedot */
+    { 0x01001e0b, 10334 }, /* dabovedot */
+    { 0x1000fe27, 10344 }, /* Dacute_accent */
+    { 0x00000af1, 10358 }, /* dagger */
+    { 0x000001cf, 10365 }, /* Dcaron */
+    { 0x000001ef, 10372 }, /* dcaron */
+    { 0x1000fe2c, 10379 }, /* Dcedilla_accent */
+    { 0x1000fe5e, 10395 }, /* Dcircumflex_accent */
+    { 0x1000fe22, 10414 }, /* Ddiaeresis */
+    { 0x0000fe80, 10425 }, /* dead_a */
+    { 0x0000fe81, 10432 }, /* dead_A */
+    { 0x0000fe64, 10439 }, /* dead_abovecomma */
+    { 0x0000fe56, 10455 }, /* dead_abovedot */
+    { 0x0000fe65, 10469 }, /* dead_abovereversedcomma */
+    { 0x0000fe58, 10493 }, /* dead_abovering */
+    { 0x0000fe91, 10508 }, /* dead_aboveverticalline */
+    { 0x0000fe51, 10531 }, /* dead_acute */
+    { 0x0000fe6b, 10542 }, /* dead_belowbreve */
+    { 0x0000fe69, 10558 }, /* dead_belowcircumflex */
+    { 0x0000fe6e, 10579 }, /* dead_belowcomma */
+    { 0x0000fe6c, 10595 }, /* dead_belowdiaeresis */
+    { 0x0000fe60, 10615 }, /* dead_belowdot */
+    { 0x0000fe68, 10629 }, /* dead_belowmacron */
+    { 0x0000fe67, 10646 }, /* dead_belowring */
+    { 0x0000fe6a, 10661 }, /* dead_belowtilde */
+    { 0x0000fe92, 10677 }, /* dead_belowverticalline */
+    { 0x0000fe55, 10700 }, /* dead_breve */
+    { 0x0000fe8b, 10711 }, /* dead_capital_schwa */
+    { 0x0000fe5a, 10730 }, /* dead_caron */
+    { 0x0000fe5b, 10741 }, /* dead_cedilla */
+    { 0x0000fe52, 10754 }, /* dead_circumflex */
+    { 0x0000fe6f, 10770 }, /* dead_currency */
+    { 0x0000fe65, 10784 }, /* dead_dasia */
+    { 0x0000fe57, 10795 }, /* dead_diaeresis */
+    { 0x0000fe59, 10810 }, /* dead_doubleacute */
+    { 0x0000fe66, 10827 }, /* dead_doublegrave */
+    { 0x0000fe82, 10844 }, /* dead_e */
+    { 0x0000fe83, 10851 }, /* dead_E */
+    { 0x0000fe50, 10858 }, /* dead_grave */
+    { 0x0000fe8c, 10869 }, /* dead_greek */
+    { 0x0000fe61, 10880 }, /* dead_hook */
+    { 0x0000fe62, 10890 }, /* dead_horn */
+    { 0x0000fe84, 10900 }, /* dead_i */
+    { 0x0000fe85, 10907 }, /* dead_I */
+    { 0x0000fe6d, 10914 }, /* dead_invertedbreve */
+    { 0x0000fe5d, 10933 }, /* dead_iota */
+    { 0x0000fe93, 10943 }, /* dead_longsolidusoverlay */
+    { 0x0000fe90, 10967 }, /* dead_lowline */
+    { 0x0000fe54, 10980 }, /* dead_macron */
+    { 0x0000fe86, 10992 }, /* dead_o */
+    { 0x0000fe87, 10999 }, /* dead_O */
+    { 0x0000fe5c, 11006 }, /* dead_ogonek */
+    { 0x0000fe53, 11018 }, /* dead_perispomeni */
+    { 0x0000fe64, 11035 }, /* dead_psili */
+    { 0x0000fe5f, 11046 }, /* dead_semivoiced_sound */
+    { 0x0000fe8a, 11068 }, /* dead_small_schwa */
+    { 0x0000fe63, 11085 }, /* dead_stroke */
+    { 0x0000fe53, 11097 }, /* dead_tilde */
+    { 0x0000fe88, 11108 }, /* dead_u */
+    { 0x0000fe89, 11115 }, /* dead_U */
+    { 0x0000fe5e, 11122 }, /* dead_voiced_sound */
+    { 0x00000abd, 11140 }, /* decimalpoint */
+    { 0x000000b0, 11153 }, /* degree */
+    { 0x0000ffff, 11160 }, /* Delete */
+    { 0x1000ff73, 11167 }, /* DeleteChar */
+    { 0x1000ff71, 11178 }, /* DeleteLine */
+    { 0x1000fe60, 11189 }, /* Dgrave_accent */
+    { 0x000000a8, 11203 }, /* diaeresis */
+    { 0x00000aed, 11213 }, /* diamond */
+    { 0x00000aa5, 11221 }, /* digitspace */
+    { 0x0100222c, 11232 }, /* dintegral */
+    { 0x000000f7, 11242 }, /* division */
+    { 0x00000024, 11251 }, /* dollar */
+    { 0x010020ab, 11258 }, /* DongSign */
+    { 0x00000aaf, 11267 }, /* doubbaselinedot */
+    { 0x000001bd, 11283 }, /* doubleacute */
+    { 0x00000af2, 11295 }, /* doubledagger */
+    { 0x00000afe, 11308 }, /* doublelowquotemark */
+    { 0x0000ff54, 11327 }, /* Down */
+    { 0x000008fe, 11332 }, /* downarrow */
+    { 0x00000ba8, 11342 }, /* downcaret */
+    { 0x00000bd6, 11352 }, /* downshoe */
+    { 0x00000bc4, 11361 }, /* downstile */
+    { 0x00000bc2, 11371 }, /* downtack */
+    { 0x1000ff00, 11380 }, /* DRemove */
+    { 0x1000feb0, 11388 }, /* Dring_accent */
+    { 0x000001d0, 11401 }, /* Dstroke */
+    { 0x000001f0, 11409 }, /* dstroke */
+    { 0x1000fe7e, 11417 }, /* Dtilde */
+    { 0x00000045, 11424 }, /* E */
+    { 0x00000065, 11426 }, /* e */
+    { 0x000003cc, 11428 }, /* Eabovedot */
+    { 0x000003ec, 11438 }, /* eabovedot */
+    { 0x000000c9, 11448 }, /* Eacute */
+    { 0x000000e9, 11455 }, /* eacute */
+    { 0x01001eb8, 11462 }, /* Ebelowdot */
+    { 0x01001eb9, 11472 }, /* ebelowdot */
+    { 0x000001cc, 11482 }, /* Ecaron */
+    { 0x000001ec, 11489 }, /* ecaron */
+    { 0x000000ca, 11496 }, /* Ecircumflex */
+    { 0x000000ea, 11508 }, /* ecircumflex */
+    { 0x01001ebe, 11520 }, /* Ecircumflexacute */
+    { 0x01001ebf, 11537 }, /* ecircumflexacute */
+    { 0x01001ec6, 11554 }, /* Ecircumflexbelowdot */
+    { 0x01001ec7, 11574 }, /* ecircumflexbelowdot */
+    { 0x01001ec0, 11594 }, /* Ecircumflexgrave */
+    { 0x01001ec1, 11611 }, /* ecircumflexgrave */
+    { 0x01001ec2, 11628 }, /* Ecircumflexhook */
+    { 0x01001ec3, 11644 }, /* ecircumflexhook */
+    { 0x01001ec4, 11660 }, /* Ecircumflextilde */
+    { 0x01001ec5, 11677 }, /* ecircumflextilde */
+    { 0x010020a0, 11694 }, /* EcuSign */
+    { 0x000000cb, 11702 }, /* Ediaeresis */
+    { 0x000000eb, 11713 }, /* ediaeresis */
+    { 0x000000c8, 11724 }, /* Egrave */
+    { 0x000000e8, 11731 }, /* egrave */
+    { 0x01001eba, 11738 }, /* Ehook */
+    { 0x01001ebb, 11744 }, /* ehook */
+    { 0x01002088, 11750 }, /* eightsubscript */
+    { 0x01002078, 11765 }, /* eightsuperior */
+    { 0x0000ff2f, 11779 }, /* Eisu_Shift */
+    { 0x0000ff30, 11790 }, /* Eisu_toggle */
+    { 0x01002208, 11802 }, /* elementof */
+    { 0x00000aae, 11812 }, /* ellipsis */
+    { 0x00000aa3, 11821 }, /* em3space */
+    { 0x00000aa4, 11830 }, /* em4space */
+    { 0x000003aa, 11839 }, /* Emacron */
+    { 0x000003ba, 11847 }, /* emacron */
+    { 0x00000aa9, 11855 }, /* emdash */
+    { 0x00000ade, 11862 }, /* emfilledcircle */
+    { 0x00000adf, 11877 }, /* emfilledrect */
+    { 0x00000ace, 11890 }, /* emopencircle */
+    { 0x00000acf, 11903 }, /* emopenrectangle */
+    { 0x01002205, 11919 }, /* emptyset */
+    { 0x00000aa1, 11928 }, /* emspace */
+    { 0x0000ff57, 11936 }, /* End */
+    { 0x00000aaa, 11940 }, /* endash */
+    { 0x00000ae6, 11947 }, /* enfilledcircbullet */
+    { 0x00000ae7, 11966 }, /* enfilledsqbullet */
+    { 0x000003bd, 11983 }, /* ENG */
+    { 0x000003bf, 11987 }, /* eng */
+    { 0x00000ae0, 11991 }, /* enopencircbullet */
+    { 0x00000ae1, 12008 }, /* enopensquarebullet */
+    { 0x00000aa2, 12027 }, /* enspace */
+    { 0x000001ca, 12035 }, /* Eogonek */
+    { 0x000001ea, 12043 }, /* eogonek */
+    { 0x0000003d, 12051 }, /* equal */
+    { 0x0000ff1b, 12057 }, /* Escape */
+    { 0x000000d0, 12064 }, /* ETH */
+    { 0x000000d0, 12068 }, /* Eth */
+    { 0x000000f0, 12072 }, /* eth */
+    { 0x01001ebc, 12076 }, /* Etilde */
+    { 0x01001ebd, 12083 }, /* etilde */
+    { 0x000020ac, 12090 }, /* EuroSign */
+    { 0x00000021, 12099 }, /* exclam */
+    { 0x000000a1, 12106 }, /* exclamdown */
+    { 0x0000ff62, 12117 }, /* Execute */
+    { 0x1000ff76, 12125 }, /* Ext16bit_L */
+    { 0x1000ff77, 12136 }, /* Ext16bit_R */
+    { 0x010001b7, 12147 }, /* EZH */
+    { 0x01000292, 12151 }, /* ezh */
+    { 0x00000046, 12155 }, /* F */
+    { 0x00000066, 12157 }, /* f */
+    { 0x0000ffbe, 12159 }, /* F1 */
+    { 0x0000ffc7, 12162 }, /* F10 */
+    { 0x0000ffc8, 12166 }, /* F11 */
+    { 0x0000ffc9, 12170 }, /* F12 */
+    { 0x0000ffca, 12174 }, /* F13 */
+    { 0x0000ffcb, 12178 }, /* F14 */
+    { 0x0000ffcc, 12182 }, /* F15 */
+    { 0x0000ffcd, 12186 }, /* F16 */
+    { 0x0000ffce, 12190 }, /* F17 */
+    { 0x0000ffcf, 12194 }, /* F18 */
+    { 0x0000ffd0, 12198 }, /* F19 */
+    { 0x0000ffbf, 12202 }, /* F2 */
+    { 0x0000ffd1, 12205 }, /* F20 */
+    { 0x0000ffd2, 12209 }, /* F21 */
+    { 0x0000ffd3, 12213 }, /* F22 */
+    { 0x0000ffd4, 12217 }, /* F23 */
+    { 0x0000ffd5, 12221 }, /* F24 */
+    { 0x0000ffd6, 12225 }, /* F25 */
+    { 0x0000ffd7, 12229 }, /* F26 */
+    { 0x0000ffd8, 12233 }, /* F27 */
+    { 0x0000ffd9, 12237 }, /* F28 */
+    { 0x0000ffda, 12241 }, /* F29 */
+    { 0x0000ffc0, 12245 }, /* F3 */
+    { 0x0000ffdb, 12248 }, /* F30 */
+    { 0x0000ffdc, 12252 }, /* F31 */
+    { 0x0000ffdd, 12256 }, /* F32 */
+    { 0x0000ffde, 12260 }, /* F33 */
+    { 0x0000ffdf, 12264 }, /* F34 */
+    { 0x0000ffe0, 12268 }, /* F35 */
+    { 0x0000ffc1, 12272 }, /* F4 */
+    { 0x0000ffc2, 12275 }, /* F5 */
+    { 0x0000ffc3, 12278 }, /* F6 */
+    { 0x0000ffc4, 12281 }, /* F7 */
+    { 0x0000ffc5, 12284 }, /* F8 */
+    { 0x0000ffc6, 12287 }, /* F9 */
+    { 0x01001e1e, 12290 }, /* Fabovedot */
+    { 0x01001e1f, 12300 }, /* fabovedot */
+    { 0x010006f0, 12310 }, /* Farsi_0 */
+    { 0x010006f1, 12318 }, /* Farsi_1 */
+    { 0x010006f2, 12326 }, /* Farsi_2 */
+    { 0x010006f3, 12334 }, /* Farsi_3 */
+    { 0x010006f4, 12342 }, /* Farsi_4 */
+    { 0x010006f5, 12350 }, /* Farsi_5 */
+    { 0x010006f6, 12358 }, /* Farsi_6 */
+    { 0x010006f7, 12366 }, /* Farsi_7 */
+    { 0x010006f8, 12374 }, /* Farsi_8 */
+    { 0x010006f9, 12382 }, /* Farsi_9 */
+    { 0x010006cc, 12390 }, /* Farsi_yeh */
+    { 0x00000af8, 12400 }, /* femalesymbol */
+    { 0x000009e3, 12413 }, /* ff */
+    { 0x010020a3, 12416 }, /* FFrancSign */
+    { 0x00000abb, 12427 }, /* figdash */
+    { 0x00000adc, 12435 }, /* filledlefttribullet */
+    { 0x00000adb, 12455 }, /* filledrectbullet */
+    { 0x00000add, 12472 }, /* filledrighttribullet */
+    { 0x00000ae9, 12493 }, /* filledtribulletdown */
+    { 0x00000ae8, 12513 }, /* filledtribulletup */
+    { 0x0000ff68, 12531 }, /* Find */
+    { 0x0000fed0, 12536 }, /* First_Virtual_Screen */
+    { 0x00000ac5, 12557 }, /* fiveeighths */
+    { 0x00000ab7, 12569 }, /* fivesixths */
+    { 0x01002085, 12580 }, /* fivesubscript */
+    { 0x01002075, 12594 }, /* fivesuperior */
+    { 0x00000ab5, 12607 }, /* fourfifths */
+    { 0x01002084, 12618 }, /* foursubscript */
+    { 0x01002074, 12632 }, /* foursuperior */
+    { 0x0100221c, 12645 }, /* fourthroot */
+    { 0x000008f6, 12656 }, /* function */
+    { 0x00000047, 12665 }, /* G */
+    { 0x00000067, 12667 }, /* g */
+    { 0x000002d5, 12669 }, /* Gabovedot */
+    { 0x000002f5, 12679 }, /* gabovedot */
+    { 0x000002ab, 12689 }, /* Gbreve */
+    { 0x000002bb, 12696 }, /* gbreve */
+    { 0x010001e6, 12703 }, /* Gcaron */
+    { 0x010001e7, 12710 }, /* gcaron */
+    { 0x000003ab, 12717 }, /* Gcedilla */
+    { 0x000003bb, 12726 }, /* gcedilla */
+    { 0x000002d8, 12735 }, /* Gcircumflex */
+    { 0x000002f8, 12747 }, /* gcircumflex */
+    { 0x010010d0, 12759 }, /* Georgian_an */
+    { 0x010010d1, 12771 }, /* Georgian_ban */
+    { 0x010010ea, 12784 }, /* Georgian_can */
+    { 0x010010ed, 12797 }, /* Georgian_char */
+    { 0x010010e9, 12811 }, /* Georgian_chin */
+    { 0x010010ec, 12825 }, /* Georgian_cil */
+    { 0x010010d3, 12838 }, /* Georgian_don */
+    { 0x010010d4, 12851 }, /* Georgian_en */
+    { 0x010010f6, 12863 }, /* Georgian_fi */
+    { 0x010010d2, 12875 }, /* Georgian_gan */
+    { 0x010010e6, 12888 }, /* Georgian_ghan */
+    { 0x010010f0, 12902 }, /* Georgian_hae */
+    { 0x010010f4, 12915 }, /* Georgian_har */
+    { 0x010010f1, 12928 }, /* Georgian_he */
+    { 0x010010f2, 12940 }, /* Georgian_hie */
+    { 0x010010f5, 12953 }, /* Georgian_hoe */
+    { 0x010010d8, 12966 }, /* Georgian_in */
+    { 0x010010ef, 12978 }, /* Georgian_jhan */
+    { 0x010010eb, 12992 }, /* Georgian_jil */
+    { 0x010010d9, 13005 }, /* Georgian_kan */
+    { 0x010010e5, 13018 }, /* Georgian_khar */
+    { 0x010010da, 13032 }, /* Georgian_las */
+    { 0x010010db, 13045 }, /* Georgian_man */
+    { 0x010010dc, 13058 }, /* Georgian_nar */
+    { 0x010010dd, 13071 }, /* Georgian_on */
+    { 0x010010de, 13083 }, /* Georgian_par */
+    { 0x010010e4, 13096 }, /* Georgian_phar */
+    { 0x010010e7, 13110 }, /* Georgian_qar */
+    { 0x010010e0, 13123 }, /* Georgian_rae */
+    { 0x010010e1, 13136 }, /* Georgian_san */
+    { 0x010010e8, 13149 }, /* Georgian_shin */
+    { 0x010010d7, 13163 }, /* Georgian_tan */
+    { 0x010010e2, 13176 }, /* Georgian_tar */
+    { 0x010010e3, 13189 }, /* Georgian_un */
+    { 0x010010d5, 13201 }, /* Georgian_vin */
+    { 0x010010f3, 13214 }, /* Georgian_we */
+    { 0x010010ee, 13226 }, /* Georgian_xan */
+    { 0x010010d6, 13239 }, /* Georgian_zen */
+    { 0x010010df, 13252 }, /* Georgian_zhar */
+    { 0x00000060, 13266 }, /* grave */
+    { 0x0000003e, 13272 }, /* greater */
+    { 0x000008be, 13280 }, /* greaterthanequal */
+    { 0x000007ae, 13297 }, /* Greek_accentdieresis */
+    { 0x000007c1, 13318 }, /* Greek_ALPHA */
+    { 0x000007e1, 13330 }, /* Greek_alpha */
+    { 0x000007a1, 13342 }, /* Greek_ALPHAaccent */
+    { 0x000007b1, 13360 }, /* Greek_alphaaccent */
+    { 0x000007c2, 13378 }, /* Greek_BETA */
+    { 0x000007e2, 13389 }, /* Greek_beta */
+    { 0x000007d7, 13400 }, /* Greek_CHI */
+    { 0x000007f7, 13410 }, /* Greek_chi */
+    { 0x000007c4, 13420 }, /* Greek_DELTA */
+    { 0x000007e4, 13432 }, /* Greek_delta */
+    { 0x000007c5, 13444 }, /* Greek_EPSILON */
+    { 0x000007e5, 13458 }, /* Greek_epsilon */
+    { 0x000007a2, 13472 }, /* Greek_EPSILONaccent */
+    { 0x000007b2, 13492 }, /* Greek_epsilonaccent */
+    { 0x000007c7, 13512 }, /* Greek_ETA */
+    { 0x000007e7, 13522 }, /* Greek_eta */
+    { 0x000007a3, 13532 }, /* Greek_ETAaccent */
+    { 0x000007b3, 13548 }, /* Greek_etaaccent */
+    { 0x000007f3, 13564 }, /* Greek_finalsmallsigma */
+    { 0x000007c3, 13586 }, /* Greek_GAMMA */
+    { 0x000007e3, 13598 }, /* Greek_gamma */
+    { 0x000007af, 13610 }, /* Greek_horizbar */
+    { 0x000007c9, 13625 }, /* Greek_IOTA */
+    { 0x000007e9, 13636 }, /* Greek_iota */
+    { 0x000007a4, 13647 }, /* Greek_IOTAaccent */
+    { 0x000007b4, 13664 }, /* Greek_iotaaccent */
+    { 0x000007b6, 13681 }, /* Greek_iotaaccentdieresis */
+    { 0x000007a5, 13706 }, /* Greek_IOTAdiaeresis */
+    { 0x000007a5, 13726 }, /* Greek_IOTAdieresis */
+    { 0x000007b5, 13745 }, /* Greek_iotadieresis */
+    { 0x000007ca, 13764 }, /* Greek_KAPPA */
+    { 0x000007ea, 13776 }, /* Greek_kappa */
+    { 0x000007cb, 13788 }, /* Greek_LAMBDA */
+    { 0x000007eb, 13801 }, /* Greek_lambda */
+    { 0x000007cb, 13814 }, /* Greek_LAMDA */
+    { 0x000007eb, 13826 }, /* Greek_lamda */
+    { 0x000007cc, 13838 }, /* Greek_MU */
+    { 0x000007ec, 13847 }, /* Greek_mu */
+    { 0x000007cd, 13856 }, /* Greek_NU */
+    { 0x000007ed, 13865 }, /* Greek_nu */
+    { 0x000007d9, 13874 }, /* Greek_OMEGA */
+    { 0x000007f9, 13886 }, /* Greek_omega */
+    { 0x000007ab, 13898 }, /* Greek_OMEGAaccent */
+    { 0x000007bb, 13916 }, /* Greek_omegaaccent */
+    { 0x000007cf, 13934 }, /* Greek_OMICRON */
+    { 0x000007ef, 13948 }, /* Greek_omicron */
+    { 0x000007a7, 13962 }, /* Greek_OMICRONaccent */
+    { 0x000007b7, 13982 }, /* Greek_omicronaccent */
+    { 0x000007d6, 14002 }, /* Greek_PHI */
+    { 0x000007f6, 14012 }, /* Greek_phi */
+    { 0x000007d0, 14022 }, /* Greek_PI */
+    { 0x000007f0, 14031 }, /* Greek_pi */
+    { 0x000007d8, 14040 }, /* Greek_PSI */
+    { 0x000007f8, 14050 }, /* Greek_psi */
+    { 0x000007d1, 14060 }, /* Greek_RHO */
+    { 0x000007f1, 14070 }, /* Greek_rho */
+    { 0x000007d2, 14080 }, /* Greek_SIGMA */
+    { 0x000007f2, 14092 }, /* Greek_sigma */
+    { 0x0000ff7e, 14104 }, /* Greek_switch */
+    { 0x000007d4, 14117 }, /* Greek_TAU */
+    { 0x000007f4, 14127 }, /* Greek_tau */
+    { 0x000007c8, 14137 }, /* Greek_THETA */
+    { 0x000007e8, 14149 }, /* Greek_theta */
+    { 0x000007d5, 14161 }, /* Greek_UPSILON */
+    { 0x000007f5, 14175 }, /* Greek_upsilon */
+    { 0x000007a8, 14189 }, /* Greek_UPSILONaccent */
+    { 0x000007b8, 14209 }, /* Greek_upsilonaccent */
+    { 0x000007ba, 14229 }, /* Greek_upsilonaccentdieresis */
+    { 0x000007a9, 14257 }, /* Greek_UPSILONdieresis */
+    { 0x000007b9, 14279 }, /* Greek_upsilondieresis */
+    { 0x000007ce, 14301 }, /* Greek_XI */
+    { 0x000007ee, 14310 }, /* Greek_xi */
+    { 0x000007c6, 14319 }, /* Greek_ZETA */
+    { 0x000007e6, 14330 }, /* Greek_zeta */
+    { 0x100000be, 14341 }, /* guilder */
+    { 0x000000ab, 14349 }, /* guillemotleft */
+    { 0x000000bb, 14363 }, /* guillemotright */
+    { 0x00000048, 14378 }, /* H */
+    { 0x00000068, 14380 }, /* h */
+    { 0x00000aa8, 14382 }, /* hairspace */
+    { 0x0000ff31, 14392 }, /* Hangul */
+    { 0x00000ebf, 14399 }, /* Hangul_A */
+    { 0x00000ec0, 14408 }, /* Hangul_AE */
+    { 0x00000ef6, 14418 }, /* Hangul_AraeA */
+    { 0x00000ef7, 14431 }, /* Hangul_AraeAE */
+    { 0x0000ff39, 14445 }, /* Hangul_Banja */
+    { 0x00000eba, 14458 }, /* Hangul_Cieuc */
+    { 0x0000ff37, 14471 }, /* Hangul_Codeinput */
+    { 0x00000ea7, 14488 }, /* Hangul_Dikeud */
+    { 0x00000ec4, 14502 }, /* Hangul_E */
+    { 0x0000ff33, 14511 }, /* Hangul_End */
+    { 0x00000ec3, 14522 }, /* Hangul_EO */
+    { 0x00000ed1, 14532 }, /* Hangul_EU */
+    { 0x0000ff34, 14542 }, /* Hangul_Hanja */
+    { 0x00000ebe, 14555 }, /* Hangul_Hieuh */
+    { 0x00000ed3, 14568 }, /* Hangul_I */
+    { 0x00000eb7, 14577 }, /* Hangul_Ieung */
+    { 0x00000eea, 14590 }, /* Hangul_J_Cieuc */
+    { 0x00000eda, 14605 }, /* Hangul_J_Dikeud */
+    { 0x00000eee, 14621 }, /* Hangul_J_Hieuh */
+    { 0x00000ee8, 14636 }, /* Hangul_J_Ieung */
+    { 0x00000ee9, 14651 }, /* Hangul_J_Jieuj */
+    { 0x00000eeb, 14666 }, /* Hangul_J_Khieuq */
+    { 0x00000ed4, 14682 }, /* Hangul_J_Kiyeog */
+    { 0x00000ed6, 14698 }, /* Hangul_J_KiyeogSios */
+    { 0x00000ef9, 14718 }, /* Hangul_J_KkogjiDalrinIeung */
+    { 0x00000ee3, 14745 }, /* Hangul_J_Mieum */
+    { 0x00000ed7, 14760 }, /* Hangul_J_Nieun */
+    { 0x00000ed9, 14775 }, /* Hangul_J_NieunHieuh */
+    { 0x00000ed8, 14795 }, /* Hangul_J_NieunJieuj */
+    { 0x00000ef8, 14815 }, /* Hangul_J_PanSios */
+    { 0x00000eed, 14832 }, /* Hangul_J_Phieuf */
+    { 0x00000ee4, 14848 }, /* Hangul_J_Pieub */
+    { 0x00000ee5, 14863 }, /* Hangul_J_PieubSios */
+    { 0x00000edb, 14882 }, /* Hangul_J_Rieul */
+    { 0x00000ee2, 14897 }, /* Hangul_J_RieulHieuh */
+    { 0x00000edc, 14917 }, /* Hangul_J_RieulKiyeog */
+    { 0x00000edd, 14938 }, /* Hangul_J_RieulMieum */
+    { 0x00000ee1, 14958 }, /* Hangul_J_RieulPhieuf */
+    { 0x00000ede, 14979 }, /* Hangul_J_RieulPieub */
+    { 0x00000edf, 14999 }, /* Hangul_J_RieulSios */
+    { 0x00000ee0, 15018 }, /* Hangul_J_RieulTieut */
+    { 0x00000ee6, 15038 }, /* Hangul_J_Sios */
+    { 0x00000ed5, 15052 }, /* Hangul_J_SsangKiyeog */
+    { 0x00000ee7, 15073 }, /* Hangul_J_SsangSios */
+    { 0x00000eec, 15092 }, /* Hangul_J_Tieut */
+    { 0x00000efa, 15107 }, /* Hangul_J_YeorinHieuh */
+    { 0x0000ff35, 15128 }, /* Hangul_Jamo */
+    { 0x0000ff38, 15140 }, /* Hangul_Jeonja */
+    { 0x00000eb8, 15154 }, /* Hangul_Jieuj */
+    { 0x00000ebb, 15167 }, /* Hangul_Khieuq */
+    { 0x00000ea1, 15181 }, /* Hangul_Kiyeog */
+    { 0x00000ea3, 15195 }, /* Hangul_KiyeogSios */
+    { 0x00000ef3, 15213 }, /* Hangul_KkogjiDalrinIeung */
+    { 0x00000eb1, 15238 }, /* Hangul_Mieum */
+    { 0x0000ff3d, 15251 }, /* Hangul_MultipleCandidate */
+    { 0x00000ea4, 15276 }, /* Hangul_Nieun */
+    { 0x00000ea6, 15289 }, /* Hangul_NieunHieuh */
+    { 0x00000ea5, 15307 }, /* Hangul_NieunJieuj */
+    { 0x00000ec7, 15325 }, /* Hangul_O */
+    { 0x00000eca, 15334 }, /* Hangul_OE */
+    { 0x00000ef2, 15344 }, /* Hangul_PanSios */
+    { 0x00000ebd, 15359 }, /* Hangul_Phieuf */
+    { 0x00000eb2, 15373 }, /* Hangul_Pieub */
+    { 0x00000eb4, 15386 }, /* Hangul_PieubSios */
+    { 0x0000ff3b, 15403 }, /* Hangul_PostHanja */
+    { 0x0000ff3a, 15420 }, /* Hangul_PreHanja */
+    { 0x0000ff3e, 15436 }, /* Hangul_PreviousCandidate */
+    { 0x00000ea9, 15461 }, /* Hangul_Rieul */
+    { 0x00000eb0, 15474 }, /* Hangul_RieulHieuh */
+    { 0x00000eaa, 15492 }, /* Hangul_RieulKiyeog */
+    { 0x00000eab, 15511 }, /* Hangul_RieulMieum */
+    { 0x00000eaf, 15529 }, /* Hangul_RieulPhieuf */
+    { 0x00000eac, 15548 }, /* Hangul_RieulPieub */
+    { 0x00000ead, 15566 }, /* Hangul_RieulSios */
+    { 0x00000eae, 15583 }, /* Hangul_RieulTieut */
+    { 0x00000eef, 15601 }, /* Hangul_RieulYeorinHieuh */
+    { 0x0000ff36, 15625 }, /* Hangul_Romaja */
+    { 0x0000ff3c, 15639 }, /* Hangul_SingleCandidate */
+    { 0x00000eb5, 15662 }, /* Hangul_Sios */
+    { 0x0000ff3f, 15674 }, /* Hangul_Special */
+    { 0x00000ea8, 15689 }, /* Hangul_SsangDikeud */
+    { 0x00000eb9, 15708 }, /* Hangul_SsangJieuj */
+    { 0x00000ea2, 15726 }, /* Hangul_SsangKiyeog */
+    { 0x00000eb3, 15745 }, /* Hangul_SsangPieub */
+    { 0x00000eb6, 15763 }, /* Hangul_SsangSios */
+    { 0x0000ff32, 15780 }, /* Hangul_Start */
+    { 0x00000ef0, 15793 }, /* Hangul_SunkyeongeumMieum */
+    { 0x00000ef4, 15818 }, /* Hangul_SunkyeongeumPhieuf */
+    { 0x00000ef1, 15844 }, /* Hangul_SunkyeongeumPieub */
+    { 0x0000ff7e, 15869 }, /* Hangul_switch */
+    { 0x00000ebc, 15883 }, /* Hangul_Tieut */
+    { 0x00000ecc, 15896 }, /* Hangul_U */
+    { 0x00000ec8, 15905 }, /* Hangul_WA */
+    { 0x00000ec9, 15915 }, /* Hangul_WAE */
+    { 0x00000ece, 15926 }, /* Hangul_WE */
+    { 0x00000ecd, 15936 }, /* Hangul_WEO */
+    { 0x00000ecf, 15947 }, /* Hangul_WI */
+    { 0x00000ec1, 15957 }, /* Hangul_YA */
+    { 0x00000ec2, 15967 }, /* Hangul_YAE */
+    { 0x00000ec6, 15978 }, /* Hangul_YE */
+    { 0x00000ec5, 15988 }, /* Hangul_YEO */
+    { 0x00000ef5, 15999 }, /* Hangul_YeorinHieuh */
+    { 0x00000ed2, 16018 }, /* Hangul_YI */
+    { 0x00000ecb, 16028 }, /* Hangul_YO */
+    { 0x00000ed0, 16038 }, /* Hangul_YU */
+    { 0x0000ff29, 16048 }, /* Hankaku */
+    { 0x000002a6, 16056 }, /* Hcircumflex */
+    { 0x000002b6, 16068 }, /* hcircumflex */
+    { 0x00000aee, 16080 }, /* heart */
+    { 0x00000ce0, 16086 }, /* hebrew_aleph */
+    { 0x00000cf2, 16099 }, /* hebrew_ayin */
+    { 0x00000ce1, 16111 }, /* hebrew_bet */
+    { 0x00000ce1, 16122 }, /* hebrew_beth */
+    { 0x00000ce7, 16134 }, /* hebrew_chet */
+    { 0x00000ce3, 16146 }, /* hebrew_dalet */
+    { 0x00000ce3, 16159 }, /* hebrew_daleth */
+    { 0x00000cdf, 16173 }, /* hebrew_doublelowline */
+    { 0x00000cea, 16194 }, /* hebrew_finalkaph */
+    { 0x00000ced, 16211 }, /* hebrew_finalmem */
+    { 0x00000cef, 16227 }, /* hebrew_finalnun */
+    { 0x00000cf3, 16243 }, /* hebrew_finalpe */
+    { 0x00000cf5, 16258 }, /* hebrew_finalzade */
+    { 0x00000cf5, 16275 }, /* hebrew_finalzadi */
+    { 0x00000ce2, 16292 }, /* hebrew_gimel */
+    { 0x00000ce2, 16305 }, /* hebrew_gimmel */
+    { 0x00000ce4, 16319 }, /* hebrew_he */
+    { 0x00000ce7, 16329 }, /* hebrew_het */
+    { 0x00000ceb, 16340 }, /* hebrew_kaph */
+    { 0x00000cf7, 16352 }, /* hebrew_kuf */
+    { 0x00000cec, 16363 }, /* hebrew_lamed */
+    { 0x00000cee, 16376 }, /* hebrew_mem */
+    { 0x00000cf0, 16387 }, /* hebrew_nun */
+    { 0x00000cf4, 16398 }, /* hebrew_pe */
+    { 0x00000cf7, 16408 }, /* hebrew_qoph */
+    { 0x00000cf8, 16420 }, /* hebrew_resh */
+    { 0x00000cf1, 16432 }, /* hebrew_samech */
+    { 0x00000cf1, 16446 }, /* hebrew_samekh */
+    { 0x00000cf9, 16460 }, /* hebrew_shin */
+    { 0x0000ff7e, 16472 }, /* Hebrew_switch */
+    { 0x00000cfa, 16486 }, /* hebrew_taf */
+    { 0x00000cfa, 16497 }, /* hebrew_taw */
+    { 0x00000ce8, 16508 }, /* hebrew_tet */
+    { 0x00000ce8, 16519 }, /* hebrew_teth */
+    { 0x00000ce5, 16531 }, /* hebrew_waw */
+    { 0x00000ce9, 16542 }, /* hebrew_yod */
+    { 0x00000cf6, 16553 }, /* hebrew_zade */
+    { 0x00000cf6, 16565 }, /* hebrew_zadi */
+    { 0x00000ce6, 16577 }, /* hebrew_zain */
+    { 0x00000ce6, 16589 }, /* hebrew_zayin */
+    { 0x0000ff6a, 16602 }, /* Help */
+    { 0x0000ff23, 16607 }, /* Henkan */
+    { 0x0000ff23, 16614 }, /* Henkan_Mode */
+    { 0x00000ada, 16626 }, /* hexagram */
+    { 0x0000ff25, 16635 }, /* Hiragana */
+    { 0x0000ff27, 16644 }, /* Hiragana_Katakana */
+    { 0x0000ff50, 16662 }, /* Home */
+    { 0x000008a3, 16667 }, /* horizconnector */
+    { 0x000009ef, 16682 }, /* horizlinescan1 */
+    { 0x000009f0, 16697 }, /* horizlinescan3 */
+    { 0x000009f1, 16712 }, /* horizlinescan5 */
+    { 0x000009f2, 16727 }, /* horizlinescan7 */
+    { 0x000009f3, 16742 }, /* horizlinescan9 */
+    { 0x1000ff74, 16757 }, /* hpBackTab */
+    { 0x100000fc, 16767 }, /* hpblock */
+    { 0x1000ff6f, 16775 }, /* hpClearLine */
+    { 0x1000ff73, 16787 }, /* hpDeleteChar */
+    { 0x1000ff71, 16800 }, /* hpDeleteLine */
+    { 0x100000be, 16813 }, /* hpguilder */
+    { 0x1000ff72, 16823 }, /* hpInsertChar */
+    { 0x1000ff70, 16836 }, /* hpInsertLine */
+    { 0x100000ee, 16849 }, /* hpIO */
+    { 0x1000ff75, 16854 }, /* hpKP_BackTab */
+    { 0x100000af, 16867 }, /* hplira */
+    { 0x100000f6, 16874 }, /* hplongminus */
+    { 0x1000ff48, 16886 }, /* hpModelock1 */
+    { 0x1000ff49, 16898 }, /* hpModelock2 */
+    { 0x100000a8, 16910 }, /* hpmute_acute */
+    { 0x100000aa, 16923 }, /* hpmute_asciicircum */
+    { 0x100000ac, 16942 }, /* hpmute_asciitilde */
+    { 0x100000ab, 16960 }, /* hpmute_diaeresis */
+    { 0x100000a9, 16977 }, /* hpmute_grave */
+    { 0x1000ff6c, 16990 }, /* hpReset */
+    { 0x1000ff6d, 16998 }, /* hpSystem */
+    { 0x1000ff6e, 17007 }, /* hpUser */
+    { 0x100000ee, 17014 }, /* hpYdiaeresis */
+    { 0x000002a1, 17027 }, /* Hstroke */
+    { 0x000002b1, 17035 }, /* hstroke */
+    { 0x000009e2, 17043 }, /* ht */
+    { 0x0000ffed, 17046 }, /* Hyper_L */
+    { 0x0000ffee, 17054 }, /* Hyper_R */
+    { 0x000000ad, 17062 }, /* hyphen */
+    { 0x00000049, 17069 }, /* I */
+    { 0x00000069, 17071 }, /* i */
+    { 0x000002a9, 17073 }, /* Iabovedot */
+    { 0x000000cd, 17083 }, /* Iacute */
+    { 0x000000ed, 17090 }, /* iacute */
+    { 0x01001eca, 17097 }, /* Ibelowdot */
+    { 0x01001ecb, 17107 }, /* ibelowdot */
+    { 0x0100012c, 17117 }, /* Ibreve */
+    { 0x0100012d, 17124 }, /* ibreve */
+    { 0x000000ce, 17131 }, /* Icircumflex */
+    { 0x000000ee, 17143 }, /* icircumflex */
+    { 0x000008cf, 17155 }, /* identical */
+    { 0x000000cf, 17165 }, /* Idiaeresis */
+    { 0x000000ef, 17176 }, /* idiaeresis */
+    { 0x000002b9, 17187 }, /* idotless */
+    { 0x000008cd, 17196 }, /* ifonlyif */
+    { 0x000000cc, 17205 }, /* Igrave */
+    { 0x000000ec, 17212 }, /* igrave */
+    { 0x01001ec8, 17219 }, /* Ihook */
+    { 0x01001ec9, 17225 }, /* ihook */
+    { 0x000003cf, 17231 }, /* Imacron */
+    { 0x000003ef, 17239 }, /* imacron */
+    { 0x000008ce, 17247 }, /* implies */
+    { 0x000008da, 17255 }, /* includedin */
+    { 0x000008db, 17266 }, /* includes */
+    { 0x000008c2, 17275 }, /* infinity */
+    { 0x0000ff63, 17284 }, /* Insert */
+    { 0x1000ff72, 17291 }, /* InsertChar */
+    { 0x1000ff70, 17302 }, /* InsertLine */
+    { 0x000008bf, 17313 }, /* integral */
+    { 0x000008dc, 17322 }, /* intersection */
+    { 0x100000ee, 17335 }, /* IO */
+    { 0x000003c7, 17338 }, /* Iogonek */
+    { 0x000003e7, 17346 }, /* iogonek */
+    { 0x0000fe33, 17354 }, /* ISO_Center_Object */
+    { 0x0000fe30, 17372 }, /* ISO_Continuous_Underline */
+    { 0x0000fe31, 17397 }, /* ISO_Discontinuous_Underline */
+    { 0x0000fe32, 17425 }, /* ISO_Emphasize */
+    { 0x0000fe34, 17439 }, /* ISO_Enter */
+    { 0x0000fe2f, 17449 }, /* ISO_Fast_Cursor_Down */
+    { 0x0000fe2c, 17470 }, /* ISO_Fast_Cursor_Left */
+    { 0x0000fe2d, 17491 }, /* ISO_Fast_Cursor_Right */
+    { 0x0000fe2e, 17513 }, /* ISO_Fast_Cursor_Up */
+    { 0x0000fe0c, 17532 }, /* ISO_First_Group */
+    { 0x0000fe0d, 17548 }, /* ISO_First_Group_Lock */
+    { 0x0000fe06, 17569 }, /* ISO_Group_Latch */
+    { 0x0000fe07, 17585 }, /* ISO_Group_Lock */
+    { 0x0000ff7e, 17600 }, /* ISO_Group_Shift */
+    { 0x0000fe0e, 17616 }, /* ISO_Last_Group */
+    { 0x0000fe0f, 17631 }, /* ISO_Last_Group_Lock */
+    { 0x0000fe20, 17651 }, /* ISO_Left_Tab */
+    { 0x0000fe02, 17664 }, /* ISO_Level2_Latch */
+    { 0x0000fe04, 17681 }, /* ISO_Level3_Latch */
+    { 0x0000fe05, 17698 }, /* ISO_Level3_Lock */
+    { 0x0000fe03, 17714 }, /* ISO_Level3_Shift */
+    { 0x0000fe12, 17731 }, /* ISO_Level5_Latch */
+    { 0x0000fe13, 17748 }, /* ISO_Level5_Lock */
+    { 0x0000fe11, 17764 }, /* ISO_Level5_Shift */
+    { 0x0000fe01, 17781 }, /* ISO_Lock */
+    { 0x0000fe22, 17790 }, /* ISO_Move_Line_Down */
+    { 0x0000fe21, 17809 }, /* ISO_Move_Line_Up */
+    { 0x0000fe08, 17826 }, /* ISO_Next_Group */
+    { 0x0000fe09, 17841 }, /* ISO_Next_Group_Lock */
+    { 0x0000fe24, 17861 }, /* ISO_Partial_Line_Down */
+    { 0x0000fe23, 17883 }, /* ISO_Partial_Line_Up */
+    { 0x0000fe25, 17903 }, /* ISO_Partial_Space_Left */
+    { 0x0000fe26, 17926 }, /* ISO_Partial_Space_Right */
+    { 0x0000fe0a, 17950 }, /* ISO_Prev_Group */
+    { 0x0000fe0b, 17965 }, /* ISO_Prev_Group_Lock */
+    { 0x0000fe2b, 17985 }, /* ISO_Release_Both_Margins */
+    { 0x0000fe29, 18010 }, /* ISO_Release_Margin_Left */
+    { 0x0000fe2a, 18034 }, /* ISO_Release_Margin_Right */
+    { 0x0000fe27, 18059 }, /* ISO_Set_Margin_Left */
+    { 0x0000fe28, 18079 }, /* ISO_Set_Margin_Right */
+    { 0x000003a5, 18100 }, /* Itilde */
+    { 0x000003b5, 18107 }, /* itilde */
+    { 0x0000004a, 18114 }, /* J */
+    { 0x0000006a, 18116 }, /* j */
+    { 0x000002ac, 18118 }, /* Jcircumflex */
+    { 0x000002bc, 18130 }, /* jcircumflex */
+    { 0x00000bca, 18142 }, /* jot */
+    { 0x0000004b, 18146 }, /* K */
+    { 0x0000006b, 18148 }, /* k */
+    { 0x000004a7, 18150 }, /* kana_a */
+    { 0x000004b1, 18157 }, /* kana_A */
+    { 0x000004c1, 18164 }, /* kana_CHI */
+    { 0x000004a3, 18173 }, /* kana_closingbracket */
+    { 0x000004a4, 18193 }, /* kana_comma */
+    { 0x000004a5, 18204 }, /* kana_conjunctive */
+    { 0x000004aa, 18221 }, /* kana_e */
+    { 0x000004b4, 18228 }, /* kana_E */
+    { 0x000004cc, 18235 }, /* kana_FU */
+    { 0x000004a1, 18243 }, /* kana_fullstop */
+    { 0x000004ca, 18257 }, /* kana_HA */
+    { 0x000004cd, 18265 }, /* kana_HE */
+    { 0x000004cb, 18273 }, /* kana_HI */
+    { 0x000004ce, 18281 }, /* kana_HO */
+    { 0x000004cc, 18289 }, /* kana_HU */
+    { 0x000004a8, 18297 }, /* kana_i */
+    { 0x000004b2, 18304 }, /* kana_I */
+    { 0x000004b6, 18311 }, /* kana_KA */
+    { 0x000004b9, 18319 }, /* kana_KE */
+    { 0x000004b7, 18327 }, /* kana_KI */
+    { 0x000004ba, 18335 }, /* kana_KO */
+    { 0x000004b8, 18343 }, /* kana_KU */
+    { 0x0000ff2d, 18351 }, /* Kana_Lock */
+    { 0x000004cf, 18361 }, /* kana_MA */
+    { 0x000004d2, 18369 }, /* kana_ME */
+    { 0x000004d0, 18377 }, /* kana_MI */
+    { 0x000004a5, 18385 }, /* kana_middledot */
+    { 0x000004d3, 18400 }, /* kana_MO */
+    { 0x000004d1, 18408 }, /* kana_MU */
+    { 0x000004dd, 18416 }, /* kana_N */
+    { 0x000004c5, 18423 }, /* kana_NA */
+    { 0x000004c8, 18431 }, /* kana_NE */
+    { 0x000004c6, 18439 }, /* kana_NI */
+    { 0x000004c9, 18447 }, /* kana_NO */
+    { 0x000004c7, 18455 }, /* kana_NU */
+    { 0x000004ab, 18463 }, /* kana_o */
+    { 0x000004b5, 18470 }, /* kana_O */
+    { 0x000004a2, 18477 }, /* kana_openingbracket */
+    { 0x000004d7, 18497 }, /* kana_RA */
+    { 0x000004da, 18505 }, /* kana_RE */
+    { 0x000004d8, 18513 }, /* kana_RI */
+    { 0x000004db, 18521 }, /* kana_RO */
+    { 0x000004d9, 18529 }, /* kana_RU */
+    { 0x000004bb, 18537 }, /* kana_SA */
+    { 0x000004be, 18545 }, /* kana_SE */
+    { 0x000004bc, 18553 }, /* kana_SHI */
+    { 0x0000ff2e, 18562 }, /* Kana_Shift */
+    { 0x000004bf, 18573 }, /* kana_SO */
+    { 0x000004bd, 18581 }, /* kana_SU */
+    { 0x0000ff7e, 18589 }, /* kana_switch */
+    { 0x000004c0, 18601 }, /* kana_TA */
+    { 0x000004c3, 18609 }, /* kana_TE */
+    { 0x000004c1, 18617 }, /* kana_TI */
+    { 0x000004c4, 18625 }, /* kana_TO */
+    { 0x000004af, 18633 }, /* kana_tsu */
+    { 0x000004c2, 18642 }, /* kana_TSU */
+    { 0x000004af, 18651 }, /* kana_tu */
+    { 0x000004c2, 18659 }, /* kana_TU */
+    { 0x000004a9, 18667 }, /* kana_u */
+    { 0x000004b3, 18674 }, /* kana_U */
+    { 0x000004dc, 18681 }, /* kana_WA */
+    { 0x000004a6, 18689 }, /* kana_WO */
+    { 0x000004ac, 18697 }, /* kana_ya */
+    { 0x000004d4, 18705 }, /* kana_YA */
+    { 0x000004ae, 18713 }, /* kana_yo */
+    { 0x000004d6, 18721 }, /* kana_YO */
+    { 0x000004ad, 18729 }, /* kana_yu */
+    { 0x000004d5, 18737 }, /* kana_YU */
+    { 0x0000ff21, 18745 }, /* Kanji */
+    { 0x0000ff37, 18751 }, /* Kanji_Bangou */
+    { 0x000003a2, 18764 }, /* kappa */
+    { 0x0000ff26, 18770 }, /* Katakana */
+    { 0x000003d3, 18779 }, /* Kcedilla */
+    { 0x000003f3, 18788 }, /* kcedilla */
+    { 0x00000eff, 18797 }, /* Korean_Won */
+    { 0x0000ffb0, 18808 }, /* KP_0 */
+    { 0x0000ffb1, 18813 }, /* KP_1 */
+    { 0x0000ffb2, 18818 }, /* KP_2 */
+    { 0x0000ffb3, 18823 }, /* KP_3 */
+    { 0x0000ffb4, 18828 }, /* KP_4 */
+    { 0x0000ffb5, 18833 }, /* KP_5 */
+    { 0x0000ffb6, 18838 }, /* KP_6 */
+    { 0x0000ffb7, 18843 }, /* KP_7 */
+    { 0x0000ffb8, 18848 }, /* KP_8 */
+    { 0x0000ffb9, 18853 }, /* KP_9 */
+    { 0x0000ffab, 18858 }, /* KP_Add */
+    { 0x1000ff75, 18865 }, /* KP_BackTab */
+    { 0x0000ff9d, 18876 }, /* KP_Begin */
+    { 0x0000ffae, 18885 }, /* KP_Decimal */
+    { 0x0000ff9f, 18896 }, /* KP_Delete */
+    { 0x0000ffaf, 18906 }, /* KP_Divide */
+    { 0x0000ff99, 18916 }, /* KP_Down */
+    { 0x0000ff9c, 18924 }, /* KP_End */
+    { 0x0000ff8d, 18931 }, /* KP_Enter */
+    { 0x0000ffbd, 18940 }, /* KP_Equal */
+    { 0x0000ff91, 18949 }, /* KP_F1 */
+    { 0x0000ff92, 18955 }, /* KP_F2 */
+    { 0x0000ff93, 18961 }, /* KP_F3 */
+    { 0x0000ff94, 18967 }, /* KP_F4 */
+    { 0x0000ff95, 18973 }, /* KP_Home */
+    { 0x0000ff9e, 18981 }, /* KP_Insert */
+    { 0x0000ff96, 18991 }, /* KP_Left */
+    { 0x0000ffaa, 18999 }, /* KP_Multiply */
+    { 0x0000ff9b, 19011 }, /* KP_Next */
+    { 0x0000ff9b, 19019 }, /* KP_Page_Down */
+    { 0x0000ff9a, 19032 }, /* KP_Page_Up */
+    { 0x0000ff9a, 19043 }, /* KP_Prior */
+    { 0x0000ff98, 19052 }, /* KP_Right */
+    { 0x0000ffac, 19061 }, /* KP_Separator */
+    { 0x0000ff80, 19074 }, /* KP_Space */
+    { 0x0000ffad, 19083 }, /* KP_Subtract */
+    { 0x0000ff89, 19095 }, /* KP_Tab */
+    { 0x0000ff97, 19102 }, /* KP_Up */
+    { 0x000003a2, 19108 }, /* kra */
+    { 0x0000004c, 19112 }, /* L */
+    { 0x0000006c, 19114 }, /* l */
+    { 0x0000ffc8, 19116 }, /* L1 */
+    { 0x0000ffd1, 19119 }, /* L10 */
+    { 0x0000ffc9, 19123 }, /* L2 */
+    { 0x0000ffca, 19126 }, /* L3 */
+    { 0x0000ffcb, 19129 }, /* L4 */
+    { 0x0000ffcc, 19132 }, /* L5 */
+    { 0x0000ffcd, 19135 }, /* L6 */
+    { 0x0000ffce, 19138 }, /* L7 */
+    { 0x0000ffcf, 19141 }, /* L8 */
+    { 0x0000ffd0, 19144 }, /* L9 */
+    { 0x000001c5, 19147 }, /* Lacute */
+    { 0x000001e5, 19154 }, /* lacute */
+    { 0x0000fed4, 19161 }, /* Last_Virtual_Screen */
+    { 0x00000ad9, 19181 }, /* latincross */
+    { 0x01001e36, 19192 }, /* Lbelowdot */
+    { 0x01001e37, 19202 }, /* lbelowdot */
+    { 0x000001a5, 19212 }, /* Lcaron */
+    { 0x000001b5, 19219 }, /* lcaron */
+    { 0x000003a6, 19226 }, /* Lcedilla */
+    { 0x000003b6, 19235 }, /* lcedilla */
+    { 0x0000ff51, 19244 }, /* Left */
+    { 0x00000abc, 19249 }, /* leftanglebracket */
+    { 0x000008fb, 19266 }, /* leftarrow */
+    { 0x00000ba3, 19276 }, /* leftcaret */
+    { 0x00000ad2, 19286 }, /* leftdoublequotemark */
+    { 0x000008af, 19306 }, /* leftmiddlecurlybrace */
+    { 0x00000acc, 19327 }, /* leftopentriangle */
+    { 0x00000aea, 19344 }, /* leftpointer */
+    { 0x000008a1, 19356 }, /* leftradical */
+    { 0x00000bda, 19368 }, /* leftshoe */
+    { 0x00000ad0, 19377 }, /* leftsinglequotemark */
+    { 0x000009f4, 19397 }, /* leftt */
+    { 0x00000bdc, 19403 }, /* lefttack */
+    { 0x0000003c, 19412 }, /* less */
+    { 0x000008bc, 19417 }, /* lessthanequal */
+    { 0x000009e5, 19431 }, /* lf */
+    { 0x0000ff0a, 19434 }, /* Linefeed */
+    { 0x100000af, 19443 }, /* lira */
+    { 0x010020a4, 19448 }, /* LiraSign */
+    { 0x000008de, 19457 }, /* logicaland */
+    { 0x000008df, 19468 }, /* logicalor */
+    { 0x100000f6, 19478 }, /* longminus */
+    { 0x000009ed, 19488 }, /* lowleftcorner */
+    { 0x000009ea, 19502 }, /* lowrightcorner */
+    { 0x000001a3, 19517 }, /* Lstroke */
+    { 0x000001b3, 19525 }, /* lstroke */
+    { 0x0000004d, 19533 }, /* M */
+    { 0x0000006d, 19535 }, /* m */
+    { 0x01001e40, 19537 }, /* Mabovedot */
+    { 0x01001e41, 19547 }, /* mabovedot */
+    { 0x000006a5, 19557 }, /* Macedonia_dse */
+    { 0x000006b5, 19571 }, /* Macedonia_DSE */
+    { 0x000006a2, 19585 }, /* Macedonia_gje */
+    { 0x000006b2, 19599 }, /* Macedonia_GJE */
+    { 0x000006ac, 19613 }, /* Macedonia_kje */
+    { 0x000006bc, 19627 }, /* Macedonia_KJE */
+    { 0x000000af, 19641 }, /* macron */
+    { 0x0000ff3e, 19648 }, /* Mae_Koho */
+    { 0x00000af7, 19657 }, /* malesymbol */
+    { 0x00000af0, 19668 }, /* maltesecross */
+    { 0x00000abf, 19681 }, /* marker */
+    { 0x000000ba, 19688 }, /* masculine */
+    { 0x0000ff2c, 19698 }, /* Massyo */
+    { 0x0000ff67, 19705 }, /* Menu */
+    { 0x0000ffe7, 19710 }, /* Meta_L */
+    { 0x0000ffe8, 19717 }, /* Meta_R */
+    { 0x010020a5, 19724 }, /* MillSign */
+    { 0x0000002d, 19733 }, /* minus */
+    { 0x00000ad6, 19739 }, /* minutes */
+    { 0x0000ff7e, 19747 }, /* Mode_switch */
+    { 0x0000fe77, 19759 }, /* MouseKeys_Accel_Enable */
+    { 0x0000fe76, 19782 }, /* MouseKeys_Enable */
+    { 0x000000b5, 19799 }, /* mu */
+    { 0x0000ff22, 19802 }, /* Muhenkan */
+    { 0x0000ff20, 19811 }, /* Multi_key */
+    { 0x0000ff3d, 19821 }, /* MultipleCandidate */
+    { 0x000000d7, 19839 }, /* multiply */
+    { 0x00000af6, 19848 }, /* musicalflat */
+    { 0x00000af5, 19860 }, /* musicalsharp */
+    { 0x100000a8, 19873 }, /* mute_acute */
+    { 0x100000aa, 19884 }, /* mute_asciicircum */
+    { 0x100000ac, 19901 }, /* mute_asciitilde */
+    { 0x100000ab, 19917 }, /* mute_diaeresis */
+    { 0x100000a9, 19932 }, /* mute_grave */
+    { 0x0000004e, 19943 }, /* N */
+    { 0x0000006e, 19945 }, /* n */
+    { 0x000008c5, 19947 }, /* nabla */
+    { 0x000001d1, 19953 }, /* Nacute */
+    { 0x000001f1, 19960 }, /* nacute */
+    { 0x010020a6, 19967 }, /* NairaSign */
+    { 0x000001d2, 19977 }, /* Ncaron */
+    { 0x000001f2, 19984 }, /* ncaron */
+    { 0x000003d1, 19991 }, /* Ncedilla */
+    { 0x000003f1, 20000 }, /* ncedilla */
+    { 0x010020aa, 20009 }, /* NewSheqelSign */
+    { 0x0000ff56, 20023 }, /* Next */
+    { 0x0000fed2, 20028 }, /* Next_Virtual_Screen */
+    { 0x01002089, 20048 }, /* ninesubscript */
+    { 0x01002079, 20062 }, /* ninesuperior */
+    { 0x000009e8, 20075 }, /* nl */
+    { 0x000000a0, 20078 }, /* nobreakspace */
+    { 0x00000000, 20091 }, /* NoSymbol */
+    { 0x01002247, 20100 }, /* notapproxeq */
+    { 0x01002209, 20112 }, /* notelementof */
+    { 0x000008bd, 20125 }, /* notequal */
+    { 0x01002262, 20134 }, /* notidentical */
+    { 0x000000ac, 20147 }, /* notsign */
+    { 0x000000d1, 20155 }, /* Ntilde */
+    { 0x000000f1, 20162 }, /* ntilde */
+    { 0x0000ff7f, 20169 }, /* Num_Lock */
+    { 0x00000023, 20178 }, /* numbersign */
+    { 0x000006b0, 20189 }, /* numerosign */
+    { 0x0000004f, 20200 }, /* O */
+    { 0x0000006f, 20202 }, /* o */
+    { 0x000000d3, 20204 }, /* Oacute */
+    { 0x000000f3, 20211 }, /* oacute */
+    { 0x0100019f, 20218 }, /* Obarred */
+    { 0x01000275, 20226 }, /* obarred */
+    { 0x01001ecc, 20234 }, /* Obelowdot */
+    { 0x01001ecd, 20244 }, /* obelowdot */
+    { 0x010001d1, 20254 }, /* Ocaron */
+    { 0x010001d2, 20261 }, /* ocaron */
+    { 0x000000d4, 20268 }, /* Ocircumflex */
+    { 0x000000f4, 20280 }, /* ocircumflex */
+    { 0x01001ed0, 20292 }, /* Ocircumflexacute */
+    { 0x01001ed1, 20309 }, /* ocircumflexacute */
+    { 0x01001ed8, 20326 }, /* Ocircumflexbelowdot */
+    { 0x01001ed9, 20346 }, /* ocircumflexbelowdot */
+    { 0x01001ed2, 20366 }, /* Ocircumflexgrave */
+    { 0x01001ed3, 20383 }, /* ocircumflexgrave */
+    { 0x01001ed4, 20400 }, /* Ocircumflexhook */
+    { 0x01001ed5, 20416 }, /* ocircumflexhook */
+    { 0x01001ed6, 20432 }, /* Ocircumflextilde */
+    { 0x01001ed7, 20449 }, /* ocircumflextilde */
+    { 0x000000d6, 20466 }, /* Odiaeresis */
+    { 0x000000f6, 20477 }, /* odiaeresis */
+    { 0x000001d5, 20488 }, /* Odoubleacute */
+    { 0x000001f5, 20501 }, /* odoubleacute */
+    { 0x000013bc, 20514 }, /* OE */
+    { 0x000013bd, 20517 }, /* oe */
+    { 0x000001b2, 20520 }, /* ogonek */
+    { 0x000000d2, 20527 }, /* Ograve */
+    { 0x000000f2, 20534 }, /* ograve */
+    { 0x01001ece, 20541 }, /* Ohook */
+    { 0x01001ecf, 20547 }, /* ohook */
+    { 0x010001a0, 20553 }, /* Ohorn */
+    { 0x010001a1, 20559 }, /* ohorn */
+    { 0x01001eda, 20565 }, /* Ohornacute */
+    { 0x01001edb, 20576 }, /* ohornacute */
+    { 0x01001ee2, 20587 }, /* Ohornbelowdot */
+    { 0x01001ee3, 20601 }, /* ohornbelowdot */
+    { 0x01001edc, 20615 }, /* Ohorngrave */
+    { 0x01001edd, 20626 }, /* ohorngrave */
+    { 0x01001ede, 20637 }, /* Ohornhook */
+    { 0x01001edf, 20647 }, /* ohornhook */
+    { 0x01001ee0, 20657 }, /* Ohorntilde */
+    { 0x01001ee1, 20668 }, /* ohorntilde */
+    { 0x000003d2, 20679 }, /* Omacron */
+    { 0x000003f2, 20687 }, /* omacron */
+    { 0x00000ac3, 20695 }, /* oneeighth */
+    { 0x00000ab2, 20705 }, /* onefifth */
+    { 0x000000bd, 20714 }, /* onehalf */
+    { 0x000000bc, 20722 }, /* onequarter */
+    { 0x00000ab6, 20733 }, /* onesixth */
+    { 0x01002081, 20742 }, /* onesubscript */
+    { 0x000000b9, 20755 }, /* onesuperior */
+    { 0x00000ab0, 20767 }, /* onethird */
+    { 0x000000d8, 20776 }, /* Ooblique */
+    { 0x000000f8, 20785 }, /* ooblique */
+    { 0x00000ae2, 20794 }, /* openrectbullet */
+    { 0x00000ae5, 20809 }, /* openstar */
+    { 0x00000ae4, 20818 }, /* opentribulletdown */
+    { 0x00000ae3, 20836 }, /* opentribulletup */
+    { 0x000000aa, 20852 }, /* ordfeminine */
+    { 0x1004ff44, 20864 }, /* osfActivate */
+    { 0x1004ff31, 20876 }, /* osfAddMode */
+    { 0x1004ff08, 20887 }, /* osfBackSpace */
+    { 0x1004ff07, 20900 }, /* osfBackTab */
+    { 0x1004ff5a, 20911 }, /* osfBeginData */
+    { 0x1004ff58, 20924 }, /* osfBeginLine */
+    { 0x1004ff69, 20937 }, /* osfCancel */
+    { 0x1004ff0b, 20947 }, /* osfClear */
+    { 0x1004ff02, 20956 }, /* osfCopy */
+    { 0x1004ff03, 20964 }, /* osfCut */
+    { 0x1004ffff, 20971 }, /* osfDelete */
+    { 0x1004ff72, 20981 }, /* osfDeselectAll */
+    { 0x1004ff54, 20996 }, /* osfDown */
+    { 0x1004ff59, 21004 }, /* osfEndData */
+    { 0x1004ff57, 21015 }, /* osfEndLine */
+    { 0x1004ff1b, 21026 }, /* osfEscape */
+    { 0x1004ff74, 21036 }, /* osfExtend */
+    { 0x1004ff6a, 21046 }, /* osfHelp */
+    { 0x1004ff63, 21054 }, /* osfInsert */
+    { 0x1004ff51, 21064 }, /* osfLeft */
+    { 0x1004ff67, 21072 }, /* osfMenu */
+    { 0x1004ff45, 21080 }, /* osfMenuBar */
+    { 0x1004ff5e, 21091 }, /* osfNextField */
+    { 0x1004ff5c, 21104 }, /* osfNextMenu */
+    { 0x1004ff42, 21116 }, /* osfPageDown */
+    { 0x1004ff40, 21128 }, /* osfPageLeft */
+    { 0x1004ff43, 21140 }, /* osfPageRight */
+    { 0x1004ff41, 21153 }, /* osfPageUp */
+    { 0x1004ff04, 21163 }, /* osfPaste */
+    { 0x1004ff5d, 21172 }, /* osfPrevField */
+    { 0x1004ff5b, 21185 }, /* osfPrevMenu */
+    { 0x1004ff32, 21197 }, /* osfPrimaryPaste */
+    { 0x1004ff33, 21213 }, /* osfQuickPaste */
+    { 0x1004ff73, 21227 }, /* osfReselect */
+    { 0x1004ff78, 21239 }, /* osfRestore */
+    { 0x1004ff53, 21250 }, /* osfRight */
+    { 0x1004ff60, 21259 }, /* osfSelect */
+    { 0x1004ff71, 21269 }, /* osfSelectAll */
+    { 0x1004ff65, 21282 }, /* osfUndo */
+    { 0x1004ff52, 21290 }, /* osfUp */
+    { 0x000000d8, 21296 }, /* Oslash */
+    { 0x000000f8, 21303 }, /* oslash */
+    { 0x000000d5, 21310 }, /* Otilde */
+    { 0x000000f5, 21317 }, /* otilde */
+    { 0x00000bc0, 21324 }, /* overbar */
+    { 0x0000fe78, 21332 }, /* Overlay1_Enable */
+    { 0x0000fe79, 21348 }, /* Overlay2_Enable */
+    { 0x0000047e, 21364 }, /* overline */
+    { 0x00000050, 21373 }, /* P */
+    { 0x00000070, 21375 }, /* p */
+    { 0x01001e56, 21377 }, /* Pabovedot */
+    { 0x01001e57, 21387 }, /* pabovedot */
+    { 0x0000ff56, 21397 }, /* Page_Down */
+    { 0x0000ff55, 21407 }, /* Page_Up */
+    { 0x000000b6, 21415 }, /* paragraph */
+    { 0x00000028, 21425 }, /* parenleft */
+    { 0x00000029, 21435 }, /* parenright */
+    { 0x01002202, 21446 }, /* partdifferential */
+    { 0x000008ef, 21463 }, /* partialderivative */
+    { 0x0000ff13, 21481 }, /* Pause */
+    { 0x00000025, 21487 }, /* percent */
+    { 0x0000002e, 21495 }, /* period */
+    { 0x000000b7, 21502 }, /* periodcentered */
+    { 0x00000ad5, 21517 }, /* permille */
+    { 0x010020a7, 21526 }, /* PesetaSign */
+    { 0x00000afb, 21537 }, /* phonographcopyright */
+    { 0x0000002b, 21557 }, /* plus */
+    { 0x000000b1, 21562 }, /* plusminus */
+    { 0x0000fefa, 21572 }, /* Pointer_Accelerate */
+    { 0x0000fee9, 21591 }, /* Pointer_Button1 */
+    { 0x0000feea, 21607 }, /* Pointer_Button2 */
+    { 0x0000feeb, 21623 }, /* Pointer_Button3 */
+    { 0x0000feec, 21639 }, /* Pointer_Button4 */
+    { 0x0000feed, 21655 }, /* Pointer_Button5 */
+    { 0x0000fee8, 21671 }, /* Pointer_Button_Dflt */
+    { 0x0000feef, 21691 }, /* Pointer_DblClick1 */
+    { 0x0000fef0, 21709 }, /* Pointer_DblClick2 */
+    { 0x0000fef1, 21727 }, /* Pointer_DblClick3 */
+    { 0x0000fef2, 21745 }, /* Pointer_DblClick4 */
+    { 0x0000fef3, 21763 }, /* Pointer_DblClick5 */
+    { 0x0000feee, 21781 }, /* Pointer_DblClick_Dflt */
+    { 0x0000fefb, 21803 }, /* Pointer_DfltBtnNext */
+    { 0x0000fefc, 21823 }, /* Pointer_DfltBtnPrev */
+    { 0x0000fee3, 21843 }, /* Pointer_Down */
+    { 0x0000fee6, 21856 }, /* Pointer_DownLeft */
+    { 0x0000fee7, 21873 }, /* Pointer_DownRight */
+    { 0x0000fef5, 21891 }, /* Pointer_Drag1 */
+    { 0x0000fef6, 21905 }, /* Pointer_Drag2 */
+    { 0x0000fef7, 21919 }, /* Pointer_Drag3 */
+    { 0x0000fef8, 21933 }, /* Pointer_Drag4 */
+    { 0x0000fefd, 21947 }, /* Pointer_Drag5 */
+    { 0x0000fef4, 21961 }, /* Pointer_Drag_Dflt */
+    { 0x0000fef9, 21979 }, /* Pointer_EnableKeys */
+    { 0x0000fee0, 21998 }, /* Pointer_Left */
+    { 0x0000fee1, 22011 }, /* Pointer_Right */
+    { 0x0000fee2, 22025 }, /* Pointer_Up */
+    { 0x0000fee4, 22036 }, /* Pointer_UpLeft */
+    { 0x0000fee5, 22051 }, /* Pointer_UpRight */
+    { 0x00000ad4, 22067 }, /* prescription */
+    { 0x0000fed1, 22080 }, /* Prev_Virtual_Screen */
+    { 0x0000ff3e, 22100 }, /* PreviousCandidate */
+    { 0x0000ff61, 22118 }, /* Print */
+    { 0x0000ff55, 22124 }, /* Prior */
+    { 0x000004b0, 22130 }, /* prolongedsound */
+    { 0x00000aa6, 22145 }, /* punctspace */
+    { 0x00000051, 22156 }, /* Q */
+    { 0x00000071, 22158 }, /* q */
+    { 0x00000bcc, 22160 }, /* quad */
+    { 0x0000003f, 22165 }, /* question */
+    { 0x000000bf, 22174 }, /* questiondown */
+    { 0x00000022, 22187 }, /* quotedbl */
+    { 0x00000060, 22196 }, /* quoteleft */
+    { 0x00000027, 22206 }, /* quoteright */
+    { 0x00000052, 22217 }, /* R */
+    { 0x00000072, 22219 }, /* r */
+    { 0x0000ffd2, 22221 }, /* R1 */
+    { 0x0000ffdb, 22224 }, /* R10 */
+    { 0x0000ffdc, 22228 }, /* R11 */
+    { 0x0000ffdd, 22232 }, /* R12 */
+    { 0x0000ffde, 22236 }, /* R13 */
+    { 0x0000ffdf, 22240 }, /* R14 */
+    { 0x0000ffe0, 22244 }, /* R15 */
+    { 0x0000ffd3, 22248 }, /* R2 */
+    { 0x0000ffd4, 22251 }, /* R3 */
+    { 0x0000ffd5, 22254 }, /* R4 */
+    { 0x0000ffd6, 22257 }, /* R5 */
+    { 0x0000ffd7, 22260 }, /* R6 */
+    { 0x0000ffd8, 22263 }, /* R7 */
+    { 0x0000ffd9, 22266 }, /* R8 */
+    { 0x0000ffda, 22269 }, /* R9 */
+    { 0x000001c0, 22272 }, /* Racute */
+    { 0x000001e0, 22279 }, /* racute */
+    { 0x000008d6, 22286 }, /* radical */
+    { 0x000001d8, 22294 }, /* Rcaron */
+    { 0x000001f8, 22301 }, /* rcaron */
+    { 0x000003a3, 22308 }, /* Rcedilla */
+    { 0x000003b3, 22317 }, /* rcedilla */
+    { 0x0000ff66, 22326 }, /* Redo */
+    { 0x000000ae, 22331 }, /* registered */
+    { 0x0000fe72, 22342 }, /* RepeatKeys_Enable */
+    { 0x1000ff6c, 22360 }, /* Reset */
+    { 0x0000ff0d, 22366 }, /* Return */
+    { 0x0000ff53, 22373 }, /* Right */
+    { 0x00000abe, 22379 }, /* rightanglebracket */
+    { 0x000008fd, 22397 }, /* rightarrow */
+    { 0x00000ba6, 22408 }, /* rightcaret */
+    { 0x00000ad3, 22419 }, /* rightdoublequotemark */
+    { 0x000008b0, 22440 }, /* rightmiddlecurlybrace */
+    { 0x000008b7, 22462 }, /* rightmiddlesummation */
+    { 0x00000acd, 22483 }, /* rightopentriangle */
+    { 0x00000aeb, 22501 }, /* rightpointer */
+    { 0x00000bd8, 22514 }, /* rightshoe */
+    { 0x00000ad1, 22524 }, /* rightsinglequotemark */
+    { 0x000009f5, 22545 }, /* rightt */
+    { 0x00000bfc, 22552 }, /* righttack */
+    { 0x0000ff24, 22562 }, /* Romaji */
+    { 0x010020a8, 22569 }, /* RupeeSign */
+    { 0x00000053, 22579 }, /* S */
+    { 0x00000073, 22581 }, /* s */
+    { 0x01001e60, 22583 }, /* Sabovedot */
+    { 0x01001e61, 22593 }, /* sabovedot */
+    { 0x000001a6, 22603 }, /* Sacute */
+    { 0x000001b6, 22610 }, /* sacute */
+    { 0x000001a9, 22617 }, /* Scaron */
+    { 0x000001b9, 22624 }, /* scaron */
+    { 0x000001aa, 22631 }, /* Scedilla */
+    { 0x000001ba, 22640 }, /* scedilla */
+    { 0x0100018f, 22649 }, /* SCHWA */
+    { 0x01000259, 22655 }, /* schwa */
+    { 0x000002de, 22661 }, /* Scircumflex */
+    { 0x000002fe, 22673 }, /* scircumflex */
+    { 0x0000ff7e, 22685 }, /* script_switch */
+    { 0x0000ff14, 22699 }, /* Scroll_Lock */
+    { 0x00000ad7, 22711 }, /* seconds */
+    { 0x000000a7, 22719 }, /* section */
+    { 0x0000ff60, 22727 }, /* Select */
+    { 0x0000003b, 22734 }, /* semicolon */
+    { 0x000004df, 22744 }, /* semivoicedsound */
+    { 0x000006a1, 22760 }, /* Serbian_dje */
+    { 0x000006b1, 22772 }, /* Serbian_DJE */
+    { 0x000006af, 22784 }, /* Serbian_dze */
+    { 0x000006bf, 22796 }, /* Serbian_DZE */
+    { 0x000006a8, 22808 }, /* Serbian_je */
+    { 0x000006b8, 22819 }, /* Serbian_JE */
+    { 0x000006a9, 22830 }, /* Serbian_lje */
+    { 0x000006b9, 22842 }, /* Serbian_LJE */
+    { 0x000006aa, 22854 }, /* Serbian_nje */
+    { 0x000006ba, 22866 }, /* Serbian_NJE */
+    { 0x000006ab, 22878 }, /* Serbian_tshe */
+    { 0x000006bb, 22891 }, /* Serbian_TSHE */
+    { 0x00000ac6, 22904 }, /* seveneighths */
+    { 0x01002087, 22917 }, /* sevensubscript */
+    { 0x01002077, 22932 }, /* sevensuperior */
+    { 0x0000ffe1, 22946 }, /* Shift_L */
+    { 0x0000ffe6, 22954 }, /* Shift_Lock */
+    { 0x0000ffe2, 22965 }, /* Shift_R */
+    { 0x00000aca, 22973 }, /* signaturemark */
+    { 0x00000aac, 22987 }, /* signifblank */
+    { 0x000008c9, 22999 }, /* similarequal */
+    { 0x0000ff3c, 23012 }, /* SingleCandidate */
+    { 0x00000afd, 23028 }, /* singlelowquotemark */
+    { 0x01000d85, 23047 }, /* Sinh_a */
+    { 0x01000d86, 23054 }, /* Sinh_aa */
+    { 0x01000dcf, 23062 }, /* Sinh_aa2 */
+    { 0x01000d87, 23071 }, /* Sinh_ae */
+    { 0x01000dd0, 23079 }, /* Sinh_ae2 */
+    { 0x01000d88, 23088 }, /* Sinh_aee */
+    { 0x01000dd1, 23097 }, /* Sinh_aee2 */
+    { 0x01000d93, 23107 }, /* Sinh_ai */
+    { 0x01000ddb, 23115 }, /* Sinh_ai2 */
+    { 0x01000dca, 23124 }, /* Sinh_al */
+    { 0x01000d96, 23132 }, /* Sinh_au */
+    { 0x01000dde, 23140 }, /* Sinh_au2 */
+    { 0x01000db6, 23149 }, /* Sinh_ba */
+    { 0x01000db7, 23157 }, /* Sinh_bha */
+    { 0x01000da0, 23166 }, /* Sinh_ca */
+    { 0x01000da1, 23174 }, /* Sinh_cha */
+    { 0x01000da9, 23183 }, /* Sinh_dda */
+    { 0x01000daa, 23192 }, /* Sinh_ddha */
+    { 0x01000daf, 23202 }, /* Sinh_dha */
+    { 0x01000db0, 23211 }, /* Sinh_dhha */
+    { 0x01000d91, 23221 }, /* Sinh_e */
+    { 0x01000dd9, 23228 }, /* Sinh_e2 */
+    { 0x01000d92, 23236 }, /* Sinh_ee */
+    { 0x01000dda, 23244 }, /* Sinh_ee2 */
+    { 0x01000dc6, 23253 }, /* Sinh_fa */
+    { 0x01000d9c, 23261 }, /* Sinh_ga */
+    { 0x01000d9d, 23269 }, /* Sinh_gha */
+    { 0x01000d83, 23278 }, /* Sinh_h2 */
+    { 0x01000dc4, 23286 }, /* Sinh_ha */
+    { 0x01000d89, 23294 }, /* Sinh_i */
+    { 0x01000dd2, 23301 }, /* Sinh_i2 */
+    { 0x01000d8a, 23309 }, /* Sinh_ii */
+    { 0x01000dd3, 23317 }, /* Sinh_ii2 */
+    { 0x01000da2, 23326 }, /* Sinh_ja */
+    { 0x01000da3, 23334 }, /* Sinh_jha */
+    { 0x01000da5, 23343 }, /* Sinh_jnya */
+    { 0x01000d9a, 23353 }, /* Sinh_ka */
+    { 0x01000d9b, 23361 }, /* Sinh_kha */
+    { 0x01000df4, 23370 }, /* Sinh_kunddaliya */
+    { 0x01000dbd, 23386 }, /* Sinh_la */
+    { 0x01000dc5, 23394 }, /* Sinh_lla */
+    { 0x01000d8f, 23403 }, /* Sinh_lu */
+    { 0x01000ddf, 23411 }, /* Sinh_lu2 */
+    { 0x01000d90, 23420 }, /* Sinh_luu */
+    { 0x01000df3, 23429 }, /* Sinh_luu2 */
+    { 0x01000db8, 23439 }, /* Sinh_ma */
+    { 0x01000db9, 23447 }, /* Sinh_mba */
+    { 0x01000db1, 23456 }, /* Sinh_na */
+    { 0x01000dac, 23464 }, /* Sinh_ndda */
+    { 0x01000db3, 23474 }, /* Sinh_ndha */
+    { 0x01000d82, 23484 }, /* Sinh_ng */
+    { 0x01000d9e, 23492 }, /* Sinh_ng2 */
+    { 0x01000d9f, 23501 }, /* Sinh_nga */
+    { 0x01000da6, 23510 }, /* Sinh_nja */
+    { 0x01000dab, 23519 }, /* Sinh_nna */
+    { 0x01000da4, 23528 }, /* Sinh_nya */
+    { 0x01000d94, 23537 }, /* Sinh_o */
+    { 0x01000ddc, 23544 }, /* Sinh_o2 */
+    { 0x01000d95, 23552 }, /* Sinh_oo */
+    { 0x01000ddd, 23560 }, /* Sinh_oo2 */
+    { 0x01000db4, 23569 }, /* Sinh_pa */
+    { 0x01000db5, 23577 }, /* Sinh_pha */
+    { 0x01000dbb, 23586 }, /* Sinh_ra */
+    { 0x01000d8d, 23594 }, /* Sinh_ri */
+    { 0x01000d8e, 23602 }, /* Sinh_rii */
+    { 0x01000dd8, 23611 }, /* Sinh_ru2 */
+    { 0x01000df2, 23620 }, /* Sinh_ruu2 */
+    { 0x01000dc3, 23630 }, /* Sinh_sa */
+    { 0x01000dc1, 23638 }, /* Sinh_sha */
+    { 0x01000dc2, 23647 }, /* Sinh_ssha */
+    { 0x01000dad, 23657 }, /* Sinh_tha */
+    { 0x01000dae, 23666 }, /* Sinh_thha */
+    { 0x01000da7, 23676 }, /* Sinh_tta */
+    { 0x01000da8, 23685 }, /* Sinh_ttha */
+    { 0x01000d8b, 23695 }, /* Sinh_u */
+    { 0x01000dd4, 23702 }, /* Sinh_u2 */
+    { 0x01000d8c, 23710 }, /* Sinh_uu */
+    { 0x01000dd6, 23718 }, /* Sinh_uu2 */
+    { 0x01000dc0, 23727 }, /* Sinh_va */
+    { 0x01000dba, 23735 }, /* Sinh_ya */
+    { 0x01002086, 23743 }, /* sixsubscript */
+    { 0x01002076, 23756 }, /* sixsuperior */
+    { 0x0000002f, 23768 }, /* slash */
+    { 0x0000fe73, 23774 }, /* SlowKeys_Enable */
+    { 0x000009e0, 23790 }, /* soliddiamond */
+    { 0x00000020, 23803 }, /* space */
+    { 0x0100221a, 23809 }, /* squareroot */
+    { 0x000000df, 23820 }, /* ssharp */
+    { 0x000000a3, 23827 }, /* sterling */
+    { 0x0000fe75, 23836 }, /* StickyKeys_Enable */
+    { 0x01002263, 23854 }, /* stricteq */
+    { 0x0000ff66, 23863 }, /* SunAgain */
+    { 0x0000ff7e, 23872 }, /* SunAltGraph */
+    { 0x1005ff77, 23884 }, /* SunAudioLowerVolume */
+    { 0x1005ff78, 23904 }, /* SunAudioMute */
+    { 0x1005ff79, 23917 }, /* SunAudioRaiseVolume */
+    { 0x0000ff20, 23937 }, /* SunCompose */
+    { 0x1005ff72, 23948 }, /* SunCopy */
+    { 0x1005ff75, 23956 }, /* SunCut */
+    { 0x1005ff10, 23963 }, /* SunF36 */
+    { 0x1005ff11, 23970 }, /* SunF37 */
+    { 0x1005ff03, 23977 }, /* SunFA_Acute */
+    { 0x1005ff05, 23989 }, /* SunFA_Cedilla */
+    { 0x1005ff01, 24003 }, /* SunFA_Circum */
+    { 0x1005ff04, 24016 }, /* SunFA_Diaeresis */
+    { 0x1005ff00, 24032 }, /* SunFA_Grave */
+    { 0x1005ff02, 24044 }, /* SunFA_Tilde */
+    { 0x0000ff68, 24056 }, /* SunFind */
+    { 0x1005ff71, 24064 }, /* SunFront */
+    { 0x1005ff73, 24073 }, /* SunOpen */
+    { 0x0000ff56, 24081 }, /* SunPageDown */
+    { 0x0000ff55, 24093 }, /* SunPageUp */
+    { 0x1005ff74, 24103 }, /* SunPaste */
+    { 0x1005ff76, 24112 }, /* SunPowerSwitch */
+    { 0x1005ff7d, 24127 }, /* SunPowerSwitchShift */
+    { 0x0000ff61, 24147 }, /* SunPrint_Screen */
+    { 0x1005ff70, 24163 }, /* SunProps */
+    { 0x0000ff69, 24172 }, /* SunStop */
+    { 0x1005ff60, 24180 }, /* SunSys_Req */
+    { 0x0000ff65, 24191 }, /* SunUndo */
+    { 0x1005ff7a, 24199 }, /* SunVideoDegauss */
+    { 0x1005ff7b, 24215 }, /* SunVideoLowerBrightness */
+    { 0x1005ff7c, 24239 }, /* SunVideoRaiseBrightness */
+    { 0x0000ffeb, 24263 }, /* Super_L */
+    { 0x0000ffec, 24271 }, /* Super_R */
+    { 0x0000ff15, 24279 }, /* Sys_Req */
+    { 0x1000ff6d, 24287 }, /* System */
+    { 0x00000054, 24294 }, /* T */
+    { 0x00000074, 24296 }, /* t */
+    { 0x0000ff09, 24298 }, /* Tab */
+    { 0x01001e6a, 24302 }, /* Tabovedot */
+    { 0x01001e6b, 24312 }, /* tabovedot */
+    { 0x000001ab, 24322 }, /* Tcaron */
+    { 0x000001bb, 24329 }, /* tcaron */
+    { 0x000001de, 24336 }, /* Tcedilla */
+    { 0x000001fe, 24345 }, /* tcedilla */
+    { 0x00000af9, 24354 }, /* telephone */
+    { 0x00000afa, 24364 }, /* telephonerecorder */
+    { 0x0000fed5, 24382 }, /* Terminate_Server */
+    { 0x00000ddf, 24399 }, /* Thai_baht */
+    { 0x00000dba, 24409 }, /* Thai_bobaimai */
+    { 0x00000da8, 24423 }, /* Thai_chochan */
+    { 0x00000daa, 24436 }, /* Thai_chochang */
+    { 0x00000da9, 24450 }, /* Thai_choching */
+    { 0x00000dac, 24464 }, /* Thai_chochoe */
+    { 0x00000dae, 24477 }, /* Thai_dochada */
+    { 0x00000db4, 24490 }, /* Thai_dodek */
+    { 0x00000dbd, 24501 }, /* Thai_fofa */
+    { 0x00000dbf, 24511 }, /* Thai_fofan */
+    { 0x00000dcb, 24522 }, /* Thai_hohip */
+    { 0x00000dce, 24533 }, /* Thai_honokhuk */
+    { 0x00000da2, 24547 }, /* Thai_khokhai */
+    { 0x00000da5, 24560 }, /* Thai_khokhon */
+    { 0x00000da3, 24573 }, /* Thai_khokhuat */
+    { 0x00000da4, 24587 }, /* Thai_khokhwai */
+    { 0x00000da6, 24601 }, /* Thai_khorakhang */
+    { 0x00000da1, 24617 }, /* Thai_kokai */
+    { 0x00000de5, 24628 }, /* Thai_lakkhangyao */
+    { 0x00000df7, 24645 }, /* Thai_lekchet */
+    { 0x00000df5, 24658 }, /* Thai_lekha */
+    { 0x00000df6, 24669 }, /* Thai_lekhok */
+    { 0x00000df9, 24681 }, /* Thai_lekkao */
+    { 0x00000df1, 24693 }, /* Thai_leknung */
+    { 0x00000df8, 24706 }, /* Thai_lekpaet */
+    { 0x00000df3, 24719 }, /* Thai_leksam */
+    { 0x00000df4, 24731 }, /* Thai_leksi */
+    { 0x00000df2, 24742 }, /* Thai_leksong */
+    { 0x00000df0, 24755 }, /* Thai_leksun */
+    { 0x00000dcc, 24767 }, /* Thai_lochula */
+    { 0x00000dc5, 24780 }, /* Thai_loling */
+    { 0x00000dc6, 24792 }, /* Thai_lu */
+    { 0x00000deb, 24800 }, /* Thai_maichattawa */
+    { 0x00000de8, 24817 }, /* Thai_maiek */
+    { 0x00000dd1, 24828 }, /* Thai_maihanakat */
+    { 0x00000dde, 24844 }, /* Thai_maihanakat_maitho */
+    { 0x00000de7, 24867 }, /* Thai_maitaikhu */
+    { 0x00000de9, 24882 }, /* Thai_maitho */
+    { 0x00000dea, 24894 }, /* Thai_maitri */
+    { 0x00000de6, 24906 }, /* Thai_maiyamok */
+    { 0x00000dc1, 24920 }, /* Thai_moma */
+    { 0x00000da7, 24930 }, /* Thai_ngongu */
+    { 0x00000ded, 24942 }, /* Thai_nikhahit */
+    { 0x00000db3, 24956 }, /* Thai_nonen */
+    { 0x00000db9, 24967 }, /* Thai_nonu */
+    { 0x00000dcd, 24977 }, /* Thai_oang */
+    { 0x00000dcf, 24987 }, /* Thai_paiyannoi */
+    { 0x00000dda, 25002 }, /* Thai_phinthu */
+    { 0x00000dbe, 25015 }, /* Thai_phophan */
+    { 0x00000dbc, 25028 }, /* Thai_phophung */
+    { 0x00000dc0, 25042 }, /* Thai_phosamphao */
+    { 0x00000dbb, 25058 }, /* Thai_popla */
+    { 0x00000dc3, 25069 }, /* Thai_rorua */
+    { 0x00000dc4, 25080 }, /* Thai_ru */
+    { 0x00000dd0, 25088 }, /* Thai_saraa */
+    { 0x00000dd2, 25099 }, /* Thai_saraaa */
+    { 0x00000de1, 25111 }, /* Thai_saraae */
+    { 0x00000de4, 25123 }, /* Thai_saraaimaimalai */
+    { 0x00000de3, 25143 }, /* Thai_saraaimaimuan */
+    { 0x00000dd3, 25162 }, /* Thai_saraam */
+    { 0x00000de0, 25174 }, /* Thai_sarae */
+    { 0x00000dd4, 25185 }, /* Thai_sarai */
+    { 0x00000dd5, 25196 }, /* Thai_saraii */
+    { 0x00000de2, 25208 }, /* Thai_sarao */
+    { 0x00000dd8, 25219 }, /* Thai_sarau */
+    { 0x00000dd6, 25230 }, /* Thai_saraue */
+    { 0x00000dd7, 25242 }, /* Thai_sarauee */
+    { 0x00000dd9, 25255 }, /* Thai_sarauu */
+    { 0x00000dc9, 25267 }, /* Thai_sorusi */
+    { 0x00000dc8, 25279 }, /* Thai_sosala */
+    { 0x00000dab, 25291 }, /* Thai_soso */
+    { 0x00000dca, 25301 }, /* Thai_sosua */
+    { 0x00000dec, 25312 }, /* Thai_thanthakhat */
+    { 0x00000db1, 25329 }, /* Thai_thonangmontho */
+    { 0x00000db2, 25348 }, /* Thai_thophuthao */
+    { 0x00000db7, 25364 }, /* Thai_thothahan */
+    { 0x00000db0, 25379 }, /* Thai_thothan */
+    { 0x00000db8, 25392 }, /* Thai_thothong */
+    { 0x00000db6, 25406 }, /* Thai_thothung */
+    { 0x00000daf, 25420 }, /* Thai_topatak */
+    { 0x00000db5, 25433 }, /* Thai_totao */
+    { 0x00000dc7, 25444 }, /* Thai_wowaen */
+    { 0x00000dc2, 25456 }, /* Thai_yoyak */
+    { 0x00000dad, 25467 }, /* Thai_yoying */
+    { 0x000008c0, 25479 }, /* therefore */
+    { 0x00000aa7, 25489 }, /* thinspace */
+    { 0x000000de, 25499 }, /* THORN */
+    { 0x000000de, 25505 }, /* Thorn */
+    { 0x000000fe, 25511 }, /* thorn */
+    { 0x00000ac4, 25517 }, /* threeeighths */
+    { 0x00000ab4, 25530 }, /* threefifths */
+    { 0x000000be, 25542 }, /* threequarters */
+    { 0x01002083, 25556 }, /* threesubscript */
+    { 0x000000b3, 25571 }, /* threesuperior */
+    { 0x0100222d, 25585 }, /* tintegral */
+    { 0x000008a4, 25595 }, /* topintegral */
+    { 0x000008ab, 25607 }, /* topleftparens */
+    { 0x000008a2, 25621 }, /* topleftradical */
+    { 0x000008a7, 25636 }, /* topleftsqbracket */
+    { 0x000008b1, 25653 }, /* topleftsummation */
+    { 0x000008ad, 25670 }, /* toprightparens */
+    { 0x000008a9, 25685 }, /* toprightsqbracket */
+    { 0x000008b5, 25703 }, /* toprightsummation */
+    { 0x000009f7, 25721 }, /* topt */
+    { 0x000008b3, 25726 }, /* topvertsummationconnector */
+    { 0x0000ff2b, 25752 }, /* Touroku */
+    { 0x00000ac9, 25760 }, /* trademark */
+    { 0x00000acb, 25770 }, /* trademarkincircle */
+    { 0x000003ac, 25788 }, /* Tslash */
+    { 0x000003bc, 25795 }, /* tslash */
+    { 0x00000ab3, 25802 }, /* twofifths */
+    { 0x01002082, 25812 }, /* twosubscript */
+    { 0x000000b2, 25825 }, /* twosuperior */
+    { 0x00000ab1, 25837 }, /* twothirds */
+    { 0x00000055, 25847 }, /* U */
+    { 0x00000075, 25849 }, /* u */
+    { 0x000000da, 25851 }, /* Uacute */
+    { 0x000000fa, 25858 }, /* uacute */
+    { 0x01001ee4, 25865 }, /* Ubelowdot */
+    { 0x01001ee5, 25875 }, /* ubelowdot */
+    { 0x000002dd, 25885 }, /* Ubreve */
+    { 0x000002fd, 25892 }, /* ubreve */
+    { 0x000000db, 25899 }, /* Ucircumflex */
+    { 0x000000fb, 25911 }, /* ucircumflex */
+    { 0x000000dc, 25923 }, /* Udiaeresis */
+    { 0x000000fc, 25934 }, /* udiaeresis */
+    { 0x000001db, 25945 }, /* Udoubleacute */
+    { 0x000001fb, 25958 }, /* udoubleacute */
+    { 0x000000d9, 25971 }, /* Ugrave */
+    { 0x000000f9, 25978 }, /* ugrave */
+    { 0x01001ee6, 25985 }, /* Uhook */
+    { 0x01001ee7, 25991 }, /* uhook */
+    { 0x010001af, 25997 }, /* Uhorn */
+    { 0x010001b0, 26003 }, /* uhorn */
+    { 0x01001ee8, 26009 }, /* Uhornacute */
+    { 0x01001ee9, 26020 }, /* uhornacute */
+    { 0x01001ef0, 26031 }, /* Uhornbelowdot */
+    { 0x01001ef1, 26045 }, /* uhornbelowdot */
+    { 0x01001eea, 26059 }, /* Uhorngrave */
+    { 0x01001eeb, 26070 }, /* uhorngrave */
+    { 0x01001eec, 26081 }, /* Uhornhook */
+    { 0x01001eed, 26091 }, /* uhornhook */
+    { 0x01001eee, 26101 }, /* Uhorntilde */
+    { 0x01001eef, 26112 }, /* uhorntilde */
+    { 0x000006ad, 26123 }, /* Ukrainian_ghe_with_upturn */
+    { 0x000006bd, 26149 }, /* Ukrainian_GHE_WITH_UPTURN */
+    { 0x000006a6, 26175 }, /* Ukrainian_i */
+    { 0x000006b6, 26187 }, /* Ukrainian_I */
+    { 0x000006a4, 26199 }, /* Ukrainian_ie */
+    { 0x000006b4, 26212 }, /* Ukrainian_IE */
+    { 0x000006a7, 26225 }, /* Ukrainian_yi */
+    { 0x000006b7, 26238 }, /* Ukrainian_YI */
+    { 0x000006a6, 26251 }, /* Ukranian_i */
+    { 0x000006b6, 26262 }, /* Ukranian_I */
+    { 0x000006a4, 26273 }, /* Ukranian_je */
+    { 0x000006b4, 26285 }, /* Ukranian_JE */
+    { 0x000006a7, 26297 }, /* Ukranian_yi */
+    { 0x000006b7, 26309 }, /* Ukranian_YI */
+    { 0x000003de, 26321 }, /* Umacron */
+    { 0x000003fe, 26329 }, /* umacron */
+    { 0x00000bc6, 26337 }, /* underbar */
+    { 0x0000005f, 26346 }, /* underscore */
+    { 0x0000ff65, 26357 }, /* Undo */
+    { 0x000008dd, 26362 }, /* union */
+    { 0x000003d9, 26368 }, /* Uogonek */
+    { 0x000003f9, 26376 }, /* uogonek */
+    { 0x0000ff52, 26384 }, /* Up */
+    { 0x000008fc, 26387 }, /* uparrow */
+    { 0x00000ba9, 26395 }, /* upcaret */
+    { 0x000009ec, 26403 }, /* upleftcorner */
+    { 0x000009eb, 26416 }, /* uprightcorner */
+    { 0x00000bc3, 26430 }, /* upshoe */
+    { 0x00000bd3, 26437 }, /* upstile */
+    { 0x00000bce, 26445 }, /* uptack */
+    { 0x000001d9, 26452 }, /* Uring */
+    { 0x000001f9, 26458 }, /* uring */
+    { 0x1000ff6e, 26464 }, /* User */
+    { 0x000003dd, 26469 }, /* Utilde */
+    { 0x000003fd, 26476 }, /* utilde */
+    { 0x00000056, 26483 }, /* V */
+    { 0x00000076, 26485 }, /* v */
+    { 0x000008c1, 26487 }, /* variation */
+    { 0x000009f8, 26497 }, /* vertbar */
+    { 0x000008a6, 26505 }, /* vertconnector */
+    { 0x000004de, 26519 }, /* voicedsound */
+    { 0x00ffffff, 26531 }, /* VoidSymbol */
+    { 0x000009e9, 26542 }, /* vt */
+    { 0x00000057, 26545 }, /* W */
+    { 0x00000077, 26547 }, /* w */
+    { 0x01001e82, 26549 }, /* Wacute */
+    { 0x01001e83, 26556 }, /* wacute */
+    { 0x01000174, 26563 }, /* Wcircumflex */
+    { 0x01000175, 26575 }, /* wcircumflex */
+    { 0x01001e84, 26587 }, /* Wdiaeresis */
+    { 0x01001e85, 26598 }, /* wdiaeresis */
+    { 0x01001e80, 26609 }, /* Wgrave */
+    { 0x01001e81, 26616 }, /* wgrave */
+    { 0x010020a9, 26623 }, /* WonSign */
+    { 0x00000058, 26631 }, /* X */
+    { 0x00000078, 26633 }, /* x */
+    { 0x01001e8a, 26635 }, /* Xabovedot */
+    { 0x01001e8b, 26645 }, /* xabovedot */
+    { 0x1008ff39, 26655 }, /* XF86AddFavorite */
+    { 0x1008ff50, 26671 }, /* XF86ApplicationLeft */
+    { 0x1008ff51, 26691 }, /* XF86ApplicationRight */
+    { 0x1008ff9b, 26712 }, /* XF86AudioCycleTrack */
+    { 0x1008ff97, 26732 }, /* XF86AudioForward */
+    { 0x1008ff11, 26749 }, /* XF86AudioLowerVolume */
+    { 0x1008ff32, 26770 }, /* XF86AudioMedia */
+    { 0x1008ffb2, 26785 }, /* XF86AudioMicMute */
+    { 0x1008ff12, 26802 }, /* XF86AudioMute */
+    { 0x1008ff17, 26816 }, /* XF86AudioNext */
+    { 0x1008ff31, 26830 }, /* XF86AudioPause */
+    { 0x1008ff14, 26845 }, /* XF86AudioPlay */
+    { 0x1008ff16, 26859 }, /* XF86AudioPrev */
+    { 0x1008ff13, 26873 }, /* XF86AudioRaiseVolume */
+    { 0x1008ff99, 26894 }, /* XF86AudioRandomPlay */
+    { 0x1008ff1c, 26914 }, /* XF86AudioRecord */
+    { 0x1008ff98, 26930 }, /* XF86AudioRepeat */
+    { 0x1008ff3e, 26946 }, /* XF86AudioRewind */
+    { 0x1008ff15, 26962 }, /* XF86AudioStop */
+    { 0x1008ff8d, 26976 }, /* XF86Away */
+    { 0x1008ff26, 26985 }, /* XF86Back */
+    { 0x1008ff3f, 26994 }, /* XF86BackForward */
+    { 0x1008ff93, 27010 }, /* XF86Battery */
+    { 0x1008ffa6, 27022 }, /* XF86Blue */
+    { 0x1008ff94, 27031 }, /* XF86Bluetooth */
+    { 0x1008ff52, 27045 }, /* XF86Book */
+    { 0x1008ff3b, 27054 }, /* XF86BrightnessAdjust */
+    { 0x1008ff54, 27075 }, /* XF86Calculater */
+    { 0x1008ff1d, 27090 }, /* XF86Calculator */
+    { 0x1008ff20, 27105 }, /* XF86Calendar */
+    { 0x1008ff53, 27118 }, /* XF86CD */
+    { 0x1008ff55, 27125 }, /* XF86Clear */
+    { 0x1008fe21, 27135 }, /* XF86ClearGrab */
+    { 0x1008ff56, 27149 }, /* XF86Close */
+    { 0x1008ff3d, 27159 }, /* XF86Community */
+    { 0x1008ff22, 27173 }, /* XF86ContrastAdjust */
+    { 0x1008ff57, 27192 }, /* XF86Copy */
+    { 0x1008ff58, 27201 }, /* XF86Cut */
+    { 0x1008ff9c, 27209 }, /* XF86CycleAngle */
+    { 0x1008ff59, 27224 }, /* XF86Display */
+    { 0x1008ff5b, 27236 }, /* XF86Documents */
+    { 0x1008ff5a, 27250 }, /* XF86DOS */
+    { 0x1008ff2c, 27258 }, /* XF86Eject */
+    { 0x1008ff5c, 27268 }, /* XF86Excel */
+    { 0x1008ff5d, 27278 }, /* XF86Explorer */
+    { 0x1008ff30, 27291 }, /* XF86Favorites */
+    { 0x1008ff3c, 27305 }, /* XF86Finance */
+    { 0x1008ff27, 27317 }, /* XF86Forward */
+    { 0x1008ff9d, 27329 }, /* XF86FrameBack */
+    { 0x1008ff9e, 27343 }, /* XF86FrameForward */
+    { 0x1008ff5e, 27360 }, /* XF86Game */
+    { 0x1008ff5f, 27369 }, /* XF86Go */
+    { 0x1008ffa4, 27376 }, /* XF86Green */
+    { 0x1008ffa8, 27386 }, /* XF86Hibernate */
+    { 0x1008ff37, 27400 }, /* XF86History */
+    { 0x1008ff18, 27412 }, /* XF86HomePage */
+    { 0x1008ff3a, 27425 }, /* XF86HotLinks */
+    { 0x1008ff60, 27438 }, /* XF86iTouch */
+    { 0x1008ff06, 27449 }, /* XF86KbdBrightnessDown */
+    { 0x1008ff05, 27471 }, /* XF86KbdBrightnessUp */
+    { 0x1008ff04, 27491 }, /* XF86KbdLightOnOff */
+    { 0x1008ff40, 27509 }, /* XF86Launch0 */
+    { 0x1008ff41, 27521 }, /* XF86Launch1 */
+    { 0x1008ff42, 27533 }, /* XF86Launch2 */
+    { 0x1008ff43, 27545 }, /* XF86Launch3 */
+    { 0x1008ff44, 27557 }, /* XF86Launch4 */
+    { 0x1008ff45, 27569 }, /* XF86Launch5 */
+    { 0x1008ff46, 27581 }, /* XF86Launch6 */
+    { 0x1008ff47, 27593 }, /* XF86Launch7 */
+    { 0x1008ff48, 27605 }, /* XF86Launch8 */
+    { 0x1008ff49, 27617 }, /* XF86Launch9 */
+    { 0x1008ff4a, 27629 }, /* XF86LaunchA */
+    { 0x1008ff4b, 27641 }, /* XF86LaunchB */
+    { 0x1008ff4c, 27653 }, /* XF86LaunchC */
+    { 0x1008ff4d, 27665 }, /* XF86LaunchD */
+    { 0x1008ff4e, 27677 }, /* XF86LaunchE */
+    { 0x1008ff4f, 27689 }, /* XF86LaunchF */
+    { 0x1008ff35, 27701 }, /* XF86LightBulb */
+    { 0x1008fe25, 27715 }, /* XF86LogGrabInfo */
+    { 0x1008ff61, 27731 }, /* XF86LogOff */
+    { 0x1008fe24, 27742 }, /* XF86LogWindowTree */
+    { 0x1008ff19, 27760 }, /* XF86Mail */
+    { 0x1008ff90, 27769 }, /* XF86MailForward */
+    { 0x1008ff62, 27785 }, /* XF86Market */
+    { 0x1008ff63, 27796 }, /* XF86Meeting */
+    { 0x1008ff1e, 27808 }, /* XF86Memo */
+    { 0x1008ff65, 27817 }, /* XF86MenuKB */
+    { 0x1008ff66, 27828 }, /* XF86MenuPB */
+    { 0x1008ff8e, 27839 }, /* XF86Messenger */
+    { 0x1008ff01, 27853 }, /* XF86ModeLock */
+    { 0x1008ff03, 27866 }, /* XF86MonBrightnessDown */
+    { 0x1008ff02, 27888 }, /* XF86MonBrightnessUp */
+    { 0x1008ff92, 27908 }, /* XF86Music */
+    { 0x1008ff33, 27918 }, /* XF86MyComputer */
+    { 0x1008ff67, 27933 }, /* XF86MySites */
+    { 0x1008ff68, 27945 }, /* XF86New */
+    { 0x1008ff69, 27953 }, /* XF86News */
+    { 0x1008fe22, 27962 }, /* XF86Next_VMode */
+    { 0x1008ff6a, 27977 }, /* XF86OfficeHome */
+    { 0x1008ff6b, 27992 }, /* XF86Open */
+    { 0x1008ff38, 28001 }, /* XF86OpenURL */
+    { 0x1008ff6c, 28013 }, /* XF86Option */
+    { 0x1008ff6d, 28024 }, /* XF86Paste */
+    { 0x1008ff6e, 28034 }, /* XF86Phone */
+    { 0x1008ff91, 28044 }, /* XF86Pictures */
+    { 0x1008ff21, 28057 }, /* XF86PowerDown */
+    { 0x1008ff2a, 28071 }, /* XF86PowerOff */
+    { 0x1008fe23, 28084 }, /* XF86Prev_VMode */
+    { 0x1008ff70, 28099 }, /* XF86Q */
+    { 0x1008ffa3, 28105 }, /* XF86Red */
+    { 0x1008ff29, 28113 }, /* XF86Refresh */
+    { 0x1008ff73, 28125 }, /* XF86Reload */
+    { 0x1008ff72, 28136 }, /* XF86Reply */
+    { 0x1008ff24, 28146 }, /* XF86RockerDown */
+    { 0x1008ff25, 28161 }, /* XF86RockerEnter */
+    { 0x1008ff23, 28177 }, /* XF86RockerUp */
+    { 0x1008ff74, 28190 }, /* XF86RotateWindows */
+    { 0x1008ff76, 28208 }, /* XF86RotationKB */
+    { 0x1008ff75, 28223 }, /* XF86RotationPB */
+    { 0x1008ff77, 28238 }, /* XF86Save */
+    { 0x1008ff2d, 28247 }, /* XF86ScreenSaver */
+    { 0x1008ff7a, 28263 }, /* XF86ScrollClick */
+    { 0x1008ff79, 28279 }, /* XF86ScrollDown */
+    { 0x1008ff78, 28294 }, /* XF86ScrollUp */
+    { 0x1008ff1b, 28307 }, /* XF86Search */
+    { 0x1008ffa0, 28318 }, /* XF86Select */
+    { 0x1008ff7b, 28329 }, /* XF86Send */
+    { 0x1008ff36, 28338 }, /* XF86Shop */
+    { 0x1008ff2f, 28347 }, /* XF86Sleep */
+    { 0x1008ff7c, 28357 }, /* XF86Spell */
+    { 0x1008ff7d, 28367 }, /* XF86SplitScreen */
+    { 0x1008ff10, 28383 }, /* XF86Standby */
+    { 0x1008ff1a, 28395 }, /* XF86Start */
+    { 0x1008ff28, 28405 }, /* XF86Stop */
+    { 0x1008ff9a, 28414 }, /* XF86Subtitle */
+    { 0x1008ff7e, 28427 }, /* XF86Support */
+    { 0x1008ffa7, 28439 }, /* XF86Suspend */
+    { 0x1008fe01, 28451 }, /* XF86Switch_VT_1 */
+    { 0x1008fe0a, 28467 }, /* XF86Switch_VT_10 */
+    { 0x1008fe0b, 28484 }, /* XF86Switch_VT_11 */
+    { 0x1008fe0c, 28501 }, /* XF86Switch_VT_12 */
+    { 0x1008fe02, 28518 }, /* XF86Switch_VT_2 */
+    { 0x1008fe03, 28534 }, /* XF86Switch_VT_3 */
+    { 0x1008fe04, 28550 }, /* XF86Switch_VT_4 */
+    { 0x1008fe05, 28566 }, /* XF86Switch_VT_5 */
+    { 0x1008fe06, 28582 }, /* XF86Switch_VT_6 */
+    { 0x1008fe07, 28598 }, /* XF86Switch_VT_7 */
+    { 0x1008fe08, 28614 }, /* XF86Switch_VT_8 */
+    { 0x1008fe09, 28630 }, /* XF86Switch_VT_9 */
+    { 0x1008ff7f, 28646 }, /* XF86TaskPane */
+    { 0x1008ff80, 28659 }, /* XF86Terminal */
+    { 0x1008ff9f, 28672 }, /* XF86Time */
+    { 0x1008ff1f, 28681 }, /* XF86ToDoList */
+    { 0x1008ff81, 28694 }, /* XF86Tools */
+    { 0x1008ffa2, 28704 }, /* XF86TopMenu */
+    { 0x1008ffb1, 28716 }, /* XF86TouchpadOff */
+    { 0x1008ffb0, 28732 }, /* XF86TouchpadOn */
+    { 0x1008ffa9, 28747 }, /* XF86TouchpadToggle */
+    { 0x1008ff82, 28766 }, /* XF86Travel */
+    { 0x1008fe20, 28777 }, /* XF86Ungrab */
+    { 0x1008ff85, 28788 }, /* XF86User1KB */
+    { 0x1008ff86, 28800 }, /* XF86User2KB */
+    { 0x1008ff84, 28812 }, /* XF86UserPB */
+    { 0x1008ff96, 28823 }, /* XF86UWB */
+    { 0x1008ff34, 28831 }, /* XF86VendorHome */
+    { 0x1008ff87, 28846 }, /* XF86Video */
+    { 0x1008ffa1, 28856 }, /* XF86View */
+    { 0x1008ff2b, 28865 }, /* XF86WakeUp */
+    { 0x1008ff8f, 28876 }, /* XF86WebCam */
+    { 0x1008ff88, 28887 }, /* XF86WheelButton */
+    { 0x1008ff95, 28903 }, /* XF86WLAN */
+    { 0x1008ff89, 28912 }, /* XF86Word */
+    { 0x1008ff2e, 28921 }, /* XF86WWW */
+    { 0x1008ff8a, 28929 }, /* XF86Xfer */
+    { 0x1008ffa5, 28938 }, /* XF86Yellow */
+    { 0x1008ff8b, 28949 }, /* XF86ZoomIn */
+    { 0x1008ff8c, 28960 }, /* XF86ZoomOut */
+    { 0x00000059, 28972 }, /* Y */
+    { 0x00000079, 28974 }, /* y */
+    { 0x000000dd, 28976 }, /* Yacute */
+    { 0x000000fd, 28983 }, /* yacute */
+    { 0x01001ef4, 28990 }, /* Ybelowdot */
+    { 0x01001ef5, 29000 }, /* ybelowdot */
+    { 0x01000176, 29010 }, /* Ycircumflex */
+    { 0x01000177, 29022 }, /* ycircumflex */
+    { 0x000000ff, 29034 }, /* ydiaeresis */
+    { 0x000013be, 29045 }, /* Ydiaeresis */
+    { 0x000000a5, 29056 }, /* yen */
+    { 0x01001ef2, 29060 }, /* Ygrave */
+    { 0x01001ef3, 29067 }, /* ygrave */
+    { 0x01001ef6, 29074 }, /* Yhook */
+    { 0x01001ef7, 29080 }, /* yhook */
+    { 0x01001ef8, 29086 }, /* Ytilde */
+    { 0x01001ef9, 29093 }, /* ytilde */
+    { 0x0000005a, 29100 }, /* Z */
+    { 0x0000007a, 29102 }, /* z */
+    { 0x000001af, 29104 }, /* Zabovedot */
+    { 0x000001bf, 29114 }, /* zabovedot */
+    { 0x000001ac, 29124 }, /* Zacute */
+    { 0x000001bc, 29131 }, /* zacute */
+    { 0x000001ae, 29138 }, /* Zcaron */
+    { 0x000001be, 29145 }, /* zcaron */
+    { 0x0000ff3d, 29152 }, /* Zen_Koho */
+    { 0x0000ff28, 29161 }, /* Zenkaku */
+    { 0x0000ff2a, 29169 }, /* Zenkaku_Hankaku */
+    { 0x01002080, 29185 }, /* zerosubscript */
+    { 0x01002070, 29199 }, /* zerosuperior */
+    { 0x010001b5, 29212 }, /* Zstroke */
+    { 0x010001b6, 29220 }, /* zstroke */
 };
 
 static const struct name_keysym keysym_to_name[] = {
-    { "NoSymbol", XKB_KEY_NoSymbol },
-    { "space", XKB_KEY_space },
-    { "exclam", XKB_KEY_exclam },
-    { "quotedbl", XKB_KEY_quotedbl },
-    { "numbersign", XKB_KEY_numbersign },
-    { "dollar", XKB_KEY_dollar },
-    { "percent", XKB_KEY_percent },
-    { "ampersand", XKB_KEY_ampersand },
-    { "apostrophe", XKB_KEY_apostrophe },
-    { "parenleft", XKB_KEY_parenleft },
-    { "parenright", XKB_KEY_parenright },
-    { "asterisk", XKB_KEY_asterisk },
-    { "plus", XKB_KEY_plus },
-    { "comma", XKB_KEY_comma },
-    { "minus", XKB_KEY_minus },
-    { "period", XKB_KEY_period },
-    { "slash", XKB_KEY_slash },
-    { "0", XKB_KEY_0 },
-    { "1", XKB_KEY_1 },
-    { "2", XKB_KEY_2 },
-    { "3", XKB_KEY_3 },
-    { "4", XKB_KEY_4 },
-    { "5", XKB_KEY_5 },
-    { "6", XKB_KEY_6 },
-    { "7", XKB_KEY_7 },
-    { "8", XKB_KEY_8 },
-    { "9", XKB_KEY_9 },
-    { "colon", XKB_KEY_colon },
-    { "semicolon", XKB_KEY_semicolon },
-    { "less", XKB_KEY_less },
-    { "equal", XKB_KEY_equal },
-    { "greater", XKB_KEY_greater },
-    { "question", XKB_KEY_question },
-    { "at", XKB_KEY_at },
-    { "A", XKB_KEY_A },
-    { "B", XKB_KEY_B },
-    { "C", XKB_KEY_C },
-    { "D", XKB_KEY_D },
-    { "E", XKB_KEY_E },
-    { "F", XKB_KEY_F },
-    { "G", XKB_KEY_G },
-    { "H", XKB_KEY_H },
-    { "I", XKB_KEY_I },
-    { "J", XKB_KEY_J },
-    { "K", XKB_KEY_K },
-    { "L", XKB_KEY_L },
-    { "M", XKB_KEY_M },
-    { "N", XKB_KEY_N },
-    { "O", XKB_KEY_O },
-    { "P", XKB_KEY_P },
-    { "Q", XKB_KEY_Q },
-    { "R", XKB_KEY_R },
-    { "S", XKB_KEY_S },
-    { "T", XKB_KEY_T },
-    { "U", XKB_KEY_U },
-    { "V", XKB_KEY_V },
-    { "W", XKB_KEY_W },
-    { "X", XKB_KEY_X },
-    { "Y", XKB_KEY_Y },
-    { "Z", XKB_KEY_Z },
-    { "bracketleft", XKB_KEY_bracketleft },
-    { "backslash", XKB_KEY_backslash },
-    { "bracketright", XKB_KEY_bracketright },
-    { "asciicircum", XKB_KEY_asciicircum },
-    { "underscore", XKB_KEY_underscore },
-    { "grave", XKB_KEY_grave },
-    { "a", XKB_KEY_a },
-    { "b", XKB_KEY_b },
-    { "c", XKB_KEY_c },
-    { "d", XKB_KEY_d },
-    { "e", XKB_KEY_e },
-    { "f", XKB_KEY_f },
-    { "g", XKB_KEY_g },
-    { "h", XKB_KEY_h },
-    { "i", XKB_KEY_i },
-    { "j", XKB_KEY_j },
-    { "k", XKB_KEY_k },
-    { "l", XKB_KEY_l },
-    { "m", XKB_KEY_m },
-    { "n", XKB_KEY_n },
-    { "o", XKB_KEY_o },
-    { "p", XKB_KEY_p },
-    { "q", XKB_KEY_q },
-    { "r", XKB_KEY_r },
-    { "s", XKB_KEY_s },
-    { "t", XKB_KEY_t },
-    { "u", XKB_KEY_u },
-    { "v", XKB_KEY_v },
-    { "w", XKB_KEY_w },
-    { "x", XKB_KEY_x },
-    { "y", XKB_KEY_y },
-    { "z", XKB_KEY_z },
-    { "braceleft", XKB_KEY_braceleft },
-    { "bar", XKB_KEY_bar },
-    { "braceright", XKB_KEY_braceright },
-    { "asciitilde", XKB_KEY_asciitilde },
-    { "nobreakspace", XKB_KEY_nobreakspace },
-    { "exclamdown", XKB_KEY_exclamdown },
-    { "cent", XKB_KEY_cent },
-    { "sterling", XKB_KEY_sterling },
-    { "currency", XKB_KEY_currency },
-    { "yen", XKB_KEY_yen },
-    { "brokenbar", XKB_KEY_brokenbar },
-    { "section", XKB_KEY_section },
-    { "diaeresis", XKB_KEY_diaeresis },
-    { "copyright", XKB_KEY_copyright },
-    { "ordfeminine", XKB_KEY_ordfeminine },
-    { "guillemotleft", XKB_KEY_guillemotleft },
-    { "notsign", XKB_KEY_notsign },
-    { "hyphen", XKB_KEY_hyphen },
-    { "registered", XKB_KEY_registered },
-    { "macron", XKB_KEY_macron },
-    { "degree", XKB_KEY_degree },
-    { "plusminus", XKB_KEY_plusminus },
-    { "twosuperior", XKB_KEY_twosuperior },
-    { "threesuperior", XKB_KEY_threesuperior },
-    { "acute", XKB_KEY_acute },
-    { "mu", XKB_KEY_mu },
-    { "paragraph", XKB_KEY_paragraph },
-    { "periodcentered", XKB_KEY_periodcentered },
-    { "cedilla", XKB_KEY_cedilla },
-    { "onesuperior", XKB_KEY_onesuperior },
-    { "masculine", XKB_KEY_masculine },
-    { "guillemotright", XKB_KEY_guillemotright },
-    { "onequarter", XKB_KEY_onequarter },
-    { "onehalf", XKB_KEY_onehalf },
-    { "threequarters", XKB_KEY_threequarters },
-    { "questiondown", XKB_KEY_questiondown },
-    { "Agrave", XKB_KEY_Agrave },
-    { "Aacute", XKB_KEY_Aacute },
-    { "Acircumflex", XKB_KEY_Acircumflex },
-    { "Atilde", XKB_KEY_Atilde },
-    { "Adiaeresis", XKB_KEY_Adiaeresis },
-    { "Aring", XKB_KEY_Aring },
-    { "AE", XKB_KEY_AE },
-    { "Ccedilla", XKB_KEY_Ccedilla },
-    { "Egrave", XKB_KEY_Egrave },
-    { "Eacute", XKB_KEY_Eacute },
-    { "Ecircumflex", XKB_KEY_Ecircumflex },
-    { "Ediaeresis", XKB_KEY_Ediaeresis },
-    { "Igrave", XKB_KEY_Igrave },
-    { "Iacute", XKB_KEY_Iacute },
-    { "Icircumflex", XKB_KEY_Icircumflex },
-    { "Idiaeresis", XKB_KEY_Idiaeresis },
-    { "ETH", XKB_KEY_ETH },
-    { "Ntilde", XKB_KEY_Ntilde },
-    { "Ograve", XKB_KEY_Ograve },
-    { "Oacute", XKB_KEY_Oacute },
-    { "Ocircumflex", XKB_KEY_Ocircumflex },
-    { "Otilde", XKB_KEY_Otilde },
-    { "Odiaeresis", XKB_KEY_Odiaeresis },
-    { "multiply", XKB_KEY_multiply },
-    { "Oslash", XKB_KEY_Oslash },
-    { "Ugrave", XKB_KEY_Ugrave },
-    { "Uacute", XKB_KEY_Uacute },
-    { "Ucircumflex", XKB_KEY_Ucircumflex },
-    { "Udiaeresis", XKB_KEY_Udiaeresis },
-    { "Yacute", XKB_KEY_Yacute },
-    { "THORN", XKB_KEY_THORN },
-    { "ssharp", XKB_KEY_ssharp },
-    { "agrave", XKB_KEY_agrave },
-    { "aacute", XKB_KEY_aacute },
-    { "acircumflex", XKB_KEY_acircumflex },
-    { "atilde", XKB_KEY_atilde },
-    { "adiaeresis", XKB_KEY_adiaeresis },
-    { "aring", XKB_KEY_aring },
-    { "ae", XKB_KEY_ae },
-    { "ccedilla", XKB_KEY_ccedilla },
-    { "egrave", XKB_KEY_egrave },
-    { "eacute", XKB_KEY_eacute },
-    { "ecircumflex", XKB_KEY_ecircumflex },
-    { "ediaeresis", XKB_KEY_ediaeresis },
-    { "igrave", XKB_KEY_igrave },
-    { "iacute", XKB_KEY_iacute },
-    { "icircumflex", XKB_KEY_icircumflex },
-    { "idiaeresis", XKB_KEY_idiaeresis },
-    { "eth", XKB_KEY_eth },
-    { "ntilde", XKB_KEY_ntilde },
-    { "ograve", XKB_KEY_ograve },
-    { "oacute", XKB_KEY_oacute },
-    { "ocircumflex", XKB_KEY_ocircumflex },
-    { "otilde", XKB_KEY_otilde },
-    { "odiaeresis", XKB_KEY_odiaeresis },
-    { "division", XKB_KEY_division },
-    { "oslash", XKB_KEY_oslash },
-    { "ugrave", XKB_KEY_ugrave },
-    { "uacute", XKB_KEY_uacute },
-    { "ucircumflex", XKB_KEY_ucircumflex },
-    { "udiaeresis", XKB_KEY_udiaeresis },
-    { "yacute", XKB_KEY_yacute },
-    { "thorn", XKB_KEY_thorn },
-    { "ydiaeresis", XKB_KEY_ydiaeresis },
-    { "Aogonek", XKB_KEY_Aogonek },
-    { "breve", XKB_KEY_breve },
-    { "Lstroke", XKB_KEY_Lstroke },
-    { "Lcaron", XKB_KEY_Lcaron },
-    { "Sacute", XKB_KEY_Sacute },
-    { "Scaron", XKB_KEY_Scaron },
-    { "Scedilla", XKB_KEY_Scedilla },
-    { "Tcaron", XKB_KEY_Tcaron },
-    { "Zacute", XKB_KEY_Zacute },
-    { "Zcaron", XKB_KEY_Zcaron },
-    { "Zabovedot", XKB_KEY_Zabovedot },
-    { "aogonek", XKB_KEY_aogonek },
-    { "ogonek", XKB_KEY_ogonek },
-    { "lstroke", XKB_KEY_lstroke },
-    { "lcaron", XKB_KEY_lcaron },
-    { "sacute", XKB_KEY_sacute },
-    { "caron", XKB_KEY_caron },
-    { "scaron", XKB_KEY_scaron },
-    { "scedilla", XKB_KEY_scedilla },
-    { "tcaron", XKB_KEY_tcaron },
-    { "zacute", XKB_KEY_zacute },
-    { "doubleacute", XKB_KEY_doubleacute },
-    { "zcaron", XKB_KEY_zcaron },
-    { "zabovedot", XKB_KEY_zabovedot },
-    { "Racute", XKB_KEY_Racute },
-    { "Abreve", XKB_KEY_Abreve },
-    { "Lacute", XKB_KEY_Lacute },
-    { "Cacute", XKB_KEY_Cacute },
-    { "Ccaron", XKB_KEY_Ccaron },
-    { "Eogonek", XKB_KEY_Eogonek },
-    { "Ecaron", XKB_KEY_Ecaron },
-    { "Dcaron", XKB_KEY_Dcaron },
-    { "Dstroke", XKB_KEY_Dstroke },
-    { "Nacute", XKB_KEY_Nacute },
-    { "Ncaron", XKB_KEY_Ncaron },
-    { "Odoubleacute", XKB_KEY_Odoubleacute },
-    { "Rcaron", XKB_KEY_Rcaron },
-    { "Uring", XKB_KEY_Uring },
-    { "Udoubleacute", XKB_KEY_Udoubleacute },
-    { "Tcedilla", XKB_KEY_Tcedilla },
-    { "racute", XKB_KEY_racute },
-    { "abreve", XKB_KEY_abreve },
-    { "lacute", XKB_KEY_lacute },
-    { "cacute", XKB_KEY_cacute },
-    { "ccaron", XKB_KEY_ccaron },
-    { "eogonek", XKB_KEY_eogonek },
-    { "ecaron", XKB_KEY_ecaron },
-    { "dcaron", XKB_KEY_dcaron },
-    { "dstroke", XKB_KEY_dstroke },
-    { "nacute", XKB_KEY_nacute },
-    { "ncaron", XKB_KEY_ncaron },
-    { "odoubleacute", XKB_KEY_odoubleacute },
-    { "rcaron", XKB_KEY_rcaron },
-    { "uring", XKB_KEY_uring },
-    { "udoubleacute", XKB_KEY_udoubleacute },
-    { "tcedilla", XKB_KEY_tcedilla },
-    { "abovedot", XKB_KEY_abovedot },
-    { "Hstroke", XKB_KEY_Hstroke },
-    { "Hcircumflex", XKB_KEY_Hcircumflex },
-    { "Iabovedot", XKB_KEY_Iabovedot },
-    { "Gbreve", XKB_KEY_Gbreve },
-    { "Jcircumflex", XKB_KEY_Jcircumflex },
-    { "hstroke", XKB_KEY_hstroke },
-    { "hcircumflex", XKB_KEY_hcircumflex },
-    { "idotless", XKB_KEY_idotless },
-    { "gbreve", XKB_KEY_gbreve },
-    { "jcircumflex", XKB_KEY_jcircumflex },
-    { "Cabovedot", XKB_KEY_Cabovedot },
-    { "Ccircumflex", XKB_KEY_Ccircumflex },
-    { "Gabovedot", XKB_KEY_Gabovedot },
-    { "Gcircumflex", XKB_KEY_Gcircumflex },
-    { "Ubreve", XKB_KEY_Ubreve },
-    { "Scircumflex", XKB_KEY_Scircumflex },
-    { "cabovedot", XKB_KEY_cabovedot },
-    { "ccircumflex", XKB_KEY_ccircumflex },
-    { "gabovedot", XKB_KEY_gabovedot },
-    { "gcircumflex", XKB_KEY_gcircumflex },
-    { "ubreve", XKB_KEY_ubreve },
-    { "scircumflex", XKB_KEY_scircumflex },
-    { "kra", XKB_KEY_kra },
-    { "Rcedilla", XKB_KEY_Rcedilla },
-    { "Itilde", XKB_KEY_Itilde },
-    { "Lcedilla", XKB_KEY_Lcedilla },
-    { "Emacron", XKB_KEY_Emacron },
-    { "Gcedilla", XKB_KEY_Gcedilla },
-    { "Tslash", XKB_KEY_Tslash },
-    { "rcedilla", XKB_KEY_rcedilla },
-    { "itilde", XKB_KEY_itilde },
-    { "lcedilla", XKB_KEY_lcedilla },
-    { "emacron", XKB_KEY_emacron },
-    { "gcedilla", XKB_KEY_gcedilla },
-    { "tslash", XKB_KEY_tslash },
-    { "ENG", XKB_KEY_ENG },
-    { "eng", XKB_KEY_eng },
-    { "Amacron", XKB_KEY_Amacron },
-    { "Iogonek", XKB_KEY_Iogonek },
-    { "Eabovedot", XKB_KEY_Eabovedot },
-    { "Imacron", XKB_KEY_Imacron },
-    { "Ncedilla", XKB_KEY_Ncedilla },
-    { "Omacron", XKB_KEY_Omacron },
-    { "Kcedilla", XKB_KEY_Kcedilla },
-    { "Uogonek", XKB_KEY_Uogonek },
-    { "Utilde", XKB_KEY_Utilde },
-    { "Umacron", XKB_KEY_Umacron },
-    { "amacron", XKB_KEY_amacron },
-    { "iogonek", XKB_KEY_iogonek },
-    { "eabovedot", XKB_KEY_eabovedot },
-    { "imacron", XKB_KEY_imacron },
-    { "ncedilla", XKB_KEY_ncedilla },
-    { "omacron", XKB_KEY_omacron },
-    { "kcedilla", XKB_KEY_kcedilla },
-    { "uogonek", XKB_KEY_uogonek },
-    { "utilde", XKB_KEY_utilde },
-    { "umacron", XKB_KEY_umacron },
-    { "overline", XKB_KEY_overline },
-    { "kana_fullstop", XKB_KEY_kana_fullstop },
-    { "kana_openingbracket", XKB_KEY_kana_openingbracket },
-    { "kana_closingbracket", XKB_KEY_kana_closingbracket },
-    { "kana_comma", XKB_KEY_kana_comma },
-    { "kana_conjunctive", XKB_KEY_kana_conjunctive },
-    { "kana_WO", XKB_KEY_kana_WO },
-    { "kana_a", XKB_KEY_kana_a },
-    { "kana_i", XKB_KEY_kana_i },
-    { "kana_u", XKB_KEY_kana_u },
-    { "kana_e", XKB_KEY_kana_e },
-    { "kana_o", XKB_KEY_kana_o },
-    { "kana_ya", XKB_KEY_kana_ya },
-    { "kana_yu", XKB_KEY_kana_yu },
-    { "kana_yo", XKB_KEY_kana_yo },
-    { "kana_tsu", XKB_KEY_kana_tsu },
-    { "prolongedsound", XKB_KEY_prolongedsound },
-    { "kana_A", XKB_KEY_kana_A },
-    { "kana_I", XKB_KEY_kana_I },
-    { "kana_U", XKB_KEY_kana_U },
-    { "kana_E", XKB_KEY_kana_E },
-    { "kana_O", XKB_KEY_kana_O },
-    { "kana_KA", XKB_KEY_kana_KA },
-    { "kana_KI", XKB_KEY_kana_KI },
-    { "kana_KU", XKB_KEY_kana_KU },
-    { "kana_KE", XKB_KEY_kana_KE },
-    { "kana_KO", XKB_KEY_kana_KO },
-    { "kana_SA", XKB_KEY_kana_SA },
-    { "kana_SHI", XKB_KEY_kana_SHI },
-    { "kana_SU", XKB_KEY_kana_SU },
-    { "kana_SE", XKB_KEY_kana_SE },
-    { "kana_SO", XKB_KEY_kana_SO },
-    { "kana_TA", XKB_KEY_kana_TA },
-    { "kana_CHI", XKB_KEY_kana_CHI },
-    { "kana_TSU", XKB_KEY_kana_TSU },
-    { "kana_TE", XKB_KEY_kana_TE },
-    { "kana_TO", XKB_KEY_kana_TO },
-    { "kana_NA", XKB_KEY_kana_NA },
-    { "kana_NI", XKB_KEY_kana_NI },
-    { "kana_NU", XKB_KEY_kana_NU },
-    { "kana_NE", XKB_KEY_kana_NE },
-    { "kana_NO", XKB_KEY_kana_NO },
-    { "kana_HA", XKB_KEY_kana_HA },
-    { "kana_HI", XKB_KEY_kana_HI },
-    { "kana_FU", XKB_KEY_kana_FU },
-    { "kana_HE", XKB_KEY_kana_HE },
-    { "kana_HO", XKB_KEY_kana_HO },
-    { "kana_MA", XKB_KEY_kana_MA },
-    { "kana_MI", XKB_KEY_kana_MI },
-    { "kana_MU", XKB_KEY_kana_MU },
-    { "kana_ME", XKB_KEY_kana_ME },
-    { "kana_MO", XKB_KEY_kana_MO },
-    { "kana_YA", XKB_KEY_kana_YA },
-    { "kana_YU", XKB_KEY_kana_YU },
-    { "kana_YO", XKB_KEY_kana_YO },
-    { "kana_RA", XKB_KEY_kana_RA },
-    { "kana_RI", XKB_KEY_kana_RI },
-    { "kana_RU", XKB_KEY_kana_RU },
-    { "kana_RE", XKB_KEY_kana_RE },
-    { "kana_RO", XKB_KEY_kana_RO },
-    { "kana_WA", XKB_KEY_kana_WA },
-    { "kana_N", XKB_KEY_kana_N },
-    { "voicedsound", XKB_KEY_voicedsound },
-    { "semivoicedsound", XKB_KEY_semivoicedsound },
-    { "Arabic_comma", XKB_KEY_Arabic_comma },
-    { "Arabic_semicolon", XKB_KEY_Arabic_semicolon },
-    { "Arabic_question_mark", XKB_KEY_Arabic_question_mark },
-    { "Arabic_hamza", XKB_KEY_Arabic_hamza },
-    { "Arabic_maddaonalef", XKB_KEY_Arabic_maddaonalef },
-    { "Arabic_hamzaonalef", XKB_KEY_Arabic_hamzaonalef },
-    { "Arabic_hamzaonwaw", XKB_KEY_Arabic_hamzaonwaw },
-    { "Arabic_hamzaunderalef", XKB_KEY_Arabic_hamzaunderalef },
-    { "Arabic_hamzaonyeh", XKB_KEY_Arabic_hamzaonyeh },
-    { "Arabic_alef", XKB_KEY_Arabic_alef },
-    { "Arabic_beh", XKB_KEY_Arabic_beh },
-    { "Arabic_tehmarbuta", XKB_KEY_Arabic_tehmarbuta },
-    { "Arabic_teh", XKB_KEY_Arabic_teh },
-    { "Arabic_theh", XKB_KEY_Arabic_theh },
-    { "Arabic_jeem", XKB_KEY_Arabic_jeem },
-    { "Arabic_hah", XKB_KEY_Arabic_hah },
-    { "Arabic_khah", XKB_KEY_Arabic_khah },
-    { "Arabic_dal", XKB_KEY_Arabic_dal },
-    { "Arabic_thal", XKB_KEY_Arabic_thal },
-    { "Arabic_ra", XKB_KEY_Arabic_ra },
-    { "Arabic_zain", XKB_KEY_Arabic_zain },
-    { "Arabic_seen", XKB_KEY_Arabic_seen },
-    { "Arabic_sheen", XKB_KEY_Arabic_sheen },
-    { "Arabic_sad", XKB_KEY_Arabic_sad },
-    { "Arabic_dad", XKB_KEY_Arabic_dad },
-    { "Arabic_tah", XKB_KEY_Arabic_tah },
-    { "Arabic_zah", XKB_KEY_Arabic_zah },
-    { "Arabic_ain", XKB_KEY_Arabic_ain },
-    { "Arabic_ghain", XKB_KEY_Arabic_ghain },
-    { "Arabic_tatweel", XKB_KEY_Arabic_tatweel },
-    { "Arabic_feh", XKB_KEY_Arabic_feh },
-    { "Arabic_qaf", XKB_KEY_Arabic_qaf },
-    { "Arabic_kaf", XKB_KEY_Arabic_kaf },
-    { "Arabic_lam", XKB_KEY_Arabic_lam },
-    { "Arabic_meem", XKB_KEY_Arabic_meem },
-    { "Arabic_noon", XKB_KEY_Arabic_noon },
-    { "Arabic_ha", XKB_KEY_Arabic_ha },
-    { "Arabic_waw", XKB_KEY_Arabic_waw },
-    { "Arabic_alefmaksura", XKB_KEY_Arabic_alefmaksura },
-    { "Arabic_yeh", XKB_KEY_Arabic_yeh },
-    { "Arabic_fathatan", XKB_KEY_Arabic_fathatan },
-    { "Arabic_dammatan", XKB_KEY_Arabic_dammatan },
-    { "Arabic_kasratan", XKB_KEY_Arabic_kasratan },
-    { "Arabic_fatha", XKB_KEY_Arabic_fatha },
-    { "Arabic_damma", XKB_KEY_Arabic_damma },
-    { "Arabic_kasra", XKB_KEY_Arabic_kasra },
-    { "Arabic_shadda", XKB_KEY_Arabic_shadda },
-    { "Arabic_sukun", XKB_KEY_Arabic_sukun },
-    { "Serbian_dje", XKB_KEY_Serbian_dje },
-    { "Macedonia_gje", XKB_KEY_Macedonia_gje },
-    { "Cyrillic_io", XKB_KEY_Cyrillic_io },
-    { "Ukrainian_ie", XKB_KEY_Ukrainian_ie },
-    { "Macedonia_dse", XKB_KEY_Macedonia_dse },
-    { "Ukrainian_i", XKB_KEY_Ukrainian_i },
-    { "Ukrainian_yi", XKB_KEY_Ukrainian_yi },
-    { "Cyrillic_je", XKB_KEY_Cyrillic_je },
-    { "Cyrillic_lje", XKB_KEY_Cyrillic_lje },
-    { "Cyrillic_nje", XKB_KEY_Cyrillic_nje },
-    { "Serbian_tshe", XKB_KEY_Serbian_tshe },
-    { "Macedonia_kje", XKB_KEY_Macedonia_kje },
-    { "Ukrainian_ghe_with_upturn", XKB_KEY_Ukrainian_ghe_with_upturn },
-    { "Byelorussian_shortu", XKB_KEY_Byelorussian_shortu },
-    { "Cyrillic_dzhe", XKB_KEY_Cyrillic_dzhe },
-    { "numerosign", XKB_KEY_numerosign },
-    { "Serbian_DJE", XKB_KEY_Serbian_DJE },
-    { "Macedonia_GJE", XKB_KEY_Macedonia_GJE },
-    { "Cyrillic_IO", XKB_KEY_Cyrillic_IO },
-    { "Ukrainian_IE", XKB_KEY_Ukrainian_IE },
-    { "Macedonia_DSE", XKB_KEY_Macedonia_DSE },
-    { "Ukrainian_I", XKB_KEY_Ukrainian_I },
-    { "Ukrainian_YI", XKB_KEY_Ukrainian_YI },
-    { "Cyrillic_JE", XKB_KEY_Cyrillic_JE },
-    { "Cyrillic_LJE", XKB_KEY_Cyrillic_LJE },
-    { "Cyrillic_NJE", XKB_KEY_Cyrillic_NJE },
-    { "Serbian_TSHE", XKB_KEY_Serbian_TSHE },
-    { "Macedonia_KJE", XKB_KEY_Macedonia_KJE },
-    { "Ukrainian_GHE_WITH_UPTURN", XKB_KEY_Ukrainian_GHE_WITH_UPTURN },
-    { "Byelorussian_SHORTU", XKB_KEY_Byelorussian_SHORTU },
-    { "Cyrillic_DZHE", XKB_KEY_Cyrillic_DZHE },
-    { "Cyrillic_yu", XKB_KEY_Cyrillic_yu },
-    { "Cyrillic_a", XKB_KEY_Cyrillic_a },
-    { "Cyrillic_be", XKB_KEY_Cyrillic_be },
-    { "Cyrillic_tse", XKB_KEY_Cyrillic_tse },
-    { "Cyrillic_de", XKB_KEY_Cyrillic_de },
-    { "Cyrillic_ie", XKB_KEY_Cyrillic_ie },
-    { "Cyrillic_ef", XKB_KEY_Cyrillic_ef },
-    { "Cyrillic_ghe", XKB_KEY_Cyrillic_ghe },
-    { "Cyrillic_ha", XKB_KEY_Cyrillic_ha },
-    { "Cyrillic_i", XKB_KEY_Cyrillic_i },
-    { "Cyrillic_shorti", XKB_KEY_Cyrillic_shorti },
-    { "Cyrillic_ka", XKB_KEY_Cyrillic_ka },
-    { "Cyrillic_el", XKB_KEY_Cyrillic_el },
-    { "Cyrillic_em", XKB_KEY_Cyrillic_em },
-    { "Cyrillic_en", XKB_KEY_Cyrillic_en },
-    { "Cyrillic_o", XKB_KEY_Cyrillic_o },
-    { "Cyrillic_pe", XKB_KEY_Cyrillic_pe },
-    { "Cyrillic_ya", XKB_KEY_Cyrillic_ya },
-    { "Cyrillic_er", XKB_KEY_Cyrillic_er },
-    { "Cyrillic_es", XKB_KEY_Cyrillic_es },
-    { "Cyrillic_te", XKB_KEY_Cyrillic_te },
-    { "Cyrillic_u", XKB_KEY_Cyrillic_u },
-    { "Cyrillic_zhe", XKB_KEY_Cyrillic_zhe },
-    { "Cyrillic_ve", XKB_KEY_Cyrillic_ve },
-    { "Cyrillic_softsign", XKB_KEY_Cyrillic_softsign },
-    { "Cyrillic_yeru", XKB_KEY_Cyrillic_yeru },
-    { "Cyrillic_ze", XKB_KEY_Cyrillic_ze },
-    { "Cyrillic_sha", XKB_KEY_Cyrillic_sha },
-    { "Cyrillic_e", XKB_KEY_Cyrillic_e },
-    { "Cyrillic_shcha", XKB_KEY_Cyrillic_shcha },
-    { "Cyrillic_che", XKB_KEY_Cyrillic_che },
-    { "Cyrillic_hardsign", XKB_KEY_Cyrillic_hardsign },
-    { "Cyrillic_YU", XKB_KEY_Cyrillic_YU },
-    { "Cyrillic_A", XKB_KEY_Cyrillic_A },
-    { "Cyrillic_BE", XKB_KEY_Cyrillic_BE },
-    { "Cyrillic_TSE", XKB_KEY_Cyrillic_TSE },
-    { "Cyrillic_DE", XKB_KEY_Cyrillic_DE },
-    { "Cyrillic_IE", XKB_KEY_Cyrillic_IE },
-    { "Cyrillic_EF", XKB_KEY_Cyrillic_EF },
-    { "Cyrillic_GHE", XKB_KEY_Cyrillic_GHE },
-    { "Cyrillic_HA", XKB_KEY_Cyrillic_HA },
-    { "Cyrillic_I", XKB_KEY_Cyrillic_I },
-    { "Cyrillic_SHORTI", XKB_KEY_Cyrillic_SHORTI },
-    { "Cyrillic_KA", XKB_KEY_Cyrillic_KA },
-    { "Cyrillic_EL", XKB_KEY_Cyrillic_EL },
-    { "Cyrillic_EM", XKB_KEY_Cyrillic_EM },
-    { "Cyrillic_EN", XKB_KEY_Cyrillic_EN },
-    { "Cyrillic_O", XKB_KEY_Cyrillic_O },
-    { "Cyrillic_PE", XKB_KEY_Cyrillic_PE },
-    { "Cyrillic_YA", XKB_KEY_Cyrillic_YA },
-    { "Cyrillic_ER", XKB_KEY_Cyrillic_ER },
-    { "Cyrillic_ES", XKB_KEY_Cyrillic_ES },
-    { "Cyrillic_TE", XKB_KEY_Cyrillic_TE },
-    { "Cyrillic_U", XKB_KEY_Cyrillic_U },
-    { "Cyrillic_ZHE", XKB_KEY_Cyrillic_ZHE },
-    { "Cyrillic_VE", XKB_KEY_Cyrillic_VE },
-    { "Cyrillic_SOFTSIGN", XKB_KEY_Cyrillic_SOFTSIGN },
-    { "Cyrillic_YERU", XKB_KEY_Cyrillic_YERU },
-    { "Cyrillic_ZE", XKB_KEY_Cyrillic_ZE },
-    { "Cyrillic_SHA", XKB_KEY_Cyrillic_SHA },
-    { "Cyrillic_E", XKB_KEY_Cyrillic_E },
-    { "Cyrillic_SHCHA", XKB_KEY_Cyrillic_SHCHA },
-    { "Cyrillic_CHE", XKB_KEY_Cyrillic_CHE },
-    { "Cyrillic_HARDSIGN", XKB_KEY_Cyrillic_HARDSIGN },
-    { "Greek_ALPHAaccent", XKB_KEY_Greek_ALPHAaccent },
-    { "Greek_EPSILONaccent", XKB_KEY_Greek_EPSILONaccent },
-    { "Greek_ETAaccent", XKB_KEY_Greek_ETAaccent },
-    { "Greek_IOTAaccent", XKB_KEY_Greek_IOTAaccent },
-    { "Greek_IOTAdieresis", XKB_KEY_Greek_IOTAdieresis },
-    { "Greek_OMICRONaccent", XKB_KEY_Greek_OMICRONaccent },
-    { "Greek_UPSILONaccent", XKB_KEY_Greek_UPSILONaccent },
-    { "Greek_UPSILONdieresis", XKB_KEY_Greek_UPSILONdieresis },
-    { "Greek_OMEGAaccent", XKB_KEY_Greek_OMEGAaccent },
-    { "Greek_accentdieresis", XKB_KEY_Greek_accentdieresis },
-    { "Greek_horizbar", XKB_KEY_Greek_horizbar },
-    { "Greek_alphaaccent", XKB_KEY_Greek_alphaaccent },
-    { "Greek_epsilonaccent", XKB_KEY_Greek_epsilonaccent },
-    { "Greek_etaaccent", XKB_KEY_Greek_etaaccent },
-    { "Greek_iotaaccent", XKB_KEY_Greek_iotaaccent },
-    { "Greek_iotadieresis", XKB_KEY_Greek_iotadieresis },
-    { "Greek_iotaaccentdieresis", XKB_KEY_Greek_iotaaccentdieresis },
-    { "Greek_omicronaccent", XKB_KEY_Greek_omicronaccent },
-    { "Greek_upsilonaccent", XKB_KEY_Greek_upsilonaccent },
-    { "Greek_upsilondieresis", XKB_KEY_Greek_upsilondieresis },
-    { "Greek_upsilonaccentdieresis", XKB_KEY_Greek_upsilonaccentdieresis },
-    { "Greek_omegaaccent", XKB_KEY_Greek_omegaaccent },
-    { "Greek_ALPHA", XKB_KEY_Greek_ALPHA },
-    { "Greek_BETA", XKB_KEY_Greek_BETA },
-    { "Greek_GAMMA", XKB_KEY_Greek_GAMMA },
-    { "Greek_DELTA", XKB_KEY_Greek_DELTA },
-    { "Greek_EPSILON", XKB_KEY_Greek_EPSILON },
-    { "Greek_ZETA", XKB_KEY_Greek_ZETA },
-    { "Greek_ETA", XKB_KEY_Greek_ETA },
-    { "Greek_THETA", XKB_KEY_Greek_THETA },
-    { "Greek_IOTA", XKB_KEY_Greek_IOTA },
-    { "Greek_KAPPA", XKB_KEY_Greek_KAPPA },
-    { "Greek_LAMDA", XKB_KEY_Greek_LAMDA },
-    { "Greek_MU", XKB_KEY_Greek_MU },
-    { "Greek_NU", XKB_KEY_Greek_NU },
-    { "Greek_XI", XKB_KEY_Greek_XI },
-    { "Greek_OMICRON", XKB_KEY_Greek_OMICRON },
-    { "Greek_PI", XKB_KEY_Greek_PI },
-    { "Greek_RHO", XKB_KEY_Greek_RHO },
-    { "Greek_SIGMA", XKB_KEY_Greek_SIGMA },
-    { "Greek_TAU", XKB_KEY_Greek_TAU },
-    { "Greek_UPSILON", XKB_KEY_Greek_UPSILON },
-    { "Greek_PHI", XKB_KEY_Greek_PHI },
-    { "Greek_CHI", XKB_KEY_Greek_CHI },
-    { "Greek_PSI", XKB_KEY_Greek_PSI },
-    { "Greek_OMEGA", XKB_KEY_Greek_OMEGA },
-    { "Greek_alpha", XKB_KEY_Greek_alpha },
-    { "Greek_beta", XKB_KEY_Greek_beta },
-    { "Greek_gamma", XKB_KEY_Greek_gamma },
-    { "Greek_delta", XKB_KEY_Greek_delta },
-    { "Greek_epsilon", XKB_KEY_Greek_epsilon },
-    { "Greek_zeta", XKB_KEY_Greek_zeta },
-    { "Greek_eta", XKB_KEY_Greek_eta },
-    { "Greek_theta", XKB_KEY_Greek_theta },
-    { "Greek_iota", XKB_KEY_Greek_iota },
-    { "Greek_kappa", XKB_KEY_Greek_kappa },
-    { "Greek_lamda", XKB_KEY_Greek_lamda },
-    { "Greek_mu", XKB_KEY_Greek_mu },
-    { "Greek_nu", XKB_KEY_Greek_nu },
-    { "Greek_xi", XKB_KEY_Greek_xi },
-    { "Greek_omicron", XKB_KEY_Greek_omicron },
-    { "Greek_pi", XKB_KEY_Greek_pi },
-    { "Greek_rho", XKB_KEY_Greek_rho },
-    { "Greek_sigma", XKB_KEY_Greek_sigma },
-    { "Greek_finalsmallsigma", XKB_KEY_Greek_finalsmallsigma },
-    { "Greek_tau", XKB_KEY_Greek_tau },
-    { "Greek_upsilon", XKB_KEY_Greek_upsilon },
-    { "Greek_phi", XKB_KEY_Greek_phi },
-    { "Greek_chi", XKB_KEY_Greek_chi },
-    { "Greek_psi", XKB_KEY_Greek_psi },
-    { "Greek_omega", XKB_KEY_Greek_omega },
-    { "leftradical", XKB_KEY_leftradical },
-    { "topleftradical", XKB_KEY_topleftradical },
-    { "horizconnector", XKB_KEY_horizconnector },
-    { "topintegral", XKB_KEY_topintegral },
-    { "botintegral", XKB_KEY_botintegral },
-    { "vertconnector", XKB_KEY_vertconnector },
-    { "topleftsqbracket", XKB_KEY_topleftsqbracket },
-    { "botleftsqbracket", XKB_KEY_botleftsqbracket },
-    { "toprightsqbracket", XKB_KEY_toprightsqbracket },
-    { "botrightsqbracket", XKB_KEY_botrightsqbracket },
-    { "topleftparens", XKB_KEY_topleftparens },
-    { "botleftparens", XKB_KEY_botleftparens },
-    { "toprightparens", XKB_KEY_toprightparens },
-    { "botrightparens", XKB_KEY_botrightparens },
-    { "leftmiddlecurlybrace", XKB_KEY_leftmiddlecurlybrace },
-    { "rightmiddlecurlybrace", XKB_KEY_rightmiddlecurlybrace },
-    { "topleftsummation", XKB_KEY_topleftsummation },
-    { "botleftsummation", XKB_KEY_botleftsummation },
-    { "topvertsummationconnector", XKB_KEY_topvertsummationconnector },
-    { "botvertsummationconnector", XKB_KEY_botvertsummationconnector },
-    { "toprightsummation", XKB_KEY_toprightsummation },
-    { "botrightsummation", XKB_KEY_botrightsummation },
-    { "rightmiddlesummation", XKB_KEY_rightmiddlesummation },
-    { "lessthanequal", XKB_KEY_lessthanequal },
-    { "notequal", XKB_KEY_notequal },
-    { "greaterthanequal", XKB_KEY_greaterthanequal },
-    { "integral", XKB_KEY_integral },
-    { "therefore", XKB_KEY_therefore },
-    { "variation", XKB_KEY_variation },
-    { "infinity", XKB_KEY_infinity },
-    { "nabla", XKB_KEY_nabla },
-    { "approximate", XKB_KEY_approximate },
-    { "similarequal", XKB_KEY_similarequal },
-    { "ifonlyif", XKB_KEY_ifonlyif },
-    { "implies", XKB_KEY_implies },
-    { "identical", XKB_KEY_identical },
-    { "radical", XKB_KEY_radical },
-    { "includedin", XKB_KEY_includedin },
-    { "includes", XKB_KEY_includes },
-    { "intersection", XKB_KEY_intersection },
-    { "union", XKB_KEY_union },
-    { "logicaland", XKB_KEY_logicaland },
-    { "logicalor", XKB_KEY_logicalor },
-    { "partialderivative", XKB_KEY_partialderivative },
-    { "function", XKB_KEY_function },
-    { "leftarrow", XKB_KEY_leftarrow },
-    { "uparrow", XKB_KEY_uparrow },
-    { "rightarrow", XKB_KEY_rightarrow },
-    { "downarrow", XKB_KEY_downarrow },
-    { "blank", XKB_KEY_blank },
-    { "soliddiamond", XKB_KEY_soliddiamond },
-    { "checkerboard", XKB_KEY_checkerboard },
-    { "ht", XKB_KEY_ht },
-    { "ff", XKB_KEY_ff },
-    { "cr", XKB_KEY_cr },
-    { "lf", XKB_KEY_lf },
-    { "nl", XKB_KEY_nl },
-    { "vt", XKB_KEY_vt },
-    { "lowrightcorner", XKB_KEY_lowrightcorner },
-    { "uprightcorner", XKB_KEY_uprightcorner },
-    { "upleftcorner", XKB_KEY_upleftcorner },
-    { "lowleftcorner", XKB_KEY_lowleftcorner },
-    { "crossinglines", XKB_KEY_crossinglines },
-    { "horizlinescan1", XKB_KEY_horizlinescan1 },
-    { "horizlinescan3", XKB_KEY_horizlinescan3 },
-    { "horizlinescan5", XKB_KEY_horizlinescan5 },
-    { "horizlinescan7", XKB_KEY_horizlinescan7 },
-    { "horizlinescan9", XKB_KEY_horizlinescan9 },
-    { "leftt", XKB_KEY_leftt },
-    { "rightt", XKB_KEY_rightt },
-    { "bott", XKB_KEY_bott },
-    { "topt", XKB_KEY_topt },
-    { "vertbar", XKB_KEY_vertbar },
-    { "emspace", XKB_KEY_emspace },
-    { "enspace", XKB_KEY_enspace },
-    { "em3space", XKB_KEY_em3space },
-    { "em4space", XKB_KEY_em4space },
-    { "digitspace", XKB_KEY_digitspace },
-    { "punctspace", XKB_KEY_punctspace },
-    { "thinspace", XKB_KEY_thinspace },
-    { "hairspace", XKB_KEY_hairspace },
-    { "emdash", XKB_KEY_emdash },
-    { "endash", XKB_KEY_endash },
-    { "signifblank", XKB_KEY_signifblank },
-    { "ellipsis", XKB_KEY_ellipsis },
-    { "doubbaselinedot", XKB_KEY_doubbaselinedot },
-    { "onethird", XKB_KEY_onethird },
-    { "twothirds", XKB_KEY_twothirds },
-    { "onefifth", XKB_KEY_onefifth },
-    { "twofifths", XKB_KEY_twofifths },
-    { "threefifths", XKB_KEY_threefifths },
-    { "fourfifths", XKB_KEY_fourfifths },
-    { "onesixth", XKB_KEY_onesixth },
-    { "fivesixths", XKB_KEY_fivesixths },
-    { "careof", XKB_KEY_careof },
-    { "figdash", XKB_KEY_figdash },
-    { "leftanglebracket", XKB_KEY_leftanglebracket },
-    { "decimalpoint", XKB_KEY_decimalpoint },
-    { "rightanglebracket", XKB_KEY_rightanglebracket },
-    { "marker", XKB_KEY_marker },
-    { "oneeighth", XKB_KEY_oneeighth },
-    { "threeeighths", XKB_KEY_threeeighths },
-    { "fiveeighths", XKB_KEY_fiveeighths },
-    { "seveneighths", XKB_KEY_seveneighths },
-    { "trademark", XKB_KEY_trademark },
-    { "signaturemark", XKB_KEY_signaturemark },
-    { "trademarkincircle", XKB_KEY_trademarkincircle },
-    { "leftopentriangle", XKB_KEY_leftopentriangle },
-    { "rightopentriangle", XKB_KEY_rightopentriangle },
-    { "emopencircle", XKB_KEY_emopencircle },
-    { "emopenrectangle", XKB_KEY_emopenrectangle },
-    { "leftsinglequotemark", XKB_KEY_leftsinglequotemark },
-    { "rightsinglequotemark", XKB_KEY_rightsinglequotemark },
-    { "leftdoublequotemark", XKB_KEY_leftdoublequotemark },
-    { "rightdoublequotemark", XKB_KEY_rightdoublequotemark },
-    { "prescription", XKB_KEY_prescription },
-    { "permille", XKB_KEY_permille },
-    { "minutes", XKB_KEY_minutes },
-    { "seconds", XKB_KEY_seconds },
-    { "latincross", XKB_KEY_latincross },
-    { "hexagram", XKB_KEY_hexagram },
-    { "filledrectbullet", XKB_KEY_filledrectbullet },
-    { "filledlefttribullet", XKB_KEY_filledlefttribullet },
-    { "filledrighttribullet", XKB_KEY_filledrighttribullet },
-    { "emfilledcircle", XKB_KEY_emfilledcircle },
-    { "emfilledrect", XKB_KEY_emfilledrect },
-    { "enopencircbullet", XKB_KEY_enopencircbullet },
-    { "enopensquarebullet", XKB_KEY_enopensquarebullet },
-    { "openrectbullet", XKB_KEY_openrectbullet },
-    { "opentribulletup", XKB_KEY_opentribulletup },
-    { "opentribulletdown", XKB_KEY_opentribulletdown },
-    { "openstar", XKB_KEY_openstar },
-    { "enfilledcircbullet", XKB_KEY_enfilledcircbullet },
-    { "enfilledsqbullet", XKB_KEY_enfilledsqbullet },
-    { "filledtribulletup", XKB_KEY_filledtribulletup },
-    { "filledtribulletdown", XKB_KEY_filledtribulletdown },
-    { "leftpointer", XKB_KEY_leftpointer },
-    { "rightpointer", XKB_KEY_rightpointer },
-    { "club", XKB_KEY_club },
-    { "diamond", XKB_KEY_diamond },
-    { "heart", XKB_KEY_heart },
-    { "maltesecross", XKB_KEY_maltesecross },
-    { "dagger", XKB_KEY_dagger },
-    { "doubledagger", XKB_KEY_doubledagger },
-    { "checkmark", XKB_KEY_checkmark },
-    { "ballotcross", XKB_KEY_ballotcross },
-    { "musicalsharp", XKB_KEY_musicalsharp },
-    { "musicalflat", XKB_KEY_musicalflat },
-    { "malesymbol", XKB_KEY_malesymbol },
-    { "femalesymbol", XKB_KEY_femalesymbol },
-    { "telephone", XKB_KEY_telephone },
-    { "telephonerecorder", XKB_KEY_telephonerecorder },
-    { "phonographcopyright", XKB_KEY_phonographcopyright },
-    { "caret", XKB_KEY_caret },
-    { "singlelowquotemark", XKB_KEY_singlelowquotemark },
-    { "doublelowquotemark", XKB_KEY_doublelowquotemark },
-    { "cursor", XKB_KEY_cursor },
-    { "leftcaret", XKB_KEY_leftcaret },
-    { "rightcaret", XKB_KEY_rightcaret },
-    { "downcaret", XKB_KEY_downcaret },
-    { "upcaret", XKB_KEY_upcaret },
-    { "overbar", XKB_KEY_overbar },
-    { "downtack", XKB_KEY_downtack },
-    { "upshoe", XKB_KEY_upshoe },
-    { "downstile", XKB_KEY_downstile },
-    { "underbar", XKB_KEY_underbar },
-    { "jot", XKB_KEY_jot },
-    { "quad", XKB_KEY_quad },
-    { "uptack", XKB_KEY_uptack },
-    { "circle", XKB_KEY_circle },
-    { "upstile", XKB_KEY_upstile },
-    { "downshoe", XKB_KEY_downshoe },
-    { "rightshoe", XKB_KEY_rightshoe },
-    { "leftshoe", XKB_KEY_leftshoe },
-    { "lefttack", XKB_KEY_lefttack },
-    { "righttack", XKB_KEY_righttack },
-    { "hebrew_doublelowline", XKB_KEY_hebrew_doublelowline },
-    { "hebrew_aleph", XKB_KEY_hebrew_aleph },
-    { "hebrew_bet", XKB_KEY_hebrew_bet },
-    { "hebrew_gimel", XKB_KEY_hebrew_gimel },
-    { "hebrew_dalet", XKB_KEY_hebrew_dalet },
-    { "hebrew_he", XKB_KEY_hebrew_he },
-    { "hebrew_waw", XKB_KEY_hebrew_waw },
-    { "hebrew_zain", XKB_KEY_hebrew_zain },
-    { "hebrew_chet", XKB_KEY_hebrew_chet },
-    { "hebrew_tet", XKB_KEY_hebrew_tet },
-    { "hebrew_yod", XKB_KEY_hebrew_yod },
-    { "hebrew_finalkaph", XKB_KEY_hebrew_finalkaph },
-    { "hebrew_kaph", XKB_KEY_hebrew_kaph },
-    { "hebrew_lamed", XKB_KEY_hebrew_lamed },
-    { "hebrew_finalmem", XKB_KEY_hebrew_finalmem },
-    { "hebrew_mem", XKB_KEY_hebrew_mem },
-    { "hebrew_finalnun", XKB_KEY_hebrew_finalnun },
-    { "hebrew_nun", XKB_KEY_hebrew_nun },
-    { "hebrew_samech", XKB_KEY_hebrew_samech },
-    { "hebrew_ayin", XKB_KEY_hebrew_ayin },
-    { "hebrew_finalpe", XKB_KEY_hebrew_finalpe },
-    { "hebrew_pe", XKB_KEY_hebrew_pe },
-    { "hebrew_finalzade", XKB_KEY_hebrew_finalzade },
-    { "hebrew_zade", XKB_KEY_hebrew_zade },
-    { "hebrew_qoph", XKB_KEY_hebrew_qoph },
-    { "hebrew_resh", XKB_KEY_hebrew_resh },
-    { "hebrew_shin", XKB_KEY_hebrew_shin },
-    { "hebrew_taw", XKB_KEY_hebrew_taw },
-    { "Thai_kokai", XKB_KEY_Thai_kokai },
-    { "Thai_khokhai", XKB_KEY_Thai_khokhai },
-    { "Thai_khokhuat", XKB_KEY_Thai_khokhuat },
-    { "Thai_khokhwai", XKB_KEY_Thai_khokhwai },
-    { "Thai_khokhon", XKB_KEY_Thai_khokhon },
-    { "Thai_khorakhang", XKB_KEY_Thai_khorakhang },
-    { "Thai_ngongu", XKB_KEY_Thai_ngongu },
-    { "Thai_chochan", XKB_KEY_Thai_chochan },
-    { "Thai_choching", XKB_KEY_Thai_choching },
-    { "Thai_chochang", XKB_KEY_Thai_chochang },
-    { "Thai_soso", XKB_KEY_Thai_soso },
-    { "Thai_chochoe", XKB_KEY_Thai_chochoe },
-    { "Thai_yoying", XKB_KEY_Thai_yoying },
-    { "Thai_dochada", XKB_KEY_Thai_dochada },
-    { "Thai_topatak", XKB_KEY_Thai_topatak },
-    { "Thai_thothan", XKB_KEY_Thai_thothan },
-    { "Thai_thonangmontho", XKB_KEY_Thai_thonangmontho },
-    { "Thai_thophuthao", XKB_KEY_Thai_thophuthao },
-    { "Thai_nonen", XKB_KEY_Thai_nonen },
-    { "Thai_dodek", XKB_KEY_Thai_dodek },
-    { "Thai_totao", XKB_KEY_Thai_totao },
-    { "Thai_thothung", XKB_KEY_Thai_thothung },
-    { "Thai_thothahan", XKB_KEY_Thai_thothahan },
-    { "Thai_thothong", XKB_KEY_Thai_thothong },
-    { "Thai_nonu", XKB_KEY_Thai_nonu },
-    { "Thai_bobaimai", XKB_KEY_Thai_bobaimai },
-    { "Thai_popla", XKB_KEY_Thai_popla },
-    { "Thai_phophung", XKB_KEY_Thai_phophung },
-    { "Thai_fofa", XKB_KEY_Thai_fofa },
-    { "Thai_phophan", XKB_KEY_Thai_phophan },
-    { "Thai_fofan", XKB_KEY_Thai_fofan },
-    { "Thai_phosamphao", XKB_KEY_Thai_phosamphao },
-    { "Thai_moma", XKB_KEY_Thai_moma },
-    { "Thai_yoyak", XKB_KEY_Thai_yoyak },
-    { "Thai_rorua", XKB_KEY_Thai_rorua },
-    { "Thai_ru", XKB_KEY_Thai_ru },
-    { "Thai_loling", XKB_KEY_Thai_loling },
-    { "Thai_lu", XKB_KEY_Thai_lu },
-    { "Thai_wowaen", XKB_KEY_Thai_wowaen },
-    { "Thai_sosala", XKB_KEY_Thai_sosala },
-    { "Thai_sorusi", XKB_KEY_Thai_sorusi },
-    { "Thai_sosua", XKB_KEY_Thai_sosua },
-    { "Thai_hohip", XKB_KEY_Thai_hohip },
-    { "Thai_lochula", XKB_KEY_Thai_lochula },
-    { "Thai_oang", XKB_KEY_Thai_oang },
-    { "Thai_honokhuk", XKB_KEY_Thai_honokhuk },
-    { "Thai_paiyannoi", XKB_KEY_Thai_paiyannoi },
-    { "Thai_saraa", XKB_KEY_Thai_saraa },
-    { "Thai_maihanakat", XKB_KEY_Thai_maihanakat },
-    { "Thai_saraaa", XKB_KEY_Thai_saraaa },
-    { "Thai_saraam", XKB_KEY_Thai_saraam },
-    { "Thai_sarai", XKB_KEY_Thai_sarai },
-    { "Thai_saraii", XKB_KEY_Thai_saraii },
-    { "Thai_saraue", XKB_KEY_Thai_saraue },
-    { "Thai_sarauee", XKB_KEY_Thai_sarauee },
-    { "Thai_sarau", XKB_KEY_Thai_sarau },
-    { "Thai_sarauu", XKB_KEY_Thai_sarauu },
-    { "Thai_phinthu", XKB_KEY_Thai_phinthu },
-    { "Thai_maihanakat_maitho", XKB_KEY_Thai_maihanakat_maitho },
-    { "Thai_baht", XKB_KEY_Thai_baht },
-    { "Thai_sarae", XKB_KEY_Thai_sarae },
-    { "Thai_saraae", XKB_KEY_Thai_saraae },
-    { "Thai_sarao", XKB_KEY_Thai_sarao },
-    { "Thai_saraaimaimuan", XKB_KEY_Thai_saraaimaimuan },
-    { "Thai_saraaimaimalai", XKB_KEY_Thai_saraaimaimalai },
-    { "Thai_lakkhangyao", XKB_KEY_Thai_lakkhangyao },
-    { "Thai_maiyamok", XKB_KEY_Thai_maiyamok },
-    { "Thai_maitaikhu", XKB_KEY_Thai_maitaikhu },
-    { "Thai_maiek", XKB_KEY_Thai_maiek },
-    { "Thai_maitho", XKB_KEY_Thai_maitho },
-    { "Thai_maitri", XKB_KEY_Thai_maitri },
-    { "Thai_maichattawa", XKB_KEY_Thai_maichattawa },
-    { "Thai_thanthakhat", XKB_KEY_Thai_thanthakhat },
-    { "Thai_nikhahit", XKB_KEY_Thai_nikhahit },
-    { "Thai_leksun", XKB_KEY_Thai_leksun },
-    { "Thai_leknung", XKB_KEY_Thai_leknung },
-    { "Thai_leksong", XKB_KEY_Thai_leksong },
-    { "Thai_leksam", XKB_KEY_Thai_leksam },
-    { "Thai_leksi", XKB_KEY_Thai_leksi },
-    { "Thai_lekha", XKB_KEY_Thai_lekha },
-    { "Thai_lekhok", XKB_KEY_Thai_lekhok },
-    { "Thai_lekchet", XKB_KEY_Thai_lekchet },
-    { "Thai_lekpaet", XKB_KEY_Thai_lekpaet },
-    { "Thai_lekkao", XKB_KEY_Thai_lekkao },
-    { "Hangul_Kiyeog", XKB_KEY_Hangul_Kiyeog },
-    { "Hangul_SsangKiyeog", XKB_KEY_Hangul_SsangKiyeog },
-    { "Hangul_KiyeogSios", XKB_KEY_Hangul_KiyeogSios },
-    { "Hangul_Nieun", XKB_KEY_Hangul_Nieun },
-    { "Hangul_NieunJieuj", XKB_KEY_Hangul_NieunJieuj },
-    { "Hangul_NieunHieuh", XKB_KEY_Hangul_NieunHieuh },
-    { "Hangul_Dikeud", XKB_KEY_Hangul_Dikeud },
-    { "Hangul_SsangDikeud", XKB_KEY_Hangul_SsangDikeud },
-    { "Hangul_Rieul", XKB_KEY_Hangul_Rieul },
-    { "Hangul_RieulKiyeog", XKB_KEY_Hangul_RieulKiyeog },
-    { "Hangul_RieulMieum", XKB_KEY_Hangul_RieulMieum },
-    { "Hangul_RieulPieub", XKB_KEY_Hangul_RieulPieub },
-    { "Hangul_RieulSios", XKB_KEY_Hangul_RieulSios },
-    { "Hangul_RieulTieut", XKB_KEY_Hangul_RieulTieut },
-    { "Hangul_RieulPhieuf", XKB_KEY_Hangul_RieulPhieuf },
-    { "Hangul_RieulHieuh", XKB_KEY_Hangul_RieulHieuh },
-    { "Hangul_Mieum", XKB_KEY_Hangul_Mieum },
-    { "Hangul_Pieub", XKB_KEY_Hangul_Pieub },
-    { "Hangul_SsangPieub", XKB_KEY_Hangul_SsangPieub },
-    { "Hangul_PieubSios", XKB_KEY_Hangul_PieubSios },
-    { "Hangul_Sios", XKB_KEY_Hangul_Sios },
-    { "Hangul_SsangSios", XKB_KEY_Hangul_SsangSios },
-    { "Hangul_Ieung", XKB_KEY_Hangul_Ieung },
-    { "Hangul_Jieuj", XKB_KEY_Hangul_Jieuj },
-    { "Hangul_SsangJieuj", XKB_KEY_Hangul_SsangJieuj },
-    { "Hangul_Cieuc", XKB_KEY_Hangul_Cieuc },
-    { "Hangul_Khieuq", XKB_KEY_Hangul_Khieuq },
-    { "Hangul_Tieut", XKB_KEY_Hangul_Tieut },
-    { "Hangul_Phieuf", XKB_KEY_Hangul_Phieuf },
-    { "Hangul_Hieuh", XKB_KEY_Hangul_Hieuh },
-    { "Hangul_A", XKB_KEY_Hangul_A },
-    { "Hangul_AE", XKB_KEY_Hangul_AE },
-    { "Hangul_YA", XKB_KEY_Hangul_YA },
-    { "Hangul_YAE", XKB_KEY_Hangul_YAE },
-    { "Hangul_EO", XKB_KEY_Hangul_EO },
-    { "Hangul_E", XKB_KEY_Hangul_E },
-    { "Hangul_YEO", XKB_KEY_Hangul_YEO },
-    { "Hangul_YE", XKB_KEY_Hangul_YE },
-    { "Hangul_O", XKB_KEY_Hangul_O },
-    { "Hangul_WA", XKB_KEY_Hangul_WA },
-    { "Hangul_WAE", XKB_KEY_Hangul_WAE },
-    { "Hangul_OE", XKB_KEY_Hangul_OE },
-    { "Hangul_YO", XKB_KEY_Hangul_YO },
-    { "Hangul_U", XKB_KEY_Hangul_U },
-    { "Hangul_WEO", XKB_KEY_Hangul_WEO },
-    { "Hangul_WE", XKB_KEY_Hangul_WE },
-    { "Hangul_WI", XKB_KEY_Hangul_WI },
-    { "Hangul_YU", XKB_KEY_Hangul_YU },
-    { "Hangul_EU", XKB_KEY_Hangul_EU },
-    { "Hangul_YI", XKB_KEY_Hangul_YI },
-    { "Hangul_I", XKB_KEY_Hangul_I },
-    { "Hangul_J_Kiyeog", XKB_KEY_Hangul_J_Kiyeog },
-    { "Hangul_J_SsangKiyeog", XKB_KEY_Hangul_J_SsangKiyeog },
-    { "Hangul_J_KiyeogSios", XKB_KEY_Hangul_J_KiyeogSios },
-    { "Hangul_J_Nieun", XKB_KEY_Hangul_J_Nieun },
-    { "Hangul_J_NieunJieuj", XKB_KEY_Hangul_J_NieunJieuj },
-    { "Hangul_J_NieunHieuh", XKB_KEY_Hangul_J_NieunHieuh },
-    { "Hangul_J_Dikeud", XKB_KEY_Hangul_J_Dikeud },
-    { "Hangul_J_Rieul", XKB_KEY_Hangul_J_Rieul },
-    { "Hangul_J_RieulKiyeog", XKB_KEY_Hangul_J_RieulKiyeog },
-    { "Hangul_J_RieulMieum", XKB_KEY_Hangul_J_RieulMieum },
-    { "Hangul_J_RieulPieub", XKB_KEY_Hangul_J_RieulPieub },
-    { "Hangul_J_RieulSios", XKB_KEY_Hangul_J_RieulSios },
-    { "Hangul_J_RieulTieut", XKB_KEY_Hangul_J_RieulTieut },
-    { "Hangul_J_RieulPhieuf", XKB_KEY_Hangul_J_RieulPhieuf },
-    { "Hangul_J_RieulHieuh", XKB_KEY_Hangul_J_RieulHieuh },
-    { "Hangul_J_Mieum", XKB_KEY_Hangul_J_Mieum },
-    { "Hangul_J_Pieub", XKB_KEY_Hangul_J_Pieub },
-    { "Hangul_J_PieubSios", XKB_KEY_Hangul_J_PieubSios },
-    { "Hangul_J_Sios", XKB_KEY_Hangul_J_Sios },
-    { "Hangul_J_SsangSios", XKB_KEY_Hangul_J_SsangSios },
-    { "Hangul_J_Ieung", XKB_KEY_Hangul_J_Ieung },
-    { "Hangul_J_Jieuj", XKB_KEY_Hangul_J_Jieuj },
-    { "Hangul_J_Cieuc", XKB_KEY_Hangul_J_Cieuc },
-    { "Hangul_J_Khieuq", XKB_KEY_Hangul_J_Khieuq },
-    { "Hangul_J_Tieut", XKB_KEY_Hangul_J_Tieut },
-    { "Hangul_J_Phieuf", XKB_KEY_Hangul_J_Phieuf },
-    { "Hangul_J_Hieuh", XKB_KEY_Hangul_J_Hieuh },
-    { "Hangul_RieulYeorinHieuh", XKB_KEY_Hangul_RieulYeorinHieuh },
-    { "Hangul_SunkyeongeumMieum", XKB_KEY_Hangul_SunkyeongeumMieum },
-    { "Hangul_SunkyeongeumPieub", XKB_KEY_Hangul_SunkyeongeumPieub },
-    { "Hangul_PanSios", XKB_KEY_Hangul_PanSios },
-    { "Hangul_KkogjiDalrinIeung", XKB_KEY_Hangul_KkogjiDalrinIeung },
-    { "Hangul_SunkyeongeumPhieuf", XKB_KEY_Hangul_SunkyeongeumPhieuf },
-    { "Hangul_YeorinHieuh", XKB_KEY_Hangul_YeorinHieuh },
-    { "Hangul_AraeA", XKB_KEY_Hangul_AraeA },
-    { "Hangul_AraeAE", XKB_KEY_Hangul_AraeAE },
-    { "Hangul_J_PanSios", XKB_KEY_Hangul_J_PanSios },
-    { "Hangul_J_KkogjiDalrinIeung", XKB_KEY_Hangul_J_KkogjiDalrinIeung },
-    { "Hangul_J_YeorinHieuh", XKB_KEY_Hangul_J_YeorinHieuh },
-    { "Korean_Won", XKB_KEY_Korean_Won },
-    { "OE", XKB_KEY_OE },
-    { "oe", XKB_KEY_oe },
-    { "Ydiaeresis", XKB_KEY_Ydiaeresis },
-    { "EuroSign", XKB_KEY_EuroSign },
-    { "3270_Duplicate", XKB_KEY_3270_Duplicate },
-    { "3270_FieldMark", XKB_KEY_3270_FieldMark },
-    { "3270_Right2", XKB_KEY_3270_Right2 },
-    { "3270_Left2", XKB_KEY_3270_Left2 },
-    { "3270_BackTab", XKB_KEY_3270_BackTab },
-    { "3270_EraseEOF", XKB_KEY_3270_EraseEOF },
-    { "3270_EraseInput", XKB_KEY_3270_EraseInput },
-    { "3270_Reset", XKB_KEY_3270_Reset },
-    { "3270_Quit", XKB_KEY_3270_Quit },
-    { "3270_PA1", XKB_KEY_3270_PA1 },
-    { "3270_PA2", XKB_KEY_3270_PA2 },
-    { "3270_PA3", XKB_KEY_3270_PA3 },
-    { "3270_Test", XKB_KEY_3270_Test },
-    { "3270_Attn", XKB_KEY_3270_Attn },
-    { "3270_CursorBlink", XKB_KEY_3270_CursorBlink },
-    { "3270_AltCursor", XKB_KEY_3270_AltCursor },
-    { "3270_KeyClick", XKB_KEY_3270_KeyClick },
-    { "3270_Jump", XKB_KEY_3270_Jump },
-    { "3270_Ident", XKB_KEY_3270_Ident },
-    { "3270_Rule", XKB_KEY_3270_Rule },
-    { "3270_Copy", XKB_KEY_3270_Copy },
-    { "3270_Play", XKB_KEY_3270_Play },
-    { "3270_Setup", XKB_KEY_3270_Setup },
-    { "3270_Record", XKB_KEY_3270_Record },
-    { "3270_ChangeScreen", XKB_KEY_3270_ChangeScreen },
-    { "3270_DeleteWord", XKB_KEY_3270_DeleteWord },
-    { "3270_ExSelect", XKB_KEY_3270_ExSelect },
-    { "3270_CursorSelect", XKB_KEY_3270_CursorSelect },
-    { "3270_PrintScreen", XKB_KEY_3270_PrintScreen },
-    { "3270_Enter", XKB_KEY_3270_Enter },
-    { "ISO_Lock", XKB_KEY_ISO_Lock },
-    { "ISO_Level2_Latch", XKB_KEY_ISO_Level2_Latch },
-    { "ISO_Level3_Shift", XKB_KEY_ISO_Level3_Shift },
-    { "ISO_Level3_Latch", XKB_KEY_ISO_Level3_Latch },
-    { "ISO_Level3_Lock", XKB_KEY_ISO_Level3_Lock },
-    { "ISO_Group_Latch", XKB_KEY_ISO_Group_Latch },
-    { "ISO_Group_Lock", XKB_KEY_ISO_Group_Lock },
-    { "ISO_Next_Group", XKB_KEY_ISO_Next_Group },
-    { "ISO_Next_Group_Lock", XKB_KEY_ISO_Next_Group_Lock },
-    { "ISO_Prev_Group", XKB_KEY_ISO_Prev_Group },
-    { "ISO_Prev_Group_Lock", XKB_KEY_ISO_Prev_Group_Lock },
-    { "ISO_First_Group", XKB_KEY_ISO_First_Group },
-    { "ISO_First_Group_Lock", XKB_KEY_ISO_First_Group_Lock },
-    { "ISO_Last_Group", XKB_KEY_ISO_Last_Group },
-    { "ISO_Last_Group_Lock", XKB_KEY_ISO_Last_Group_Lock },
-    { "ISO_Level5_Shift", XKB_KEY_ISO_Level5_Shift },
-    { "ISO_Level5_Latch", XKB_KEY_ISO_Level5_Latch },
-    { "ISO_Level5_Lock", XKB_KEY_ISO_Level5_Lock },
-    { "ISO_Left_Tab", XKB_KEY_ISO_Left_Tab },
-    { "ISO_Move_Line_Up", XKB_KEY_ISO_Move_Line_Up },
-    { "ISO_Move_Line_Down", XKB_KEY_ISO_Move_Line_Down },
-    { "ISO_Partial_Line_Up", XKB_KEY_ISO_Partial_Line_Up },
-    { "ISO_Partial_Line_Down", XKB_KEY_ISO_Partial_Line_Down },
-    { "ISO_Partial_Space_Left", XKB_KEY_ISO_Partial_Space_Left },
-    { "ISO_Partial_Space_Right", XKB_KEY_ISO_Partial_Space_Right },
-    { "ISO_Set_Margin_Left", XKB_KEY_ISO_Set_Margin_Left },
-    { "ISO_Set_Margin_Right", XKB_KEY_ISO_Set_Margin_Right },
-    { "ISO_Release_Margin_Left", XKB_KEY_ISO_Release_Margin_Left },
-    { "ISO_Release_Margin_Right", XKB_KEY_ISO_Release_Margin_Right },
-    { "ISO_Release_Both_Margins", XKB_KEY_ISO_Release_Both_Margins },
-    { "ISO_Fast_Cursor_Left", XKB_KEY_ISO_Fast_Cursor_Left },
-    { "ISO_Fast_Cursor_Right", XKB_KEY_ISO_Fast_Cursor_Right },
-    { "ISO_Fast_Cursor_Up", XKB_KEY_ISO_Fast_Cursor_Up },
-    { "ISO_Fast_Cursor_Down", XKB_KEY_ISO_Fast_Cursor_Down },
-    { "ISO_Continuous_Underline", XKB_KEY_ISO_Continuous_Underline },
-    { "ISO_Discontinuous_Underline", XKB_KEY_ISO_Discontinuous_Underline },
-    { "ISO_Emphasize", XKB_KEY_ISO_Emphasize },
-    { "ISO_Center_Object", XKB_KEY_ISO_Center_Object },
-    { "ISO_Enter", XKB_KEY_ISO_Enter },
-    { "dead_grave", XKB_KEY_dead_grave },
-    { "dead_acute", XKB_KEY_dead_acute },
-    { "dead_circumflex", XKB_KEY_dead_circumflex },
-    { "dead_tilde", XKB_KEY_dead_tilde },
-    { "dead_macron", XKB_KEY_dead_macron },
-    { "dead_breve", XKB_KEY_dead_breve },
-    { "dead_abovedot", XKB_KEY_dead_abovedot },
-    { "dead_diaeresis", XKB_KEY_dead_diaeresis },
-    { "dead_abovering", XKB_KEY_dead_abovering },
-    { "dead_doubleacute", XKB_KEY_dead_doubleacute },
-    { "dead_caron", XKB_KEY_dead_caron },
-    { "dead_cedilla", XKB_KEY_dead_cedilla },
-    { "dead_ogonek", XKB_KEY_dead_ogonek },
-    { "dead_iota", XKB_KEY_dead_iota },
-    { "dead_voiced_sound", XKB_KEY_dead_voiced_sound },
-    { "dead_semivoiced_sound", XKB_KEY_dead_semivoiced_sound },
-    { "dead_belowdot", XKB_KEY_dead_belowdot },
-    { "dead_hook", XKB_KEY_dead_hook },
-    { "dead_horn", XKB_KEY_dead_horn },
-    { "dead_stroke", XKB_KEY_dead_stroke },
-    { "dead_abovecomma", XKB_KEY_dead_abovecomma },
-    { "dead_abovereversedcomma", XKB_KEY_dead_abovereversedcomma },
-    { "dead_doublegrave", XKB_KEY_dead_doublegrave },
-    { "dead_belowring", XKB_KEY_dead_belowring },
-    { "dead_belowmacron", XKB_KEY_dead_belowmacron },
-    { "dead_belowcircumflex", XKB_KEY_dead_belowcircumflex },
-    { "dead_belowtilde", XKB_KEY_dead_belowtilde },
-    { "dead_belowbreve", XKB_KEY_dead_belowbreve },
-    { "dead_belowdiaeresis", XKB_KEY_dead_belowdiaeresis },
-    { "dead_invertedbreve", XKB_KEY_dead_invertedbreve },
-    { "dead_belowcomma", XKB_KEY_dead_belowcomma },
-    { "dead_currency", XKB_KEY_dead_currency },
-    { "AccessX_Enable", XKB_KEY_AccessX_Enable },
-    { "AccessX_Feedback_Enable", XKB_KEY_AccessX_Feedback_Enable },
-    { "RepeatKeys_Enable", XKB_KEY_RepeatKeys_Enable },
-    { "SlowKeys_Enable", XKB_KEY_SlowKeys_Enable },
-    { "BounceKeys_Enable", XKB_KEY_BounceKeys_Enable },
-    { "StickyKeys_Enable", XKB_KEY_StickyKeys_Enable },
-    { "MouseKeys_Enable", XKB_KEY_MouseKeys_Enable },
-    { "MouseKeys_Accel_Enable", XKB_KEY_MouseKeys_Accel_Enable },
-    { "Overlay1_Enable", XKB_KEY_Overlay1_Enable },
-    { "Overlay2_Enable", XKB_KEY_Overlay2_Enable },
-    { "AudibleBell_Enable", XKB_KEY_AudibleBell_Enable },
-    { "dead_a", XKB_KEY_dead_a },
-    { "dead_A", XKB_KEY_dead_A },
-    { "dead_e", XKB_KEY_dead_e },
-    { "dead_E", XKB_KEY_dead_E },
-    { "dead_i", XKB_KEY_dead_i },
-    { "dead_I", XKB_KEY_dead_I },
-    { "dead_o", XKB_KEY_dead_o },
-    { "dead_O", XKB_KEY_dead_O },
-    { "dead_u", XKB_KEY_dead_u },
-    { "dead_U", XKB_KEY_dead_U },
-    { "dead_small_schwa", XKB_KEY_dead_small_schwa },
-    { "dead_capital_schwa", XKB_KEY_dead_capital_schwa },
-    { "dead_greek", XKB_KEY_dead_greek },
-    { "ch", XKB_KEY_ch },
-    { "Ch", XKB_KEY_Ch },
-    { "CH", XKB_KEY_CH },
-    { "c_h", XKB_KEY_c_h },
-    { "C_h", XKB_KEY_C_h },
-    { "C_H", XKB_KEY_C_H },
-    { "First_Virtual_Screen", XKB_KEY_First_Virtual_Screen },
-    { "Prev_Virtual_Screen", XKB_KEY_Prev_Virtual_Screen },
-    { "Next_Virtual_Screen", XKB_KEY_Next_Virtual_Screen },
-    { "Last_Virtual_Screen", XKB_KEY_Last_Virtual_Screen },
-    { "Terminate_Server", XKB_KEY_Terminate_Server },
-    { "Pointer_Left", XKB_KEY_Pointer_Left },
-    { "Pointer_Right", XKB_KEY_Pointer_Right },
-    { "Pointer_Up", XKB_KEY_Pointer_Up },
-    { "Pointer_Down", XKB_KEY_Pointer_Down },
-    { "Pointer_UpLeft", XKB_KEY_Pointer_UpLeft },
-    { "Pointer_UpRight", XKB_KEY_Pointer_UpRight },
-    { "Pointer_DownLeft", XKB_KEY_Pointer_DownLeft },
-    { "Pointer_DownRight", XKB_KEY_Pointer_DownRight },
-    { "Pointer_Button_Dflt", XKB_KEY_Pointer_Button_Dflt },
-    { "Pointer_Button1", XKB_KEY_Pointer_Button1 },
-    { "Pointer_Button2", XKB_KEY_Pointer_Button2 },
-    { "Pointer_Button3", XKB_KEY_Pointer_Button3 },
-    { "Pointer_Button4", XKB_KEY_Pointer_Button4 },
-    { "Pointer_Button5", XKB_KEY_Pointer_Button5 },
-    { "Pointer_DblClick_Dflt", XKB_KEY_Pointer_DblClick_Dflt },
-    { "Pointer_DblClick1", XKB_KEY_Pointer_DblClick1 },
-    { "Pointer_DblClick2", XKB_KEY_Pointer_DblClick2 },
-    { "Pointer_DblClick3", XKB_KEY_Pointer_DblClick3 },
-    { "Pointer_DblClick4", XKB_KEY_Pointer_DblClick4 },
-    { "Pointer_DblClick5", XKB_KEY_Pointer_DblClick5 },
-    { "Pointer_Drag_Dflt", XKB_KEY_Pointer_Drag_Dflt },
-    { "Pointer_Drag1", XKB_KEY_Pointer_Drag1 },
-    { "Pointer_Drag2", XKB_KEY_Pointer_Drag2 },
-    { "Pointer_Drag3", XKB_KEY_Pointer_Drag3 },
-    { "Pointer_Drag4", XKB_KEY_Pointer_Drag4 },
-    { "Pointer_EnableKeys", XKB_KEY_Pointer_EnableKeys },
-    { "Pointer_Accelerate", XKB_KEY_Pointer_Accelerate },
-    { "Pointer_DfltBtnNext", XKB_KEY_Pointer_DfltBtnNext },
-    { "Pointer_DfltBtnPrev", XKB_KEY_Pointer_DfltBtnPrev },
-    { "Pointer_Drag5", XKB_KEY_Pointer_Drag5 },
-    { "BackSpace", XKB_KEY_BackSpace },
-    { "Tab", XKB_KEY_Tab },
-    { "Linefeed", XKB_KEY_Linefeed },
-    { "Clear", XKB_KEY_Clear },
-    { "Return", XKB_KEY_Return },
-    { "Pause", XKB_KEY_Pause },
-    { "Scroll_Lock", XKB_KEY_Scroll_Lock },
-    { "Sys_Req", XKB_KEY_Sys_Req },
-    { "Escape", XKB_KEY_Escape },
-    { "Multi_key", XKB_KEY_Multi_key },
-    { "Kanji", XKB_KEY_Kanji },
-    { "Muhenkan", XKB_KEY_Muhenkan },
-    { "Henkan_Mode", XKB_KEY_Henkan_Mode },
-    { "Romaji", XKB_KEY_Romaji },
-    { "Hiragana", XKB_KEY_Hiragana },
-    { "Katakana", XKB_KEY_Katakana },
-    { "Hiragana_Katakana", XKB_KEY_Hiragana_Katakana },
-    { "Zenkaku", XKB_KEY_Zenkaku },
-    { "Hankaku", XKB_KEY_Hankaku },
-    { "Zenkaku_Hankaku", XKB_KEY_Zenkaku_Hankaku },
-    { "Touroku", XKB_KEY_Touroku },
-    { "Massyo", XKB_KEY_Massyo },
-    { "Kana_Lock", XKB_KEY_Kana_Lock },
-    { "Kana_Shift", XKB_KEY_Kana_Shift },
-    { "Eisu_Shift", XKB_KEY_Eisu_Shift },
-    { "Eisu_toggle", XKB_KEY_Eisu_toggle },
-    { "Hangul", XKB_KEY_Hangul },
-    { "Hangul_Start", XKB_KEY_Hangul_Start },
-    { "Hangul_End", XKB_KEY_Hangul_End },
-    { "Hangul_Hanja", XKB_KEY_Hangul_Hanja },
-    { "Hangul_Jamo", XKB_KEY_Hangul_Jamo },
-    { "Hangul_Romaja", XKB_KEY_Hangul_Romaja },
-    { "Codeinput", XKB_KEY_Codeinput },
-    { "Hangul_Jeonja", XKB_KEY_Hangul_Jeonja },
-    { "Hangul_Banja", XKB_KEY_Hangul_Banja },
-    { "Hangul_PreHanja", XKB_KEY_Hangul_PreHanja },
-    { "Hangul_PostHanja", XKB_KEY_Hangul_PostHanja },
-    { "SingleCandidate", XKB_KEY_SingleCandidate },
-    { "MultipleCandidate", XKB_KEY_MultipleCandidate },
-    { "PreviousCandidate", XKB_KEY_PreviousCandidate },
-    { "Hangul_Special", XKB_KEY_Hangul_Special },
-    { "Home", XKB_KEY_Home },
-    { "Left", XKB_KEY_Left },
-    { "Up", XKB_KEY_Up },
-    { "Right", XKB_KEY_Right },
-    { "Down", XKB_KEY_Down },
-    { "Prior", XKB_KEY_Prior },
-    { "Next", XKB_KEY_Next },
-    { "End", XKB_KEY_End },
-    { "Begin", XKB_KEY_Begin },
-    { "Select", XKB_KEY_Select },
-    { "Print", XKB_KEY_Print },
-    { "Execute", XKB_KEY_Execute },
-    { "Insert", XKB_KEY_Insert },
-    { "Undo", XKB_KEY_Undo },
-    { "Redo", XKB_KEY_Redo },
-    { "Menu", XKB_KEY_Menu },
-    { "Find", XKB_KEY_Find },
-    { "Cancel", XKB_KEY_Cancel },
-    { "Help", XKB_KEY_Help },
-    { "Break", XKB_KEY_Break },
-    { "Mode_switch", XKB_KEY_Mode_switch },
-    { "Num_Lock", XKB_KEY_Num_Lock },
-    { "KP_Space", XKB_KEY_KP_Space },
-    { "KP_Tab", XKB_KEY_KP_Tab },
-    { "KP_Enter", XKB_KEY_KP_Enter },
-    { "KP_F1", XKB_KEY_KP_F1 },
-    { "KP_F2", XKB_KEY_KP_F2 },
-    { "KP_F3", XKB_KEY_KP_F3 },
-    { "KP_F4", XKB_KEY_KP_F4 },
-    { "KP_Home", XKB_KEY_KP_Home },
-    { "KP_Left", XKB_KEY_KP_Left },
-    { "KP_Up", XKB_KEY_KP_Up },
-    { "KP_Right", XKB_KEY_KP_Right },
-    { "KP_Down", XKB_KEY_KP_Down },
-    { "KP_Prior", XKB_KEY_KP_Prior },
-    { "KP_Next", XKB_KEY_KP_Next },
-    { "KP_End", XKB_KEY_KP_End },
-    { "KP_Begin", XKB_KEY_KP_Begin },
-    { "KP_Insert", XKB_KEY_KP_Insert },
-    { "KP_Delete", XKB_KEY_KP_Delete },
-    { "KP_Multiply", XKB_KEY_KP_Multiply },
-    { "KP_Add", XKB_KEY_KP_Add },
-    { "KP_Separator", XKB_KEY_KP_Separator },
-    { "KP_Subtract", XKB_KEY_KP_Subtract },
-    { "KP_Decimal", XKB_KEY_KP_Decimal },
-    { "KP_Divide", XKB_KEY_KP_Divide },
-    { "KP_0", XKB_KEY_KP_0 },
-    { "KP_1", XKB_KEY_KP_1 },
-    { "KP_2", XKB_KEY_KP_2 },
-    { "KP_3", XKB_KEY_KP_3 },
-    { "KP_4", XKB_KEY_KP_4 },
-    { "KP_5", XKB_KEY_KP_5 },
-    { "KP_6", XKB_KEY_KP_6 },
-    { "KP_7", XKB_KEY_KP_7 },
-    { "KP_8", XKB_KEY_KP_8 },
-    { "KP_9", XKB_KEY_KP_9 },
-    { "KP_Equal", XKB_KEY_KP_Equal },
-    { "F1", XKB_KEY_F1 },
-    { "F2", XKB_KEY_F2 },
-    { "F3", XKB_KEY_F3 },
-    { "F4", XKB_KEY_F4 },
-    { "F5", XKB_KEY_F5 },
-    { "F6", XKB_KEY_F6 },
-    { "F7", XKB_KEY_F7 },
-    { "F8", XKB_KEY_F8 },
-    { "F9", XKB_KEY_F9 },
-    { "F10", XKB_KEY_F10 },
-    { "F11", XKB_KEY_F11 },
-    { "F12", XKB_KEY_F12 },
-    { "F13", XKB_KEY_F13 },
-    { "F14", XKB_KEY_F14 },
-    { "F15", XKB_KEY_F15 },
-    { "F16", XKB_KEY_F16 },
-    { "F17", XKB_KEY_F17 },
-    { "F18", XKB_KEY_F18 },
-    { "F19", XKB_KEY_F19 },
-    { "F20", XKB_KEY_F20 },
-    { "F21", XKB_KEY_F21 },
-    { "F22", XKB_KEY_F22 },
-    { "F23", XKB_KEY_F23 },
-    { "F24", XKB_KEY_F24 },
-    { "F25", XKB_KEY_F25 },
-    { "F26", XKB_KEY_F26 },
-    { "F27", XKB_KEY_F27 },
-    { "F28", XKB_KEY_F28 },
-    { "F29", XKB_KEY_F29 },
-    { "F30", XKB_KEY_F30 },
-    { "F31", XKB_KEY_F31 },
-    { "F32", XKB_KEY_F32 },
-    { "F33", XKB_KEY_F33 },
-    { "F34", XKB_KEY_F34 },
-    { "F35", XKB_KEY_F35 },
-    { "Shift_L", XKB_KEY_Shift_L },
-    { "Shift_R", XKB_KEY_Shift_R },
-    { "Control_L", XKB_KEY_Control_L },
-    { "Control_R", XKB_KEY_Control_R },
-    { "Caps_Lock", XKB_KEY_Caps_Lock },
-    { "Shift_Lock", XKB_KEY_Shift_Lock },
-    { "Meta_L", XKB_KEY_Meta_L },
-    { "Meta_R", XKB_KEY_Meta_R },
-    { "Alt_L", XKB_KEY_Alt_L },
-    { "Alt_R", XKB_KEY_Alt_R },
-    { "Super_L", XKB_KEY_Super_L },
-    { "Super_R", XKB_KEY_Super_R },
-    { "Hyper_L", XKB_KEY_Hyper_L },
-    { "Hyper_R", XKB_KEY_Hyper_R },
-    { "braille_dot_1", XKB_KEY_braille_dot_1 },
-    { "braille_dot_2", XKB_KEY_braille_dot_2 },
-    { "braille_dot_3", XKB_KEY_braille_dot_3 },
-    { "braille_dot_4", XKB_KEY_braille_dot_4 },
-    { "braille_dot_5", XKB_KEY_braille_dot_5 },
-    { "braille_dot_6", XKB_KEY_braille_dot_6 },
-    { "braille_dot_7", XKB_KEY_braille_dot_7 },
-    { "braille_dot_8", XKB_KEY_braille_dot_8 },
-    { "braille_dot_9", XKB_KEY_braille_dot_9 },
-    { "braille_dot_10", XKB_KEY_braille_dot_10 },
-    { "Delete", XKB_KEY_Delete },
-    { "VoidSymbol", XKB_KEY_VoidSymbol },
-    { "Ibreve", XKB_KEY_Ibreve },
-    { "ibreve", XKB_KEY_ibreve },
-    { "Wcircumflex", XKB_KEY_Wcircumflex },
-    { "wcircumflex", XKB_KEY_wcircumflex },
-    { "Ycircumflex", XKB_KEY_Ycircumflex },
-    { "ycircumflex", XKB_KEY_ycircumflex },
-    { "SCHWA", XKB_KEY_SCHWA },
-    { "Obarred", XKB_KEY_Obarred },
-    { "Ohorn", XKB_KEY_Ohorn },
-    { "ohorn", XKB_KEY_ohorn },
-    { "Uhorn", XKB_KEY_Uhorn },
-    { "uhorn", XKB_KEY_uhorn },
-    { "Zstroke", XKB_KEY_Zstroke },
-    { "zstroke", XKB_KEY_zstroke },
-    { "EZH", XKB_KEY_EZH },
-    { "Ocaron", XKB_KEY_Ocaron },
-    { "ocaron", XKB_KEY_ocaron },
-    { "Gcaron", XKB_KEY_Gcaron },
-    { "gcaron", XKB_KEY_gcaron },
-    { "schwa", XKB_KEY_schwa },
-    { "obarred", XKB_KEY_obarred },
-    { "ezh", XKB_KEY_ezh },
-    { "Cyrillic_GHE_bar", XKB_KEY_Cyrillic_GHE_bar },
-    { "Cyrillic_ghe_bar", XKB_KEY_Cyrillic_ghe_bar },
-    { "Cyrillic_ZHE_descender", XKB_KEY_Cyrillic_ZHE_descender },
-    { "Cyrillic_zhe_descender", XKB_KEY_Cyrillic_zhe_descender },
-    { "Cyrillic_KA_descender", XKB_KEY_Cyrillic_KA_descender },
-    { "Cyrillic_ka_descender", XKB_KEY_Cyrillic_ka_descender },
-    { "Cyrillic_KA_vertstroke", XKB_KEY_Cyrillic_KA_vertstroke },
-    { "Cyrillic_ka_vertstroke", XKB_KEY_Cyrillic_ka_vertstroke },
-    { "Cyrillic_EN_descender", XKB_KEY_Cyrillic_EN_descender },
-    { "Cyrillic_en_descender", XKB_KEY_Cyrillic_en_descender },
-    { "Cyrillic_U_straight", XKB_KEY_Cyrillic_U_straight },
-    { "Cyrillic_u_straight", XKB_KEY_Cyrillic_u_straight },
-    { "Cyrillic_U_straight_bar", XKB_KEY_Cyrillic_U_straight_bar },
-    { "Cyrillic_u_straight_bar", XKB_KEY_Cyrillic_u_straight_bar },
-    { "Cyrillic_HA_descender", XKB_KEY_Cyrillic_HA_descender },
-    { "Cyrillic_ha_descender", XKB_KEY_Cyrillic_ha_descender },
-    { "Cyrillic_CHE_descender", XKB_KEY_Cyrillic_CHE_descender },
-    { "Cyrillic_che_descender", XKB_KEY_Cyrillic_che_descender },
-    { "Cyrillic_CHE_vertstroke", XKB_KEY_Cyrillic_CHE_vertstroke },
-    { "Cyrillic_che_vertstroke", XKB_KEY_Cyrillic_che_vertstroke },
-    { "Cyrillic_SHHA", XKB_KEY_Cyrillic_SHHA },
-    { "Cyrillic_shha", XKB_KEY_Cyrillic_shha },
-    { "Cyrillic_SCHWA", XKB_KEY_Cyrillic_SCHWA },
-    { "Cyrillic_schwa", XKB_KEY_Cyrillic_schwa },
-    { "Cyrillic_I_macron", XKB_KEY_Cyrillic_I_macron },
-    { "Cyrillic_i_macron", XKB_KEY_Cyrillic_i_macron },
-    { "Cyrillic_O_bar", XKB_KEY_Cyrillic_O_bar },
-    { "Cyrillic_o_bar", XKB_KEY_Cyrillic_o_bar },
-    { "Cyrillic_U_macron", XKB_KEY_Cyrillic_U_macron },
-    { "Cyrillic_u_macron", XKB_KEY_Cyrillic_u_macron },
-    { "Armenian_AYB", XKB_KEY_Armenian_AYB },
-    { "Armenian_BEN", XKB_KEY_Armenian_BEN },
-    { "Armenian_GIM", XKB_KEY_Armenian_GIM },
-    { "Armenian_DA", XKB_KEY_Armenian_DA },
-    { "Armenian_YECH", XKB_KEY_Armenian_YECH },
-    { "Armenian_ZA", XKB_KEY_Armenian_ZA },
-    { "Armenian_E", XKB_KEY_Armenian_E },
-    { "Armenian_AT", XKB_KEY_Armenian_AT },
-    { "Armenian_TO", XKB_KEY_Armenian_TO },
-    { "Armenian_ZHE", XKB_KEY_Armenian_ZHE },
-    { "Armenian_INI", XKB_KEY_Armenian_INI },
-    { "Armenian_LYUN", XKB_KEY_Armenian_LYUN },
-    { "Armenian_KHE", XKB_KEY_Armenian_KHE },
-    { "Armenian_TSA", XKB_KEY_Armenian_TSA },
-    { "Armenian_KEN", XKB_KEY_Armenian_KEN },
-    { "Armenian_HO", XKB_KEY_Armenian_HO },
-    { "Armenian_DZA", XKB_KEY_Armenian_DZA },
-    { "Armenian_GHAT", XKB_KEY_Armenian_GHAT },
-    { "Armenian_TCHE", XKB_KEY_Armenian_TCHE },
-    { "Armenian_MEN", XKB_KEY_Armenian_MEN },
-    { "Armenian_HI", XKB_KEY_Armenian_HI },
-    { "Armenian_NU", XKB_KEY_Armenian_NU },
-    { "Armenian_SHA", XKB_KEY_Armenian_SHA },
-    { "Armenian_VO", XKB_KEY_Armenian_VO },
-    { "Armenian_CHA", XKB_KEY_Armenian_CHA },
-    { "Armenian_PE", XKB_KEY_Armenian_PE },
-    { "Armenian_JE", XKB_KEY_Armenian_JE },
-    { "Armenian_RA", XKB_KEY_Armenian_RA },
-    { "Armenian_SE", XKB_KEY_Armenian_SE },
-    { "Armenian_VEV", XKB_KEY_Armenian_VEV },
-    { "Armenian_TYUN", XKB_KEY_Armenian_TYUN },
-    { "Armenian_RE", XKB_KEY_Armenian_RE },
-    { "Armenian_TSO", XKB_KEY_Armenian_TSO },
-    { "Armenian_VYUN", XKB_KEY_Armenian_VYUN },
-    { "Armenian_PYUR", XKB_KEY_Armenian_PYUR },
-    { "Armenian_KE", XKB_KEY_Armenian_KE },
-    { "Armenian_O", XKB_KEY_Armenian_O },
-    { "Armenian_FE", XKB_KEY_Armenian_FE },
-    { "Armenian_apostrophe", XKB_KEY_Armenian_apostrophe },
-    { "Armenian_accent", XKB_KEY_Armenian_accent },
-    { "Armenian_exclam", XKB_KEY_Armenian_exclam },
-    { "Armenian_separation_mark", XKB_KEY_Armenian_separation_mark },
-    { "Armenian_question", XKB_KEY_Armenian_question },
-    { "Armenian_ayb", XKB_KEY_Armenian_ayb },
-    { "Armenian_ben", XKB_KEY_Armenian_ben },
-    { "Armenian_gim", XKB_KEY_Armenian_gim },
-    { "Armenian_da", XKB_KEY_Armenian_da },
-    { "Armenian_yech", XKB_KEY_Armenian_yech },
-    { "Armenian_za", XKB_KEY_Armenian_za },
-    { "Armenian_e", XKB_KEY_Armenian_e },
-    { "Armenian_at", XKB_KEY_Armenian_at },
-    { "Armenian_to", XKB_KEY_Armenian_to },
-    { "Armenian_zhe", XKB_KEY_Armenian_zhe },
-    { "Armenian_ini", XKB_KEY_Armenian_ini },
-    { "Armenian_lyun", XKB_KEY_Armenian_lyun },
-    { "Armenian_khe", XKB_KEY_Armenian_khe },
-    { "Armenian_tsa", XKB_KEY_Armenian_tsa },
-    { "Armenian_ken", XKB_KEY_Armenian_ken },
-    { "Armenian_ho", XKB_KEY_Armenian_ho },
-    { "Armenian_dza", XKB_KEY_Armenian_dza },
-    { "Armenian_ghat", XKB_KEY_Armenian_ghat },
-    { "Armenian_tche", XKB_KEY_Armenian_tche },
-    { "Armenian_men", XKB_KEY_Armenian_men },
-    { "Armenian_hi", XKB_KEY_Armenian_hi },
-    { "Armenian_nu", XKB_KEY_Armenian_nu },
-    { "Armenian_sha", XKB_KEY_Armenian_sha },
-    { "Armenian_vo", XKB_KEY_Armenian_vo },
-    { "Armenian_cha", XKB_KEY_Armenian_cha },
-    { "Armenian_pe", XKB_KEY_Armenian_pe },
-    { "Armenian_je", XKB_KEY_Armenian_je },
-    { "Armenian_ra", XKB_KEY_Armenian_ra },
-    { "Armenian_se", XKB_KEY_Armenian_se },
-    { "Armenian_vev", XKB_KEY_Armenian_vev },
-    { "Armenian_tyun", XKB_KEY_Armenian_tyun },
-    { "Armenian_re", XKB_KEY_Armenian_re },
-    { "Armenian_tso", XKB_KEY_Armenian_tso },
-    { "Armenian_vyun", XKB_KEY_Armenian_vyun },
-    { "Armenian_pyur", XKB_KEY_Armenian_pyur },
-    { "Armenian_ke", XKB_KEY_Armenian_ke },
-    { "Armenian_o", XKB_KEY_Armenian_o },
-    { "Armenian_fe", XKB_KEY_Armenian_fe },
-    { "Armenian_ligature_ew", XKB_KEY_Armenian_ligature_ew },
-    { "Armenian_full_stop", XKB_KEY_Armenian_full_stop },
-    { "Armenian_hyphen", XKB_KEY_Armenian_hyphen },
-    { "Arabic_madda_above", XKB_KEY_Arabic_madda_above },
-    { "Arabic_hamza_above", XKB_KEY_Arabic_hamza_above },
-    { "Arabic_hamza_below", XKB_KEY_Arabic_hamza_below },
-    { "Arabic_0", XKB_KEY_Arabic_0 },
-    { "Arabic_1", XKB_KEY_Arabic_1 },
-    { "Arabic_2", XKB_KEY_Arabic_2 },
-    { "Arabic_3", XKB_KEY_Arabic_3 },
-    { "Arabic_4", XKB_KEY_Arabic_4 },
-    { "Arabic_5", XKB_KEY_Arabic_5 },
-    { "Arabic_6", XKB_KEY_Arabic_6 },
-    { "Arabic_7", XKB_KEY_Arabic_7 },
-    { "Arabic_8", XKB_KEY_Arabic_8 },
-    { "Arabic_9", XKB_KEY_Arabic_9 },
-    { "Arabic_percent", XKB_KEY_Arabic_percent },
-    { "Arabic_superscript_alef", XKB_KEY_Arabic_superscript_alef },
-    { "Arabic_tteh", XKB_KEY_Arabic_tteh },
-    { "Arabic_peh", XKB_KEY_Arabic_peh },
-    { "Arabic_tcheh", XKB_KEY_Arabic_tcheh },
-    { "Arabic_ddal", XKB_KEY_Arabic_ddal },
-    { "Arabic_rreh", XKB_KEY_Arabic_rreh },
-    { "Arabic_jeh", XKB_KEY_Arabic_jeh },
-    { "Arabic_veh", XKB_KEY_Arabic_veh },
-    { "Arabic_keheh", XKB_KEY_Arabic_keheh },
-    { "Arabic_gaf", XKB_KEY_Arabic_gaf },
-    { "Arabic_noon_ghunna", XKB_KEY_Arabic_noon_ghunna },
-    { "Arabic_heh_doachashmee", XKB_KEY_Arabic_heh_doachashmee },
-    { "Arabic_heh_goal", XKB_KEY_Arabic_heh_goal },
-    { "Farsi_yeh", XKB_KEY_Farsi_yeh },
-    { "Arabic_yeh_baree", XKB_KEY_Arabic_yeh_baree },
-    { "Arabic_fullstop", XKB_KEY_Arabic_fullstop },
-    { "Farsi_0", XKB_KEY_Farsi_0 },
-    { "Farsi_1", XKB_KEY_Farsi_1 },
-    { "Farsi_2", XKB_KEY_Farsi_2 },
-    { "Farsi_3", XKB_KEY_Farsi_3 },
-    { "Farsi_4", XKB_KEY_Farsi_4 },
-    { "Farsi_5", XKB_KEY_Farsi_5 },
-    { "Farsi_6", XKB_KEY_Farsi_6 },
-    { "Farsi_7", XKB_KEY_Farsi_7 },
-    { "Farsi_8", XKB_KEY_Farsi_8 },
-    { "Farsi_9", XKB_KEY_Farsi_9 },
-    { "Sinh_ng", XKB_KEY_Sinh_ng },
-    { "Sinh_h2", XKB_KEY_Sinh_h2 },
-    { "Sinh_a", XKB_KEY_Sinh_a },
-    { "Sinh_aa", XKB_KEY_Sinh_aa },
-    { "Sinh_ae", XKB_KEY_Sinh_ae },
-    { "Sinh_aee", XKB_KEY_Sinh_aee },
-    { "Sinh_i", XKB_KEY_Sinh_i },
-    { "Sinh_ii", XKB_KEY_Sinh_ii },
-    { "Sinh_u", XKB_KEY_Sinh_u },
-    { "Sinh_uu", XKB_KEY_Sinh_uu },
-    { "Sinh_ri", XKB_KEY_Sinh_ri },
-    { "Sinh_rii", XKB_KEY_Sinh_rii },
-    { "Sinh_lu", XKB_KEY_Sinh_lu },
-    { "Sinh_luu", XKB_KEY_Sinh_luu },
-    { "Sinh_e", XKB_KEY_Sinh_e },
-    { "Sinh_ee", XKB_KEY_Sinh_ee },
-    { "Sinh_ai", XKB_KEY_Sinh_ai },
-    { "Sinh_o", XKB_KEY_Sinh_o },
-    { "Sinh_oo", XKB_KEY_Sinh_oo },
-    { "Sinh_au", XKB_KEY_Sinh_au },
-    { "Sinh_ka", XKB_KEY_Sinh_ka },
-    { "Sinh_kha", XKB_KEY_Sinh_kha },
-    { "Sinh_ga", XKB_KEY_Sinh_ga },
-    { "Sinh_gha", XKB_KEY_Sinh_gha },
-    { "Sinh_ng2", XKB_KEY_Sinh_ng2 },
-    { "Sinh_nga", XKB_KEY_Sinh_nga },
-    { "Sinh_ca", XKB_KEY_Sinh_ca },
-    { "Sinh_cha", XKB_KEY_Sinh_cha },
-    { "Sinh_ja", XKB_KEY_Sinh_ja },
-    { "Sinh_jha", XKB_KEY_Sinh_jha },
-    { "Sinh_nya", XKB_KEY_Sinh_nya },
-    { "Sinh_jnya", XKB_KEY_Sinh_jnya },
-    { "Sinh_nja", XKB_KEY_Sinh_nja },
-    { "Sinh_tta", XKB_KEY_Sinh_tta },
-    { "Sinh_ttha", XKB_KEY_Sinh_ttha },
-    { "Sinh_dda", XKB_KEY_Sinh_dda },
-    { "Sinh_ddha", XKB_KEY_Sinh_ddha },
-    { "Sinh_nna", XKB_KEY_Sinh_nna },
-    { "Sinh_ndda", XKB_KEY_Sinh_ndda },
-    { "Sinh_tha", XKB_KEY_Sinh_tha },
-    { "Sinh_thha", XKB_KEY_Sinh_thha },
-    { "Sinh_dha", XKB_KEY_Sinh_dha },
-    { "Sinh_dhha", XKB_KEY_Sinh_dhha },
-    { "Sinh_na", XKB_KEY_Sinh_na },
-    { "Sinh_ndha", XKB_KEY_Sinh_ndha },
-    { "Sinh_pa", XKB_KEY_Sinh_pa },
-    { "Sinh_pha", XKB_KEY_Sinh_pha },
-    { "Sinh_ba", XKB_KEY_Sinh_ba },
-    { "Sinh_bha", XKB_KEY_Sinh_bha },
-    { "Sinh_ma", XKB_KEY_Sinh_ma },
-    { "Sinh_mba", XKB_KEY_Sinh_mba },
-    { "Sinh_ya", XKB_KEY_Sinh_ya },
-    { "Sinh_ra", XKB_KEY_Sinh_ra },
-    { "Sinh_la", XKB_KEY_Sinh_la },
-    { "Sinh_va", XKB_KEY_Sinh_va },
-    { "Sinh_sha", XKB_KEY_Sinh_sha },
-    { "Sinh_ssha", XKB_KEY_Sinh_ssha },
-    { "Sinh_sa", XKB_KEY_Sinh_sa },
-    { "Sinh_ha", XKB_KEY_Sinh_ha },
-    { "Sinh_lla", XKB_KEY_Sinh_lla },
-    { "Sinh_fa", XKB_KEY_Sinh_fa },
-    { "Sinh_al", XKB_KEY_Sinh_al },
-    { "Sinh_aa2", XKB_KEY_Sinh_aa2 },
-    { "Sinh_ae2", XKB_KEY_Sinh_ae2 },
-    { "Sinh_aee2", XKB_KEY_Sinh_aee2 },
-    { "Sinh_i2", XKB_KEY_Sinh_i2 },
-    { "Sinh_ii2", XKB_KEY_Sinh_ii2 },
-    { "Sinh_u2", XKB_KEY_Sinh_u2 },
-    { "Sinh_uu2", XKB_KEY_Sinh_uu2 },
-    { "Sinh_ru2", XKB_KEY_Sinh_ru2 },
-    { "Sinh_e2", XKB_KEY_Sinh_e2 },
-    { "Sinh_ee2", XKB_KEY_Sinh_ee2 },
-    { "Sinh_ai2", XKB_KEY_Sinh_ai2 },
-    { "Sinh_o2", XKB_KEY_Sinh_o2 },
-    { "Sinh_oo2", XKB_KEY_Sinh_oo2 },
-    { "Sinh_au2", XKB_KEY_Sinh_au2 },
-    { "Sinh_lu2", XKB_KEY_Sinh_lu2 },
-    { "Sinh_ruu2", XKB_KEY_Sinh_ruu2 },
-    { "Sinh_luu2", XKB_KEY_Sinh_luu2 },
-    { "Sinh_kunddaliya", XKB_KEY_Sinh_kunddaliya },
-    { "Georgian_an", XKB_KEY_Georgian_an },
-    { "Georgian_ban", XKB_KEY_Georgian_ban },
-    { "Georgian_gan", XKB_KEY_Georgian_gan },
-    { "Georgian_don", XKB_KEY_Georgian_don },
-    { "Georgian_en", XKB_KEY_Georgian_en },
-    { "Georgian_vin", XKB_KEY_Georgian_vin },
-    { "Georgian_zen", XKB_KEY_Georgian_zen },
-    { "Georgian_tan", XKB_KEY_Georgian_tan },
-    { "Georgian_in", XKB_KEY_Georgian_in },
-    { "Georgian_kan", XKB_KEY_Georgian_kan },
-    { "Georgian_las", XKB_KEY_Georgian_las },
-    { "Georgian_man", XKB_KEY_Georgian_man },
-    { "Georgian_nar", XKB_KEY_Georgian_nar },
-    { "Georgian_on", XKB_KEY_Georgian_on },
-    { "Georgian_par", XKB_KEY_Georgian_par },
-    { "Georgian_zhar", XKB_KEY_Georgian_zhar },
-    { "Georgian_rae", XKB_KEY_Georgian_rae },
-    { "Georgian_san", XKB_KEY_Georgian_san },
-    { "Georgian_tar", XKB_KEY_Georgian_tar },
-    { "Georgian_un", XKB_KEY_Georgian_un },
-    { "Georgian_phar", XKB_KEY_Georgian_phar },
-    { "Georgian_khar", XKB_KEY_Georgian_khar },
-    { "Georgian_ghan", XKB_KEY_Georgian_ghan },
-    { "Georgian_qar", XKB_KEY_Georgian_qar },
-    { "Georgian_shin", XKB_KEY_Georgian_shin },
-    { "Georgian_chin", XKB_KEY_Georgian_chin },
-    { "Georgian_can", XKB_KEY_Georgian_can },
-    { "Georgian_jil", XKB_KEY_Georgian_jil },
-    { "Georgian_cil", XKB_KEY_Georgian_cil },
-    { "Georgian_char", XKB_KEY_Georgian_char },
-    { "Georgian_xan", XKB_KEY_Georgian_xan },
-    { "Georgian_jhan", XKB_KEY_Georgian_jhan },
-    { "Georgian_hae", XKB_KEY_Georgian_hae },
-    { "Georgian_he", XKB_KEY_Georgian_he },
-    { "Georgian_hie", XKB_KEY_Georgian_hie },
-    { "Georgian_we", XKB_KEY_Georgian_we },
-    { "Georgian_har", XKB_KEY_Georgian_har },
-    { "Georgian_hoe", XKB_KEY_Georgian_hoe },
-    { "Georgian_fi", XKB_KEY_Georgian_fi },
-    { "Babovedot", XKB_KEY_Babovedot },
-    { "babovedot", XKB_KEY_babovedot },
-    { "Dabovedot", XKB_KEY_Dabovedot },
-    { "dabovedot", XKB_KEY_dabovedot },
-    { "Fabovedot", XKB_KEY_Fabovedot },
-    { "fabovedot", XKB_KEY_fabovedot },
-    { "Lbelowdot", XKB_KEY_Lbelowdot },
-    { "lbelowdot", XKB_KEY_lbelowdot },
-    { "Mabovedot", XKB_KEY_Mabovedot },
-    { "mabovedot", XKB_KEY_mabovedot },
-    { "Pabovedot", XKB_KEY_Pabovedot },
-    { "pabovedot", XKB_KEY_pabovedot },
-    { "Sabovedot", XKB_KEY_Sabovedot },
-    { "sabovedot", XKB_KEY_sabovedot },
-    { "Tabovedot", XKB_KEY_Tabovedot },
-    { "tabovedot", XKB_KEY_tabovedot },
-    { "Wgrave", XKB_KEY_Wgrave },
-    { "wgrave", XKB_KEY_wgrave },
-    { "Wacute", XKB_KEY_Wacute },
-    { "wacute", XKB_KEY_wacute },
-    { "Wdiaeresis", XKB_KEY_Wdiaeresis },
-    { "wdiaeresis", XKB_KEY_wdiaeresis },
-    { "Xabovedot", XKB_KEY_Xabovedot },
-    { "xabovedot", XKB_KEY_xabovedot },
-    { "Abelowdot", XKB_KEY_Abelowdot },
-    { "abelowdot", XKB_KEY_abelowdot },
-    { "Ahook", XKB_KEY_Ahook },
-    { "ahook", XKB_KEY_ahook },
-    { "Acircumflexacute", XKB_KEY_Acircumflexacute },
-    { "acircumflexacute", XKB_KEY_acircumflexacute },
-    { "Acircumflexgrave", XKB_KEY_Acircumflexgrave },
-    { "acircumflexgrave", XKB_KEY_acircumflexgrave },
-    { "Acircumflexhook", XKB_KEY_Acircumflexhook },
-    { "acircumflexhook", XKB_KEY_acircumflexhook },
-    { "Acircumflextilde", XKB_KEY_Acircumflextilde },
-    { "acircumflextilde", XKB_KEY_acircumflextilde },
-    { "Acircumflexbelowdot", XKB_KEY_Acircumflexbelowdot },
-    { "acircumflexbelowdot", XKB_KEY_acircumflexbelowdot },
-    { "Abreveacute", XKB_KEY_Abreveacute },
-    { "abreveacute", XKB_KEY_abreveacute },
-    { "Abrevegrave", XKB_KEY_Abrevegrave },
-    { "abrevegrave", XKB_KEY_abrevegrave },
-    { "Abrevehook", XKB_KEY_Abrevehook },
-    { "abrevehook", XKB_KEY_abrevehook },
-    { "Abrevetilde", XKB_KEY_Abrevetilde },
-    { "abrevetilde", XKB_KEY_abrevetilde },
-    { "Abrevebelowdot", XKB_KEY_Abrevebelowdot },
-    { "abrevebelowdot", XKB_KEY_abrevebelowdot },
-    { "Ebelowdot", XKB_KEY_Ebelowdot },
-    { "ebelowdot", XKB_KEY_ebelowdot },
-    { "Ehook", XKB_KEY_Ehook },
-    { "ehook", XKB_KEY_ehook },
-    { "Etilde", XKB_KEY_Etilde },
-    { "etilde", XKB_KEY_etilde },
-    { "Ecircumflexacute", XKB_KEY_Ecircumflexacute },
-    { "ecircumflexacute", XKB_KEY_ecircumflexacute },
-    { "Ecircumflexgrave", XKB_KEY_Ecircumflexgrave },
-    { "ecircumflexgrave", XKB_KEY_ecircumflexgrave },
-    { "Ecircumflexhook", XKB_KEY_Ecircumflexhook },
-    { "ecircumflexhook", XKB_KEY_ecircumflexhook },
-    { "Ecircumflextilde", XKB_KEY_Ecircumflextilde },
-    { "ecircumflextilde", XKB_KEY_ecircumflextilde },
-    { "Ecircumflexbelowdot", XKB_KEY_Ecircumflexbelowdot },
-    { "ecircumflexbelowdot", XKB_KEY_ecircumflexbelowdot },
-    { "Ihook", XKB_KEY_Ihook },
-    { "ihook", XKB_KEY_ihook },
-    { "Ibelowdot", XKB_KEY_Ibelowdot },
-    { "ibelowdot", XKB_KEY_ibelowdot },
-    { "Obelowdot", XKB_KEY_Obelowdot },
-    { "obelowdot", XKB_KEY_obelowdot },
-    { "Ohook", XKB_KEY_Ohook },
-    { "ohook", XKB_KEY_ohook },
-    { "Ocircumflexacute", XKB_KEY_Ocircumflexacute },
-    { "ocircumflexacute", XKB_KEY_ocircumflexacute },
-    { "Ocircumflexgrave", XKB_KEY_Ocircumflexgrave },
-    { "ocircumflexgrave", XKB_KEY_ocircumflexgrave },
-    { "Ocircumflexhook", XKB_KEY_Ocircumflexhook },
-    { "ocircumflexhook", XKB_KEY_ocircumflexhook },
-    { "Ocircumflextilde", XKB_KEY_Ocircumflextilde },
-    { "ocircumflextilde", XKB_KEY_ocircumflextilde },
-    { "Ocircumflexbelowdot", XKB_KEY_Ocircumflexbelowdot },
-    { "ocircumflexbelowdot", XKB_KEY_ocircumflexbelowdot },
-    { "Ohornacute", XKB_KEY_Ohornacute },
-    { "ohornacute", XKB_KEY_ohornacute },
-    { "Ohorngrave", XKB_KEY_Ohorngrave },
-    { "ohorngrave", XKB_KEY_ohorngrave },
-    { "Ohornhook", XKB_KEY_Ohornhook },
-    { "ohornhook", XKB_KEY_ohornhook },
-    { "Ohorntilde", XKB_KEY_Ohorntilde },
-    { "ohorntilde", XKB_KEY_ohorntilde },
-    { "Ohornbelowdot", XKB_KEY_Ohornbelowdot },
-    { "ohornbelowdot", XKB_KEY_ohornbelowdot },
-    { "Ubelowdot", XKB_KEY_Ubelowdot },
-    { "ubelowdot", XKB_KEY_ubelowdot },
-    { "Uhook", XKB_KEY_Uhook },
-    { "uhook", XKB_KEY_uhook },
-    { "Uhornacute", XKB_KEY_Uhornacute },
-    { "uhornacute", XKB_KEY_uhornacute },
-    { "Uhorngrave", XKB_KEY_Uhorngrave },
-    { "uhorngrave", XKB_KEY_uhorngrave },
-    { "Uhornhook", XKB_KEY_Uhornhook },
-    { "uhornhook", XKB_KEY_uhornhook },
-    { "Uhorntilde", XKB_KEY_Uhorntilde },
-    { "uhorntilde", XKB_KEY_uhorntilde },
-    { "Uhornbelowdot", XKB_KEY_Uhornbelowdot },
-    { "uhornbelowdot", XKB_KEY_uhornbelowdot },
-    { "Ygrave", XKB_KEY_Ygrave },
-    { "ygrave", XKB_KEY_ygrave },
-    { "Ybelowdot", XKB_KEY_Ybelowdot },
-    { "ybelowdot", XKB_KEY_ybelowdot },
-    { "Yhook", XKB_KEY_Yhook },
-    { "yhook", XKB_KEY_yhook },
-    { "Ytilde", XKB_KEY_Ytilde },
-    { "ytilde", XKB_KEY_ytilde },
-    { "zerosuperior", XKB_KEY_zerosuperior },
-    { "foursuperior", XKB_KEY_foursuperior },
-    { "fivesuperior", XKB_KEY_fivesuperior },
-    { "sixsuperior", XKB_KEY_sixsuperior },
-    { "sevensuperior", XKB_KEY_sevensuperior },
-    { "eightsuperior", XKB_KEY_eightsuperior },
-    { "ninesuperior", XKB_KEY_ninesuperior },
-    { "zerosubscript", XKB_KEY_zerosubscript },
-    { "onesubscript", XKB_KEY_onesubscript },
-    { "twosubscript", XKB_KEY_twosubscript },
-    { "threesubscript", XKB_KEY_threesubscript },
-    { "foursubscript", XKB_KEY_foursubscript },
-    { "fivesubscript", XKB_KEY_fivesubscript },
-    { "sixsubscript", XKB_KEY_sixsubscript },
-    { "sevensubscript", XKB_KEY_sevensubscript },
-    { "eightsubscript", XKB_KEY_eightsubscript },
-    { "ninesubscript", XKB_KEY_ninesubscript },
-    { "EcuSign", XKB_KEY_EcuSign },
-    { "ColonSign", XKB_KEY_ColonSign },
-    { "CruzeiroSign", XKB_KEY_CruzeiroSign },
-    { "FFrancSign", XKB_KEY_FFrancSign },
-    { "LiraSign", XKB_KEY_LiraSign },
-    { "MillSign", XKB_KEY_MillSign },
-    { "NairaSign", XKB_KEY_NairaSign },
-    { "PesetaSign", XKB_KEY_PesetaSign },
-    { "RupeeSign", XKB_KEY_RupeeSign },
-    { "WonSign", XKB_KEY_WonSign },
-    { "NewSheqelSign", XKB_KEY_NewSheqelSign },
-    { "DongSign", XKB_KEY_DongSign },
-    { "partdifferential", XKB_KEY_partdifferential },
-    { "emptyset", XKB_KEY_emptyset },
-    { "elementof", XKB_KEY_elementof },
-    { "notelementof", XKB_KEY_notelementof },
-    { "containsas", XKB_KEY_containsas },
-    { "squareroot", XKB_KEY_squareroot },
-    { "cuberoot", XKB_KEY_cuberoot },
-    { "fourthroot", XKB_KEY_fourthroot },
-    { "dintegral", XKB_KEY_dintegral },
-    { "tintegral", XKB_KEY_tintegral },
-    { "because", XKB_KEY_because },
-    { "notapproxeq", XKB_KEY_notapproxeq },
-    { "approxeq", XKB_KEY_approxeq },
-    { "notidentical", XKB_KEY_notidentical },
-    { "stricteq", XKB_KEY_stricteq },
-    { "braille_blank", XKB_KEY_braille_blank },
-    { "braille_dots_1", XKB_KEY_braille_dots_1 },
-    { "braille_dots_2", XKB_KEY_braille_dots_2 },
-    { "braille_dots_12", XKB_KEY_braille_dots_12 },
-    { "braille_dots_3", XKB_KEY_braille_dots_3 },
-    { "braille_dots_13", XKB_KEY_braille_dots_13 },
-    { "braille_dots_23", XKB_KEY_braille_dots_23 },
-    { "braille_dots_123", XKB_KEY_braille_dots_123 },
-    { "braille_dots_4", XKB_KEY_braille_dots_4 },
-    { "braille_dots_14", XKB_KEY_braille_dots_14 },
-    { "braille_dots_24", XKB_KEY_braille_dots_24 },
-    { "braille_dots_124", XKB_KEY_braille_dots_124 },
-    { "braille_dots_34", XKB_KEY_braille_dots_34 },
-    { "braille_dots_134", XKB_KEY_braille_dots_134 },
-    { "braille_dots_234", XKB_KEY_braille_dots_234 },
-    { "braille_dots_1234", XKB_KEY_braille_dots_1234 },
-    { "braille_dots_5", XKB_KEY_braille_dots_5 },
-    { "braille_dots_15", XKB_KEY_braille_dots_15 },
-    { "braille_dots_25", XKB_KEY_braille_dots_25 },
-    { "braille_dots_125", XKB_KEY_braille_dots_125 },
-    { "braille_dots_35", XKB_KEY_braille_dots_35 },
-    { "braille_dots_135", XKB_KEY_braille_dots_135 },
-    { "braille_dots_235", XKB_KEY_braille_dots_235 },
-    { "braille_dots_1235", XKB_KEY_braille_dots_1235 },
-    { "braille_dots_45", XKB_KEY_braille_dots_45 },
-    { "braille_dots_145", XKB_KEY_braille_dots_145 },
-    { "braille_dots_245", XKB_KEY_braille_dots_245 },
-    { "braille_dots_1245", XKB_KEY_braille_dots_1245 },
-    { "braille_dots_345", XKB_KEY_braille_dots_345 },
-    { "braille_dots_1345", XKB_KEY_braille_dots_1345 },
-    { "braille_dots_2345", XKB_KEY_braille_dots_2345 },
-    { "braille_dots_12345", XKB_KEY_braille_dots_12345 },
-    { "braille_dots_6", XKB_KEY_braille_dots_6 },
-    { "braille_dots_16", XKB_KEY_braille_dots_16 },
-    { "braille_dots_26", XKB_KEY_braille_dots_26 },
-    { "braille_dots_126", XKB_KEY_braille_dots_126 },
-    { "braille_dots_36", XKB_KEY_braille_dots_36 },
-    { "braille_dots_136", XKB_KEY_braille_dots_136 },
-    { "braille_dots_236", XKB_KEY_braille_dots_236 },
-    { "braille_dots_1236", XKB_KEY_braille_dots_1236 },
-    { "braille_dots_46", XKB_KEY_braille_dots_46 },
-    { "braille_dots_146", XKB_KEY_braille_dots_146 },
-    { "braille_dots_246", XKB_KEY_braille_dots_246 },
-    { "braille_dots_1246", XKB_KEY_braille_dots_1246 },
-    { "braille_dots_346", XKB_KEY_braille_dots_346 },
-    { "braille_dots_1346", XKB_KEY_braille_dots_1346 },
-    { "braille_dots_2346", XKB_KEY_braille_dots_2346 },
-    { "braille_dots_12346", XKB_KEY_braille_dots_12346 },
-    { "braille_dots_56", XKB_KEY_braille_dots_56 },
-    { "braille_dots_156", XKB_KEY_braille_dots_156 },
-    { "braille_dots_256", XKB_KEY_braille_dots_256 },
-    { "braille_dots_1256", XKB_KEY_braille_dots_1256 },
-    { "braille_dots_356", XKB_KEY_braille_dots_356 },
-    { "braille_dots_1356", XKB_KEY_braille_dots_1356 },
-    { "braille_dots_2356", XKB_KEY_braille_dots_2356 },
-    { "braille_dots_12356", XKB_KEY_braille_dots_12356 },
-    { "braille_dots_456", XKB_KEY_braille_dots_456 },
-    { "braille_dots_1456", XKB_KEY_braille_dots_1456 },
-    { "braille_dots_2456", XKB_KEY_braille_dots_2456 },
-    { "braille_dots_12456", XKB_KEY_braille_dots_12456 },
-    { "braille_dots_3456", XKB_KEY_braille_dots_3456 },
-    { "braille_dots_13456", XKB_KEY_braille_dots_13456 },
-    { "braille_dots_23456", XKB_KEY_braille_dots_23456 },
-    { "braille_dots_123456", XKB_KEY_braille_dots_123456 },
-    { "braille_dots_7", XKB_KEY_braille_dots_7 },
-    { "braille_dots_17", XKB_KEY_braille_dots_17 },
-    { "braille_dots_27", XKB_KEY_braille_dots_27 },
-    { "braille_dots_127", XKB_KEY_braille_dots_127 },
-    { "braille_dots_37", XKB_KEY_braille_dots_37 },
-    { "braille_dots_137", XKB_KEY_braille_dots_137 },
-    { "braille_dots_237", XKB_KEY_braille_dots_237 },
-    { "braille_dots_1237", XKB_KEY_braille_dots_1237 },
-    { "braille_dots_47", XKB_KEY_braille_dots_47 },
-    { "braille_dots_147", XKB_KEY_braille_dots_147 },
-    { "braille_dots_247", XKB_KEY_braille_dots_247 },
-    { "braille_dots_1247", XKB_KEY_braille_dots_1247 },
-    { "braille_dots_347", XKB_KEY_braille_dots_347 },
-    { "braille_dots_1347", XKB_KEY_braille_dots_1347 },
-    { "braille_dots_2347", XKB_KEY_braille_dots_2347 },
-    { "braille_dots_12347", XKB_KEY_braille_dots_12347 },
-    { "braille_dots_57", XKB_KEY_braille_dots_57 },
-    { "braille_dots_157", XKB_KEY_braille_dots_157 },
-    { "braille_dots_257", XKB_KEY_braille_dots_257 },
-    { "braille_dots_1257", XKB_KEY_braille_dots_1257 },
-    { "braille_dots_357", XKB_KEY_braille_dots_357 },
-    { "braille_dots_1357", XKB_KEY_braille_dots_1357 },
-    { "braille_dots_2357", XKB_KEY_braille_dots_2357 },
-    { "braille_dots_12357", XKB_KEY_braille_dots_12357 },
-    { "braille_dots_457", XKB_KEY_braille_dots_457 },
-    { "braille_dots_1457", XKB_KEY_braille_dots_1457 },
-    { "braille_dots_2457", XKB_KEY_braille_dots_2457 },
-    { "braille_dots_12457", XKB_KEY_braille_dots_12457 },
-    { "braille_dots_3457", XKB_KEY_braille_dots_3457 },
-    { "braille_dots_13457", XKB_KEY_braille_dots_13457 },
-    { "braille_dots_23457", XKB_KEY_braille_dots_23457 },
-    { "braille_dots_123457", XKB_KEY_braille_dots_123457 },
-    { "braille_dots_67", XKB_KEY_braille_dots_67 },
-    { "braille_dots_167", XKB_KEY_braille_dots_167 },
-    { "braille_dots_267", XKB_KEY_braille_dots_267 },
-    { "braille_dots_1267", XKB_KEY_braille_dots_1267 },
-    { "braille_dots_367", XKB_KEY_braille_dots_367 },
-    { "braille_dots_1367", XKB_KEY_braille_dots_1367 },
-    { "braille_dots_2367", XKB_KEY_braille_dots_2367 },
-    { "braille_dots_12367", XKB_KEY_braille_dots_12367 },
-    { "braille_dots_467", XKB_KEY_braille_dots_467 },
-    { "braille_dots_1467", XKB_KEY_braille_dots_1467 },
-    { "braille_dots_2467", XKB_KEY_braille_dots_2467 },
-    { "braille_dots_12467", XKB_KEY_braille_dots_12467 },
-    { "braille_dots_3467", XKB_KEY_braille_dots_3467 },
-    { "braille_dots_13467", XKB_KEY_braille_dots_13467 },
-    { "braille_dots_23467", XKB_KEY_braille_dots_23467 },
-    { "braille_dots_123467", XKB_KEY_braille_dots_123467 },
-    { "braille_dots_567", XKB_KEY_braille_dots_567 },
-    { "braille_dots_1567", XKB_KEY_braille_dots_1567 },
-    { "braille_dots_2567", XKB_KEY_braille_dots_2567 },
-    { "braille_dots_12567", XKB_KEY_braille_dots_12567 },
-    { "braille_dots_3567", XKB_KEY_braille_dots_3567 },
-    { "braille_dots_13567", XKB_KEY_braille_dots_13567 },
-    { "braille_dots_23567", XKB_KEY_braille_dots_23567 },
-    { "braille_dots_123567", XKB_KEY_braille_dots_123567 },
-    { "braille_dots_4567", XKB_KEY_braille_dots_4567 },
-    { "braille_dots_14567", XKB_KEY_braille_dots_14567 },
-    { "braille_dots_24567", XKB_KEY_braille_dots_24567 },
-    { "braille_dots_124567", XKB_KEY_braille_dots_124567 },
-    { "braille_dots_34567", XKB_KEY_braille_dots_34567 },
-    { "braille_dots_134567", XKB_KEY_braille_dots_134567 },
-    { "braille_dots_234567", XKB_KEY_braille_dots_234567 },
-    { "braille_dots_1234567", XKB_KEY_braille_dots_1234567 },
-    { "braille_dots_8", XKB_KEY_braille_dots_8 },
-    { "braille_dots_18", XKB_KEY_braille_dots_18 },
-    { "braille_dots_28", XKB_KEY_braille_dots_28 },
-    { "braille_dots_128", XKB_KEY_braille_dots_128 },
-    { "braille_dots_38", XKB_KEY_braille_dots_38 },
-    { "braille_dots_138", XKB_KEY_braille_dots_138 },
-    { "braille_dots_238", XKB_KEY_braille_dots_238 },
-    { "braille_dots_1238", XKB_KEY_braille_dots_1238 },
-    { "braille_dots_48", XKB_KEY_braille_dots_48 },
-    { "braille_dots_148", XKB_KEY_braille_dots_148 },
-    { "braille_dots_248", XKB_KEY_braille_dots_248 },
-    { "braille_dots_1248", XKB_KEY_braille_dots_1248 },
-    { "braille_dots_348", XKB_KEY_braille_dots_348 },
-    { "braille_dots_1348", XKB_KEY_braille_dots_1348 },
-    { "braille_dots_2348", XKB_KEY_braille_dots_2348 },
-    { "braille_dots_12348", XKB_KEY_braille_dots_12348 },
-    { "braille_dots_58", XKB_KEY_braille_dots_58 },
-    { "braille_dots_158", XKB_KEY_braille_dots_158 },
-    { "braille_dots_258", XKB_KEY_braille_dots_258 },
-    { "braille_dots_1258", XKB_KEY_braille_dots_1258 },
-    { "braille_dots_358", XKB_KEY_braille_dots_358 },
-    { "braille_dots_1358", XKB_KEY_braille_dots_1358 },
-    { "braille_dots_2358", XKB_KEY_braille_dots_2358 },
-    { "braille_dots_12358", XKB_KEY_braille_dots_12358 },
-    { "braille_dots_458", XKB_KEY_braille_dots_458 },
-    { "braille_dots_1458", XKB_KEY_braille_dots_1458 },
-    { "braille_dots_2458", XKB_KEY_braille_dots_2458 },
-    { "braille_dots_12458", XKB_KEY_braille_dots_12458 },
-    { "braille_dots_3458", XKB_KEY_braille_dots_3458 },
-    { "braille_dots_13458", XKB_KEY_braille_dots_13458 },
-    { "braille_dots_23458", XKB_KEY_braille_dots_23458 },
-    { "braille_dots_123458", XKB_KEY_braille_dots_123458 },
-    { "braille_dots_68", XKB_KEY_braille_dots_68 },
-    { "braille_dots_168", XKB_KEY_braille_dots_168 },
-    { "braille_dots_268", XKB_KEY_braille_dots_268 },
-    { "braille_dots_1268", XKB_KEY_braille_dots_1268 },
-    { "braille_dots_368", XKB_KEY_braille_dots_368 },
-    { "braille_dots_1368", XKB_KEY_braille_dots_1368 },
-    { "braille_dots_2368", XKB_KEY_braille_dots_2368 },
-    { "braille_dots_12368", XKB_KEY_braille_dots_12368 },
-    { "braille_dots_468", XKB_KEY_braille_dots_468 },
-    { "braille_dots_1468", XKB_KEY_braille_dots_1468 },
-    { "braille_dots_2468", XKB_KEY_braille_dots_2468 },
-    { "braille_dots_12468", XKB_KEY_braille_dots_12468 },
-    { "braille_dots_3468", XKB_KEY_braille_dots_3468 },
-    { "braille_dots_13468", XKB_KEY_braille_dots_13468 },
-    { "braille_dots_23468", XKB_KEY_braille_dots_23468 },
-    { "braille_dots_123468", XKB_KEY_braille_dots_123468 },
-    { "braille_dots_568", XKB_KEY_braille_dots_568 },
-    { "braille_dots_1568", XKB_KEY_braille_dots_1568 },
-    { "braille_dots_2568", XKB_KEY_braille_dots_2568 },
-    { "braille_dots_12568", XKB_KEY_braille_dots_12568 },
-    { "braille_dots_3568", XKB_KEY_braille_dots_3568 },
-    { "braille_dots_13568", XKB_KEY_braille_dots_13568 },
-    { "braille_dots_23568", XKB_KEY_braille_dots_23568 },
-    { "braille_dots_123568", XKB_KEY_braille_dots_123568 },
-    { "braille_dots_4568", XKB_KEY_braille_dots_4568 },
-    { "braille_dots_14568", XKB_KEY_braille_dots_14568 },
-    { "braille_dots_24568", XKB_KEY_braille_dots_24568 },
-    { "braille_dots_124568", XKB_KEY_braille_dots_124568 },
-    { "braille_dots_34568", XKB_KEY_braille_dots_34568 },
-    { "braille_dots_134568", XKB_KEY_braille_dots_134568 },
-    { "braille_dots_234568", XKB_KEY_braille_dots_234568 },
-    { "braille_dots_1234568", XKB_KEY_braille_dots_1234568 },
-    { "braille_dots_78", XKB_KEY_braille_dots_78 },
-    { "braille_dots_178", XKB_KEY_braille_dots_178 },
-    { "braille_dots_278", XKB_KEY_braille_dots_278 },
-    { "braille_dots_1278", XKB_KEY_braille_dots_1278 },
-    { "braille_dots_378", XKB_KEY_braille_dots_378 },
-    { "braille_dots_1378", XKB_KEY_braille_dots_1378 },
-    { "braille_dots_2378", XKB_KEY_braille_dots_2378 },
-    { "braille_dots_12378", XKB_KEY_braille_dots_12378 },
-    { "braille_dots_478", XKB_KEY_braille_dots_478 },
-    { "braille_dots_1478", XKB_KEY_braille_dots_1478 },
-    { "braille_dots_2478", XKB_KEY_braille_dots_2478 },
-    { "braille_dots_12478", XKB_KEY_braille_dots_12478 },
-    { "braille_dots_3478", XKB_KEY_braille_dots_3478 },
-    { "braille_dots_13478", XKB_KEY_braille_dots_13478 },
-    { "braille_dots_23478", XKB_KEY_braille_dots_23478 },
-    { "braille_dots_123478", XKB_KEY_braille_dots_123478 },
-    { "braille_dots_578", XKB_KEY_braille_dots_578 },
-    { "braille_dots_1578", XKB_KEY_braille_dots_1578 },
-    { "braille_dots_2578", XKB_KEY_braille_dots_2578 },
-    { "braille_dots_12578", XKB_KEY_braille_dots_12578 },
-    { "braille_dots_3578", XKB_KEY_braille_dots_3578 },
-    { "braille_dots_13578", XKB_KEY_braille_dots_13578 },
-    { "braille_dots_23578", XKB_KEY_braille_dots_23578 },
-    { "braille_dots_123578", XKB_KEY_braille_dots_123578 },
-    { "braille_dots_4578", XKB_KEY_braille_dots_4578 },
-    { "braille_dots_14578", XKB_KEY_braille_dots_14578 },
-    { "braille_dots_24578", XKB_KEY_braille_dots_24578 },
-    { "braille_dots_124578", XKB_KEY_braille_dots_124578 },
-    { "braille_dots_34578", XKB_KEY_braille_dots_34578 },
-    { "braille_dots_134578", XKB_KEY_braille_dots_134578 },
-    { "braille_dots_234578", XKB_KEY_braille_dots_234578 },
-    { "braille_dots_1234578", XKB_KEY_braille_dots_1234578 },
-    { "braille_dots_678", XKB_KEY_braille_dots_678 },
-    { "braille_dots_1678", XKB_KEY_braille_dots_1678 },
-    { "braille_dots_2678", XKB_KEY_braille_dots_2678 },
-    { "braille_dots_12678", XKB_KEY_braille_dots_12678 },
-    { "braille_dots_3678", XKB_KEY_braille_dots_3678 },
-    { "braille_dots_13678", XKB_KEY_braille_dots_13678 },
-    { "braille_dots_23678", XKB_KEY_braille_dots_23678 },
-    { "braille_dots_123678", XKB_KEY_braille_dots_123678 },
-    { "braille_dots_4678", XKB_KEY_braille_dots_4678 },
-    { "braille_dots_14678", XKB_KEY_braille_dots_14678 },
-    { "braille_dots_24678", XKB_KEY_braille_dots_24678 },
-    { "braille_dots_124678", XKB_KEY_braille_dots_124678 },
-    { "braille_dots_34678", XKB_KEY_braille_dots_34678 },
-    { "braille_dots_134678", XKB_KEY_braille_dots_134678 },
-    { "braille_dots_234678", XKB_KEY_braille_dots_234678 },
-    { "braille_dots_1234678", XKB_KEY_braille_dots_1234678 },
-    { "braille_dots_5678", XKB_KEY_braille_dots_5678 },
-    { "braille_dots_15678", XKB_KEY_braille_dots_15678 },
-    { "braille_dots_25678", XKB_KEY_braille_dots_25678 },
-    { "braille_dots_125678", XKB_KEY_braille_dots_125678 },
-    { "braille_dots_35678", XKB_KEY_braille_dots_35678 },
-    { "braille_dots_135678", XKB_KEY_braille_dots_135678 },
-    { "braille_dots_235678", XKB_KEY_braille_dots_235678 },
-    { "braille_dots_1235678", XKB_KEY_braille_dots_1235678 },
-    { "braille_dots_45678", XKB_KEY_braille_dots_45678 },
-    { "braille_dots_145678", XKB_KEY_braille_dots_145678 },
-    { "braille_dots_245678", XKB_KEY_braille_dots_245678 },
-    { "braille_dots_1245678", XKB_KEY_braille_dots_1245678 },
-    { "braille_dots_345678", XKB_KEY_braille_dots_345678 },
-    { "braille_dots_1345678", XKB_KEY_braille_dots_1345678 },
-    { "braille_dots_2345678", XKB_KEY_braille_dots_2345678 },
-    { "braille_dots_12345678", XKB_KEY_braille_dots_12345678 },
-    { "hpmute_acute", XKB_KEY_hpmute_acute },
-    { "hpmute_grave", XKB_KEY_hpmute_grave },
-    { "hpmute_asciicircum", XKB_KEY_hpmute_asciicircum },
-    { "hpmute_diaeresis", XKB_KEY_hpmute_diaeresis },
-    { "hpmute_asciitilde", XKB_KEY_hpmute_asciitilde },
-    { "hplira", XKB_KEY_hplira },
-    { "hpguilder", XKB_KEY_hpguilder },
-    { "hpYdiaeresis", XKB_KEY_hpYdiaeresis },
-    { "hplongminus", XKB_KEY_hplongminus },
-    { "hpblock", XKB_KEY_hpblock },
-    { "Ddiaeresis", XKB_KEY_Ddiaeresis },
-    { "Dacute_accent", XKB_KEY_Dacute_accent },
-    { "Dcedilla_accent", XKB_KEY_Dcedilla_accent },
-    { "Dcircumflex_accent", XKB_KEY_Dcircumflex_accent },
-    { "Dgrave_accent", XKB_KEY_Dgrave_accent },
-    { "Dtilde", XKB_KEY_Dtilde },
-    { "Dring_accent", XKB_KEY_Dring_accent },
-    { "DRemove", XKB_KEY_DRemove },
-    { "hpModelock1", XKB_KEY_hpModelock1 },
-    { "hpModelock2", XKB_KEY_hpModelock2 },
-    { "hpReset", XKB_KEY_hpReset },
-    { "hpSystem", XKB_KEY_hpSystem },
-    { "hpUser", XKB_KEY_hpUser },
-    { "hpClearLine", XKB_KEY_hpClearLine },
-    { "hpInsertLine", XKB_KEY_hpInsertLine },
-    { "hpDeleteLine", XKB_KEY_hpDeleteLine },
-    { "hpInsertChar", XKB_KEY_hpInsertChar },
-    { "hpDeleteChar", XKB_KEY_hpDeleteChar },
-    { "hpBackTab", XKB_KEY_hpBackTab },
-    { "hpKP_BackTab", XKB_KEY_hpKP_BackTab },
-    { "Ext16bit_L", XKB_KEY_Ext16bit_L },
-    { "Ext16bit_R", XKB_KEY_Ext16bit_R },
-    { "osfCopy", XKB_KEY_osfCopy },
-    { "osfCut", XKB_KEY_osfCut },
-    { "osfPaste", XKB_KEY_osfPaste },
-    { "osfBackTab", XKB_KEY_osfBackTab },
-    { "osfBackSpace", XKB_KEY_osfBackSpace },
-    { "osfClear", XKB_KEY_osfClear },
-    { "osfEscape", XKB_KEY_osfEscape },
-    { "osfAddMode", XKB_KEY_osfAddMode },
-    { "osfPrimaryPaste", XKB_KEY_osfPrimaryPaste },
-    { "osfQuickPaste", XKB_KEY_osfQuickPaste },
-    { "osfPageLeft", XKB_KEY_osfPageLeft },
-    { "osfPageUp", XKB_KEY_osfPageUp },
-    { "osfPageDown", XKB_KEY_osfPageDown },
-    { "osfPageRight", XKB_KEY_osfPageRight },
-    { "osfActivate", XKB_KEY_osfActivate },
-    { "osfMenuBar", XKB_KEY_osfMenuBar },
-    { "osfLeft", XKB_KEY_osfLeft },
-    { "osfUp", XKB_KEY_osfUp },
-    { "osfRight", XKB_KEY_osfRight },
-    { "osfDown", XKB_KEY_osfDown },
-    { "osfEndLine", XKB_KEY_osfEndLine },
-    { "osfBeginLine", XKB_KEY_osfBeginLine },
-    { "osfEndData", XKB_KEY_osfEndData },
-    { "osfBeginData", XKB_KEY_osfBeginData },
-    { "osfPrevMenu", XKB_KEY_osfPrevMenu },
-    { "osfNextMenu", XKB_KEY_osfNextMenu },
-    { "osfPrevField", XKB_KEY_osfPrevField },
-    { "osfNextField", XKB_KEY_osfNextField },
-    { "osfSelect", XKB_KEY_osfSelect },
-    { "osfInsert", XKB_KEY_osfInsert },
-    { "osfUndo", XKB_KEY_osfUndo },
-    { "osfMenu", XKB_KEY_osfMenu },
-    { "osfCancel", XKB_KEY_osfCancel },
-    { "osfHelp", XKB_KEY_osfHelp },
-    { "osfSelectAll", XKB_KEY_osfSelectAll },
-    { "osfDeselectAll", XKB_KEY_osfDeselectAll },
-    { "osfReselect", XKB_KEY_osfReselect },
-    { "osfExtend", XKB_KEY_osfExtend },
-    { "osfRestore", XKB_KEY_osfRestore },
-    { "osfDelete", XKB_KEY_osfDelete },
-    { "SunFA_Grave", XKB_KEY_SunFA_Grave },
-    { "SunFA_Circum", XKB_KEY_SunFA_Circum },
-    { "SunFA_Tilde", XKB_KEY_SunFA_Tilde },
-    { "SunFA_Acute", XKB_KEY_SunFA_Acute },
-    { "SunFA_Diaeresis", XKB_KEY_SunFA_Diaeresis },
-    { "SunFA_Cedilla", XKB_KEY_SunFA_Cedilla },
-    { "SunF36", XKB_KEY_SunF36 },
-    { "SunF37", XKB_KEY_SunF37 },
-    { "SunSys_Req", XKB_KEY_SunSys_Req },
-    { "SunProps", XKB_KEY_SunProps },
-    { "SunFront", XKB_KEY_SunFront },
-    { "SunCopy", XKB_KEY_SunCopy },
-    { "SunOpen", XKB_KEY_SunOpen },
-    { "SunPaste", XKB_KEY_SunPaste },
-    { "SunCut", XKB_KEY_SunCut },
-    { "SunPowerSwitch", XKB_KEY_SunPowerSwitch },
-    { "SunAudioLowerVolume", XKB_KEY_SunAudioLowerVolume },
-    { "SunAudioMute", XKB_KEY_SunAudioMute },
-    { "SunAudioRaiseVolume", XKB_KEY_SunAudioRaiseVolume },
-    { "SunVideoDegauss", XKB_KEY_SunVideoDegauss },
-    { "SunVideoLowerBrightness", XKB_KEY_SunVideoLowerBrightness },
-    { "SunVideoRaiseBrightness", XKB_KEY_SunVideoRaiseBrightness },
-    { "SunPowerSwitchShift", XKB_KEY_SunPowerSwitchShift },
-    { "XF86Switch_VT_1", XKB_KEY_XF86Switch_VT_1 },
-    { "XF86Switch_VT_2", XKB_KEY_XF86Switch_VT_2 },
-    { "XF86Switch_VT_3", XKB_KEY_XF86Switch_VT_3 },
-    { "XF86Switch_VT_4", XKB_KEY_XF86Switch_VT_4 },
-    { "XF86Switch_VT_5", XKB_KEY_XF86Switch_VT_5 },
-    { "XF86Switch_VT_6", XKB_KEY_XF86Switch_VT_6 },
-    { "XF86Switch_VT_7", XKB_KEY_XF86Switch_VT_7 },
-    { "XF86Switch_VT_8", XKB_KEY_XF86Switch_VT_8 },
-    { "XF86Switch_VT_9", XKB_KEY_XF86Switch_VT_9 },
-    { "XF86Switch_VT_10", XKB_KEY_XF86Switch_VT_10 },
-    { "XF86Switch_VT_11", XKB_KEY_XF86Switch_VT_11 },
-    { "XF86Switch_VT_12", XKB_KEY_XF86Switch_VT_12 },
-    { "XF86Ungrab", XKB_KEY_XF86Ungrab },
-    { "XF86ClearGrab", XKB_KEY_XF86ClearGrab },
-    { "XF86Next_VMode", XKB_KEY_XF86Next_VMode },
-    { "XF86Prev_VMode", XKB_KEY_XF86Prev_VMode },
-    { "XF86LogWindowTree", XKB_KEY_XF86LogWindowTree },
-    { "XF86LogGrabInfo", XKB_KEY_XF86LogGrabInfo },
-    { "XF86ModeLock", XKB_KEY_XF86ModeLock },
-    { "XF86MonBrightnessUp", XKB_KEY_XF86MonBrightnessUp },
-    { "XF86MonBrightnessDown", XKB_KEY_XF86MonBrightnessDown },
-    { "XF86KbdLightOnOff", XKB_KEY_XF86KbdLightOnOff },
-    { "XF86KbdBrightnessUp", XKB_KEY_XF86KbdBrightnessUp },
-    { "XF86KbdBrightnessDown", XKB_KEY_XF86KbdBrightnessDown },
-    { "XF86Standby", XKB_KEY_XF86Standby },
-    { "XF86AudioLowerVolume", XKB_KEY_XF86AudioLowerVolume },
-    { "XF86AudioMute", XKB_KEY_XF86AudioMute },
-    { "XF86AudioRaiseVolume", XKB_KEY_XF86AudioRaiseVolume },
-    { "XF86AudioPlay", XKB_KEY_XF86AudioPlay },
-    { "XF86AudioStop", XKB_KEY_XF86AudioStop },
-    { "XF86AudioPrev", XKB_KEY_XF86AudioPrev },
-    { "XF86AudioNext", XKB_KEY_XF86AudioNext },
-    { "XF86HomePage", XKB_KEY_XF86HomePage },
-    { "XF86Mail", XKB_KEY_XF86Mail },
-    { "XF86Start", XKB_KEY_XF86Start },
-    { "XF86Search", XKB_KEY_XF86Search },
-    { "XF86AudioRecord", XKB_KEY_XF86AudioRecord },
-    { "XF86Calculator", XKB_KEY_XF86Calculator },
-    { "XF86Memo", XKB_KEY_XF86Memo },
-    { "XF86ToDoList", XKB_KEY_XF86ToDoList },
-    { "XF86Calendar", XKB_KEY_XF86Calendar },
-    { "XF86PowerDown", XKB_KEY_XF86PowerDown },
-    { "XF86ContrastAdjust", XKB_KEY_XF86ContrastAdjust },
-    { "XF86RockerUp", XKB_KEY_XF86RockerUp },
-    { "XF86RockerDown", XKB_KEY_XF86RockerDown },
-    { "XF86RockerEnter", XKB_KEY_XF86RockerEnter },
-    { "XF86Back", XKB_KEY_XF86Back },
-    { "XF86Forward", XKB_KEY_XF86Forward },
-    { "XF86Stop", XKB_KEY_XF86Stop },
-    { "XF86Refresh", XKB_KEY_XF86Refresh },
-    { "XF86PowerOff", XKB_KEY_XF86PowerOff },
-    { "XF86WakeUp", XKB_KEY_XF86WakeUp },
-    { "XF86Eject", XKB_KEY_XF86Eject },
-    { "XF86ScreenSaver", XKB_KEY_XF86ScreenSaver },
-    { "XF86WWW", XKB_KEY_XF86WWW },
-    { "XF86Sleep", XKB_KEY_XF86Sleep },
-    { "XF86Favorites", XKB_KEY_XF86Favorites },
-    { "XF86AudioPause", XKB_KEY_XF86AudioPause },
-    { "XF86AudioMedia", XKB_KEY_XF86AudioMedia },
-    { "XF86MyComputer", XKB_KEY_XF86MyComputer },
-    { "XF86VendorHome", XKB_KEY_XF86VendorHome },
-    { "XF86LightBulb", XKB_KEY_XF86LightBulb },
-    { "XF86Shop", XKB_KEY_XF86Shop },
-    { "XF86History", XKB_KEY_XF86History },
-    { "XF86OpenURL", XKB_KEY_XF86OpenURL },
-    { "XF86AddFavorite", XKB_KEY_XF86AddFavorite },
-    { "XF86HotLinks", XKB_KEY_XF86HotLinks },
-    { "XF86BrightnessAdjust", XKB_KEY_XF86BrightnessAdjust },
-    { "XF86Finance", XKB_KEY_XF86Finance },
-    { "XF86Community", XKB_KEY_XF86Community },
-    { "XF86AudioRewind", XKB_KEY_XF86AudioRewind },
-    { "XF86BackForward", XKB_KEY_XF86BackForward },
-    { "XF86Launch0", XKB_KEY_XF86Launch0 },
-    { "XF86Launch1", XKB_KEY_XF86Launch1 },
-    { "XF86Launch2", XKB_KEY_XF86Launch2 },
-    { "XF86Launch3", XKB_KEY_XF86Launch3 },
-    { "XF86Launch4", XKB_KEY_XF86Launch4 },
-    { "XF86Launch5", XKB_KEY_XF86Launch5 },
-    { "XF86Launch6", XKB_KEY_XF86Launch6 },
-    { "XF86Launch7", XKB_KEY_XF86Launch7 },
-    { "XF86Launch8", XKB_KEY_XF86Launch8 },
-    { "XF86Launch9", XKB_KEY_XF86Launch9 },
-    { "XF86LaunchA", XKB_KEY_XF86LaunchA },
-    { "XF86LaunchB", XKB_KEY_XF86LaunchB },
-    { "XF86LaunchC", XKB_KEY_XF86LaunchC },
-    { "XF86LaunchD", XKB_KEY_XF86LaunchD },
-    { "XF86LaunchE", XKB_KEY_XF86LaunchE },
-    { "XF86LaunchF", XKB_KEY_XF86LaunchF },
-    { "XF86ApplicationLeft", XKB_KEY_XF86ApplicationLeft },
-    { "XF86ApplicationRight", XKB_KEY_XF86ApplicationRight },
-    { "XF86Book", XKB_KEY_XF86Book },
-    { "XF86CD", XKB_KEY_XF86CD },
-    { "XF86Calculater", XKB_KEY_XF86Calculater },
-    { "XF86Clear", XKB_KEY_XF86Clear },
-    { "XF86Close", XKB_KEY_XF86Close },
-    { "XF86Copy", XKB_KEY_XF86Copy },
-    { "XF86Cut", XKB_KEY_XF86Cut },
-    { "XF86Display", XKB_KEY_XF86Display },
-    { "XF86DOS", XKB_KEY_XF86DOS },
-    { "XF86Documents", XKB_KEY_XF86Documents },
-    { "XF86Excel", XKB_KEY_XF86Excel },
-    { "XF86Explorer", XKB_KEY_XF86Explorer },
-    { "XF86Game", XKB_KEY_XF86Game },
-    { "XF86Go", XKB_KEY_XF86Go },
-    { "XF86iTouch", XKB_KEY_XF86iTouch },
-    { "XF86LogOff", XKB_KEY_XF86LogOff },
-    { "XF86Market", XKB_KEY_XF86Market },
-    { "XF86Meeting", XKB_KEY_XF86Meeting },
-    { "XF86MenuKB", XKB_KEY_XF86MenuKB },
-    { "XF86MenuPB", XKB_KEY_XF86MenuPB },
-    { "XF86MySites", XKB_KEY_XF86MySites },
-    { "XF86New", XKB_KEY_XF86New },
-    { "XF86News", XKB_KEY_XF86News },
-    { "XF86OfficeHome", XKB_KEY_XF86OfficeHome },
-    { "XF86Open", XKB_KEY_XF86Open },
-    { "XF86Option", XKB_KEY_XF86Option },
-    { "XF86Paste", XKB_KEY_XF86Paste },
-    { "XF86Phone", XKB_KEY_XF86Phone },
-    { "XF86Q", XKB_KEY_XF86Q },
-    { "XF86Reply", XKB_KEY_XF86Reply },
-    { "XF86Reload", XKB_KEY_XF86Reload },
-    { "XF86RotateWindows", XKB_KEY_XF86RotateWindows },
-    { "XF86RotationPB", XKB_KEY_XF86RotationPB },
-    { "XF86RotationKB", XKB_KEY_XF86RotationKB },
-    { "XF86Save", XKB_KEY_XF86Save },
-    { "XF86ScrollUp", XKB_KEY_XF86ScrollUp },
-    { "XF86ScrollDown", XKB_KEY_XF86ScrollDown },
-    { "XF86ScrollClick", XKB_KEY_XF86ScrollClick },
-    { "XF86Send", XKB_KEY_XF86Send },
-    { "XF86Spell", XKB_KEY_XF86Spell },
-    { "XF86SplitScreen", XKB_KEY_XF86SplitScreen },
-    { "XF86Support", XKB_KEY_XF86Support },
-    { "XF86TaskPane", XKB_KEY_XF86TaskPane },
-    { "XF86Terminal", XKB_KEY_XF86Terminal },
-    { "XF86Tools", XKB_KEY_XF86Tools },
-    { "XF86Travel", XKB_KEY_XF86Travel },
-    { "XF86UserPB", XKB_KEY_XF86UserPB },
-    { "XF86User1KB", XKB_KEY_XF86User1KB },
-    { "XF86User2KB", XKB_KEY_XF86User2KB },
-    { "XF86Video", XKB_KEY_XF86Video },
-    { "XF86WheelButton", XKB_KEY_XF86WheelButton },
-    { "XF86Word", XKB_KEY_XF86Word },
-    { "XF86Xfer", XKB_KEY_XF86Xfer },
-    { "XF86ZoomIn", XKB_KEY_XF86ZoomIn },
-    { "XF86ZoomOut", XKB_KEY_XF86ZoomOut },
-    { "XF86Away", XKB_KEY_XF86Away },
-    { "XF86Messenger", XKB_KEY_XF86Messenger },
-    { "XF86WebCam", XKB_KEY_XF86WebCam },
-    { "XF86MailForward", XKB_KEY_XF86MailForward },
-    { "XF86Pictures", XKB_KEY_XF86Pictures },
-    { "XF86Music", XKB_KEY_XF86Music },
-    { "XF86Battery", XKB_KEY_XF86Battery },
-    { "XF86Bluetooth", XKB_KEY_XF86Bluetooth },
-    { "XF86WLAN", XKB_KEY_XF86WLAN },
-    { "XF86UWB", XKB_KEY_XF86UWB },
-    { "XF86AudioForward", XKB_KEY_XF86AudioForward },
-    { "XF86AudioRepeat", XKB_KEY_XF86AudioRepeat },
-    { "XF86AudioRandomPlay", XKB_KEY_XF86AudioRandomPlay },
-    { "XF86Subtitle", XKB_KEY_XF86Subtitle },
-    { "XF86AudioCycleTrack", XKB_KEY_XF86AudioCycleTrack },
-    { "XF86CycleAngle", XKB_KEY_XF86CycleAngle },
-    { "XF86FrameBack", XKB_KEY_XF86FrameBack },
-    { "XF86FrameForward", XKB_KEY_XF86FrameForward },
-    { "XF86Time", XKB_KEY_XF86Time },
-    { "XF86Select", XKB_KEY_XF86Select },
-    { "XF86View", XKB_KEY_XF86View },
-    { "XF86TopMenu", XKB_KEY_XF86TopMenu },
-    { "XF86Red", XKB_KEY_XF86Red },
-    { "XF86Green", XKB_KEY_XF86Green },
-    { "XF86Yellow", XKB_KEY_XF86Yellow },
-    { "XF86Blue", XKB_KEY_XF86Blue },
-    { "XF86Suspend", XKB_KEY_XF86Suspend },
-    { "XF86Hibernate", XKB_KEY_XF86Hibernate },
-    { "XF86TouchpadToggle", XKB_KEY_XF86TouchpadToggle },
-    { "XF86TouchpadOn", XKB_KEY_XF86TouchpadOn },
-    { "XF86TouchpadOff", XKB_KEY_XF86TouchpadOff },
+    { 0x00000000, 20091 }, /* NoSymbol */
+    { 0x00000020, 23803 }, /* space */
+    { 0x00000021, 12099 }, /* exclam */
+    { 0x00000022, 22187 }, /* quotedbl */
+    { 0x00000023, 20178 }, /* numbersign */
+    { 0x00000024, 11251 }, /* dollar */
+    { 0x00000025, 21487 }, /* percent */
+    { 0x00000026, 908 }, /* ampersand */
+    { 0x00000027, 934 }, /* apostrophe */
+    { 0x00000028, 21425 }, /* parenleft */
+    { 0x00000029, 21435 }, /* parenright */
+    { 0x0000002a, 3283 }, /* asterisk */
+    { 0x0000002b, 21557 }, /* plus */
+    { 0x0000002c, 8680 }, /* comma */
+    { 0x0000002d, 19733 }, /* minus */
+    { 0x0000002e, 21495 }, /* period */
+    { 0x0000002f, 23768 }, /* slash */
+    { 0x00000030, 0 }, /* 0 */
+    { 0x00000031, 2 }, /* 1 */
+    { 0x00000032, 4 }, /* 2 */
+    { 0x00000033, 6 }, /* 3 */
+    { 0x00000034, 386 }, /* 4 */
+    { 0x00000035, 388 }, /* 5 */
+    { 0x00000036, 390 }, /* 6 */
+    { 0x00000037, 392 }, /* 7 */
+    { 0x00000038, 394 }, /* 8 */
+    { 0x00000039, 396 }, /* 9 */
+    { 0x0000003a, 8664 }, /* colon */
+    { 0x0000003b, 22734 }, /* semicolon */
+    { 0x0000003c, 19412 }, /* less */
+    { 0x0000003d, 12051 }, /* equal */
+    { 0x0000003e, 13272 }, /* greater */
+    { 0x0000003f, 22165 }, /* question */
+    { 0x00000040, 3292 }, /* at */
+    { 0x00000041, 398 }, /* A */
+    { 0x00000042, 3328 }, /* B */
+    { 0x00000043, 8439 }, /* C */
+    { 0x00000044, 10320 }, /* D */
+    { 0x00000045, 11424 }, /* E */
+    { 0x00000046, 12155 }, /* F */
+    { 0x00000047, 12665 }, /* G */
+    { 0x00000048, 14378 }, /* H */
+    { 0x00000049, 17069 }, /* I */
+    { 0x0000004a, 18114 }, /* J */
+    { 0x0000004b, 18146 }, /* K */
+    { 0x0000004c, 19112 }, /* L */
+    { 0x0000004d, 19533 }, /* M */
+    { 0x0000004e, 19943 }, /* N */
+    { 0x0000004f, 20200 }, /* O */
+    { 0x00000050, 21373 }, /* P */
+    { 0x00000051, 22156 }, /* Q */
+    { 0x00000052, 22217 }, /* R */
+    { 0x00000053, 22579 }, /* S */
+    { 0x00000054, 24294 }, /* T */
+    { 0x00000055, 25847 }, /* U */
+    { 0x00000056, 26483 }, /* V */
+    { 0x00000057, 26545 }, /* W */
+    { 0x00000058, 26631 }, /* X */
+    { 0x00000059, 28972 }, /* Y */
+    { 0x0000005a, 29100 }, /* Z */
+    { 0x0000005b, 3603 }, /* bracketleft */
+    { 0x0000005c, 3352 }, /* backslash */
+    { 0x0000005d, 3615 }, /* bracketright */
+    { 0x0000005e, 3260 }, /* asciicircum */
+    { 0x0000005f, 26346 }, /* underscore */
+    { 0x00000060, 13266 }, /* grave */
+    { 0x00000061, 400 }, /* a */
+    { 0x00000062, 3330 }, /* b */
+    { 0x00000063, 8441 }, /* c */
+    { 0x00000064, 10322 }, /* d */
+    { 0x00000065, 11426 }, /* e */
+    { 0x00000066, 12157 }, /* f */
+    { 0x00000067, 12667 }, /* g */
+    { 0x00000068, 14380 }, /* h */
+    { 0x00000069, 17071 }, /* i */
+    { 0x0000006a, 18116 }, /* j */
+    { 0x0000006b, 18148 }, /* k */
+    { 0x0000006c, 19114 }, /* l */
+    { 0x0000006d, 19535 }, /* m */
+    { 0x0000006e, 19945 }, /* n */
+    { 0x0000006f, 20202 }, /* o */
+    { 0x00000070, 21375 }, /* p */
+    { 0x00000071, 22158 }, /* q */
+    { 0x00000072, 22219 }, /* r */
+    { 0x00000073, 22581 }, /* s */
+    { 0x00000074, 24296 }, /* t */
+    { 0x00000075, 25849 }, /* u */
+    { 0x00000076, 26485 }, /* v */
+    { 0x00000077, 26547 }, /* w */
+    { 0x00000078, 26633 }, /* x */
+    { 0x00000079, 28974 }, /* y */
+    { 0x0000007a, 29102 }, /* z */
+    { 0x0000007b, 3582 }, /* braceleft */
+    { 0x0000007c, 3392 }, /* bar */
+    { 0x0000007d, 3592 }, /* braceright */
+    { 0x0000007e, 3272 }, /* asciitilde */
+    { 0x000000a0, 20078 }, /* nobreakspace */
+    { 0x000000a1, 12106 }, /* exclamdown */
+    { 0x000000a2, 8589 }, /* cent */
+    { 0x000000a3, 23827 }, /* sterling */
+    { 0x000000a4, 8766 }, /* currency */
+    { 0x000000a5, 29056 }, /* yen */
+    { 0x000000a6, 8389 }, /* brokenbar */
+    { 0x000000a7, 22719 }, /* section */
+    { 0x000000a8, 11203 }, /* diaeresis */
+    { 0x000000a9, 8717 }, /* copyright */
+    { 0x000000aa, 20852 }, /* ordfeminine */
+    { 0x000000ab, 14349 }, /* guillemotleft */
+    { 0x000000ac, 20147 }, /* notsign */
+    { 0x000000ad, 17062 }, /* hyphen */
+    { 0x000000ae, 22331 }, /* registered */
+    { 0x000000af, 19641 }, /* macron */
+    { 0x000000b0, 11153 }, /* degree */
+    { 0x000000b1, 21562 }, /* plusminus */
+    { 0x000000b2, 25825 }, /* twosuperior */
+    { 0x000000b3, 25571 }, /* threesuperior */
+    { 0x000000b4, 820 }, /* acute */
+    { 0x000000b5, 19799 }, /* mu */
+    { 0x000000b6, 21415 }, /* paragraph */
+    { 0x000000b7, 21502 }, /* periodcentered */
+    { 0x000000b8, 8581 }, /* cedilla */
+    { 0x000000b9, 20755 }, /* onesuperior */
+    { 0x000000ba, 19688 }, /* masculine */
+    { 0x000000bb, 14363 }, /* guillemotright */
+    { 0x000000bc, 20722 }, /* onequarter */
+    { 0x000000bd, 20714 }, /* onehalf */
+    { 0x000000be, 25542 }, /* threequarters */
+    { 0x000000bf, 22174 }, /* questiondown */
+    { 0x000000c0, 854 }, /* Agrave */
+    { 0x000000c1, 402 }, /* Aacute */
+    { 0x000000c2, 622 }, /* Acircumflex */
+    { 0x000000c3, 3295 }, /* Atilde */
+    { 0x000000c4, 826 }, /* Adiaeresis */
+    { 0x000000c5, 2036 }, /* Aring */
+    { 0x000000c6, 848 }, /* AE */
+    { 0x000000c7, 8539 }, /* Ccedilla */
+    { 0x000000c8, 11724 }, /* Egrave */
+    { 0x000000c9, 11448 }, /* Eacute */
+    { 0x000000ca, 11496 }, /* Ecircumflex */
+    { 0x000000cb, 11702 }, /* Ediaeresis */
+    { 0x000000cc, 17205 }, /* Igrave */
+    { 0x000000cd, 17083 }, /* Iacute */
+    { 0x000000ce, 17131 }, /* Icircumflex */
+    { 0x000000cf, 17165 }, /* Idiaeresis */
+    { 0x000000d0, 12064 }, /* ETH */
+    { 0x000000d1, 20155 }, /* Ntilde */
+    { 0x000000d2, 20527 }, /* Ograve */
+    { 0x000000d3, 20204 }, /* Oacute */
+    { 0x000000d4, 20268 }, /* Ocircumflex */
+    { 0x000000d5, 21310 }, /* Otilde */
+    { 0x000000d6, 20466 }, /* Odiaeresis */
+    { 0x000000d7, 19839 }, /* multiply */
+    { 0x000000d8, 21296 }, /* Oslash */
+    { 0x000000d9, 25971 }, /* Ugrave */
+    { 0x000000da, 25851 }, /* Uacute */
+    { 0x000000db, 25899 }, /* Ucircumflex */
+    { 0x000000dc, 25923 }, /* Udiaeresis */
+    { 0x000000dd, 28976 }, /* Yacute */
+    { 0x000000de, 25499 }, /* THORN */
+    { 0x000000df, 23820 }, /* ssharp */
+    { 0x000000e0, 861 }, /* agrave */
+    { 0x000000e1, 409 }, /* aacute */
+    { 0x000000e2, 634 }, /* acircumflex */
+    { 0x000000e3, 3302 }, /* atilde */
+    { 0x000000e4, 837 }, /* adiaeresis */
+    { 0x000000e5, 2042 }, /* aring */
+    { 0x000000e6, 851 }, /* ae */
+    { 0x000000e7, 8548 }, /* ccedilla */
+    { 0x000000e8, 11731 }, /* egrave */
+    { 0x000000e9, 11455 }, /* eacute */
+    { 0x000000ea, 11508 }, /* ecircumflex */
+    { 0x000000eb, 11713 }, /* ediaeresis */
+    { 0x000000ec, 17212 }, /* igrave */
+    { 0x000000ed, 17090 }, /* iacute */
+    { 0x000000ee, 17143 }, /* icircumflex */
+    { 0x000000ef, 17176 }, /* idiaeresis */
+    { 0x000000f0, 12072 }, /* eth */
+    { 0x000000f1, 20162 }, /* ntilde */
+    { 0x000000f2, 20534 }, /* ograve */
+    { 0x000000f3, 20211 }, /* oacute */
+    { 0x000000f4, 20280 }, /* ocircumflex */
+    { 0x000000f5, 21317 }, /* otilde */
+    { 0x000000f6, 20477 }, /* odiaeresis */
+    { 0x000000f7, 11242 }, /* division */
+    { 0x000000f8, 21303 }, /* oslash */
+    { 0x000000f9, 25978 }, /* ugrave */
+    { 0x000000fa, 25858 }, /* uacute */
+    { 0x000000fb, 25911 }, /* ucircumflex */
+    { 0x000000fc, 25934 }, /* udiaeresis */
+    { 0x000000fd, 28983 }, /* yacute */
+    { 0x000000fe, 25511 }, /* thorn */
+    { 0x000000ff, 29034 }, /* ydiaeresis */
+    { 0x000001a1, 918 }, /* Aogonek */
+    { 0x000001a2, 8383 }, /* breve */
+    { 0x000001a3, 19517 }, /* Lstroke */
+    { 0x000001a5, 19212 }, /* Lcaron */
+    { 0x000001a6, 22603 }, /* Sacute */
+    { 0x000001a9, 22617 }, /* Scaron */
+    { 0x000001aa, 22631 }, /* Scedilla */
+    { 0x000001ab, 24322 }, /* Tcaron */
+    { 0x000001ac, 29124 }, /* Zacute */
+    { 0x000001ae, 29138 }, /* Zcaron */
+    { 0x000001af, 29104 }, /* Zabovedot */
+    { 0x000001b1, 926 }, /* aogonek */
+    { 0x000001b2, 20520 }, /* ogonek */
+    { 0x000001b3, 19525 }, /* lstroke */
+    { 0x000001b5, 19219 }, /* lcaron */
+    { 0x000001b6, 22610 }, /* sacute */
+    { 0x000001b7, 8519 }, /* caron */
+    { 0x000001b9, 22624 }, /* scaron */
+    { 0x000001ba, 22640 }, /* scedilla */
+    { 0x000001bb, 24329 }, /* tcaron */
+    { 0x000001bc, 29131 }, /* zacute */
+    { 0x000001bd, 11283 }, /* doubleacute */
+    { 0x000001be, 29145 }, /* zcaron */
+    { 0x000001bf, 29114 }, /* zabovedot */
+    { 0x000001c0, 22272 }, /* Racute */
+    { 0x000001c3, 445 }, /* Abreve */
+    { 0x000001c5, 19147 }, /* Lacute */
+    { 0x000001c6, 8475 }, /* Cacute */
+    { 0x000001c8, 8525 }, /* Ccaron */
+    { 0x000001ca, 12035 }, /* Eogonek */
+    { 0x000001cc, 11482 }, /* Ecaron */
+    { 0x000001cf, 10365 }, /* Dcaron */
+    { 0x000001d0, 11401 }, /* Dstroke */
+    { 0x000001d1, 19953 }, /* Nacute */
+    { 0x000001d2, 19977 }, /* Ncaron */
+    { 0x000001d5, 20488 }, /* Odoubleacute */
+    { 0x000001d8, 22294 }, /* Rcaron */
+    { 0x000001d9, 26452 }, /* Uring */
+    { 0x000001db, 25945 }, /* Udoubleacute */
+    { 0x000001de, 24336 }, /* Tcedilla */
+    { 0x000001e0, 22279 }, /* racute */
+    { 0x000001e3, 452 }, /* abreve */
+    { 0x000001e5, 19154 }, /* lacute */
+    { 0x000001e6, 8482 }, /* cacute */
+    { 0x000001e8, 8532 }, /* ccaron */
+    { 0x000001ea, 12043 }, /* eogonek */
+    { 0x000001ec, 11489 }, /* ecaron */
+    { 0x000001ef, 10372 }, /* dcaron */
+    { 0x000001f0, 11409 }, /* dstroke */
+    { 0x000001f1, 19960 }, /* nacute */
+    { 0x000001f2, 19984 }, /* ncaron */
+    { 0x000001f5, 20501 }, /* odoubleacute */
+    { 0x000001f8, 22301 }, /* rcaron */
+    { 0x000001f9, 26458 }, /* uring */
+    { 0x000001fb, 25958 }, /* udoubleacute */
+    { 0x000001fe, 24345 }, /* tcedilla */
+    { 0x000001ff, 436 }, /* abovedot */
+    { 0x000002a1, 17027 }, /* Hstroke */
+    { 0x000002a6, 16056 }, /* Hcircumflex */
+    { 0x000002a9, 17073 }, /* Iabovedot */
+    { 0x000002ab, 12689 }, /* Gbreve */
+    { 0x000002ac, 18118 }, /* Jcircumflex */
+    { 0x000002b1, 17035 }, /* hstroke */
+    { 0x000002b6, 16068 }, /* hcircumflex */
+    { 0x000002b9, 17187 }, /* idotless */
+    { 0x000002bb, 12696 }, /* gbreve */
+    { 0x000002bc, 18130 }, /* jcircumflex */
+    { 0x000002c5, 8455 }, /* Cabovedot */
+    { 0x000002c6, 8557 }, /* Ccircumflex */
+    { 0x000002d5, 12669 }, /* Gabovedot */
+    { 0x000002d8, 12735 }, /* Gcircumflex */
+    { 0x000002dd, 25885 }, /* Ubreve */
+    { 0x000002de, 22661 }, /* Scircumflex */
+    { 0x000002e5, 8465 }, /* cabovedot */
+    { 0x000002e6, 8569 }, /* ccircumflex */
+    { 0x000002f5, 12679 }, /* gabovedot */
+    { 0x000002f8, 12747 }, /* gcircumflex */
+    { 0x000002fd, 25892 }, /* ubreve */
+    { 0x000002fe, 22673 }, /* scircumflex */
+    { 0x000003a2, 19108 }, /* kra */
+    { 0x000003a3, 22308 }, /* Rcedilla */
+    { 0x000003a5, 18100 }, /* Itilde */
+    { 0x000003a6, 19226 }, /* Lcedilla */
+    { 0x000003aa, 11839 }, /* Emacron */
+    { 0x000003ab, 12717 }, /* Gcedilla */
+    { 0x000003ac, 25788 }, /* Tslash */
+    { 0x000003b3, 22317 }, /* rcedilla */
+    { 0x000003b5, 18107 }, /* itilde */
+    { 0x000003b6, 19235 }, /* lcedilla */
+    { 0x000003ba, 11847 }, /* emacron */
+    { 0x000003bb, 12726 }, /* gcedilla */
+    { 0x000003bc, 25795 }, /* tslash */
+    { 0x000003bd, 11983 }, /* ENG */
+    { 0x000003bf, 11987 }, /* eng */
+    { 0x000003c0, 892 }, /* Amacron */
+    { 0x000003c7, 17338 }, /* Iogonek */
+    { 0x000003cc, 11428 }, /* Eabovedot */
+    { 0x000003cf, 17231 }, /* Imacron */
+    { 0x000003d1, 19991 }, /* Ncedilla */
+    { 0x000003d2, 20679 }, /* Omacron */
+    { 0x000003d3, 18779 }, /* Kcedilla */
+    { 0x000003d9, 26368 }, /* Uogonek */
+    { 0x000003dd, 26469 }, /* Utilde */
+    { 0x000003de, 26321 }, /* Umacron */
+    { 0x000003e0, 900 }, /* amacron */
+    { 0x000003e7, 17346 }, /* iogonek */
+    { 0x000003ec, 11438 }, /* eabovedot */
+    { 0x000003ef, 17239 }, /* imacron */
+    { 0x000003f1, 20000 }, /* ncedilla */
+    { 0x000003f2, 20687 }, /* omacron */
+    { 0x000003f3, 18788 }, /* kcedilla */
+    { 0x000003f9, 26376 }, /* uogonek */
+    { 0x000003fd, 26476 }, /* utilde */
+    { 0x000003fe, 26329 }, /* umacron */
+    { 0x0000047e, 21364 }, /* overline */
+    { 0x000004a1, 18243 }, /* kana_fullstop */
+    { 0x000004a2, 18477 }, /* kana_openingbracket */
+    { 0x000004a3, 18173 }, /* kana_closingbracket */
+    { 0x000004a4, 18193 }, /* kana_comma */
+    { 0x000004a5, 18204 }, /* kana_conjunctive */
+    { 0x000004a6, 18689 }, /* kana_WO */
+    { 0x000004a7, 18150 }, /* kana_a */
+    { 0x000004a8, 18297 }, /* kana_i */
+    { 0x000004a9, 18667 }, /* kana_u */
+    { 0x000004aa, 18221 }, /* kana_e */
+    { 0x000004ab, 18463 }, /* kana_o */
+    { 0x000004ac, 18697 }, /* kana_ya */
+    { 0x000004ad, 18729 }, /* kana_yu */
+    { 0x000004ae, 18713 }, /* kana_yo */
+    { 0x000004af, 18633 }, /* kana_tsu */
+    { 0x000004b0, 22130 }, /* prolongedsound */
+    { 0x000004b1, 18157 }, /* kana_A */
+    { 0x000004b2, 18304 }, /* kana_I */
+    { 0x000004b3, 18674 }, /* kana_U */
+    { 0x000004b4, 18228 }, /* kana_E */
+    { 0x000004b5, 18470 }, /* kana_O */
+    { 0x000004b6, 18311 }, /* kana_KA */
+    { 0x000004b7, 18327 }, /* kana_KI */
+    { 0x000004b8, 18343 }, /* kana_KU */
+    { 0x000004b9, 18319 }, /* kana_KE */
+    { 0x000004ba, 18335 }, /* kana_KO */
+    { 0x000004bb, 18537 }, /* kana_SA */
+    { 0x000004bc, 18553 }, /* kana_SHI */
+    { 0x000004bd, 18581 }, /* kana_SU */
+    { 0x000004be, 18545 }, /* kana_SE */
+    { 0x000004bf, 18573 }, /* kana_SO */
+    { 0x000004c0, 18601 }, /* kana_TA */
+    { 0x000004c1, 18164 }, /* kana_CHI */
+    { 0x000004c2, 18642 }, /* kana_TSU */
+    { 0x000004c3, 18609 }, /* kana_TE */
+    { 0x000004c4, 18625 }, /* kana_TO */
+    { 0x000004c5, 18423 }, /* kana_NA */
+    { 0x000004c6, 18439 }, /* kana_NI */
+    { 0x000004c7, 18455 }, /* kana_NU */
+    { 0x000004c8, 18431 }, /* kana_NE */
+    { 0x000004c9, 18447 }, /* kana_NO */
+    { 0x000004ca, 18257 }, /* kana_HA */
+    { 0x000004cb, 18273 }, /* kana_HI */
+    { 0x000004cc, 18235 }, /* kana_FU */
+    { 0x000004cd, 18265 }, /* kana_HE */
+    { 0x000004ce, 18281 }, /* kana_HO */
+    { 0x000004cf, 18361 }, /* kana_MA */
+    { 0x000004d0, 18377 }, /* kana_MI */
+    { 0x000004d1, 18408 }, /* kana_MU */
+    { 0x000004d2, 18369 }, /* kana_ME */
+    { 0x000004d3, 18400 }, /* kana_MO */
+    { 0x000004d4, 18705 }, /* kana_YA */
+    { 0x000004d5, 18737 }, /* kana_YU */
+    { 0x000004d6, 18721 }, /* kana_YO */
+    { 0x000004d7, 18497 }, /* kana_RA */
+    { 0x000004d8, 18513 }, /* kana_RI */
+    { 0x000004d9, 18529 }, /* kana_RU */
+    { 0x000004da, 18505 }, /* kana_RE */
+    { 0x000004db, 18521 }, /* kana_RO */
+    { 0x000004dc, 18681 }, /* kana_WA */
+    { 0x000004dd, 18416 }, /* kana_N */
+    { 0x000004de, 26519 }, /* voicedsound */
+    { 0x000004df, 22744 }, /* semivoicedsound */
+    { 0x000005ac, 1109 }, /* Arabic_comma */
+    { 0x000005bb, 1764 }, /* Arabic_semicolon */
+    { 0x000005bf, 1698 }, /* Arabic_question_mark */
+    { 0x000005c1, 1303 }, /* Arabic_hamza */
+    { 0x000005c2, 1599 }, /* Arabic_maddaonalef */
+    { 0x000005c3, 1354 }, /* Arabic_hamzaonalef */
+    { 0x000005c4, 1373 }, /* Arabic_hamzaonwaw */
+    { 0x000005c5, 1409 }, /* Arabic_hamzaunderalef */
+    { 0x000005c6, 1391 }, /* Arabic_hamzaonyeh */
+    { 0x000005c7, 1067 }, /* Arabic_alef */
+    { 0x000005c8, 1098 }, /* Arabic_beh */
+    { 0x000005c9, 1909 }, /* Arabic_tehmarbuta */
+    { 0x000005ca, 1898 }, /* Arabic_teh */
+    { 0x000005cb, 1939 }, /* Arabic_theh */
+    { 0x000005cc, 1481 }, /* Arabic_jeem */
+    { 0x000005cd, 1292 }, /* Arabic_hah */
+    { 0x000005ce, 1557 }, /* Arabic_khah */
+    { 0x000005cf, 1133 }, /* Arabic_dal */
+    { 0x000005d0, 1927 }, /* Arabic_thal */
+    { 0x000005d1, 1719 }, /* Arabic_ra */
+    { 0x000005d2, 2024 }, /* Arabic_zain */
+    { 0x000005d3, 1752 }, /* Arabic_seen */
+    { 0x000005d4, 1795 }, /* Arabic_sheen */
+    { 0x000005d5, 1741 }, /* Arabic_sad */
+    { 0x000005d6, 1122 }, /* Arabic_dad */
+    { 0x000005d7, 1859 }, /* Arabic_tah */
+    { 0x000005d8, 2013 }, /* Arabic_zah */
+    { 0x000005d9, 1056 }, /* Arabic_ain */
+    { 0x000005da, 1269 }, /* Arabic_ghain */
+    { 0x000005e0, 1870 }, /* Arabic_tatweel */
+    { 0x000005e1, 1231 }, /* Arabic_feh */
+    { 0x000005e2, 1687 }, /* Arabic_qaf */
+    { 0x000005e3, 1504 }, /* Arabic_kaf */
+    { 0x000005e4, 1569 }, /* Arabic_lam */
+    { 0x000005e5, 1618 }, /* Arabic_meem */
+    { 0x000005e6, 1630 }, /* Arabic_noon */
+    { 0x000005e7, 1282 }, /* Arabic_ha */
+    { 0x000005e8, 1974 }, /* Arabic_waw */
+    { 0x000005e9, 1079 }, /* Arabic_alefmaksura */
+    { 0x000005ea, 1985 }, /* Arabic_yeh */
+    { 0x000005eb, 1215 }, /* Arabic_fathatan */
+    { 0x000005ec, 1157 }, /* Arabic_dammatan */
+    { 0x000005ed, 1528 }, /* Arabic_kasratan */
+    { 0x000005ee, 1202 }, /* Arabic_fatha */
+    { 0x000005ef, 1144 }, /* Arabic_damma */
+    { 0x000005f0, 1515 }, /* Arabic_kasra */
+    { 0x000005f1, 1781 }, /* Arabic_shadda */
+    { 0x000005f2, 1808 }, /* Arabic_sukun */
+    { 0x000006a1, 22760 }, /* Serbian_dje */
+    { 0x000006a2, 19585 }, /* Macedonia_gje */
+    { 0x000006a3, 9456 }, /* Cyrillic_io */
+    { 0x000006a4, 26199 }, /* Ukrainian_ie */
+    { 0x000006a5, 19557 }, /* Macedonia_dse */
+    { 0x000006a6, 26175 }, /* Ukrainian_i */
+    { 0x000006a7, 26225 }, /* Ukrainian_yi */
+    { 0x000006a8, 9480 }, /* Cyrillic_je */
+    { 0x000006a9, 9618 }, /* Cyrillic_lje */
+    { 0x000006aa, 9644 }, /* Cyrillic_nje */
+    { 0x000006ab, 22878 }, /* Serbian_tshe */
+    { 0x000006ac, 19613 }, /* Macedonia_kje */
+    { 0x000006ad, 26123 }, /* Ukrainian_ghe_with_upturn */
+    { 0x000006ae, 8399 }, /* Byelorussian_shortu */
+    { 0x000006af, 8972 }, /* Cyrillic_dzhe */
+    { 0x000006b0, 20189 }, /* numerosign */
+    { 0x000006b1, 22772 }, /* Serbian_DJE */
+    { 0x000006b2, 19599 }, /* Macedonia_GJE */
+    { 0x000006b3, 9468 }, /* Cyrillic_IO */
+    { 0x000006b4, 26212 }, /* Ukrainian_IE */
+    { 0x000006b5, 19571 }, /* Macedonia_DSE */
+    { 0x000006b6, 26187 }, /* Ukrainian_I */
+    { 0x000006b7, 26238 }, /* Ukrainian_YI */
+    { 0x000006b8, 9492 }, /* Cyrillic_JE */
+    { 0x000006b9, 9631 }, /* Cyrillic_LJE */
+    { 0x000006ba, 9657 }, /* Cyrillic_NJE */
+    { 0x000006bb, 22891 }, /* Serbian_TSHE */
+    { 0x000006bc, 19627 }, /* Macedonia_KJE */
+    { 0x000006bd, 26149 }, /* Ukrainian_GHE_WITH_UPTURN */
+    { 0x000006be, 8419 }, /* Byelorussian_SHORTU */
+    { 0x000006bf, 8986 }, /* Cyrillic_DZHE */
+    { 0x000006c0, 10200 }, /* Cyrillic_yu */
+    { 0x000006c1, 8782 }, /* Cyrillic_a */
+    { 0x000006c2, 8804 }, /* Cyrillic_be */
+    { 0x000006c3, 9952 }, /* Cyrillic_tse */
+    { 0x000006c4, 8948 }, /* Cyrillic_de */
+    { 0x000006c5, 9432 }, /* Cyrillic_ie */
+    { 0x000006c6, 9022 }, /* Cyrillic_ef */
+    { 0x000006c7, 9210 }, /* Cyrillic_ghe */
+    { 0x000006c8, 9270 }, /* Cyrillic_ha */
+    { 0x000006c9, 9374 }, /* Cyrillic_i */
+    { 0x000006ca, 9860 }, /* Cyrillic_shorti */
+    { 0x000006cb, 9504 }, /* Cyrillic_ka */
+    { 0x000006cc, 9046 }, /* Cyrillic_el */
+    { 0x000006cd, 9070 }, /* Cyrillic_em */
+    { 0x000006ce, 9094 }, /* Cyrillic_en */
+    { 0x000006cf, 9670 }, /* Cyrillic_o */
+    { 0x000006d0, 9722 }, /* Cyrillic_pe */
+    { 0x000006d1, 10148 }, /* Cyrillic_ya */
+    { 0x000006d2, 9162 }, /* Cyrillic_er */
+    { 0x000006d3, 9186 }, /* Cyrillic_es */
+    { 0x000006d4, 9928 }, /* Cyrillic_te */
+    { 0x000006d5, 9978 }, /* Cyrillic_u */
+    { 0x000006d6, 10248 }, /* Cyrillic_zhe */
+    { 0x000006d7, 10124 }, /* Cyrillic_ve */
+    { 0x000006d8, 9892 }, /* Cyrillic_softsign */
+    { 0x000006d9, 10172 }, /* Cyrillic_yeru */
+    { 0x000006da, 10224 }, /* Cyrillic_ze */
+    { 0x000006db, 9776 }, /* Cyrillic_sha */
+    { 0x000006dc, 9000 }, /* Cyrillic_e */
+    { 0x000006dd, 9802 }, /* Cyrillic_shcha */
+    { 0x000006de, 8828 }, /* Cyrillic_che */
+    { 0x000006df, 9338 }, /* Cyrillic_hardsign */
+    { 0x000006e0, 10212 }, /* Cyrillic_YU */
+    { 0x000006e1, 8793 }, /* Cyrillic_A */
+    { 0x000006e2, 8816 }, /* Cyrillic_BE */
+    { 0x000006e3, 9965 }, /* Cyrillic_TSE */
+    { 0x000006e4, 8960 }, /* Cyrillic_DE */
+    { 0x000006e5, 9444 }, /* Cyrillic_IE */
+    { 0x000006e6, 9034 }, /* Cyrillic_EF */
+    { 0x000006e7, 9223 }, /* Cyrillic_GHE */
+    { 0x000006e8, 9282 }, /* Cyrillic_HA */
+    { 0x000006e9, 9385 }, /* Cyrillic_I */
+    { 0x000006ea, 9876 }, /* Cyrillic_SHORTI */
+    { 0x000006eb, 9516 }, /* Cyrillic_KA */
+    { 0x000006ec, 9058 }, /* Cyrillic_EL */
+    { 0x000006ed, 9082 }, /* Cyrillic_EM */
+    { 0x000006ee, 9106 }, /* Cyrillic_EN */
+    { 0x000006ef, 9681 }, /* Cyrillic_O */
+    { 0x000006f0, 9734 }, /* Cyrillic_PE */
+    { 0x000006f1, 10160 }, /* Cyrillic_YA */
+    { 0x000006f2, 9174 }, /* Cyrillic_ER */
+    { 0x000006f3, 9198 }, /* Cyrillic_ES */
+    { 0x000006f4, 9940 }, /* Cyrillic_TE */
+    { 0x000006f5, 9989 }, /* Cyrillic_U */
+    { 0x000006f6, 10261 }, /* Cyrillic_ZHE */
+    { 0x000006f7, 10136 }, /* Cyrillic_VE */
+    { 0x000006f8, 9910 }, /* Cyrillic_SOFTSIGN */
+    { 0x000006f9, 10186 }, /* Cyrillic_YERU */
+    { 0x000006fa, 10236 }, /* Cyrillic_ZE */
+    { 0x000006fb, 9789 }, /* Cyrillic_SHA */
+    { 0x000006fc, 9011 }, /* Cyrillic_E */
+    { 0x000006fd, 9817 }, /* Cyrillic_SHCHA */
+    { 0x000006fe, 8841 }, /* Cyrillic_CHE */
+    { 0x000006ff, 9356 }, /* Cyrillic_HARDSIGN */
+    { 0x000007a1, 13342 }, /* Greek_ALPHAaccent */
+    { 0x000007a2, 13472 }, /* Greek_EPSILONaccent */
+    { 0x000007a3, 13532 }, /* Greek_ETAaccent */
+    { 0x000007a4, 13647 }, /* Greek_IOTAaccent */
+    { 0x000007a5, 13726 }, /* Greek_IOTAdieresis */
+    { 0x000007a7, 13962 }, /* Greek_OMICRONaccent */
+    { 0x000007a8, 14189 }, /* Greek_UPSILONaccent */
+    { 0x000007a9, 14257 }, /* Greek_UPSILONdieresis */
+    { 0x000007ab, 13898 }, /* Greek_OMEGAaccent */
+    { 0x000007ae, 13297 }, /* Greek_accentdieresis */
+    { 0x000007af, 13610 }, /* Greek_horizbar */
+    { 0x000007b1, 13360 }, /* Greek_alphaaccent */
+    { 0x000007b2, 13492 }, /* Greek_epsilonaccent */
+    { 0x000007b3, 13548 }, /* Greek_etaaccent */
+    { 0x000007b4, 13664 }, /* Greek_iotaaccent */
+    { 0x000007b5, 13745 }, /* Greek_iotadieresis */
+    { 0x000007b6, 13681 }, /* Greek_iotaaccentdieresis */
+    { 0x000007b7, 13982 }, /* Greek_omicronaccent */
+    { 0x000007b8, 14209 }, /* Greek_upsilonaccent */
+    { 0x000007b9, 14279 }, /* Greek_upsilondieresis */
+    { 0x000007ba, 14229 }, /* Greek_upsilonaccentdieresis */
+    { 0x000007bb, 13916 }, /* Greek_omegaaccent */
+    { 0x000007c1, 13318 }, /* Greek_ALPHA */
+    { 0x000007c2, 13378 }, /* Greek_BETA */
+    { 0x000007c3, 13586 }, /* Greek_GAMMA */
+    { 0x000007c4, 13420 }, /* Greek_DELTA */
+    { 0x000007c5, 13444 }, /* Greek_EPSILON */
+    { 0x000007c6, 14319 }, /* Greek_ZETA */
+    { 0x000007c7, 13512 }, /* Greek_ETA */
+    { 0x000007c8, 14137 }, /* Greek_THETA */
+    { 0x000007c9, 13625 }, /* Greek_IOTA */
+    { 0x000007ca, 13764 }, /* Greek_KAPPA */
+    { 0x000007cb, 13814 }, /* Greek_LAMDA */
+    { 0x000007cc, 13838 }, /* Greek_MU */
+    { 0x000007cd, 13856 }, /* Greek_NU */
+    { 0x000007ce, 14301 }, /* Greek_XI */
+    { 0x000007cf, 13934 }, /* Greek_OMICRON */
+    { 0x000007d0, 14022 }, /* Greek_PI */
+    { 0x000007d1, 14060 }, /* Greek_RHO */
+    { 0x000007d2, 14080 }, /* Greek_SIGMA */
+    { 0x000007d4, 14117 }, /* Greek_TAU */
+    { 0x000007d5, 14161 }, /* Greek_UPSILON */
+    { 0x000007d6, 14002 }, /* Greek_PHI */
+    { 0x000007d7, 13400 }, /* Greek_CHI */
+    { 0x000007d8, 14040 }, /* Greek_PSI */
+    { 0x000007d9, 13874 }, /* Greek_OMEGA */
+    { 0x000007e1, 13330 }, /* Greek_alpha */
+    { 0x000007e2, 13389 }, /* Greek_beta */
+    { 0x000007e3, 13598 }, /* Greek_gamma */
+    { 0x000007e4, 13432 }, /* Greek_delta */
+    { 0x000007e5, 13458 }, /* Greek_epsilon */
+    { 0x000007e6, 14330 }, /* Greek_zeta */
+    { 0x000007e7, 13522 }, /* Greek_eta */
+    { 0x000007e8, 14149 }, /* Greek_theta */
+    { 0x000007e9, 13636 }, /* Greek_iota */
+    { 0x000007ea, 13776 }, /* Greek_kappa */
+    { 0x000007eb, 13826 }, /* Greek_lamda */
+    { 0x000007ec, 13847 }, /* Greek_mu */
+    { 0x000007ed, 13865 }, /* Greek_nu */
+    { 0x000007ee, 14310 }, /* Greek_xi */
+    { 0x000007ef, 13948 }, /* Greek_omicron */
+    { 0x000007f0, 14031 }, /* Greek_pi */
+    { 0x000007f1, 14070 }, /* Greek_rho */
+    { 0x000007f2, 14092 }, /* Greek_sigma */
+    { 0x000007f3, 13564 }, /* Greek_finalsmallsigma */
+    { 0x000007f4, 14127 }, /* Greek_tau */
+    { 0x000007f5, 14175 }, /* Greek_upsilon */
+    { 0x000007f6, 14012 }, /* Greek_phi */
+    { 0x000007f7, 13410 }, /* Greek_chi */
+    { 0x000007f8, 14050 }, /* Greek_psi */
+    { 0x000007f9, 13886 }, /* Greek_omega */
+    { 0x000008a1, 19356 }, /* leftradical */
+    { 0x000008a2, 25621 }, /* topleftradical */
+    { 0x000008a3, 16667 }, /* horizconnector */
+    { 0x000008a4, 25595 }, /* topintegral */
+    { 0x000008a5, 3422 }, /* botintegral */
+    { 0x000008a6, 26505 }, /* vertconnector */
+    { 0x000008a7, 25636 }, /* topleftsqbracket */
+    { 0x000008a8, 3448 }, /* botleftsqbracket */
+    { 0x000008a9, 25685 }, /* toprightsqbracket */
+    { 0x000008aa, 3497 }, /* botrightsqbracket */
+    { 0x000008ab, 25607 }, /* topleftparens */
+    { 0x000008ac, 3434 }, /* botleftparens */
+    { 0x000008ad, 25670 }, /* toprightparens */
+    { 0x000008ae, 3482 }, /* botrightparens */
+    { 0x000008af, 19306 }, /* leftmiddlecurlybrace */
+    { 0x000008b0, 22440 }, /* rightmiddlecurlybrace */
+    { 0x000008b1, 25653 }, /* topleftsummation */
+    { 0x000008b2, 3465 }, /* botleftsummation */
+    { 0x000008b3, 25726 }, /* topvertsummationconnector */
+    { 0x000008b4, 3538 }, /* botvertsummationconnector */
+    { 0x000008b5, 25703 }, /* toprightsummation */
+    { 0x000008b6, 3515 }, /* botrightsummation */
+    { 0x000008b7, 22462 }, /* rightmiddlesummation */
+    { 0x000008bc, 19417 }, /* lessthanequal */
+    { 0x000008bd, 20125 }, /* notequal */
+    { 0x000008be, 13280 }, /* greaterthanequal */
+    { 0x000008bf, 17313 }, /* integral */
+    { 0x000008c0, 25479 }, /* therefore */
+    { 0x000008c1, 26487 }, /* variation */
+    { 0x000008c2, 17275 }, /* infinity */
+    { 0x000008c5, 19947 }, /* nabla */
+    { 0x000008c8, 954 }, /* approximate */
+    { 0x000008c9, 22999 }, /* similarequal */
+    { 0x000008cd, 17196 }, /* ifonlyif */
+    { 0x000008ce, 17247 }, /* implies */
+    { 0x000008cf, 17155 }, /* identical */
+    { 0x000008d6, 22286 }, /* radical */
+    { 0x000008da, 17255 }, /* includedin */
+    { 0x000008db, 17266 }, /* includes */
+    { 0x000008dc, 17322 }, /* intersection */
+    { 0x000008dd, 26362 }, /* union */
+    { 0x000008de, 19457 }, /* logicaland */
+    { 0x000008df, 19468 }, /* logicalor */
+    { 0x000008ef, 21463 }, /* partialderivative */
+    { 0x000008f6, 12656 }, /* function */
+    { 0x000008fb, 19266 }, /* leftarrow */
+    { 0x000008fc, 26387 }, /* uparrow */
+    { 0x000008fd, 22397 }, /* rightarrow */
+    { 0x000008fe, 11332 }, /* downarrow */
+    { 0x000009df, 3410 }, /* blank */
+    { 0x000009e0, 23790 }, /* soliddiamond */
+    { 0x000009e1, 8603 }, /* checkerboard */
+    { 0x000009e2, 17043 }, /* ht */
+    { 0x000009e3, 12413 }, /* ff */
+    { 0x000009e4, 8727 }, /* cr */
+    { 0x000009e5, 19431 }, /* lf */
+    { 0x000009e8, 20075 }, /* nl */
+    { 0x000009e9, 26542 }, /* vt */
+    { 0x000009ea, 19502 }, /* lowrightcorner */
+    { 0x000009eb, 26416 }, /* uprightcorner */
+    { 0x000009ec, 26403 }, /* upleftcorner */
+    { 0x000009ed, 19488 }, /* lowleftcorner */
+    { 0x000009ee, 8730 }, /* crossinglines */
+    { 0x000009ef, 16682 }, /* horizlinescan1 */
+    { 0x000009f0, 16697 }, /* horizlinescan3 */
+    { 0x000009f1, 16712 }, /* horizlinescan5 */
+    { 0x000009f2, 16727 }, /* horizlinescan7 */
+    { 0x000009f3, 16742 }, /* horizlinescan9 */
+    { 0x000009f4, 19397 }, /* leftt */
+    { 0x000009f5, 22545 }, /* rightt */
+    { 0x000009f6, 3533 }, /* bott */
+    { 0x000009f7, 25721 }, /* topt */
+    { 0x000009f8, 26497 }, /* vertbar */
+    { 0x00000aa1, 11928 }, /* emspace */
+    { 0x00000aa2, 12027 }, /* enspace */
+    { 0x00000aa3, 11821 }, /* em3space */
+    { 0x00000aa4, 11830 }, /* em4space */
+    { 0x00000aa5, 11221 }, /* digitspace */
+    { 0x00000aa6, 22145 }, /* punctspace */
+    { 0x00000aa7, 25489 }, /* thinspace */
+    { 0x00000aa8, 14382 }, /* hairspace */
+    { 0x00000aa9, 11855 }, /* emdash */
+    { 0x00000aaa, 11940 }, /* endash */
+    { 0x00000aac, 22987 }, /* signifblank */
+    { 0x00000aae, 11812 }, /* ellipsis */
+    { 0x00000aaf, 11267 }, /* doubbaselinedot */
+    { 0x00000ab0, 20767 }, /* onethird */
+    { 0x00000ab1, 25837 }, /* twothirds */
+    { 0x00000ab2, 20705 }, /* onefifth */
+    { 0x00000ab3, 25802 }, /* twofifths */
+    { 0x00000ab4, 25530 }, /* threefifths */
+    { 0x00000ab5, 12607 }, /* fourfifths */
+    { 0x00000ab6, 20733 }, /* onesixth */
+    { 0x00000ab7, 12569 }, /* fivesixths */
+    { 0x00000ab8, 8506 }, /* careof */
+    { 0x00000abb, 12427 }, /* figdash */
+    { 0x00000abc, 19249 }, /* leftanglebracket */
+    { 0x00000abd, 11140 }, /* decimalpoint */
+    { 0x00000abe, 22379 }, /* rightanglebracket */
+    { 0x00000abf, 19681 }, /* marker */
+    { 0x00000ac3, 20695 }, /* oneeighth */
+    { 0x00000ac4, 25517 }, /* threeeighths */
+    { 0x00000ac5, 12557 }, /* fiveeighths */
+    { 0x00000ac6, 22904 }, /* seveneighths */
+    { 0x00000ac9, 25760 }, /* trademark */
+    { 0x00000aca, 22973 }, /* signaturemark */
+    { 0x00000acb, 25770 }, /* trademarkincircle */
+    { 0x00000acc, 19327 }, /* leftopentriangle */
+    { 0x00000acd, 22483 }, /* rightopentriangle */
+    { 0x00000ace, 11890 }, /* emopencircle */
+    { 0x00000acf, 11903 }, /* emopenrectangle */
+    { 0x00000ad0, 19377 }, /* leftsinglequotemark */
+    { 0x00000ad1, 22524 }, /* rightsinglequotemark */
+    { 0x00000ad2, 19286 }, /* leftdoublequotemark */
+    { 0x00000ad3, 22419 }, /* rightdoublequotemark */
+    { 0x00000ad4, 22067 }, /* prescription */
+    { 0x00000ad5, 21517 }, /* permille */
+    { 0x00000ad6, 19739 }, /* minutes */
+    { 0x00000ad7, 22711 }, /* seconds */
+    { 0x00000ad9, 19181 }, /* latincross */
+    { 0x00000ada, 16626 }, /* hexagram */
+    { 0x00000adb, 12455 }, /* filledrectbullet */
+    { 0x00000adc, 12435 }, /* filledlefttribullet */
+    { 0x00000add, 12472 }, /* filledrighttribullet */
+    { 0x00000ade, 11862 }, /* emfilledcircle */
+    { 0x00000adf, 11877 }, /* emfilledrect */
+    { 0x00000ae0, 11991 }, /* enopencircbullet */
+    { 0x00000ae1, 12008 }, /* enopensquarebullet */
+    { 0x00000ae2, 20794 }, /* openrectbullet */
+    { 0x00000ae3, 20836 }, /* opentribulletup */
+    { 0x00000ae4, 20818 }, /* opentribulletdown */
+    { 0x00000ae5, 20809 }, /* openstar */
+    { 0x00000ae6, 11947 }, /* enfilledcircbullet */
+    { 0x00000ae7, 11966 }, /* enfilledsqbullet */
+    { 0x00000ae8, 12513 }, /* filledtribulletup */
+    { 0x00000ae9, 12493 }, /* filledtribulletdown */
+    { 0x00000aea, 19344 }, /* leftpointer */
+    { 0x00000aeb, 22501 }, /* rightpointer */
+    { 0x00000aec, 8649 }, /* club */
+    { 0x00000aed, 11213 }, /* diamond */
+    { 0x00000aee, 16080 }, /* heart */
+    { 0x00000af0, 19668 }, /* maltesecross */
+    { 0x00000af1, 10358 }, /* dagger */
+    { 0x00000af2, 11295 }, /* doubledagger */
+    { 0x00000af3, 8616 }, /* checkmark */
+    { 0x00000af4, 3380 }, /* ballotcross */
+    { 0x00000af5, 19860 }, /* musicalsharp */
+    { 0x00000af6, 19848 }, /* musicalflat */
+    { 0x00000af7, 19657 }, /* malesymbol */
+    { 0x00000af8, 12400 }, /* femalesymbol */
+    { 0x00000af9, 24354 }, /* telephone */
+    { 0x00000afa, 24364 }, /* telephonerecorder */
+    { 0x00000afb, 21537 }, /* phonographcopyright */
+    { 0x00000afc, 8513 }, /* caret */
+    { 0x00000afd, 23028 }, /* singlelowquotemark */
+    { 0x00000afe, 11308 }, /* doublelowquotemark */
+    { 0x00000aff, 8775 }, /* cursor */
+    { 0x00000ba3, 19276 }, /* leftcaret */
+    { 0x00000ba6, 22408 }, /* rightcaret */
+    { 0x00000ba8, 11342 }, /* downcaret */
+    { 0x00000ba9, 26395 }, /* upcaret */
+    { 0x00000bc0, 21324 }, /* overbar */
+    { 0x00000bc2, 11371 }, /* downtack */
+    { 0x00000bc3, 26430 }, /* upshoe */
+    { 0x00000bc4, 11361 }, /* downstile */
+    { 0x00000bc6, 26337 }, /* underbar */
+    { 0x00000bca, 18142 }, /* jot */
+    { 0x00000bcc, 22160 }, /* quad */
+    { 0x00000bce, 26445 }, /* uptack */
+    { 0x00000bcf, 8626 }, /* circle */
+    { 0x00000bd3, 26437 }, /* upstile */
+    { 0x00000bd6, 11352 }, /* downshoe */
+    { 0x00000bd8, 22514 }, /* rightshoe */
+    { 0x00000bda, 19368 }, /* leftshoe */
+    { 0x00000bdc, 19403 }, /* lefttack */
+    { 0x00000bfc, 22552 }, /* righttack */
+    { 0x00000cdf, 16173 }, /* hebrew_doublelowline */
+    { 0x00000ce0, 16086 }, /* hebrew_aleph */
+    { 0x00000ce1, 16111 }, /* hebrew_bet */
+    { 0x00000ce2, 16292 }, /* hebrew_gimel */
+    { 0x00000ce3, 16146 }, /* hebrew_dalet */
+    { 0x00000ce4, 16319 }, /* hebrew_he */
+    { 0x00000ce5, 16531 }, /* hebrew_waw */
+    { 0x00000ce6, 16577 }, /* hebrew_zain */
+    { 0x00000ce7, 16134 }, /* hebrew_chet */
+    { 0x00000ce8, 16508 }, /* hebrew_tet */
+    { 0x00000ce9, 16542 }, /* hebrew_yod */
+    { 0x00000cea, 16194 }, /* hebrew_finalkaph */
+    { 0x00000ceb, 16340 }, /* hebrew_kaph */
+    { 0x00000cec, 16363 }, /* hebrew_lamed */
+    { 0x00000ced, 16211 }, /* hebrew_finalmem */
+    { 0x00000cee, 16376 }, /* hebrew_mem */
+    { 0x00000cef, 16227 }, /* hebrew_finalnun */
+    { 0x00000cf0, 16387 }, /* hebrew_nun */
+    { 0x00000cf1, 16432 }, /* hebrew_samech */
+    { 0x00000cf2, 16099 }, /* hebrew_ayin */
+    { 0x00000cf3, 16243 }, /* hebrew_finalpe */
+    { 0x00000cf4, 16398 }, /* hebrew_pe */
+    { 0x00000cf5, 16258 }, /* hebrew_finalzade */
+    { 0x00000cf6, 16553 }, /* hebrew_zade */
+    { 0x00000cf7, 16408 }, /* hebrew_qoph */
+    { 0x00000cf8, 16420 }, /* hebrew_resh */
+    { 0x00000cf9, 16460 }, /* hebrew_shin */
+    { 0x00000cfa, 16497 }, /* hebrew_taw */
+    { 0x00000da1, 24617 }, /* Thai_kokai */
+    { 0x00000da2, 24547 }, /* Thai_khokhai */
+    { 0x00000da3, 24573 }, /* Thai_khokhuat */
+    { 0x00000da4, 24587 }, /* Thai_khokhwai */
+    { 0x00000da5, 24560 }, /* Thai_khokhon */
+    { 0x00000da6, 24601 }, /* Thai_khorakhang */
+    { 0x00000da7, 24930 }, /* Thai_ngongu */
+    { 0x00000da8, 24423 }, /* Thai_chochan */
+    { 0x00000da9, 24450 }, /* Thai_choching */
+    { 0x00000daa, 24436 }, /* Thai_chochang */
+    { 0x00000dab, 25291 }, /* Thai_soso */
+    { 0x00000dac, 24464 }, /* Thai_chochoe */
+    { 0x00000dad, 25467 }, /* Thai_yoying */
+    { 0x00000dae, 24477 }, /* Thai_dochada */
+    { 0x00000daf, 25420 }, /* Thai_topatak */
+    { 0x00000db0, 25379 }, /* Thai_thothan */
+    { 0x00000db1, 25329 }, /* Thai_thonangmontho */
+    { 0x00000db2, 25348 }, /* Thai_thophuthao */
+    { 0x00000db3, 24956 }, /* Thai_nonen */
+    { 0x00000db4, 24490 }, /* Thai_dodek */
+    { 0x00000db5, 25433 }, /* Thai_totao */
+    { 0x00000db6, 25406 }, /* Thai_thothung */
+    { 0x00000db7, 25364 }, /* Thai_thothahan */
+    { 0x00000db8, 25392 }, /* Thai_thothong */
+    { 0x00000db9, 24967 }, /* Thai_nonu */
+    { 0x00000dba, 24409 }, /* Thai_bobaimai */
+    { 0x00000dbb, 25058 }, /* Thai_popla */
+    { 0x00000dbc, 25028 }, /* Thai_phophung */
+    { 0x00000dbd, 24501 }, /* Thai_fofa */
+    { 0x00000dbe, 25015 }, /* Thai_phophan */
+    { 0x00000dbf, 24511 }, /* Thai_fofan */
+    { 0x00000dc0, 25042 }, /* Thai_phosamphao */
+    { 0x00000dc1, 24920 }, /* Thai_moma */
+    { 0x00000dc2, 25456 }, /* Thai_yoyak */
+    { 0x00000dc3, 25069 }, /* Thai_rorua */
+    { 0x00000dc4, 25080 }, /* Thai_ru */
+    { 0x00000dc5, 24780 }, /* Thai_loling */
+    { 0x00000dc6, 24792 }, /* Thai_lu */
+    { 0x00000dc7, 25444 }, /* Thai_wowaen */
+    { 0x00000dc8, 25279 }, /* Thai_sosala */
+    { 0x00000dc9, 25267 }, /* Thai_sorusi */
+    { 0x00000dca, 25301 }, /* Thai_sosua */
+    { 0x00000dcb, 24522 }, /* Thai_hohip */
+    { 0x00000dcc, 24767 }, /* Thai_lochula */
+    { 0x00000dcd, 24977 }, /* Thai_oang */
+    { 0x00000dce, 24533 }, /* Thai_honokhuk */
+    { 0x00000dcf, 24987 }, /* Thai_paiyannoi */
+    { 0x00000dd0, 25088 }, /* Thai_saraa */
+    { 0x00000dd1, 24828 }, /* Thai_maihanakat */
+    { 0x00000dd2, 25099 }, /* Thai_saraaa */
+    { 0x00000dd3, 25162 }, /* Thai_saraam */
+    { 0x00000dd4, 25185 }, /* Thai_sarai */
+    { 0x00000dd5, 25196 }, /* Thai_saraii */
+    { 0x00000dd6, 25230 }, /* Thai_saraue */
+    { 0x00000dd7, 25242 }, /* Thai_sarauee */
+    { 0x00000dd8, 25219 }, /* Thai_sarau */
+    { 0x00000dd9, 25255 }, /* Thai_sarauu */
+    { 0x00000dda, 25002 }, /* Thai_phinthu */
+    { 0x00000dde, 24844 }, /* Thai_maihanakat_maitho */
+    { 0x00000ddf, 24399 }, /* Thai_baht */
+    { 0x00000de0, 25174 }, /* Thai_sarae */
+    { 0x00000de1, 25111 }, /* Thai_saraae */
+    { 0x00000de2, 25208 }, /* Thai_sarao */
+    { 0x00000de3, 25143 }, /* Thai_saraaimaimuan */
+    { 0x00000de4, 25123 }, /* Thai_saraaimaimalai */
+    { 0x00000de5, 24628 }, /* Thai_lakkhangyao */
+    { 0x00000de6, 24906 }, /* Thai_maiyamok */
+    { 0x00000de7, 24867 }, /* Thai_maitaikhu */
+    { 0x00000de8, 24817 }, /* Thai_maiek */
+    { 0x00000de9, 24882 }, /* Thai_maitho */
+    { 0x00000dea, 24894 }, /* Thai_maitri */
+    { 0x00000deb, 24800 }, /* Thai_maichattawa */
+    { 0x00000dec, 25312 }, /* Thai_thanthakhat */
+    { 0x00000ded, 24942 }, /* Thai_nikhahit */
+    { 0x00000df0, 24755 }, /* Thai_leksun */
+    { 0x00000df1, 24693 }, /* Thai_leknung */
+    { 0x00000df2, 24742 }, /* Thai_leksong */
+    { 0x00000df3, 24719 }, /* Thai_leksam */
+    { 0x00000df4, 24731 }, /* Thai_leksi */
+    { 0x00000df5, 24658 }, /* Thai_lekha */
+    { 0x00000df6, 24669 }, /* Thai_lekhok */
+    { 0x00000df7, 24645 }, /* Thai_lekchet */
+    { 0x00000df8, 24706 }, /* Thai_lekpaet */
+    { 0x00000df9, 24681 }, /* Thai_lekkao */
+    { 0x00000ea1, 15181 }, /* Hangul_Kiyeog */
+    { 0x00000ea2, 15726 }, /* Hangul_SsangKiyeog */
+    { 0x00000ea3, 15195 }, /* Hangul_KiyeogSios */
+    { 0x00000ea4, 15276 }, /* Hangul_Nieun */
+    { 0x00000ea5, 15307 }, /* Hangul_NieunJieuj */
+    { 0x00000ea6, 15289 }, /* Hangul_NieunHieuh */
+    { 0x00000ea7, 14488 }, /* Hangul_Dikeud */
+    { 0x00000ea8, 15689 }, /* Hangul_SsangDikeud */
+    { 0x00000ea9, 15461 }, /* Hangul_Rieul */
+    { 0x00000eaa, 15492 }, /* Hangul_RieulKiyeog */
+    { 0x00000eab, 15511 }, /* Hangul_RieulMieum */
+    { 0x00000eac, 15548 }, /* Hangul_RieulPieub */
+    { 0x00000ead, 15566 }, /* Hangul_RieulSios */
+    { 0x00000eae, 15583 }, /* Hangul_RieulTieut */
+    { 0x00000eaf, 15529 }, /* Hangul_RieulPhieuf */
+    { 0x00000eb0, 15474 }, /* Hangul_RieulHieuh */
+    { 0x00000eb1, 15238 }, /* Hangul_Mieum */
+    { 0x00000eb2, 15373 }, /* Hangul_Pieub */
+    { 0x00000eb3, 15745 }, /* Hangul_SsangPieub */
+    { 0x00000eb4, 15386 }, /* Hangul_PieubSios */
+    { 0x00000eb5, 15662 }, /* Hangul_Sios */
+    { 0x00000eb6, 15763 }, /* Hangul_SsangSios */
+    { 0x00000eb7, 14577 }, /* Hangul_Ieung */
+    { 0x00000eb8, 15154 }, /* Hangul_Jieuj */
+    { 0x00000eb9, 15708 }, /* Hangul_SsangJieuj */
+    { 0x00000eba, 14458 }, /* Hangul_Cieuc */
+    { 0x00000ebb, 15167 }, /* Hangul_Khieuq */
+    { 0x00000ebc, 15883 }, /* Hangul_Tieut */
+    { 0x00000ebd, 15359 }, /* Hangul_Phieuf */
+    { 0x00000ebe, 14555 }, /* Hangul_Hieuh */
+    { 0x00000ebf, 14399 }, /* Hangul_A */
+    { 0x00000ec0, 14408 }, /* Hangul_AE */
+    { 0x00000ec1, 15957 }, /* Hangul_YA */
+    { 0x00000ec2, 15967 }, /* Hangul_YAE */
+    { 0x00000ec3, 14522 }, /* Hangul_EO */
+    { 0x00000ec4, 14502 }, /* Hangul_E */
+    { 0x00000ec5, 15988 }, /* Hangul_YEO */
+    { 0x00000ec6, 15978 }, /* Hangul_YE */
+    { 0x00000ec7, 15325 }, /* Hangul_O */
+    { 0x00000ec8, 15905 }, /* Hangul_WA */
+    { 0x00000ec9, 15915 }, /* Hangul_WAE */
+    { 0x00000eca, 15334 }, /* Hangul_OE */
+    { 0x00000ecb, 16028 }, /* Hangul_YO */
+    { 0x00000ecc, 15896 }, /* Hangul_U */
+    { 0x00000ecd, 15936 }, /* Hangul_WEO */
+    { 0x00000ece, 15926 }, /* Hangul_WE */
+    { 0x00000ecf, 15947 }, /* Hangul_WI */
+    { 0x00000ed0, 16038 }, /* Hangul_YU */
+    { 0x00000ed1, 14532 }, /* Hangul_EU */
+    { 0x00000ed2, 16018 }, /* Hangul_YI */
+    { 0x00000ed3, 14568 }, /* Hangul_I */
+    { 0x00000ed4, 14682 }, /* Hangul_J_Kiyeog */
+    { 0x00000ed5, 15052 }, /* Hangul_J_SsangKiyeog */
+    { 0x00000ed6, 14698 }, /* Hangul_J_KiyeogSios */
+    { 0x00000ed7, 14760 }, /* Hangul_J_Nieun */
+    { 0x00000ed8, 14795 }, /* Hangul_J_NieunJieuj */
+    { 0x00000ed9, 14775 }, /* Hangul_J_NieunHieuh */
+    { 0x00000eda, 14605 }, /* Hangul_J_Dikeud */
+    { 0x00000edb, 14882 }, /* Hangul_J_Rieul */
+    { 0x00000edc, 14917 }, /* Hangul_J_RieulKiyeog */
+    { 0x00000edd, 14938 }, /* Hangul_J_RieulMieum */
+    { 0x00000ede, 14979 }, /* Hangul_J_RieulPieub */
+    { 0x00000edf, 14999 }, /* Hangul_J_RieulSios */
+    { 0x00000ee0, 15018 }, /* Hangul_J_RieulTieut */
+    { 0x00000ee1, 14958 }, /* Hangul_J_RieulPhieuf */
+    { 0x00000ee2, 14897 }, /* Hangul_J_RieulHieuh */
+    { 0x00000ee3, 14745 }, /* Hangul_J_Mieum */
+    { 0x00000ee4, 14848 }, /* Hangul_J_Pieub */
+    { 0x00000ee5, 14863 }, /* Hangul_J_PieubSios */
+    { 0x00000ee6, 15038 }, /* Hangul_J_Sios */
+    { 0x00000ee7, 15073 }, /* Hangul_J_SsangSios */
+    { 0x00000ee8, 14636 }, /* Hangul_J_Ieung */
+    { 0x00000ee9, 14651 }, /* Hangul_J_Jieuj */
+    { 0x00000eea, 14590 }, /* Hangul_J_Cieuc */
+    { 0x00000eeb, 14666 }, /* Hangul_J_Khieuq */
+    { 0x00000eec, 15092 }, /* Hangul_J_Tieut */
+    { 0x00000eed, 14832 }, /* Hangul_J_Phieuf */
+    { 0x00000eee, 14621 }, /* Hangul_J_Hieuh */
+    { 0x00000eef, 15601 }, /* Hangul_RieulYeorinHieuh */
+    { 0x00000ef0, 15793 }, /* Hangul_SunkyeongeumMieum */
+    { 0x00000ef1, 15844 }, /* Hangul_SunkyeongeumPieub */
+    { 0x00000ef2, 15344 }, /* Hangul_PanSios */
+    { 0x00000ef3, 15213 }, /* Hangul_KkogjiDalrinIeung */
+    { 0x00000ef4, 15818 }, /* Hangul_SunkyeongeumPhieuf */
+    { 0x00000ef5, 15999 }, /* Hangul_YeorinHieuh */
+    { 0x00000ef6, 14418 }, /* Hangul_AraeA */
+    { 0x00000ef7, 14431 }, /* Hangul_AraeAE */
+    { 0x00000ef8, 14815 }, /* Hangul_J_PanSios */
+    { 0x00000ef9, 14718 }, /* Hangul_J_KkogjiDalrinIeung */
+    { 0x00000efa, 15107 }, /* Hangul_J_YeorinHieuh */
+    { 0x00000eff, 18797 }, /* Korean_Won */
+    { 0x000013bc, 20514 }, /* OE */
+    { 0x000013bd, 20517 }, /* oe */
+    { 0x000013be, 29045 }, /* Ydiaeresis */
+    { 0x000020ac, 12090 }, /* EuroSign */
+    { 0x0000fd01, 125 }, /* 3270_Duplicate */
+    { 0x0000fd02, 195 }, /* 3270_FieldMark */
+    { 0x0000fd03, 343 }, /* 3270_Right2 */
+    { 0x0000fd04, 245 }, /* 3270_Left2 */
+    { 0x0000fd05, 33 }, /* 3270_BackTab */
+    { 0x0000fd06, 151 }, /* 3270_EraseEOF */
+    { 0x0000fd07, 165 }, /* 3270_EraseInput */
+    { 0x0000fd08, 332 }, /* 3270_Reset */
+    { 0x0000fd09, 310 }, /* 3270_Quit */
+    { 0x0000fd0a, 256 }, /* 3270_PA1 */
+    { 0x0000fd0b, 265 }, /* 3270_PA2 */
+    { 0x0000fd0c, 274 }, /* 3270_PA3 */
+    { 0x0000fd0d, 376 }, /* 3270_Test */
+    { 0x0000fd0e, 23 }, /* 3270_Attn */
+    { 0x0000fd0f, 74 }, /* 3270_CursorBlink */
+    { 0x0000fd10, 8 }, /* 3270_AltCursor */
+    { 0x0000fd11, 231 }, /* 3270_KeyClick */
+    { 0x0000fd12, 221 }, /* 3270_Jump */
+    { 0x0000fd13, 210 }, /* 3270_Ident */
+    { 0x0000fd14, 355 }, /* 3270_Rule */
+    { 0x0000fd15, 64 }, /* 3270_Copy */
+    { 0x0000fd16, 283 }, /* 3270_Play */
+    { 0x0000fd17, 365 }, /* 3270_Setup */
+    { 0x0000fd18, 320 }, /* 3270_Record */
+    { 0x0000fd19, 46 }, /* 3270_ChangeScreen */
+    { 0x0000fd1a, 109 }, /* 3270_DeleteWord */
+    { 0x0000fd1b, 181 }, /* 3270_ExSelect */
+    { 0x0000fd1c, 91 }, /* 3270_CursorSelect */
+    { 0x0000fd1d, 293 }, /* 3270_PrintScreen */
+    { 0x0000fd1e, 140 }, /* 3270_Enter */
+    { 0x0000fe01, 17781 }, /* ISO_Lock */
+    { 0x0000fe02, 17664 }, /* ISO_Level2_Latch */
+    { 0x0000fe03, 17714 }, /* ISO_Level3_Shift */
+    { 0x0000fe04, 17681 }, /* ISO_Level3_Latch */
+    { 0x0000fe05, 17698 }, /* ISO_Level3_Lock */
+    { 0x0000fe06, 17569 }, /* ISO_Group_Latch */
+    { 0x0000fe07, 17585 }, /* ISO_Group_Lock */
+    { 0x0000fe08, 17826 }, /* ISO_Next_Group */
+    { 0x0000fe09, 17841 }, /* ISO_Next_Group_Lock */
+    { 0x0000fe0a, 17950 }, /* ISO_Prev_Group */
+    { 0x0000fe0b, 17965 }, /* ISO_Prev_Group_Lock */
+    { 0x0000fe0c, 17532 }, /* ISO_First_Group */
+    { 0x0000fe0d, 17548 }, /* ISO_First_Group_Lock */
+    { 0x0000fe0e, 17616 }, /* ISO_Last_Group */
+    { 0x0000fe0f, 17631 }, /* ISO_Last_Group_Lock */
+    { 0x0000fe11, 17764 }, /* ISO_Level5_Shift */
+    { 0x0000fe12, 17731 }, /* ISO_Level5_Latch */
+    { 0x0000fe13, 17748 }, /* ISO_Level5_Lock */
+    { 0x0000fe20, 17651 }, /* ISO_Left_Tab */
+    { 0x0000fe21, 17809 }, /* ISO_Move_Line_Up */
+    { 0x0000fe22, 17790 }, /* ISO_Move_Line_Down */
+    { 0x0000fe23, 17883 }, /* ISO_Partial_Line_Up */
+    { 0x0000fe24, 17861 }, /* ISO_Partial_Line_Down */
+    { 0x0000fe25, 17903 }, /* ISO_Partial_Space_Left */
+    { 0x0000fe26, 17926 }, /* ISO_Partial_Space_Right */
+    { 0x0000fe27, 18059 }, /* ISO_Set_Margin_Left */
+    { 0x0000fe28, 18079 }, /* ISO_Set_Margin_Right */
+    { 0x0000fe29, 18010 }, /* ISO_Release_Margin_Left */
+    { 0x0000fe2a, 18034 }, /* ISO_Release_Margin_Right */
+    { 0x0000fe2b, 17985 }, /* ISO_Release_Both_Margins */
+    { 0x0000fe2c, 17470 }, /* ISO_Fast_Cursor_Left */
+    { 0x0000fe2d, 17491 }, /* ISO_Fast_Cursor_Right */
+    { 0x0000fe2e, 17513 }, /* ISO_Fast_Cursor_Up */
+    { 0x0000fe2f, 17449 }, /* ISO_Fast_Cursor_Down */
+    { 0x0000fe30, 17372 }, /* ISO_Continuous_Underline */
+    { 0x0000fe31, 17397 }, /* ISO_Discontinuous_Underline */
+    { 0x0000fe32, 17425 }, /* ISO_Emphasize */
+    { 0x0000fe33, 17354 }, /* ISO_Center_Object */
+    { 0x0000fe34, 17439 }, /* ISO_Enter */
+    { 0x0000fe50, 10858 }, /* dead_grave */
+    { 0x0000fe51, 10531 }, /* dead_acute */
+    { 0x0000fe52, 10754 }, /* dead_circumflex */
+    { 0x0000fe53, 11097 }, /* dead_tilde */
+    { 0x0000fe54, 10980 }, /* dead_macron */
+    { 0x0000fe55, 10700 }, /* dead_breve */
+    { 0x0000fe56, 10455 }, /* dead_abovedot */
+    { 0x0000fe57, 10795 }, /* dead_diaeresis */
+    { 0x0000fe58, 10493 }, /* dead_abovering */
+    { 0x0000fe59, 10810 }, /* dead_doubleacute */
+    { 0x0000fe5a, 10730 }, /* dead_caron */
+    { 0x0000fe5b, 10741 }, /* dead_cedilla */
+    { 0x0000fe5c, 11006 }, /* dead_ogonek */
+    { 0x0000fe5d, 10933 }, /* dead_iota */
+    { 0x0000fe5e, 11122 }, /* dead_voiced_sound */
+    { 0x0000fe5f, 11046 }, /* dead_semivoiced_sound */
+    { 0x0000fe60, 10615 }, /* dead_belowdot */
+    { 0x0000fe61, 10880 }, /* dead_hook */
+    { 0x0000fe62, 10890 }, /* dead_horn */
+    { 0x0000fe63, 11085 }, /* dead_stroke */
+    { 0x0000fe64, 10439 }, /* dead_abovecomma */
+    { 0x0000fe65, 10469 }, /* dead_abovereversedcomma */
+    { 0x0000fe66, 10827 }, /* dead_doublegrave */
+    { 0x0000fe67, 10646 }, /* dead_belowring */
+    { 0x0000fe68, 10629 }, /* dead_belowmacron */
+    { 0x0000fe69, 10558 }, /* dead_belowcircumflex */
+    { 0x0000fe6a, 10661 }, /* dead_belowtilde */
+    { 0x0000fe6b, 10542 }, /* dead_belowbreve */
+    { 0x0000fe6c, 10595 }, /* dead_belowdiaeresis */
+    { 0x0000fe6d, 10914 }, /* dead_invertedbreve */
+    { 0x0000fe6e, 10579 }, /* dead_belowcomma */
+    { 0x0000fe6f, 10770 }, /* dead_currency */
+    { 0x0000fe70, 583 }, /* AccessX_Enable */
+    { 0x0000fe71, 598 }, /* AccessX_Feedback_Enable */
+    { 0x0000fe72, 22342 }, /* RepeatKeys_Enable */
+    { 0x0000fe73, 23774 }, /* SlowKeys_Enable */
+    { 0x0000fe74, 3564 }, /* BounceKeys_Enable */
+    { 0x0000fe75, 23836 }, /* StickyKeys_Enable */
+    { 0x0000fe76, 19782 }, /* MouseKeys_Enable */
+    { 0x0000fe77, 19759 }, /* MouseKeys_Accel_Enable */
+    { 0x0000fe78, 21332 }, /* Overlay1_Enable */
+    { 0x0000fe79, 21348 }, /* Overlay2_Enable */
+    { 0x0000fe7a, 3309 }, /* AudibleBell_Enable */
+    { 0x0000fe80, 10425 }, /* dead_a */
+    { 0x0000fe81, 10432 }, /* dead_A */
+    { 0x0000fe82, 10844 }, /* dead_e */
+    { 0x0000fe83, 10851 }, /* dead_E */
+    { 0x0000fe84, 10900 }, /* dead_i */
+    { 0x0000fe85, 10907 }, /* dead_I */
+    { 0x0000fe86, 10992 }, /* dead_o */
+    { 0x0000fe87, 10999 }, /* dead_O */
+    { 0x0000fe88, 11108 }, /* dead_u */
+    { 0x0000fe89, 11115 }, /* dead_U */
+    { 0x0000fe8a, 11068 }, /* dead_small_schwa */
+    { 0x0000fe8b, 10711 }, /* dead_capital_schwa */
+    { 0x0000fe8c, 10869 }, /* dead_greek */
+    { 0x0000fe90, 10967 }, /* dead_lowline */
+    { 0x0000fe91, 10508 }, /* dead_aboveverticalline */
+    { 0x0000fe92, 10677 }, /* dead_belowverticalline */
+    { 0x0000fe93, 10943 }, /* dead_longsolidusoverlay */
+    { 0x0000fea0, 8594 }, /* ch */
+    { 0x0000fea1, 8597 }, /* Ch */
+    { 0x0000fea2, 8600 }, /* CH */
+    { 0x0000fea3, 8443 }, /* c_h */
+    { 0x0000fea4, 8447 }, /* C_h */
+    { 0x0000fea5, 8451 }, /* C_H */
+    { 0x0000fed0, 12536 }, /* First_Virtual_Screen */
+    { 0x0000fed1, 22080 }, /* Prev_Virtual_Screen */
+    { 0x0000fed2, 20028 }, /* Next_Virtual_Screen */
+    { 0x0000fed4, 19161 }, /* Last_Virtual_Screen */
+    { 0x0000fed5, 24382 }, /* Terminate_Server */
+    { 0x0000fee0, 21998 }, /* Pointer_Left */
+    { 0x0000fee1, 22011 }, /* Pointer_Right */
+    { 0x0000fee2, 22025 }, /* Pointer_Up */
+    { 0x0000fee3, 21843 }, /* Pointer_Down */
+    { 0x0000fee4, 22036 }, /* Pointer_UpLeft */
+    { 0x0000fee5, 22051 }, /* Pointer_UpRight */
+    { 0x0000fee6, 21856 }, /* Pointer_DownLeft */
+    { 0x0000fee7, 21873 }, /* Pointer_DownRight */
+    { 0x0000fee8, 21671 }, /* Pointer_Button_Dflt */
+    { 0x0000fee9, 21591 }, /* Pointer_Button1 */
+    { 0x0000feea, 21607 }, /* Pointer_Button2 */
+    { 0x0000feeb, 21623 }, /* Pointer_Button3 */
+    { 0x0000feec, 21639 }, /* Pointer_Button4 */
+    { 0x0000feed, 21655 }, /* Pointer_Button5 */
+    { 0x0000feee, 21781 }, /* Pointer_DblClick_Dflt */
+    { 0x0000feef, 21691 }, /* Pointer_DblClick1 */
+    { 0x0000fef0, 21709 }, /* Pointer_DblClick2 */
+    { 0x0000fef1, 21727 }, /* Pointer_DblClick3 */
+    { 0x0000fef2, 21745 }, /* Pointer_DblClick4 */
+    { 0x0000fef3, 21763 }, /* Pointer_DblClick5 */
+    { 0x0000fef4, 21961 }, /* Pointer_Drag_Dflt */
+    { 0x0000fef5, 21891 }, /* Pointer_Drag1 */
+    { 0x0000fef6, 21905 }, /* Pointer_Drag2 */
+    { 0x0000fef7, 21919 }, /* Pointer_Drag3 */
+    { 0x0000fef8, 21933 }, /* Pointer_Drag4 */
+    { 0x0000fef9, 21979 }, /* Pointer_EnableKeys */
+    { 0x0000fefa, 21572 }, /* Pointer_Accelerate */
+    { 0x0000fefb, 21803 }, /* Pointer_DfltBtnNext */
+    { 0x0000fefc, 21823 }, /* Pointer_DfltBtnPrev */
+    { 0x0000fefd, 21947 }, /* Pointer_Drag5 */
+    { 0x0000ff08, 3362 }, /* BackSpace */
+    { 0x0000ff09, 24298 }, /* Tab */
+    { 0x0000ff0a, 19434 }, /* Linefeed */
+    { 0x0000ff0b, 8633 }, /* Clear */
+    { 0x0000ff0d, 22366 }, /* Return */
+    { 0x0000ff13, 21481 }, /* Pause */
+    { 0x0000ff14, 22699 }, /* Scroll_Lock */
+    { 0x0000ff15, 24279 }, /* Sys_Req */
+    { 0x0000ff1b, 12057 }, /* Escape */
+    { 0x0000ff20, 19811 }, /* Multi_key */
+    { 0x0000ff21, 18745 }, /* Kanji */
+    { 0x0000ff22, 19802 }, /* Muhenkan */
+    { 0x0000ff23, 16614 }, /* Henkan_Mode */
+    { 0x0000ff24, 22562 }, /* Romaji */
+    { 0x0000ff25, 16635 }, /* Hiragana */
+    { 0x0000ff26, 18770 }, /* Katakana */
+    { 0x0000ff27, 16644 }, /* Hiragana_Katakana */
+    { 0x0000ff28, 29161 }, /* Zenkaku */
+    { 0x0000ff29, 16048 }, /* Hankaku */
+    { 0x0000ff2a, 29169 }, /* Zenkaku_Hankaku */
+    { 0x0000ff2b, 25752 }, /* Touroku */
+    { 0x0000ff2c, 19698 }, /* Massyo */
+    { 0x0000ff2d, 18351 }, /* Kana_Lock */
+    { 0x0000ff2e, 18562 }, /* Kana_Shift */
+    { 0x0000ff2f, 11779 }, /* Eisu_Shift */
+    { 0x0000ff30, 11790 }, /* Eisu_toggle */
+    { 0x0000ff31, 14392 }, /* Hangul */
+    { 0x0000ff32, 15780 }, /* Hangul_Start */
+    { 0x0000ff33, 14511 }, /* Hangul_End */
+    { 0x0000ff34, 14542 }, /* Hangul_Hanja */
+    { 0x0000ff35, 15128 }, /* Hangul_Jamo */
+    { 0x0000ff36, 15625 }, /* Hangul_Romaja */
+    { 0x0000ff37, 8654 }, /* Codeinput */
+    { 0x0000ff38, 15140 }, /* Hangul_Jeonja */
+    { 0x0000ff39, 14445 }, /* Hangul_Banja */
+    { 0x0000ff3a, 15420 }, /* Hangul_PreHanja */
+    { 0x0000ff3b, 15403 }, /* Hangul_PostHanja */
+    { 0x0000ff3c, 23012 }, /* SingleCandidate */
+    { 0x0000ff3d, 19821 }, /* MultipleCandidate */
+    { 0x0000ff3e, 22100 }, /* PreviousCandidate */
+    { 0x0000ff3f, 15674 }, /* Hangul_Special */
+    { 0x0000ff50, 16662 }, /* Home */
+    { 0x0000ff51, 19244 }, /* Left */
+    { 0x0000ff52, 26384 }, /* Up */
+    { 0x0000ff53, 22373 }, /* Right */
+    { 0x0000ff54, 11327 }, /* Down */
+    { 0x0000ff55, 22124 }, /* Prior */
+    { 0x0000ff56, 20023 }, /* Next */
+    { 0x0000ff57, 11936 }, /* End */
+    { 0x0000ff58, 3404 }, /* Begin */
+    { 0x0000ff60, 22727 }, /* Select */
+    { 0x0000ff61, 22118 }, /* Print */
+    { 0x0000ff62, 12117 }, /* Execute */
+    { 0x0000ff63, 17284 }, /* Insert */
+    { 0x0000ff65, 26357 }, /* Undo */
+    { 0x0000ff66, 22326 }, /* Redo */
+    { 0x0000ff67, 19705 }, /* Menu */
+    { 0x0000ff68, 12531 }, /* Find */
+    { 0x0000ff69, 8489 }, /* Cancel */
+    { 0x0000ff6a, 16602 }, /* Help */
+    { 0x0000ff6b, 8377 }, /* Break */
+    { 0x0000ff7e, 19747 }, /* Mode_switch */
+    { 0x0000ff7f, 20169 }, /* Num_Lock */
+    { 0x0000ff80, 19074 }, /* KP_Space */
+    { 0x0000ff89, 19095 }, /* KP_Tab */
+    { 0x0000ff8d, 18931 }, /* KP_Enter */
+    { 0x0000ff91, 18949 }, /* KP_F1 */
+    { 0x0000ff92, 18955 }, /* KP_F2 */
+    { 0x0000ff93, 18961 }, /* KP_F3 */
+    { 0x0000ff94, 18967 }, /* KP_F4 */
+    { 0x0000ff95, 18973 }, /* KP_Home */
+    { 0x0000ff96, 18991 }, /* KP_Left */
+    { 0x0000ff97, 19102 }, /* KP_Up */
+    { 0x0000ff98, 19052 }, /* KP_Right */
+    { 0x0000ff99, 18916 }, /* KP_Down */
+    { 0x0000ff9a, 19043 }, /* KP_Prior */
+    { 0x0000ff9b, 19011 }, /* KP_Next */
+    { 0x0000ff9c, 18924 }, /* KP_End */
+    { 0x0000ff9d, 18876 }, /* KP_Begin */
+    { 0x0000ff9e, 18981 }, /* KP_Insert */
+    { 0x0000ff9f, 18896 }, /* KP_Delete */
+    { 0x0000ffaa, 18999 }, /* KP_Multiply */
+    { 0x0000ffab, 18858 }, /* KP_Add */
+    { 0x0000ffac, 19061 }, /* KP_Separator */
+    { 0x0000ffad, 19083 }, /* KP_Subtract */
+    { 0x0000ffae, 18885 }, /* KP_Decimal */
+    { 0x0000ffaf, 18906 }, /* KP_Divide */
+    { 0x0000ffb0, 18808 }, /* KP_0 */
+    { 0x0000ffb1, 18813 }, /* KP_1 */
+    { 0x0000ffb2, 18818 }, /* KP_2 */
+    { 0x0000ffb3, 18823 }, /* KP_3 */
+    { 0x0000ffb4, 18828 }, /* KP_4 */
+    { 0x0000ffb5, 18833 }, /* KP_5 */
+    { 0x0000ffb6, 18838 }, /* KP_6 */
+    { 0x0000ffb7, 18843 }, /* KP_7 */
+    { 0x0000ffb8, 18848 }, /* KP_8 */
+    { 0x0000ffb9, 18853 }, /* KP_9 */
+    { 0x0000ffbd, 18940 }, /* KP_Equal */
+    { 0x0000ffbe, 12159 }, /* F1 */
+    { 0x0000ffbf, 12202 }, /* F2 */
+    { 0x0000ffc0, 12245 }, /* F3 */
+    { 0x0000ffc1, 12272 }, /* F4 */
+    { 0x0000ffc2, 12275 }, /* F5 */
+    { 0x0000ffc3, 12278 }, /* F6 */
+    { 0x0000ffc4, 12281 }, /* F7 */
+    { 0x0000ffc5, 12284 }, /* F8 */
+    { 0x0000ffc6, 12287 }, /* F9 */
+    { 0x0000ffc7, 12162 }, /* F10 */
+    { 0x0000ffc8, 12166 }, /* F11 */
+    { 0x0000ffc9, 12170 }, /* F12 */
+    { 0x0000ffca, 12174 }, /* F13 */
+    { 0x0000ffcb, 12178 }, /* F14 */
+    { 0x0000ffcc, 12182 }, /* F15 */
+    { 0x0000ffcd, 12186 }, /* F16 */
+    { 0x0000ffce, 12190 }, /* F17 */
+    { 0x0000ffcf, 12194 }, /* F18 */
+    { 0x0000ffd0, 12198 }, /* F19 */
+    { 0x0000ffd1, 12205 }, /* F20 */
+    { 0x0000ffd2, 12209 }, /* F21 */
+    { 0x0000ffd3, 12213 }, /* F22 */
+    { 0x0000ffd4, 12217 }, /* F23 */
+    { 0x0000ffd5, 12221 }, /* F24 */
+    { 0x0000ffd6, 12225 }, /* F25 */
+    { 0x0000ffd7, 12229 }, /* F26 */
+    { 0x0000ffd8, 12233 }, /* F27 */
+    { 0x0000ffd9, 12237 }, /* F28 */
+    { 0x0000ffda, 12241 }, /* F29 */
+    { 0x0000ffdb, 12248 }, /* F30 */
+    { 0x0000ffdc, 12252 }, /* F31 */
+    { 0x0000ffdd, 12256 }, /* F32 */
+    { 0x0000ffde, 12260 }, /* F33 */
+    { 0x0000ffdf, 12264 }, /* F34 */
+    { 0x0000ffe0, 12268 }, /* F35 */
+    { 0x0000ffe1, 22946 }, /* Shift_L */
+    { 0x0000ffe2, 22965 }, /* Shift_R */
+    { 0x0000ffe3, 8697 }, /* Control_L */
+    { 0x0000ffe4, 8707 }, /* Control_R */
+    { 0x0000ffe5, 8496 }, /* Caps_Lock */
+    { 0x0000ffe6, 22954 }, /* Shift_Lock */
+    { 0x0000ffe7, 19710 }, /* Meta_L */
+    { 0x0000ffe8, 19717 }, /* Meta_R */
+    { 0x0000ffe9, 880 }, /* Alt_L */
+    { 0x0000ffea, 886 }, /* Alt_R */
+    { 0x0000ffeb, 24263 }, /* Super_L */
+    { 0x0000ffec, 24271 }, /* Super_R */
+    { 0x0000ffed, 17046 }, /* Hyper_L */
+    { 0x0000ffee, 17054 }, /* Hyper_R */
+    { 0x0000fff1, 3642 }, /* braille_dot_1 */
+    { 0x0000fff2, 3671 }, /* braille_dot_2 */
+    { 0x0000fff3, 3685 }, /* braille_dot_3 */
+    { 0x0000fff4, 3699 }, /* braille_dot_4 */
+    { 0x0000fff5, 3713 }, /* braille_dot_5 */
+    { 0x0000fff6, 3727 }, /* braille_dot_6 */
+    { 0x0000fff7, 3741 }, /* braille_dot_7 */
+    { 0x0000fff8, 3755 }, /* braille_dot_8 */
+    { 0x0000fff9, 3769 }, /* braille_dot_9 */
+    { 0x0000fffa, 3656 }, /* braille_dot_10 */
+    { 0x0000ffff, 11160 }, /* Delete */
+    { 0x00ffffff, 26531 }, /* VoidSymbol */
+    { 0x0100012c, 17117 }, /* Ibreve */
+    { 0x0100012d, 17124 }, /* ibreve */
+    { 0x01000174, 26563 }, /* Wcircumflex */
+    { 0x01000175, 26575 }, /* wcircumflex */
+    { 0x01000176, 29010 }, /* Ycircumflex */
+    { 0x01000177, 29022 }, /* ycircumflex */
+    { 0x0100018f, 22649 }, /* SCHWA */
+    { 0x0100019f, 20218 }, /* Obarred */
+    { 0x010001a0, 20553 }, /* Ohorn */
+    { 0x010001a1, 20559 }, /* ohorn */
+    { 0x010001af, 25997 }, /* Uhorn */
+    { 0x010001b0, 26003 }, /* uhorn */
+    { 0x010001b5, 29212 }, /* Zstroke */
+    { 0x010001b6, 29220 }, /* zstroke */
+    { 0x010001b7, 12147 }, /* EZH */
+    { 0x010001d1, 20254 }, /* Ocaron */
+    { 0x010001d2, 20261 }, /* ocaron */
+    { 0x010001e6, 12703 }, /* Gcaron */
+    { 0x010001e7, 12710 }, /* gcaron */
+    { 0x01000259, 22655 }, /* schwa */
+    { 0x01000275, 20226 }, /* obarred */
+    { 0x01000292, 12151 }, /* ezh */
+    { 0x01000492, 9236 }, /* Cyrillic_GHE_bar */
+    { 0x01000493, 9253 }, /* Cyrillic_ghe_bar */
+    { 0x01000496, 10274 }, /* Cyrillic_ZHE_descender */
+    { 0x01000497, 10297 }, /* Cyrillic_zhe_descender */
+    { 0x0100049a, 9528 }, /* Cyrillic_KA_descender */
+    { 0x0100049b, 9550 }, /* Cyrillic_ka_descender */
+    { 0x0100049c, 9572 }, /* Cyrillic_KA_vertstroke */
+    { 0x0100049d, 9595 }, /* Cyrillic_ka_vertstroke */
+    { 0x010004a2, 9118 }, /* Cyrillic_EN_descender */
+    { 0x010004a3, 9140 }, /* Cyrillic_en_descender */
+    { 0x010004ae, 10036 }, /* Cyrillic_U_straight */
+    { 0x010004af, 10056 }, /* Cyrillic_u_straight */
+    { 0x010004b0, 10076 }, /* Cyrillic_U_straight_bar */
+    { 0x010004b1, 10100 }, /* Cyrillic_u_straight_bar */
+    { 0x010004b2, 9294 }, /* Cyrillic_HA_descender */
+    { 0x010004b3, 9316 }, /* Cyrillic_ha_descender */
+    { 0x010004b6, 8854 }, /* Cyrillic_CHE_descender */
+    { 0x010004b7, 8877 }, /* Cyrillic_che_descender */
+    { 0x010004b8, 8900 }, /* Cyrillic_CHE_vertstroke */
+    { 0x010004b9, 8924 }, /* Cyrillic_che_vertstroke */
+    { 0x010004ba, 9832 }, /* Cyrillic_SHHA */
+    { 0x010004bb, 9846 }, /* Cyrillic_shha */
+    { 0x010004d8, 9746 }, /* Cyrillic_SCHWA */
+    { 0x010004d9, 9761 }, /* Cyrillic_schwa */
+    { 0x010004e2, 9396 }, /* Cyrillic_I_macron */
+    { 0x010004e3, 9414 }, /* Cyrillic_i_macron */
+    { 0x010004e8, 9692 }, /* Cyrillic_O_bar */
+    { 0x010004e9, 9707 }, /* Cyrillic_o_bar */
+    { 0x010004ee, 10000 }, /* Cyrillic_U_macron */
+    { 0x010004ef, 10018 }, /* Cyrillic_u_macron */
+    { 0x01000531, 2124 }, /* Armenian_AYB */
+    { 0x01000532, 2150 }, /* Armenian_BEN */
+    { 0x01000533, 2374 }, /* Armenian_GIM */
+    { 0x01000534, 2215 }, /* Armenian_DA */
+    { 0x01000535, 3164 }, /* Armenian_YECH */
+    { 0x01000536, 3210 }, /* Armenian_ZA */
+    { 0x01000537, 2265 }, /* Armenian_E */
+    { 0x01000538, 2100 }, /* Armenian_AT */
+    { 0x01000539, 2964 }, /* Armenian_TO */
+    { 0x0100053a, 3234 }, /* Armenian_ZHE */
+    { 0x0100053b, 2464 }, /* Armenian_INI */
+    { 0x0100053c, 2611 }, /* Armenian_LYUN */
+    { 0x0100053d, 2564 }, /* Armenian_KHE */
+    { 0x0100053e, 2988 }, /* Armenian_TSA */
+    { 0x0100053f, 2538 }, /* Armenian_KEN */
+    { 0x01000540, 2424 }, /* Armenian_HO */
+    { 0x01000541, 2239 }, /* Armenian_DZA */
+    { 0x01000542, 2346 }, /* Armenian_GHAT */
+    { 0x01000543, 2936 }, /* Armenian_TCHE */
+    { 0x01000544, 2639 }, /* Armenian_MEN */
+    { 0x01000545, 2400 }, /* Armenian_HI */
+    { 0x01000546, 2665 }, /* Armenian_NU */
+    { 0x01000547, 2894 }, /* Armenian_SHA */
+    { 0x01000548, 3112 }, /* Armenian_VO */
+    { 0x01000549, 2189 }, /* Armenian_CHA */
+    { 0x0100054a, 2727 }, /* Armenian_PE */
+    { 0x0100054b, 2490 }, /* Armenian_JE */
+    { 0x0100054c, 2797 }, /* Armenian_RA */
+    { 0x0100054d, 2845 }, /* Armenian_SE */
+    { 0x0100054e, 3086 }, /* Armenian_VEV */
+    { 0x0100054f, 3040 }, /* Armenian_TYUN */
+    { 0x01000550, 2821 }, /* Armenian_RE */
+    { 0x01000551, 3014 }, /* Armenian_TSO */
+    { 0x01000552, 3136 }, /* Armenian_VYUN */
+    { 0x01000553, 2751 }, /* Armenian_PYUR */
+    { 0x01000554, 2514 }, /* Armenian_KE */
+    { 0x01000555, 2689 }, /* Armenian_O */
+    { 0x01000556, 2303 }, /* Armenian_FE */
+    { 0x0100055a, 2080 }, /* Armenian_apostrophe */
+    { 0x0100055b, 2048 }, /* Armenian_accent */
+    { 0x0100055c, 2287 }, /* Armenian_exclam */
+    { 0x0100055d, 2869 }, /* Armenian_separation_mark */
+    { 0x0100055e, 2779 }, /* Armenian_question */
+    { 0x01000561, 2137 }, /* Armenian_ayb */
+    { 0x01000562, 2163 }, /* Armenian_ben */
+    { 0x01000563, 2387 }, /* Armenian_gim */
+    { 0x01000564, 2227 }, /* Armenian_da */
+    { 0x01000565, 3178 }, /* Armenian_yech */
+    { 0x01000566, 3222 }, /* Armenian_za */
+    { 0x01000567, 2276 }, /* Armenian_e */
+    { 0x01000568, 2112 }, /* Armenian_at */
+    { 0x01000569, 2976 }, /* Armenian_to */
+    { 0x0100056a, 3247 }, /* Armenian_zhe */
+    { 0x0100056b, 2477 }, /* Armenian_ini */
+    { 0x0100056c, 2625 }, /* Armenian_lyun */
+    { 0x0100056d, 2577 }, /* Armenian_khe */
+    { 0x0100056e, 3001 }, /* Armenian_tsa */
+    { 0x0100056f, 2551 }, /* Armenian_ken */
+    { 0x01000570, 2436 }, /* Armenian_ho */
+    { 0x01000571, 2252 }, /* Armenian_dza */
+    { 0x01000572, 2360 }, /* Armenian_ghat */
+    { 0x01000573, 2950 }, /* Armenian_tche */
+    { 0x01000574, 2652 }, /* Armenian_men */
+    { 0x01000575, 2412 }, /* Armenian_hi */
+    { 0x01000576, 2677 }, /* Armenian_nu */
+    { 0x01000577, 2907 }, /* Armenian_sha */
+    { 0x01000578, 3124 }, /* Armenian_vo */
+    { 0x01000579, 2202 }, /* Armenian_cha */
+    { 0x0100057a, 2739 }, /* Armenian_pe */
+    { 0x0100057b, 2502 }, /* Armenian_je */
+    { 0x0100057c, 2809 }, /* Armenian_ra */
+    { 0x0100057d, 2857 }, /* Armenian_se */
+    { 0x0100057e, 3099 }, /* Armenian_vev */
+    { 0x0100057f, 3054 }, /* Armenian_tyun */
+    { 0x01000580, 2833 }, /* Armenian_re */
+    { 0x01000581, 3027 }, /* Armenian_tso */
+    { 0x01000582, 3150 }, /* Armenian_vyun */
+    { 0x01000583, 2765 }, /* Armenian_pyur */
+    { 0x01000584, 2526 }, /* Armenian_ke */
+    { 0x01000585, 2700 }, /* Armenian_o */
+    { 0x01000586, 2315 }, /* Armenian_fe */
+    { 0x01000587, 2590 }, /* Armenian_ligature_ew */
+    { 0x01000589, 2327 }, /* Armenian_full_stop */
+    { 0x0100058a, 2448 }, /* Armenian_hyphen */
+    { 0x01000653, 1580 }, /* Arabic_madda_above */
+    { 0x01000654, 1316 }, /* Arabic_hamza_above */
+    { 0x01000655, 1335 }, /* Arabic_hamza_below */
+    { 0x01000660, 966 }, /* Arabic_0 */
+    { 0x01000661, 975 }, /* Arabic_1 */
+    { 0x01000662, 984 }, /* Arabic_2 */
+    { 0x01000663, 993 }, /* Arabic_3 */
+    { 0x01000664, 1002 }, /* Arabic_4 */
+    { 0x01000665, 1011 }, /* Arabic_5 */
+    { 0x01000666, 1020 }, /* Arabic_6 */
+    { 0x01000667, 1029 }, /* Arabic_7 */
+    { 0x01000668, 1038 }, /* Arabic_8 */
+    { 0x01000669, 1047 }, /* Arabic_9 */
+    { 0x0100066a, 1672 }, /* Arabic_percent */
+    { 0x01000670, 1821 }, /* Arabic_superscript_alef */
+    { 0x01000679, 1951 }, /* Arabic_tteh */
+    { 0x0100067e, 1661 }, /* Arabic_peh */
+    { 0x01000686, 1885 }, /* Arabic_tcheh */
+    { 0x01000688, 1173 }, /* Arabic_ddal */
+    { 0x01000691, 1729 }, /* Arabic_rreh */
+    { 0x01000698, 1493 }, /* Arabic_jeh */
+    { 0x010006a4, 1963 }, /* Arabic_veh */
+    { 0x010006a9, 1544 }, /* Arabic_keheh */
+    { 0x010006af, 1258 }, /* Arabic_gaf */
+    { 0x010006ba, 1642 }, /* Arabic_noon_ghunna */
+    { 0x010006be, 1442 }, /* Arabic_heh_doachashmee */
+    { 0x010006c1, 1465 }, /* Arabic_heh_goal */
+    { 0x010006cc, 12390 }, /* Farsi_yeh */
+    { 0x010006d2, 1996 }, /* Arabic_yeh_baree */
+    { 0x010006d4, 1242 }, /* Arabic_fullstop */
+    { 0x010006f0, 12310 }, /* Farsi_0 */
+    { 0x010006f1, 12318 }, /* Farsi_1 */
+    { 0x010006f2, 12326 }, /* Farsi_2 */
+    { 0x010006f3, 12334 }, /* Farsi_3 */
+    { 0x010006f4, 12342 }, /* Farsi_4 */
+    { 0x010006f5, 12350 }, /* Farsi_5 */
+    { 0x010006f6, 12358 }, /* Farsi_6 */
+    { 0x010006f7, 12366 }, /* Farsi_7 */
+    { 0x010006f8, 12374 }, /* Farsi_8 */
+    { 0x010006f9, 12382 }, /* Farsi_9 */
+    { 0x01000d82, 23484 }, /* Sinh_ng */
+    { 0x01000d83, 23278 }, /* Sinh_h2 */
+    { 0x01000d85, 23047 }, /* Sinh_a */
+    { 0x01000d86, 23054 }, /* Sinh_aa */
+    { 0x01000d87, 23071 }, /* Sinh_ae */
+    { 0x01000d88, 23088 }, /* Sinh_aee */
+    { 0x01000d89, 23294 }, /* Sinh_i */
+    { 0x01000d8a, 23309 }, /* Sinh_ii */
+    { 0x01000d8b, 23695 }, /* Sinh_u */
+    { 0x01000d8c, 23710 }, /* Sinh_uu */
+    { 0x01000d8d, 23594 }, /* Sinh_ri */
+    { 0x01000d8e, 23602 }, /* Sinh_rii */
+    { 0x01000d8f, 23403 }, /* Sinh_lu */
+    { 0x01000d90, 23420 }, /* Sinh_luu */
+    { 0x01000d91, 23221 }, /* Sinh_e */
+    { 0x01000d92, 23236 }, /* Sinh_ee */
+    { 0x01000d93, 23107 }, /* Sinh_ai */
+    { 0x01000d94, 23537 }, /* Sinh_o */
+    { 0x01000d95, 23552 }, /* Sinh_oo */
+    { 0x01000d96, 23132 }, /* Sinh_au */
+    { 0x01000d9a, 23353 }, /* Sinh_ka */
+    { 0x01000d9b, 23361 }, /* Sinh_kha */
+    { 0x01000d9c, 23261 }, /* Sinh_ga */
+    { 0x01000d9d, 23269 }, /* Sinh_gha */
+    { 0x01000d9e, 23492 }, /* Sinh_ng2 */
+    { 0x01000d9f, 23501 }, /* Sinh_nga */
+    { 0x01000da0, 23166 }, /* Sinh_ca */
+    { 0x01000da1, 23174 }, /* Sinh_cha */
+    { 0x01000da2, 23326 }, /* Sinh_ja */
+    { 0x01000da3, 23334 }, /* Sinh_jha */
+    { 0x01000da4, 23528 }, /* Sinh_nya */
+    { 0x01000da5, 23343 }, /* Sinh_jnya */
+    { 0x01000da6, 23510 }, /* Sinh_nja */
+    { 0x01000da7, 23676 }, /* Sinh_tta */
+    { 0x01000da8, 23685 }, /* Sinh_ttha */
+    { 0x01000da9, 23183 }, /* Sinh_dda */
+    { 0x01000daa, 23192 }, /* Sinh_ddha */
+    { 0x01000dab, 23519 }, /* Sinh_nna */
+    { 0x01000dac, 23464 }, /* Sinh_ndda */
+    { 0x01000dad, 23657 }, /* Sinh_tha */
+    { 0x01000dae, 23666 }, /* Sinh_thha */
+    { 0x01000daf, 23202 }, /* Sinh_dha */
+    { 0x01000db0, 23211 }, /* Sinh_dhha */
+    { 0x01000db1, 23456 }, /* Sinh_na */
+    { 0x01000db3, 23474 }, /* Sinh_ndha */
+    { 0x01000db4, 23569 }, /* Sinh_pa */
+    { 0x01000db5, 23577 }, /* Sinh_pha */
+    { 0x01000db6, 23149 }, /* Sinh_ba */
+    { 0x01000db7, 23157 }, /* Sinh_bha */
+    { 0x01000db8, 23439 }, /* Sinh_ma */
+    { 0x01000db9, 23447 }, /* Sinh_mba */
+    { 0x01000dba, 23735 }, /* Sinh_ya */
+    { 0x01000dbb, 23586 }, /* Sinh_ra */
+    { 0x01000dbd, 23386 }, /* Sinh_la */
+    { 0x01000dc0, 23727 }, /* Sinh_va */
+    { 0x01000dc1, 23638 }, /* Sinh_sha */
+    { 0x01000dc2, 23647 }, /* Sinh_ssha */
+    { 0x01000dc3, 23630 }, /* Sinh_sa */
+    { 0x01000dc4, 23286 }, /* Sinh_ha */
+    { 0x01000dc5, 23394 }, /* Sinh_lla */
+    { 0x01000dc6, 23253 }, /* Sinh_fa */
+    { 0x01000dca, 23124 }, /* Sinh_al */
+    { 0x01000dcf, 23062 }, /* Sinh_aa2 */
+    { 0x01000dd0, 23079 }, /* Sinh_ae2 */
+    { 0x01000dd1, 23097 }, /* Sinh_aee2 */
+    { 0x01000dd2, 23301 }, /* Sinh_i2 */
+    { 0x01000dd3, 23317 }, /* Sinh_ii2 */
+    { 0x01000dd4, 23702 }, /* Sinh_u2 */
+    { 0x01000dd6, 23718 }, /* Sinh_uu2 */
+    { 0x01000dd8, 23611 }, /* Sinh_ru2 */
+    { 0x01000dd9, 23228 }, /* Sinh_e2 */
+    { 0x01000dda, 23244 }, /* Sinh_ee2 */
+    { 0x01000ddb, 23115 }, /* Sinh_ai2 */
+    { 0x01000ddc, 23544 }, /* Sinh_o2 */
+    { 0x01000ddd, 23560 }, /* Sinh_oo2 */
+    { 0x01000dde, 23140 }, /* Sinh_au2 */
+    { 0x01000ddf, 23411 }, /* Sinh_lu2 */
+    { 0x01000df2, 23620 }, /* Sinh_ruu2 */
+    { 0x01000df3, 23429 }, /* Sinh_luu2 */
+    { 0x01000df4, 23370 }, /* Sinh_kunddaliya */
+    { 0x010010d0, 12759 }, /* Georgian_an */
+    { 0x010010d1, 12771 }, /* Georgian_ban */
+    { 0x010010d2, 12875 }, /* Georgian_gan */
+    { 0x010010d3, 12838 }, /* Georgian_don */
+    { 0x010010d4, 12851 }, /* Georgian_en */
+    { 0x010010d5, 13201 }, /* Georgian_vin */
+    { 0x010010d6, 13239 }, /* Georgian_zen */
+    { 0x010010d7, 13163 }, /* Georgian_tan */
+    { 0x010010d8, 12966 }, /* Georgian_in */
+    { 0x010010d9, 13005 }, /* Georgian_kan */
+    { 0x010010da, 13032 }, /* Georgian_las */
+    { 0x010010db, 13045 }, /* Georgian_man */
+    { 0x010010dc, 13058 }, /* Georgian_nar */
+    { 0x010010dd, 13071 }, /* Georgian_on */
+    { 0x010010de, 13083 }, /* Georgian_par */
+    { 0x010010df, 13252 }, /* Georgian_zhar */
+    { 0x010010e0, 13123 }, /* Georgian_rae */
+    { 0x010010e1, 13136 }, /* Georgian_san */
+    { 0x010010e2, 13176 }, /* Georgian_tar */
+    { 0x010010e3, 13189 }, /* Georgian_un */
+    { 0x010010e4, 13096 }, /* Georgian_phar */
+    { 0x010010e5, 13018 }, /* Georgian_khar */
+    { 0x010010e6, 12888 }, /* Georgian_ghan */
+    { 0x010010e7, 13110 }, /* Georgian_qar */
+    { 0x010010e8, 13149 }, /* Georgian_shin */
+    { 0x010010e9, 12811 }, /* Georgian_chin */
+    { 0x010010ea, 12784 }, /* Georgian_can */
+    { 0x010010eb, 12992 }, /* Georgian_jil */
+    { 0x010010ec, 12825 }, /* Georgian_cil */
+    { 0x010010ed, 12797 }, /* Georgian_char */
+    { 0x010010ee, 13226 }, /* Georgian_xan */
+    { 0x010010ef, 12978 }, /* Georgian_jhan */
+    { 0x010010f0, 12902 }, /* Georgian_hae */
+    { 0x010010f1, 12928 }, /* Georgian_he */
+    { 0x010010f2, 12940 }, /* Georgian_hie */
+    { 0x010010f3, 13214 }, /* Georgian_we */
+    { 0x010010f4, 12915 }, /* Georgian_har */
+    { 0x010010f5, 12953 }, /* Georgian_hoe */
+    { 0x010010f6, 12863 }, /* Georgian_fi */
+    { 0x01001e02, 3332 }, /* Babovedot */
+    { 0x01001e03, 3342 }, /* babovedot */
+    { 0x01001e0a, 10324 }, /* Dabovedot */
+    { 0x01001e0b, 10334 }, /* dabovedot */
+    { 0x01001e1e, 12290 }, /* Fabovedot */
+    { 0x01001e1f, 12300 }, /* fabovedot */
+    { 0x01001e36, 19192 }, /* Lbelowdot */
+    { 0x01001e37, 19202 }, /* lbelowdot */
+    { 0x01001e40, 19537 }, /* Mabovedot */
+    { 0x01001e41, 19547 }, /* mabovedot */
+    { 0x01001e56, 21377 }, /* Pabovedot */
+    { 0x01001e57, 21387 }, /* pabovedot */
+    { 0x01001e60, 22583 }, /* Sabovedot */
+    { 0x01001e61, 22593 }, /* sabovedot */
+    { 0x01001e6a, 24302 }, /* Tabovedot */
+    { 0x01001e6b, 24312 }, /* tabovedot */
+    { 0x01001e80, 26609 }, /* Wgrave */
+    { 0x01001e81, 26616 }, /* wgrave */
+    { 0x01001e82, 26549 }, /* Wacute */
+    { 0x01001e83, 26556 }, /* wacute */
+    { 0x01001e84, 26587 }, /* Wdiaeresis */
+    { 0x01001e85, 26598 }, /* wdiaeresis */
+    { 0x01001e8a, 26635 }, /* Xabovedot */
+    { 0x01001e8b, 26645 }, /* xabovedot */
+    { 0x01001ea0, 416 }, /* Abelowdot */
+    { 0x01001ea1, 426 }, /* abelowdot */
+    { 0x01001ea2, 868 }, /* Ahook */
+    { 0x01001ea3, 874 }, /* ahook */
+    { 0x01001ea4, 646 }, /* Acircumflexacute */
+    { 0x01001ea5, 663 }, /* acircumflexacute */
+    { 0x01001ea6, 720 }, /* Acircumflexgrave */
+    { 0x01001ea7, 737 }, /* acircumflexgrave */
+    { 0x01001ea8, 754 }, /* Acircumflexhook */
+    { 0x01001ea9, 770 }, /* acircumflexhook */
+    { 0x01001eaa, 786 }, /* Acircumflextilde */
+    { 0x01001eab, 803 }, /* acircumflextilde */
+    { 0x01001eac, 680 }, /* Acircumflexbelowdot */
+    { 0x01001ead, 700 }, /* acircumflexbelowdot */
+    { 0x01001eae, 459 }, /* Abreveacute */
+    { 0x01001eaf, 471 }, /* abreveacute */
+    { 0x01001eb0, 513 }, /* Abrevegrave */
+    { 0x01001eb1, 525 }, /* abrevegrave */
+    { 0x01001eb2, 537 }, /* Abrevehook */
+    { 0x01001eb3, 548 }, /* abrevehook */
+    { 0x01001eb4, 559 }, /* Abrevetilde */
+    { 0x01001eb5, 571 }, /* abrevetilde */
+    { 0x01001eb6, 483 }, /* Abrevebelowdot */
+    { 0x01001eb7, 498 }, /* abrevebelowdot */
+    { 0x01001eb8, 11462 }, /* Ebelowdot */
+    { 0x01001eb9, 11472 }, /* ebelowdot */
+    { 0x01001eba, 11738 }, /* Ehook */
+    { 0x01001ebb, 11744 }, /* ehook */
+    { 0x01001ebc, 12076 }, /* Etilde */
+    { 0x01001ebd, 12083 }, /* etilde */
+    { 0x01001ebe, 11520 }, /* Ecircumflexacute */
+    { 0x01001ebf, 11537 }, /* ecircumflexacute */
+    { 0x01001ec0, 11594 }, /* Ecircumflexgrave */
+    { 0x01001ec1, 11611 }, /* ecircumflexgrave */
+    { 0x01001ec2, 11628 }, /* Ecircumflexhook */
+    { 0x01001ec3, 11644 }, /* ecircumflexhook */
+    { 0x01001ec4, 11660 }, /* Ecircumflextilde */
+    { 0x01001ec5, 11677 }, /* ecircumflextilde */
+    { 0x01001ec6, 11554 }, /* Ecircumflexbelowdot */
+    { 0x01001ec7, 11574 }, /* ecircumflexbelowdot */
+    { 0x01001ec8, 17219 }, /* Ihook */
+    { 0x01001ec9, 17225 }, /* ihook */
+    { 0x01001eca, 17097 }, /* Ibelowdot */
+    { 0x01001ecb, 17107 }, /* ibelowdot */
+    { 0x01001ecc, 20234 }, /* Obelowdot */
+    { 0x01001ecd, 20244 }, /* obelowdot */
+    { 0x01001ece, 20541 }, /* Ohook */
+    { 0x01001ecf, 20547 }, /* ohook */
+    { 0x01001ed0, 20292 }, /* Ocircumflexacute */
+    { 0x01001ed1, 20309 }, /* ocircumflexacute */
+    { 0x01001ed2, 20366 }, /* Ocircumflexgrave */
+    { 0x01001ed3, 20383 }, /* ocircumflexgrave */
+    { 0x01001ed4, 20400 }, /* Ocircumflexhook */
+    { 0x01001ed5, 20416 }, /* ocircumflexhook */
+    { 0x01001ed6, 20432 }, /* Ocircumflextilde */
+    { 0x01001ed7, 20449 }, /* ocircumflextilde */
+    { 0x01001ed8, 20326 }, /* Ocircumflexbelowdot */
+    { 0x01001ed9, 20346 }, /* ocircumflexbelowdot */
+    { 0x01001eda, 20565 }, /* Ohornacute */
+    { 0x01001edb, 20576 }, /* ohornacute */
+    { 0x01001edc, 20615 }, /* Ohorngrave */
+    { 0x01001edd, 20626 }, /* ohorngrave */
+    { 0x01001ede, 20637 }, /* Ohornhook */
+    { 0x01001edf, 20647 }, /* ohornhook */
+    { 0x01001ee0, 20657 }, /* Ohorntilde */
+    { 0x01001ee1, 20668 }, /* ohorntilde */
+    { 0x01001ee2, 20587 }, /* Ohornbelowdot */
+    { 0x01001ee3, 20601 }, /* ohornbelowdot */
+    { 0x01001ee4, 25865 }, /* Ubelowdot */
+    { 0x01001ee5, 25875 }, /* ubelowdot */
+    { 0x01001ee6, 25985 }, /* Uhook */
+    { 0x01001ee7, 25991 }, /* uhook */
+    { 0x01001ee8, 26009 }, /* Uhornacute */
+    { 0x01001ee9, 26020 }, /* uhornacute */
+    { 0x01001eea, 26059 }, /* Uhorngrave */
+    { 0x01001eeb, 26070 }, /* uhorngrave */
+    { 0x01001eec, 26081 }, /* Uhornhook */
+    { 0x01001eed, 26091 }, /* uhornhook */
+    { 0x01001eee, 26101 }, /* Uhorntilde */
+    { 0x01001eef, 26112 }, /* uhorntilde */
+    { 0x01001ef0, 26031 }, /* Uhornbelowdot */
+    { 0x01001ef1, 26045 }, /* uhornbelowdot */
+    { 0x01001ef2, 29060 }, /* Ygrave */
+    { 0x01001ef3, 29067 }, /* ygrave */
+    { 0x01001ef4, 28990 }, /* Ybelowdot */
+    { 0x01001ef5, 29000 }, /* ybelowdot */
+    { 0x01001ef6, 29074 }, /* Yhook */
+    { 0x01001ef7, 29080 }, /* yhook */
+    { 0x01001ef8, 29086 }, /* Ytilde */
+    { 0x01001ef9, 29093 }, /* ytilde */
+    { 0x01002070, 29199 }, /* zerosuperior */
+    { 0x01002074, 12632 }, /* foursuperior */
+    { 0x01002075, 12594 }, /* fivesuperior */
+    { 0x01002076, 23756 }, /* sixsuperior */
+    { 0x01002077, 22932 }, /* sevensuperior */
+    { 0x01002078, 11765 }, /* eightsuperior */
+    { 0x01002079, 20062 }, /* ninesuperior */
+    { 0x01002080, 29185 }, /* zerosubscript */
+    { 0x01002081, 20742 }, /* onesubscript */
+    { 0x01002082, 25812 }, /* twosubscript */
+    { 0x01002083, 25556 }, /* threesubscript */
+    { 0x01002084, 12618 }, /* foursubscript */
+    { 0x01002085, 12580 }, /* fivesubscript */
+    { 0x01002086, 23743 }, /* sixsubscript */
+    { 0x01002087, 22917 }, /* sevensubscript */
+    { 0x01002088, 11750 }, /* eightsubscript */
+    { 0x01002089, 20048 }, /* ninesubscript */
+    { 0x010020a0, 11694 }, /* EcuSign */
+    { 0x010020a1, 8670 }, /* ColonSign */
+    { 0x010020a2, 8744 }, /* CruzeiroSign */
+    { 0x010020a3, 12416 }, /* FFrancSign */
+    { 0x010020a4, 19448 }, /* LiraSign */
+    { 0x010020a5, 19724 }, /* MillSign */
+    { 0x010020a6, 19967 }, /* NairaSign */
+    { 0x010020a7, 21526 }, /* PesetaSign */
+    { 0x010020a8, 22569 }, /* RupeeSign */
+    { 0x010020a9, 26623 }, /* WonSign */
+    { 0x010020aa, 20009 }, /* NewSheqelSign */
+    { 0x010020ab, 11258 }, /* DongSign */
+    { 0x01002202, 21446 }, /* partdifferential */
+    { 0x01002205, 11919 }, /* emptyset */
+    { 0x01002208, 11802 }, /* elementof */
+    { 0x01002209, 20112 }, /* notelementof */
+    { 0x0100220b, 8686 }, /* containsas */
+    { 0x0100221a, 23809 }, /* squareroot */
+    { 0x0100221b, 8757 }, /* cuberoot */
+    { 0x0100221c, 12645 }, /* fourthroot */
+    { 0x0100222c, 11232 }, /* dintegral */
+    { 0x0100222d, 25585 }, /* tintegral */
+    { 0x01002235, 3396 }, /* because */
+    { 0x01002247, 20100 }, /* notapproxeq */
+    { 0x01002248, 945 }, /* approxeq */
+    { 0x01002262, 20134 }, /* notidentical */
+    { 0x01002263, 23854 }, /* stricteq */
+    { 0x01002800, 3628 }, /* braille_blank */
+    { 0x01002801, 3783 }, /* braille_dots_1 */
+    { 0x01002802, 6151 }, /* braille_dots_2 */
+    { 0x01002803, 3798 }, /* braille_dots_12 */
+    { 0x01002804, 7303 }, /* braille_dots_3 */
+    { 0x01002805, 5014 }, /* braille_dots_13 */
+    { 0x01002806, 6166 }, /* braille_dots_23 */
+    { 0x01002807, 3814 }, /* braille_dots_123 */
+    { 0x01002808, 7863 }, /* braille_dots_4 */
+    { 0x01002809, 5606 }, /* braille_dots_14 */
+    { 0x0100280a, 6758 }, /* braille_dots_24 */
+    { 0x0100280b, 4438 }, /* braille_dots_124 */
+    { 0x0100280c, 7318 }, /* braille_dots_34 */
+    { 0x0100280d, 5030 }, /* braille_dots_134 */
+    { 0x0100280e, 6182 }, /* braille_dots_234 */
+    { 0x0100280f, 3831 }, /* braille_dots_1234 */
+    { 0x01002810, 8135 }, /* braille_dots_5 */
+    { 0x01002811, 5894 }, /* braille_dots_15 */
+    { 0x01002812, 7046 }, /* braille_dots_25 */
+    { 0x01002813, 4742 }, /* braille_dots_125 */
+    { 0x01002814, 7606 }, /* braille_dots_35 */
+    { 0x01002815, 5334 }, /* braille_dots_135 */
+    { 0x01002816, 6486 }, /* braille_dots_235 */
+    { 0x01002817, 4151 }, /* braille_dots_1235 */
+    { 0x01002818, 7878 }, /* braille_dots_45 */
+    { 0x01002819, 5622 }, /* braille_dots_145 */
+    { 0x0100281a, 6774 }, /* braille_dots_245 */
+    { 0x0100281b, 4455 }, /* braille_dots_1245 */
+    { 0x0100281c, 7334 }, /* braille_dots_345 */
+    { 0x0100281d, 5047 }, /* braille_dots_1345 */
+    { 0x0100281e, 6199 }, /* braille_dots_2345 */
+    { 0x0100281f, 3849 }, /* braille_dots_12345 */
+    { 0x01002820, 8267 }, /* braille_dots_6 */
+    { 0x01002821, 6034 }, /* braille_dots_16 */
+    { 0x01002822, 7186 }, /* braille_dots_26 */
+    { 0x01002823, 4890 }, /* braille_dots_126 */
+    { 0x01002824, 7746 }, /* braille_dots_36 */
+    { 0x01002825, 5482 }, /* braille_dots_136 */
+    { 0x01002826, 6634 }, /* braille_dots_236 */
+    { 0x01002827, 4307 }, /* braille_dots_1236 */
+    { 0x01002828, 8018 }, /* braille_dots_46 */
+    { 0x01002829, 5770 }, /* braille_dots_146 */
+    { 0x0100282a, 6922 }, /* braille_dots_246 */
+    { 0x0100282b, 4611 }, /* braille_dots_1246 */
+    { 0x0100282c, 7482 }, /* braille_dots_346 */
+    { 0x0100282d, 5203 }, /* braille_dots_1346 */
+    { 0x0100282e, 6355 }, /* braille_dots_2346 */
+    { 0x0100282f, 4013 }, /* braille_dots_12346 */
+    { 0x01002830, 8150 }, /* braille_dots_56 */
+    { 0x01002831, 5910 }, /* braille_dots_156 */
+    { 0x01002832, 7062 }, /* braille_dots_256 */
+    { 0x01002833, 4759 }, /* braille_dots_1256 */
+    { 0x01002834, 7622 }, /* braille_dots_356 */
+    { 0x01002835, 5351 }, /* braille_dots_1356 */
+    { 0x01002836, 6503 }, /* braille_dots_2356 */
+    { 0x01002837, 4169 }, /* braille_dots_12356 */
+    { 0x01002838, 7894 }, /* braille_dots_456 */
+    { 0x01002839, 5639 }, /* braille_dots_1456 */
+    { 0x0100283a, 6791 }, /* braille_dots_2456 */
+    { 0x0100283b, 4473 }, /* braille_dots_12456 */
+    { 0x0100283c, 7351 }, /* braille_dots_3456 */
+    { 0x0100283d, 5065 }, /* braille_dots_13456 */
+    { 0x0100283e, 6217 }, /* braille_dots_23456 */
+    { 0x0100283f, 3868 }, /* braille_dots_123456 */
+    { 0x01002840, 8331 }, /* braille_dots_7 */
+    { 0x01002841, 6102 }, /* braille_dots_17 */
+    { 0x01002842, 7254 }, /* braille_dots_27 */
+    { 0x01002843, 4962 }, /* braille_dots_127 */
+    { 0x01002844, 7814 }, /* braille_dots_37 */
+    { 0x01002845, 5554 }, /* braille_dots_137 */
+    { 0x01002846, 6706 }, /* braille_dots_237 */
+    { 0x01002847, 4383 }, /* braille_dots_1237 */
+    { 0x01002848, 8086 }, /* braille_dots_47 */
+    { 0x01002849, 5842 }, /* braille_dots_147 */
+    { 0x0100284a, 6994 }, /* braille_dots_247 */
+    { 0x0100284b, 4687 }, /* braille_dots_1247 */
+    { 0x0100284c, 7554 }, /* braille_dots_347 */
+    { 0x0100284d, 5279 }, /* braille_dots_1347 */
+    { 0x0100284e, 6431 }, /* braille_dots_2347 */
+    { 0x0100284f, 4093 }, /* braille_dots_12347 */
+    { 0x01002850, 8218 }, /* braille_dots_57 */
+    { 0x01002851, 5982 }, /* braille_dots_157 */
+    { 0x01002852, 7134 }, /* braille_dots_257 */
+    { 0x01002853, 4835 }, /* braille_dots_1257 */
+    { 0x01002854, 7694 }, /* braille_dots_357 */
+    { 0x01002855, 5427 }, /* braille_dots_1357 */
+    { 0x01002856, 6579 }, /* braille_dots_2357 */
+    { 0x01002857, 4249 }, /* braille_dots_12357 */
+    { 0x01002858, 7966 }, /* braille_dots_457 */
+    { 0x01002859, 5715 }, /* braille_dots_1457 */
+    { 0x0100285a, 6867 }, /* braille_dots_2457 */
+    { 0x0100285b, 4553 }, /* braille_dots_12457 */
+    { 0x0100285c, 7427 }, /* braille_dots_3457 */
+    { 0x0100285d, 5145 }, /* braille_dots_13457 */
+    { 0x0100285e, 6297 }, /* braille_dots_23457 */
+    { 0x0100285f, 3952 }, /* braille_dots_123457 */
+    { 0x01002860, 8282 }, /* braille_dots_67 */
+    { 0x01002861, 6050 }, /* braille_dots_167 */
+    { 0x01002862, 7202 }, /* braille_dots_267 */
+    { 0x01002863, 4907 }, /* braille_dots_1267 */
+    { 0x01002864, 7762 }, /* braille_dots_367 */
+    { 0x01002865, 5499 }, /* braille_dots_1367 */
+    { 0x01002866, 6651 }, /* braille_dots_2367 */
+    { 0x01002867, 4325 }, /* braille_dots_12367 */
+    { 0x01002868, 8034 }, /* braille_dots_467 */
+    { 0x01002869, 5787 }, /* braille_dots_1467 */
+    { 0x0100286a, 6939 }, /* braille_dots_2467 */
+    { 0x0100286b, 4629 }, /* braille_dots_12467 */
+    { 0x0100286c, 7499 }, /* braille_dots_3467 */
+    { 0x0100286d, 5221 }, /* braille_dots_13467 */
+    { 0x0100286e, 6373 }, /* braille_dots_23467 */
+    { 0x0100286f, 4032 }, /* braille_dots_123467 */
+    { 0x01002870, 8166 }, /* braille_dots_567 */
+    { 0x01002871, 5927 }, /* braille_dots_1567 */
+    { 0x01002872, 7079 }, /* braille_dots_2567 */
+    { 0x01002873, 4777 }, /* braille_dots_12567 */
+    { 0x01002874, 7639 }, /* braille_dots_3567 */
+    { 0x01002875, 5369 }, /* braille_dots_13567 */
+    { 0x01002876, 6521 }, /* braille_dots_23567 */
+    { 0x01002877, 4188 }, /* braille_dots_123567 */
+    { 0x01002878, 7911 }, /* braille_dots_4567 */
+    { 0x01002879, 5657 }, /* braille_dots_14567 */
+    { 0x0100287a, 6809 }, /* braille_dots_24567 */
+    { 0x0100287b, 4492 }, /* braille_dots_124567 */
+    { 0x0100287c, 7369 }, /* braille_dots_34567 */
+    { 0x0100287d, 5084 }, /* braille_dots_134567 */
+    { 0x0100287e, 6236 }, /* braille_dots_234567 */
+    { 0x0100287f, 3888 }, /* braille_dots_1234567 */
+    { 0x01002880, 8362 }, /* braille_dots_8 */
+    { 0x01002881, 6135 }, /* braille_dots_18 */
+    { 0x01002882, 7287 }, /* braille_dots_28 */
+    { 0x01002883, 4997 }, /* braille_dots_128 */
+    { 0x01002884, 7847 }, /* braille_dots_38 */
+    { 0x01002885, 5589 }, /* braille_dots_138 */
+    { 0x01002886, 6741 }, /* braille_dots_238 */
+    { 0x01002887, 4420 }, /* braille_dots_1238 */
+    { 0x01002888, 8119 }, /* braille_dots_48 */
+    { 0x01002889, 5877 }, /* braille_dots_148 */
+    { 0x0100288a, 7029 }, /* braille_dots_248 */
+    { 0x0100288b, 4724 }, /* braille_dots_1248 */
+    { 0x0100288c, 7589 }, /* braille_dots_348 */
+    { 0x0100288d, 5316 }, /* braille_dots_1348 */
+    { 0x0100288e, 6468 }, /* braille_dots_2348 */
+    { 0x0100288f, 4132 }, /* braille_dots_12348 */
+    { 0x01002890, 8251 }, /* braille_dots_58 */
+    { 0x01002891, 6017 }, /* braille_dots_158 */
+    { 0x01002892, 7169 }, /* braille_dots_258 */
+    { 0x01002893, 4872 }, /* braille_dots_1258 */
+    { 0x01002894, 7729 }, /* braille_dots_358 */
+    { 0x01002895, 5464 }, /* braille_dots_1358 */
+    { 0x01002896, 6616 }, /* braille_dots_2358 */
+    { 0x01002897, 4288 }, /* braille_dots_12358 */
+    { 0x01002898, 8001 }, /* braille_dots_458 */
+    { 0x01002899, 5752 }, /* braille_dots_1458 */
+    { 0x0100289a, 6904 }, /* braille_dots_2458 */
+    { 0x0100289b, 4592 }, /* braille_dots_12458 */
+    { 0x0100289c, 7464 }, /* braille_dots_3458 */
+    { 0x0100289d, 5184 }, /* braille_dots_13458 */
+    { 0x0100289e, 6336 }, /* braille_dots_23458 */
+    { 0x0100289f, 3993 }, /* braille_dots_123458 */
+    { 0x010028a0, 8315 }, /* braille_dots_68 */
+    { 0x010028a1, 6085 }, /* braille_dots_168 */
+    { 0x010028a2, 7237 }, /* braille_dots_268 */
+    { 0x010028a3, 4944 }, /* braille_dots_1268 */
+    { 0x010028a4, 7797 }, /* braille_dots_368 */
+    { 0x010028a5, 5536 }, /* braille_dots_1368 */
+    { 0x010028a6, 6688 }, /* braille_dots_2368 */
+    { 0x010028a7, 4364 }, /* braille_dots_12368 */
+    { 0x010028a8, 8069 }, /* braille_dots_468 */
+    { 0x010028a9, 5824 }, /* braille_dots_1468 */
+    { 0x010028aa, 6976 }, /* braille_dots_2468 */
+    { 0x010028ab, 4668 }, /* braille_dots_12468 */
+    { 0x010028ac, 7536 }, /* braille_dots_3468 */
+    { 0x010028ad, 5260 }, /* braille_dots_13468 */
+    { 0x010028ae, 6412 }, /* braille_dots_23468 */
+    { 0x010028af, 4073 }, /* braille_dots_123468 */
+    { 0x010028b0, 8201 }, /* braille_dots_568 */
+    { 0x010028b1, 5964 }, /* braille_dots_1568 */
+    { 0x010028b2, 7116 }, /* braille_dots_2568 */
+    { 0x010028b3, 4816 }, /* braille_dots_12568 */
+    { 0x010028b4, 7676 }, /* braille_dots_3568 */
+    { 0x010028b5, 5408 }, /* braille_dots_13568 */
+    { 0x010028b6, 6560 }, /* braille_dots_23568 */
+    { 0x010028b7, 4229 }, /* braille_dots_123568 */
+    { 0x010028b8, 7948 }, /* braille_dots_4568 */
+    { 0x010028b9, 5696 }, /* braille_dots_14568 */
+    { 0x010028ba, 6848 }, /* braille_dots_24568 */
+    { 0x010028bb, 4533 }, /* braille_dots_124568 */
+    { 0x010028bc, 7408 }, /* braille_dots_34568 */
+    { 0x010028bd, 5125 }, /* braille_dots_134568 */
+    { 0x010028be, 6277 }, /* braille_dots_234568 */
+    { 0x010028bf, 3931 }, /* braille_dots_1234568 */
+    { 0x010028c0, 8346 }, /* braille_dots_78 */
+    { 0x010028c1, 6118 }, /* braille_dots_178 */
+    { 0x010028c2, 7270 }, /* braille_dots_278 */
+    { 0x010028c3, 4979 }, /* braille_dots_1278 */
+    { 0x010028c4, 7830 }, /* braille_dots_378 */
+    { 0x010028c5, 5571 }, /* braille_dots_1378 */
+    { 0x010028c6, 6723 }, /* braille_dots_2378 */
+    { 0x010028c7, 4401 }, /* braille_dots_12378 */
+    { 0x010028c8, 8102 }, /* braille_dots_478 */
+    { 0x010028c9, 5859 }, /* braille_dots_1478 */
+    { 0x010028ca, 7011 }, /* braille_dots_2478 */
+    { 0x010028cb, 4705 }, /* braille_dots_12478 */
+    { 0x010028cc, 7571 }, /* braille_dots_3478 */
+    { 0x010028cd, 5297 }, /* braille_dots_13478 */
+    { 0x010028ce, 6449 }, /* braille_dots_23478 */
+    { 0x010028cf, 4112 }, /* braille_dots_123478 */
+    { 0x010028d0, 8234 }, /* braille_dots_578 */
+    { 0x010028d1, 5999 }, /* braille_dots_1578 */
+    { 0x010028d2, 7151 }, /* braille_dots_2578 */
+    { 0x010028d3, 4853 }, /* braille_dots_12578 */
+    { 0x010028d4, 7711 }, /* braille_dots_3578 */
+    { 0x010028d5, 5445 }, /* braille_dots_13578 */
+    { 0x010028d6, 6597 }, /* braille_dots_23578 */
+    { 0x010028d7, 4268 }, /* braille_dots_123578 */
+    { 0x010028d8, 7983 }, /* braille_dots_4578 */
+    { 0x010028d9, 5733 }, /* braille_dots_14578 */
+    { 0x010028da, 6885 }, /* braille_dots_24578 */
+    { 0x010028db, 4572 }, /* braille_dots_124578 */
+    { 0x010028dc, 7445 }, /* braille_dots_34578 */
+    { 0x010028dd, 5164 }, /* braille_dots_134578 */
+    { 0x010028de, 6316 }, /* braille_dots_234578 */
+    { 0x010028df, 3972 }, /* braille_dots_1234578 */
+    { 0x010028e0, 8298 }, /* braille_dots_678 */
+    { 0x010028e1, 6067 }, /* braille_dots_1678 */
+    { 0x010028e2, 7219 }, /* braille_dots_2678 */
+    { 0x010028e3, 4925 }, /* braille_dots_12678 */
+    { 0x010028e4, 7779 }, /* braille_dots_3678 */
+    { 0x010028e5, 5517 }, /* braille_dots_13678 */
+    { 0x010028e6, 6669 }, /* braille_dots_23678 */
+    { 0x010028e7, 4344 }, /* braille_dots_123678 */
+    { 0x010028e8, 8051 }, /* braille_dots_4678 */
+    { 0x010028e9, 5805 }, /* braille_dots_14678 */
+    { 0x010028ea, 6957 }, /* braille_dots_24678 */
+    { 0x010028eb, 4648 }, /* braille_dots_124678 */
+    { 0x010028ec, 7517 }, /* braille_dots_34678 */
+    { 0x010028ed, 5240 }, /* braille_dots_134678 */
+    { 0x010028ee, 6392 }, /* braille_dots_234678 */
+    { 0x010028ef, 4052 }, /* braille_dots_1234678 */
+    { 0x010028f0, 8183 }, /* braille_dots_5678 */
+    { 0x010028f1, 5945 }, /* braille_dots_15678 */
+    { 0x010028f2, 7097 }, /* braille_dots_25678 */
+    { 0x010028f3, 4796 }, /* braille_dots_125678 */
+    { 0x010028f4, 7657 }, /* braille_dots_35678 */
+    { 0x010028f5, 5388 }, /* braille_dots_135678 */
+    { 0x010028f6, 6540 }, /* braille_dots_235678 */
+    { 0x010028f7, 4208 }, /* braille_dots_1235678 */
+    { 0x010028f8, 7929 }, /* braille_dots_45678 */
+    { 0x010028f9, 5676 }, /* braille_dots_145678 */
+    { 0x010028fa, 6828 }, /* braille_dots_245678 */
+    { 0x010028fb, 4512 }, /* braille_dots_1245678 */
+    { 0x010028fc, 7388 }, /* braille_dots_345678 */
+    { 0x010028fd, 5104 }, /* braille_dots_1345678 */
+    { 0x010028fe, 6256 }, /* braille_dots_2345678 */
+    { 0x010028ff, 3909 }, /* braille_dots_12345678 */
+    { 0x100000a8, 16910 }, /* hpmute_acute */
+    { 0x100000a9, 16977 }, /* hpmute_grave */
+    { 0x100000aa, 16923 }, /* hpmute_asciicircum */
+    { 0x100000ab, 16960 }, /* hpmute_diaeresis */
+    { 0x100000ac, 16942 }, /* hpmute_asciitilde */
+    { 0x100000af, 16867 }, /* hplira */
+    { 0x100000be, 16813 }, /* hpguilder */
+    { 0x100000ee, 17014 }, /* hpYdiaeresis */
+    { 0x100000f6, 16874 }, /* hplongminus */
+    { 0x100000fc, 16767 }, /* hpblock */
+    { 0x1000fe22, 10414 }, /* Ddiaeresis */
+    { 0x1000fe27, 10344 }, /* Dacute_accent */
+    { 0x1000fe2c, 10379 }, /* Dcedilla_accent */
+    { 0x1000fe5e, 10395 }, /* Dcircumflex_accent */
+    { 0x1000fe60, 11189 }, /* Dgrave_accent */
+    { 0x1000fe7e, 11417 }, /* Dtilde */
+    { 0x1000feb0, 11388 }, /* Dring_accent */
+    { 0x1000ff00, 11380 }, /* DRemove */
+    { 0x1000ff48, 16886 }, /* hpModelock1 */
+    { 0x1000ff49, 16898 }, /* hpModelock2 */
+    { 0x1000ff6c, 16990 }, /* hpReset */
+    { 0x1000ff6d, 16998 }, /* hpSystem */
+    { 0x1000ff6e, 17007 }, /* hpUser */
+    { 0x1000ff6f, 16775 }, /* hpClearLine */
+    { 0x1000ff70, 16836 }, /* hpInsertLine */
+    { 0x1000ff71, 16800 }, /* hpDeleteLine */
+    { 0x1000ff72, 16823 }, /* hpInsertChar */
+    { 0x1000ff73, 16787 }, /* hpDeleteChar */
+    { 0x1000ff74, 16757 }, /* hpBackTab */
+    { 0x1000ff75, 16854 }, /* hpKP_BackTab */
+    { 0x1000ff76, 12125 }, /* Ext16bit_L */
+    { 0x1000ff77, 12136 }, /* Ext16bit_R */
+    { 0x1004ff02, 20956 }, /* osfCopy */
+    { 0x1004ff03, 20964 }, /* osfCut */
+    { 0x1004ff04, 21163 }, /* osfPaste */
+    { 0x1004ff07, 20900 }, /* osfBackTab */
+    { 0x1004ff08, 20887 }, /* osfBackSpace */
+    { 0x1004ff0b, 20947 }, /* osfClear */
+    { 0x1004ff1b, 21026 }, /* osfEscape */
+    { 0x1004ff31, 20876 }, /* osfAddMode */
+    { 0x1004ff32, 21197 }, /* osfPrimaryPaste */
+    { 0x1004ff33, 21213 }, /* osfQuickPaste */
+    { 0x1004ff40, 21128 }, /* osfPageLeft */
+    { 0x1004ff41, 21153 }, /* osfPageUp */
+    { 0x1004ff42, 21116 }, /* osfPageDown */
+    { 0x1004ff43, 21140 }, /* osfPageRight */
+    { 0x1004ff44, 20864 }, /* osfActivate */
+    { 0x1004ff45, 21080 }, /* osfMenuBar */
+    { 0x1004ff51, 21064 }, /* osfLeft */
+    { 0x1004ff52, 21290 }, /* osfUp */
+    { 0x1004ff53, 21250 }, /* osfRight */
+    { 0x1004ff54, 20996 }, /* osfDown */
+    { 0x1004ff57, 21015 }, /* osfEndLine */
+    { 0x1004ff58, 20924 }, /* osfBeginLine */
+    { 0x1004ff59, 21004 }, /* osfEndData */
+    { 0x1004ff5a, 20911 }, /* osfBeginData */
+    { 0x1004ff5b, 21185 }, /* osfPrevMenu */
+    { 0x1004ff5c, 21104 }, /* osfNextMenu */
+    { 0x1004ff5d, 21172 }, /* osfPrevField */
+    { 0x1004ff5e, 21091 }, /* osfNextField */
+    { 0x1004ff60, 21259 }, /* osfSelect */
+    { 0x1004ff63, 21054 }, /* osfInsert */
+    { 0x1004ff65, 21282 }, /* osfUndo */
+    { 0x1004ff67, 21072 }, /* osfMenu */
+    { 0x1004ff69, 20937 }, /* osfCancel */
+    { 0x1004ff6a, 21046 }, /* osfHelp */
+    { 0x1004ff71, 21269 }, /* osfSelectAll */
+    { 0x1004ff72, 20981 }, /* osfDeselectAll */
+    { 0x1004ff73, 21227 }, /* osfReselect */
+    { 0x1004ff74, 21036 }, /* osfExtend */
+    { 0x1004ff78, 21239 }, /* osfRestore */
+    { 0x1004ffff, 20971 }, /* osfDelete */
+    { 0x1005ff00, 24032 }, /* SunFA_Grave */
+    { 0x1005ff01, 24003 }, /* SunFA_Circum */
+    { 0x1005ff02, 24044 }, /* SunFA_Tilde */
+    { 0x1005ff03, 23977 }, /* SunFA_Acute */
+    { 0x1005ff04, 24016 }, /* SunFA_Diaeresis */
+    { 0x1005ff05, 23989 }, /* SunFA_Cedilla */
+    { 0x1005ff10, 23963 }, /* SunF36 */
+    { 0x1005ff11, 23970 }, /* SunF37 */
+    { 0x1005ff60, 24180 }, /* SunSys_Req */
+    { 0x1005ff70, 24163 }, /* SunProps */
+    { 0x1005ff71, 24064 }, /* SunFront */
+    { 0x1005ff72, 23948 }, /* SunCopy */
+    { 0x1005ff73, 24073 }, /* SunOpen */
+    { 0x1005ff74, 24103 }, /* SunPaste */
+    { 0x1005ff75, 23956 }, /* SunCut */
+    { 0x1005ff76, 24112 }, /* SunPowerSwitch */
+    { 0x1005ff77, 23884 }, /* SunAudioLowerVolume */
+    { 0x1005ff78, 23904 }, /* SunAudioMute */
+    { 0x1005ff79, 23917 }, /* SunAudioRaiseVolume */
+    { 0x1005ff7a, 24199 }, /* SunVideoDegauss */
+    { 0x1005ff7b, 24215 }, /* SunVideoLowerBrightness */
+    { 0x1005ff7c, 24239 }, /* SunVideoRaiseBrightness */
+    { 0x1005ff7d, 24127 }, /* SunPowerSwitchShift */
+    { 0x1008fe01, 28451 }, /* XF86Switch_VT_1 */
+    { 0x1008fe02, 28518 }, /* XF86Switch_VT_2 */
+    { 0x1008fe03, 28534 }, /* XF86Switch_VT_3 */
+    { 0x1008fe04, 28550 }, /* XF86Switch_VT_4 */
+    { 0x1008fe05, 28566 }, /* XF86Switch_VT_5 */
+    { 0x1008fe06, 28582 }, /* XF86Switch_VT_6 */
+    { 0x1008fe07, 28598 }, /* XF86Switch_VT_7 */
+    { 0x1008fe08, 28614 }, /* XF86Switch_VT_8 */
+    { 0x1008fe09, 28630 }, /* XF86Switch_VT_9 */
+    { 0x1008fe0a, 28467 }, /* XF86Switch_VT_10 */
+    { 0x1008fe0b, 28484 }, /* XF86Switch_VT_11 */
+    { 0x1008fe0c, 28501 }, /* XF86Switch_VT_12 */
+    { 0x1008fe20, 28777 }, /* XF86Ungrab */
+    { 0x1008fe21, 27135 }, /* XF86ClearGrab */
+    { 0x1008fe22, 27962 }, /* XF86Next_VMode */
+    { 0x1008fe23, 28084 }, /* XF86Prev_VMode */
+    { 0x1008fe24, 27742 }, /* XF86LogWindowTree */
+    { 0x1008fe25, 27715 }, /* XF86LogGrabInfo */
+    { 0x1008ff01, 27853 }, /* XF86ModeLock */
+    { 0x1008ff02, 27888 }, /* XF86MonBrightnessUp */
+    { 0x1008ff03, 27866 }, /* XF86MonBrightnessDown */
+    { 0x1008ff04, 27491 }, /* XF86KbdLightOnOff */
+    { 0x1008ff05, 27471 }, /* XF86KbdBrightnessUp */
+    { 0x1008ff06, 27449 }, /* XF86KbdBrightnessDown */
+    { 0x1008ff10, 28383 }, /* XF86Standby */
+    { 0x1008ff11, 26749 }, /* XF86AudioLowerVolume */
+    { 0x1008ff12, 26802 }, /* XF86AudioMute */
+    { 0x1008ff13, 26873 }, /* XF86AudioRaiseVolume */
+    { 0x1008ff14, 26845 }, /* XF86AudioPlay */
+    { 0x1008ff15, 26962 }, /* XF86AudioStop */
+    { 0x1008ff16, 26859 }, /* XF86AudioPrev */
+    { 0x1008ff17, 26816 }, /* XF86AudioNext */
+    { 0x1008ff18, 27412 }, /* XF86HomePage */
+    { 0x1008ff19, 27760 }, /* XF86Mail */
+    { 0x1008ff1a, 28395 }, /* XF86Start */
+    { 0x1008ff1b, 28307 }, /* XF86Search */
+    { 0x1008ff1c, 26914 }, /* XF86AudioRecord */
+    { 0x1008ff1d, 27090 }, /* XF86Calculator */
+    { 0x1008ff1e, 27808 }, /* XF86Memo */
+    { 0x1008ff1f, 28681 }, /* XF86ToDoList */
+    { 0x1008ff20, 27105 }, /* XF86Calendar */
+    { 0x1008ff21, 28057 }, /* XF86PowerDown */
+    { 0x1008ff22, 27173 }, /* XF86ContrastAdjust */
+    { 0x1008ff23, 28177 }, /* XF86RockerUp */
+    { 0x1008ff24, 28146 }, /* XF86RockerDown */
+    { 0x1008ff25, 28161 }, /* XF86RockerEnter */
+    { 0x1008ff26, 26985 }, /* XF86Back */
+    { 0x1008ff27, 27317 }, /* XF86Forward */
+    { 0x1008ff28, 28405 }, /* XF86Stop */
+    { 0x1008ff29, 28113 }, /* XF86Refresh */
+    { 0x1008ff2a, 28071 }, /* XF86PowerOff */
+    { 0x1008ff2b, 28865 }, /* XF86WakeUp */
+    { 0x1008ff2c, 27258 }, /* XF86Eject */
+    { 0x1008ff2d, 28247 }, /* XF86ScreenSaver */
+    { 0x1008ff2e, 28921 }, /* XF86WWW */
+    { 0x1008ff2f, 28347 }, /* XF86Sleep */
+    { 0x1008ff30, 27291 }, /* XF86Favorites */
+    { 0x1008ff31, 26830 }, /* XF86AudioPause */
+    { 0x1008ff32, 26770 }, /* XF86AudioMedia */
+    { 0x1008ff33, 27918 }, /* XF86MyComputer */
+    { 0x1008ff34, 28831 }, /* XF86VendorHome */
+    { 0x1008ff35, 27701 }, /* XF86LightBulb */
+    { 0x1008ff36, 28338 }, /* XF86Shop */
+    { 0x1008ff37, 27400 }, /* XF86History */
+    { 0x1008ff38, 28001 }, /* XF86OpenURL */
+    { 0x1008ff39, 26655 }, /* XF86AddFavorite */
+    { 0x1008ff3a, 27425 }, /* XF86HotLinks */
+    { 0x1008ff3b, 27054 }, /* XF86BrightnessAdjust */
+    { 0x1008ff3c, 27305 }, /* XF86Finance */
+    { 0x1008ff3d, 27159 }, /* XF86Community */
+    { 0x1008ff3e, 26946 }, /* XF86AudioRewind */
+    { 0x1008ff3f, 26994 }, /* XF86BackForward */
+    { 0x1008ff40, 27509 }, /* XF86Launch0 */
+    { 0x1008ff41, 27521 }, /* XF86Launch1 */
+    { 0x1008ff42, 27533 }, /* XF86Launch2 */
+    { 0x1008ff43, 27545 }, /* XF86Launch3 */
+    { 0x1008ff44, 27557 }, /* XF86Launch4 */
+    { 0x1008ff45, 27569 }, /* XF86Launch5 */
+    { 0x1008ff46, 27581 }, /* XF86Launch6 */
+    { 0x1008ff47, 27593 }, /* XF86Launch7 */
+    { 0x1008ff48, 27605 }, /* XF86Launch8 */
+    { 0x1008ff49, 27617 }, /* XF86Launch9 */
+    { 0x1008ff4a, 27629 }, /* XF86LaunchA */
+    { 0x1008ff4b, 27641 }, /* XF86LaunchB */
+    { 0x1008ff4c, 27653 }, /* XF86LaunchC */
+    { 0x1008ff4d, 27665 }, /* XF86LaunchD */
+    { 0x1008ff4e, 27677 }, /* XF86LaunchE */
+    { 0x1008ff4f, 27689 }, /* XF86LaunchF */
+    { 0x1008ff50, 26671 }, /* XF86ApplicationLeft */
+    { 0x1008ff51, 26691 }, /* XF86ApplicationRight */
+    { 0x1008ff52, 27045 }, /* XF86Book */
+    { 0x1008ff53, 27118 }, /* XF86CD */
+    { 0x1008ff54, 27075 }, /* XF86Calculater */
+    { 0x1008ff55, 27125 }, /* XF86Clear */
+    { 0x1008ff56, 27149 }, /* XF86Close */
+    { 0x1008ff57, 27192 }, /* XF86Copy */
+    { 0x1008ff58, 27201 }, /* XF86Cut */
+    { 0x1008ff59, 27224 }, /* XF86Display */
+    { 0x1008ff5a, 27250 }, /* XF86DOS */
+    { 0x1008ff5b, 27236 }, /* XF86Documents */
+    { 0x1008ff5c, 27268 }, /* XF86Excel */
+    { 0x1008ff5d, 27278 }, /* XF86Explorer */
+    { 0x1008ff5e, 27360 }, /* XF86Game */
+    { 0x1008ff5f, 27369 }, /* XF86Go */
+    { 0x1008ff60, 27438 }, /* XF86iTouch */
+    { 0x1008ff61, 27731 }, /* XF86LogOff */
+    { 0x1008ff62, 27785 }, /* XF86Market */
+    { 0x1008ff63, 27796 }, /* XF86Meeting */
+    { 0x1008ff65, 27817 }, /* XF86MenuKB */
+    { 0x1008ff66, 27828 }, /* XF86MenuPB */
+    { 0x1008ff67, 27933 }, /* XF86MySites */
+    { 0x1008ff68, 27945 }, /* XF86New */
+    { 0x1008ff69, 27953 }, /* XF86News */
+    { 0x1008ff6a, 27977 }, /* XF86OfficeHome */
+    { 0x1008ff6b, 27992 }, /* XF86Open */
+    { 0x1008ff6c, 28013 }, /* XF86Option */
+    { 0x1008ff6d, 28024 }, /* XF86Paste */
+    { 0x1008ff6e, 28034 }, /* XF86Phone */
+    { 0x1008ff70, 28099 }, /* XF86Q */
+    { 0x1008ff72, 28136 }, /* XF86Reply */
+    { 0x1008ff73, 28125 }, /* XF86Reload */
+    { 0x1008ff74, 28190 }, /* XF86RotateWindows */
+    { 0x1008ff75, 28223 }, /* XF86RotationPB */
+    { 0x1008ff76, 28208 }, /* XF86RotationKB */
+    { 0x1008ff77, 28238 }, /* XF86Save */
+    { 0x1008ff78, 28294 }, /* XF86ScrollUp */
+    { 0x1008ff79, 28279 }, /* XF86ScrollDown */
+    { 0x1008ff7a, 28263 }, /* XF86ScrollClick */
+    { 0x1008ff7b, 28329 }, /* XF86Send */
+    { 0x1008ff7c, 28357 }, /* XF86Spell */
+    { 0x1008ff7d, 28367 }, /* XF86SplitScreen */
+    { 0x1008ff7e, 28427 }, /* XF86Support */
+    { 0x1008ff7f, 28646 }, /* XF86TaskPane */
+    { 0x1008ff80, 28659 }, /* XF86Terminal */
+    { 0x1008ff81, 28694 }, /* XF86Tools */
+    { 0x1008ff82, 28766 }, /* XF86Travel */
+    { 0x1008ff84, 28812 }, /* XF86UserPB */
+    { 0x1008ff85, 28788 }, /* XF86User1KB */
+    { 0x1008ff86, 28800 }, /* XF86User2KB */
+    { 0x1008ff87, 28846 }, /* XF86Video */
+    { 0x1008ff88, 28887 }, /* XF86WheelButton */
+    { 0x1008ff89, 28912 }, /* XF86Word */
+    { 0x1008ff8a, 28929 }, /* XF86Xfer */
+    { 0x1008ff8b, 28949 }, /* XF86ZoomIn */
+    { 0x1008ff8c, 28960 }, /* XF86ZoomOut */
+    { 0x1008ff8d, 26976 }, /* XF86Away */
+    { 0x1008ff8e, 27839 }, /* XF86Messenger */
+    { 0x1008ff8f, 28876 }, /* XF86WebCam */
+    { 0x1008ff90, 27769 }, /* XF86MailForward */
+    { 0x1008ff91, 28044 }, /* XF86Pictures */
+    { 0x1008ff92, 27908 }, /* XF86Music */
+    { 0x1008ff93, 27010 }, /* XF86Battery */
+    { 0x1008ff94, 27031 }, /* XF86Bluetooth */
+    { 0x1008ff95, 28903 }, /* XF86WLAN */
+    { 0x1008ff96, 28823 }, /* XF86UWB */
+    { 0x1008ff97, 26732 }, /* XF86AudioForward */
+    { 0x1008ff98, 26930 }, /* XF86AudioRepeat */
+    { 0x1008ff99, 26894 }, /* XF86AudioRandomPlay */
+    { 0x1008ff9a, 28414 }, /* XF86Subtitle */
+    { 0x1008ff9b, 26712 }, /* XF86AudioCycleTrack */
+    { 0x1008ff9c, 27209 }, /* XF86CycleAngle */
+    { 0x1008ff9d, 27329 }, /* XF86FrameBack */
+    { 0x1008ff9e, 27343 }, /* XF86FrameForward */
+    { 0x1008ff9f, 28672 }, /* XF86Time */
+    { 0x1008ffa0, 28318 }, /* XF86Select */
+    { 0x1008ffa1, 28856 }, /* XF86View */
+    { 0x1008ffa2, 28704 }, /* XF86TopMenu */
+    { 0x1008ffa3, 28105 }, /* XF86Red */
+    { 0x1008ffa4, 27376 }, /* XF86Green */
+    { 0x1008ffa5, 28938 }, /* XF86Yellow */
+    { 0x1008ffa6, 27022 }, /* XF86Blue */
+    { 0x1008ffa7, 28439 }, /* XF86Suspend */
+    { 0x1008ffa8, 27386 }, /* XF86Hibernate */
+    { 0x1008ffa9, 28747 }, /* XF86TouchpadToggle */
+    { 0x1008ffb0, 28732 }, /* XF86TouchpadOn */
+    { 0x1008ffb1, 28716 }, /* XF86TouchpadOff */
+    { 0x1008ffb2, 26785 }, /* XF86AudioMicMute */
 };
diff --git a/src/3rdparty/xkbcommon/src/state.c b/src/3rdparty/xkbcommon/src/state.c
index ac4576f5b8..768d47c182 100644
--- a/src/3rdparty/xkbcommon/src/state.c
+++ b/src/3rdparty/xkbcommon/src/state.c
@@ -60,6 +60,7 @@
  */
 
 #include "keymap.h"
+#include "keysym.h"
 
 struct xkb_filter {
     union xkb_action action;
@@ -405,7 +406,6 @@ xkb_action_breaks_latch(const union xkb_action *action)
     case ACTION_TYPE_PTR_LOCK:
     case ACTION_TYPE_CTRL_SET:
     case ACTION_TYPE_CTRL_LOCK:
-    case ACTION_TYPE_KEY_REDIRECT:
     case ACTION_TYPE_SWITCH_VT:
     case ACTION_TYPE_TERMINATE:
         return true;
@@ -833,13 +833,26 @@ XKB_EXPORT xkb_keysym_t
 xkb_state_key_get_one_sym(struct xkb_state *state, xkb_keycode_t kc)
 {
     const xkb_keysym_t *syms;
+    xkb_keysym_t sym;
     int num_syms;
+    xkb_mod_index_t caps;
 
     num_syms = xkb_state_key_get_syms(state, kc, &syms);
     if (num_syms != 1)
         return XKB_KEY_NoSymbol;
 
-    return syms[0];
+    sym = syms[0];
+
+    /*
+     * Perform capitalization transformation, see:
+     * http://www.x.org/releases/current/doc/kbproto/xkbproto.html#Interpreting_the_Lock_Modifier
+     */
+    caps = xkb_keymap_mod_get_index(state->keymap, XKB_MOD_NAME_CAPS);
+    if (xkb_state_mod_index_is_active(state, caps, XKB_STATE_MODS_EFFECTIVE) > 0 &&
+        xkb_state_mod_index_is_consumed(state, kc, caps) == 0)
+        sym = xkb_keysym_to_upper(sym);
+
+    return sym;
 }
 
 /**
@@ -989,13 +1002,12 @@ xkb_state_mod_names_are_active(struct xkb_state *state,
 {
     va_list ap;
     xkb_mod_index_t idx = 0;
-    const char *str;
     xkb_mod_mask_t wanted = 0;
     int ret = 0;
 
     va_start(ap, match);
     while (1) {
-        str = va_arg(ap, const char *);
+        const char *str = va_arg(ap, const char *);
         if (str == NULL)
             break;
         idx = xkb_keymap_mod_get_index(state->keymap, str);
diff --git a/src/3rdparty/xkbcommon/src/text.c b/src/3rdparty/xkbcommon/src/text.c
index 4b8ad0984f..59d6c775cb 100644
--- a/src/3rdparty/xkbcommon/src/text.c
+++ b/src/3rdparty/xkbcommon/src/text.c
@@ -175,10 +175,10 @@ const LookupEntry actionTypeNames[] = {
     { "SwitchScreen", ACTION_TYPE_SWITCH_VT },
     { "SetControls", ACTION_TYPE_CTRL_SET },
     { "LockControls", ACTION_TYPE_CTRL_LOCK },
-    { "RedirectKey", ACTION_TYPE_KEY_REDIRECT },
-    { "Redirect", ACTION_TYPE_KEY_REDIRECT },
     { "Private", ACTION_TYPE_PRIVATE },
     /* deprecated actions below here - unused */
+    { "RedirectKey", ACTION_TYPE_NONE },
+    { "Redirect", ACTION_TYPE_NONE },
     { "ISOLock", ACTION_TYPE_NONE },
     { "ActionMessage", ACTION_TYPE_NONE },
     { "MessageAction", ACTION_TYPE_NONE },
@@ -251,9 +251,9 @@ const char *
 KeyNameText(struct xkb_context *ctx, xkb_atom_t name)
 {
     const char *sname = xkb_atom_text(ctx, name);
-    size_t len = strlen(sname) + 3;
+    size_t len = strlen_safe(sname) + 3;
     char *buf = xkb_context_get_buffer(ctx, len);
-    snprintf(buf, len, "<%s>", sname);
+    snprintf(buf, len, "<%s>", strempty(sname));
     return buf;
 }
 
diff --git a/src/3rdparty/xkbcommon/src/utils.c b/src/3rdparty/xkbcommon/src/utils.c
new file mode 100644
index 0000000000..a00b04eeec
--- /dev/null
+++ b/src/3rdparty/xkbcommon/src/utils.c
@@ -0,0 +1,107 @@
+/*
+ * Copyright © 2013 Ran Benita <ran234@gmail.com>
+ *
+ * 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.
+ */
+
+#include "utils.h"
+
+#ifdef HAVE_MMAP
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+bool
+map_file(FILE *file, const char **string_out, size_t *size_out)
+{
+    struct stat stat_buf;
+    const int fd = fileno(file);
+    char *string;
+
+    /* Make sure to keep the errno on failure! */
+
+    if (fstat(fd, &stat_buf) != 0)
+        return false;
+
+    string = mmap(NULL, stat_buf.st_size, PROT_READ, MAP_SHARED, fd, 0);
+    if (string == MAP_FAILED)
+        return false;
+
+    *string_out = string;
+    *size_out = stat_buf.st_size;
+    return true;
+}
+
+void
+unmap_file(const char *str, size_t size)
+{
+    munmap(UNCONSTIFY(str), size);
+}
+
+#else
+
+bool
+map_file(FILE *file, const char **string_out, size_t *size_out)
+{
+    long ret;
+    size_t ret_s;
+    char *string;
+    size_t size;
+
+    /* Make sure to keep the errno on failure! */
+
+    ret = fseek(file, 0, SEEK_END);
+    if (ret != 0)
+        return false;
+
+    ret = ftell(file);
+    if (ret < 0)
+        return false;
+    size = (size_t) ret;
+
+    ret = fseek(file, 0, SEEK_SET);
+    if (ret < 0)
+        return false;
+
+    string = malloc(size);
+    if (!string)
+        return false;
+
+    ret_s = fread(string, 1, size, file);
+    if (ret_s < size) {
+        free(string);
+        return false;
+    }
+
+    *string_out = string;
+    *size_out = size;
+    return true;
+}
+
+void
+unmap_file(const char *str, size_t size)
+{
+    free(UNCONSTIFY(str));
+}
+
+#endif
diff --git a/src/3rdparty/xkbcommon/src/utils.h b/src/3rdparty/xkbcommon/src/utils.h
index b4daaddaaa..81d1cc9412 100644
--- a/src/3rdparty/xkbcommon/src/utils.h
+++ b/src/3rdparty/xkbcommon/src/utils.h
@@ -24,8 +24,10 @@
 #ifndef UTILS_H
 #define UTILS_H 1
 
+#include <errno.h>
 #include <inttypes.h>
 #include <stdbool.h>
+#include <stdio.h>
 #include <string.h>
 #include <strings.h>
 
@@ -70,6 +72,12 @@ strdup_safe(const char *s)
     return s ? strdup(s) : NULL;
 }
 
+static inline size_t
+strlen_safe(const char *s)
+{
+    return s ? strlen(s) : 0;
+}
+
 static inline bool
 isempty(const char *s)
 {
@@ -82,6 +90,12 @@ strnull(const char *s)
     return s ? s : "(null)";
 }
 
+static inline const char *
+strempty(const char *s)
+{
+    return s ? s : "";
+}
+
 static inline void *
 memdup(const void *mem, size_t nmemb, size_t size)
 {
@@ -91,6 +105,81 @@ memdup(const void *mem, size_t nmemb, size_t size)
     return p;
 }
 
+static inline int
+min(int misc, int other)
+{
+    return (misc < other) ? misc : other;
+}
+
+static inline int
+max(int misc, int other)
+{
+    return (misc > other) ? misc : other;
+}
+
+/* ctype.h is locale-dependent and has other oddities. */
+static inline bool
+is_space(char ch)
+{
+    return ch == ' ' || (ch >= '\t' && ch <= '\r');
+}
+
+static inline bool
+is_alpha(char ch)
+{
+    return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');
+}
+
+static inline bool
+is_digit(char ch)
+{
+    return ch >= '0' && ch <= '9';
+}
+
+static inline bool
+is_alnum(char ch)
+{
+    return is_alpha(ch) || is_digit(ch);
+}
+
+static inline bool
+is_xdigit(char ch)
+{
+    return
+        (ch >= '0' && ch <= '9') ||
+        (ch >= 'a' && ch <= 'f') ||
+        (ch >= 'A' && ch <= 'F');
+}
+
+static inline bool
+is_graph(char ch)
+{
+    /* See table in ascii(7). */
+    return ch >= '!' && ch <= '~';
+}
+
+/*
+ * Return the bit position of the most significant bit.
+ * Note: this is 1-based! It's more useful this way, and returns 0 when
+ * mask is all 0s.
+ */
+static inline int
+msb_pos(uint32_t mask)
+{
+    int pos = 0;
+    while (mask) {
+        pos++;
+        mask >>= 1;
+    }
+    return pos;
+}
+
+bool
+map_file(FILE *file, const char **string_out, size_t *size_out);
+
+void
+unmap_file(const char *str, size_t size);
+
 #define ARRAY_SIZE(arr) ((sizeof(arr) / sizeof(*(arr))))
 
 #define MIN(a, b) ((a) < (b) ? (a) : (b))
@@ -133,4 +222,10 @@ memdup(const void *mem, size_t nmemb, size_t size)
 # define ATTR_NULL_SENTINEL
 #endif /* GNUC >= 4 */
 
+#if (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 295)
+#define ATTR_PACKED  __attribute__((__packed__))
+#else
+#define ATTR_PACKED
+#endif
+
 #endif /* UTILS_H */
diff --git a/src/3rdparty/xkbcommon/src/x11/util.c b/src/3rdparty/xkbcommon/src/x11/util.c
new file mode 100644
index 0000000000..92ff2e630e
--- /dev/null
+++ b/src/3rdparty/xkbcommon/src/x11/util.c
@@ -0,0 +1,215 @@
+/*
+ * Copyright © 2013 Ran Benita
+ *
+ * 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.
+ */
+
+#include "x11-priv.h"
+
+XKB_EXPORT int
+xkb_x11_setup_xkb_extension(xcb_connection_t *conn,
+                            uint16_t major_xkb_version,
+                            uint16_t minor_xkb_version,
+                            enum xkb_x11_setup_xkb_extension_flags flags,
+                            uint16_t *major_xkb_version_out,
+                            uint16_t *minor_xkb_version_out,
+                            uint8_t *base_event_out,
+                            uint8_t *base_error_out)
+{
+    uint8_t base_event, base_error;
+    uint16_t server_major, server_minor;
+
+    if (flags & ~(XKB_X11_SETUP_XKB_EXTENSION_NO_FLAGS)) {
+        /* log_err_func(ctx, "unrecognized flags: %#x\n", flags); */
+        return 0;
+    }
+
+    {
+        const xcb_query_extension_reply_t *reply =
+            xcb_get_extension_data(conn, &xcb_xkb_id);
+        if (!reply) {
+            /* log_err_func(ctx, "failed to query for XKB extension\n"); */
+            return 0;
+        }
+
+        if (!reply->present) {
+            /* log_err_func(ctx, "failed to start using XKB extension: not available in server\n"); */
+            return 0;
+        }
+
+        base_event = reply->first_event;
+        base_error = reply->first_error;
+    }
+
+    {
+        xcb_generic_error_t *error = NULL;
+        xcb_xkb_use_extension_cookie_t cookie =
+            xcb_xkb_use_extension(conn, major_xkb_version, minor_xkb_version);
+        xcb_xkb_use_extension_reply_t *reply =
+            xcb_xkb_use_extension_reply(conn, cookie, &error);
+
+        if (!reply) {
+            /* log_err_func(ctx, */
+            /*              "failed to start using XKB extension: error code %d\n", */
+            /*              error ? error->error_code : -1); */
+            free(error);
+            return 0;
+        }
+
+        if (!reply->supported) {
+            /* log_err_func(ctx, */
+            /*              "failed to start using XKB extension: server doesn't support version %d.%d\n", */
+            /*              major_xkb_version, minor_xkb_version); */
+            free(reply);
+            return 0;
+        }
+
+        server_major = reply->serverMajor;
+        server_minor = reply->serverMinor;
+
+        free(reply);
+    }
+
+    /*
+    * The XkbUseExtension() in libX11 has a *bunch* of legacy stuff, but
+    * it doesn't seem like any of it is useful to us.
+    */
+
+    if (major_xkb_version_out)
+        *major_xkb_version_out = server_major;
+    if (minor_xkb_version_out)
+        *minor_xkb_version_out = server_minor;
+    if (base_event_out)
+        *base_event_out = base_event;
+    if (base_error_out)
+        *base_error_out = base_error;
+
+    return 1;
+}
+
+XKB_EXPORT int32_t
+xkb_x11_get_core_keyboard_device_id(xcb_connection_t *conn)
+{
+    int32_t device_id;
+    xcb_xkb_get_device_info_cookie_t cookie =
+        xcb_xkb_get_device_info(conn, XCB_XKB_ID_USE_CORE_KBD,
+                                0, 0, 0, 0, 0, 0);
+    xcb_xkb_get_device_info_reply_t *reply =
+        xcb_xkb_get_device_info_reply(conn, cookie, NULL);
+
+    if (!reply)
+        return -1;
+
+    device_id = reply->deviceID;
+    free(reply);
+    return device_id;
+}
+
+bool
+get_atom_name(xcb_connection_t *conn, xcb_atom_t atom, char **out)
+{
+    xcb_get_atom_name_cookie_t cookie;
+    xcb_get_atom_name_reply_t *reply;
+    int length;
+    char *name;
+
+    if (atom == 0) {
+        *out = NULL;
+        return true;
+    }
+
+    cookie = xcb_get_atom_name(conn, atom);
+    reply = xcb_get_atom_name_reply(conn, cookie, NULL);
+    if (!reply)
+        return false;
+
+    length = xcb_get_atom_name_name_length(reply);
+    name = xcb_get_atom_name_name(reply);
+
+    *out = strndup(name, length);
+    if (!*out) {
+        free(reply);
+        return false;
+    }
+
+    free(reply);
+    return true;
+}
+
+bool
+adopt_atoms(struct xkb_context *ctx, xcb_connection_t *conn,
+            const xcb_atom_t *from, xkb_atom_t *to, const size_t count)
+{
+    enum { SIZE = 128 };
+    xcb_get_atom_name_cookie_t cookies[SIZE];
+
+    /* Send and collect the atoms in batches of reasonable SIZE. */
+    for (size_t batch = 0; batch <= count / SIZE; batch++) {
+        const size_t start = batch * SIZE;
+        const size_t stop = min((batch + 1) * SIZE, count);
+
+        /* Send. */
+        for (size_t i = start; i < stop; i++)
+            if (from[i] != XCB_ATOM_NONE)
+                cookies[i % SIZE] = xcb_get_atom_name(conn, from[i]);
+
+        /* Collect. */
+        for (size_t i = start; i < stop; i++) {
+            xcb_get_atom_name_reply_t *reply;
+
+            if (from[i] == XCB_ATOM_NONE) {
+                to[i] = XKB_ATOM_NONE;
+                continue;
+            }
+
+            reply = xcb_get_atom_name_reply(conn, cookies[i % SIZE], NULL);
+            if (!reply)
+                goto err_discard;
+
+            to[i] = xkb_atom_intern(ctx,
+                                    xcb_get_atom_name_name(reply),
+                                    xcb_get_atom_name_name_length(reply));
+            free(reply);
+
+            if (to[i] == XKB_ATOM_NONE)
+                goto err_discard;
+
+            continue;
+
+            /*
+             * If we don't discard the uncollected replies, they just
+             * sit there waiting. Sad.
+             */
+err_discard:
+            for (size_t j = i + 1; j < stop; j++)
+                xcb_discard_reply(conn, cookies[j].sequence);
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool
+adopt_atom(struct xkb_context *ctx, xcb_connection_t *conn, xcb_atom_t atom,
+           xkb_atom_t *out)
+{
+    return adopt_atoms(ctx, conn, &atom, out, 1);
+}
diff --git a/src/3rdparty/xkbcommon/src/x11/x11-keymap.c b/src/3rdparty/xkbcommon/src/x11/x11-keymap.c
new file mode 100644
index 0000000000..968f187621
--- /dev/null
+++ b/src/3rdparty/xkbcommon/src/x11/x11-keymap.c
@@ -0,0 +1,1146 @@
+/*
+ * Copyright © 2013 Ran Benita
+ *
+ * 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.
+ */
+
+#include "x11-priv.h"
+
+/*
+ * References for the lonesome traveler:
+ * Xkb protocol specification:
+ *      http://www.x.org/releases/current/doc/kbproto/xkbproto.html
+ * The XCB xkb XML protocol file:
+ *      /user/share/xcb/xkb.xml
+ * The XCB xkb header file:
+ *      /usr/include/xcb/xkb.h
+ * The old kbproto header files:
+ *      /usr/include/X11/extensions/XKB{,proto,str}.h
+ * Xlib XKB source code:
+ *      <libX11>/src/xkb/XKBGetMap.c (and friends)
+ * X server XKB protocol handling:
+ *      <xserver>/xkb/xkb.c
+ * Man pages:
+ *      XkbGetMap(3), XkbGetCompatMap(3), etc.
+ */
+
+/* Constants from /usr/include/X11/extensions/XKB.h */
+/* XkbNumModifiers. */
+#define NUM_REAL_MODS 8
+/* XkbNumVirtualMods. */
+#define NUM_VMODS 16
+/* XkbNoModifier. */
+#define NO_MODIFIER 0xff
+/* XkbNumIndicators. */
+#define NUM_INDICATORS 32
+/* XkbAllIndicatorsMask. */
+#define ALL_INDICATORS_MASK 0xffffffff
+
+/* Some macros. Not very nice but it'd be worse without them. */
+
+/*
+ * We try not to trust the server too much and be paranoid. If we get
+ * something which we definitely shouldn't, we fail.
+ */
+#define STRINGIFY(expr) #expr
+#define FAIL_UNLESS(expr) do {                                          \
+    if (!(expr)) {                                                      \
+        log_err(keymap->ctx,                                            \
+                "x11: failed to get keymap from X server: unmet condition in %s(): %s\n", \
+                __func__, STRINGIFY(expr));                             \
+        goto fail;                                                      \
+    }                                                                   \
+} while (0)
+
+#define FAIL_IF_BAD_REPLY(reply, request_name) do {                     \
+    if (!reply) {                                                       \
+        log_err(keymap->ctx,                                            \
+                "x11: failed to get keymap from X server: %s request failed\n", \
+                (request_name));                                        \
+        goto fail;                                                      \
+    }                                                                   \
+} while (0)
+
+#define ALLOC_OR_FAIL(arr, nmemb) do {                                  \
+    if ((nmemb) > 0) {                                                  \
+        (arr) = calloc((nmemb), sizeof(*(arr)));                        \
+        if (!(arr))                                                     \
+            goto fail;                                                  \
+    }                                                                   \
+} while (0)
+
+
+static xkb_mod_mask_t
+translate_mods(uint8_t rmods, uint16_t vmods_low, uint16_t vmods_high)
+{
+    /* We represent mod masks in a single uint32_t value, with real mods
+     * first and vmods after (though we don't make these distinctions). */
+    return rmods | (vmods_low << 8) | (vmods_high << 16);
+}
+
+static enum xkb_action_controls
+translate_controls_mask(uint16_t wire)
+{
+    enum xkb_action_controls ret = 0;
+    if (wire & XCB_XKB_BOOL_CTRL_REPEAT_KEYS)
+        ret |= CONTROL_REPEAT;
+    if (wire & XCB_XKB_BOOL_CTRL_SLOW_KEYS)
+        ret |= CONTROL_SLOW;
+    if (wire & XCB_XKB_BOOL_CTRL_BOUNCE_KEYS)
+        ret |= CONTROL_DEBOUNCE;
+    if (wire & XCB_XKB_BOOL_CTRL_STICKY_KEYS)
+        ret |= CONTROL_STICKY;
+    if (wire & XCB_XKB_BOOL_CTRL_MOUSE_KEYS)
+        ret |= CONTROL_MOUSEKEYS;
+    if (wire & XCB_XKB_BOOL_CTRL_MOUSE_KEYS_ACCEL)
+        ret |= CONTROL_MOUSEKEYS_ACCEL;
+    if (wire & XCB_XKB_BOOL_CTRL_ACCESS_X_KEYS)
+        ret |= CONTROL_AX;
+    if (wire & XCB_XKB_BOOL_CTRL_ACCESS_X_TIMEOUT_MASK)
+        ret |= CONTROL_AX_TIMEOUT;
+    if (wire & XCB_XKB_BOOL_CTRL_ACCESS_X_FEEDBACK_MASK)
+        ret |= CONTROL_AX_FEEDBACK;
+    if (wire & XCB_XKB_BOOL_CTRL_AUDIBLE_BELL_MASK)
+        ret |= CONTROL_BELL;
+    if (wire & XCB_XKB_BOOL_CTRL_IGNORE_GROUP_LOCK_MASK)
+        ret |= CONTROL_IGNORE_GROUP_LOCK;
+    /* Some controls are not supported and don't appear here. */
+    return ret;
+}
+
+static void
+translate_action(union xkb_action *action, const xcb_xkb_action_t *wire)
+{
+    switch (wire->type) {
+    case XCB_XKB_SA_TYPE_SET_MODS:
+        action->type = ACTION_TYPE_MOD_SET;
+
+        action->mods.mods.mods = translate_mods(wire->setmods.realMods,
+                                                wire->setmods.vmodsLow,
+                                                wire->setmods.vmodsHigh);
+        action->mods.mods.mask = translate_mods(wire->setmods.mask, 0, 0);
+
+        if (wire->setmods.flags & XCB_XKB_SA_CLEAR_LOCKS)
+            action->mods.flags |= ACTION_LOCK_CLEAR;
+        if (wire->setmods.flags & XCB_XKB_SA_LATCH_TO_LOCK)
+            action->mods.flags |= ACTION_LATCH_TO_LOCK;
+        if (wire->setmods.flags & XCB_XKB_SA_USE_MOD_MAP_MODS)
+            action->mods.flags |= ACTION_MODS_LOOKUP_MODMAP;
+
+        break;
+    case XCB_XKB_SA_TYPE_LATCH_MODS:
+        action->type = ACTION_TYPE_MOD_LATCH;
+
+        action->mods.mods.mods = translate_mods(wire->latchmods.realMods,
+                                                wire->latchmods.vmodsLow,
+                                                wire->latchmods.vmodsHigh);
+        action->mods.mods.mask = translate_mods(wire->latchmods.mask, 0, 0);
+
+        if (wire->latchmods.flags & XCB_XKB_SA_CLEAR_LOCKS)
+            action->mods.flags |= ACTION_LOCK_CLEAR;
+        if (wire->latchmods.flags & XCB_XKB_SA_LATCH_TO_LOCK)
+            action->mods.flags |= ACTION_LATCH_TO_LOCK;
+        if (wire->latchmods.flags & XCB_XKB_SA_USE_MOD_MAP_MODS)
+            action->mods.flags |= ACTION_MODS_LOOKUP_MODMAP;
+
+        break;
+    case XCB_XKB_SA_TYPE_LOCK_MODS:
+        action->type = ACTION_TYPE_MOD_LOCK;
+
+        action->mods.mods.mods = translate_mods(wire->lockmods.realMods,
+                                                wire->lockmods.vmodsLow,
+                                                wire->lockmods.vmodsHigh);
+        action->mods.mods.mask = translate_mods(wire->lockmods.mask, 0, 0);
+
+        if (wire->lockmods.flags & XCB_XKB_SA_ISO_LOCK_FLAG_NO_LOCK)
+            action->mods.flags |= ACTION_LOCK_NO_LOCK;
+        if (wire->lockmods.flags & XCB_XKB_SA_ISO_LOCK_FLAG_NO_UNLOCK)
+            action->mods.flags |= ACTION_LOCK_NO_UNLOCK;
+        if (wire->lockmods.flags & XCB_XKB_SA_USE_MOD_MAP_MODS)
+            action->mods.flags |= ACTION_MODS_LOOKUP_MODMAP;
+
+        break;
+    case XCB_XKB_SA_TYPE_SET_GROUP:
+        action->type = ACTION_TYPE_GROUP_SET;
+
+        action->group.group = wire->setgroup.group;
+
+        if (wire->setmods.flags & XCB_XKB_SA_CLEAR_LOCKS)
+            action->group.flags |= ACTION_LOCK_CLEAR;
+        if (wire->setmods.flags & XCB_XKB_SA_LATCH_TO_LOCK)
+            action->group.flags |= ACTION_LATCH_TO_LOCK;
+        if (wire->setmods.flags & XCB_XKB_SA_ISO_LOCK_FLAG_GROUP_ABSOLUTE)
+            action->group.flags |= ACTION_ABSOLUTE_SWITCH;
+
+        break;
+    case XCB_XKB_SA_TYPE_LATCH_GROUP:
+        action->type = ACTION_TYPE_GROUP_LATCH;
+
+        action->group.group = wire->latchgroup.group;
+
+        if (wire->latchmods.flags & XCB_XKB_SA_CLEAR_LOCKS)
+            action->group.flags |= ACTION_LOCK_CLEAR;
+        if (wire->latchmods.flags & XCB_XKB_SA_LATCH_TO_LOCK)
+            action->group.flags |= ACTION_LATCH_TO_LOCK;
+        if (wire->latchmods.flags & XCB_XKB_SA_ISO_LOCK_FLAG_GROUP_ABSOLUTE)
+            action->group.flags |= ACTION_ABSOLUTE_SWITCH;
+
+        break;
+    case XCB_XKB_SA_TYPE_LOCK_GROUP:
+        action->type = ACTION_TYPE_GROUP_LOCK;
+
+        action->group.group = wire->lockgroup.group;
+
+        if (wire->lockgroup.flags & XCB_XKB_SA_ISO_LOCK_FLAG_GROUP_ABSOLUTE)
+            action->group.flags |= ACTION_ABSOLUTE_SWITCH;
+
+        break;
+    case XCB_XKB_SA_TYPE_MOVE_PTR:
+        action->type = ACTION_TYPE_PTR_MOVE;
+
+        action->ptr.x = (wire->moveptr.xLow | (wire->moveptr.xHigh << 8));
+        action->ptr.y = (wire->moveptr.yLow | (wire->moveptr.yHigh << 8));
+
+        if (wire->moveptr.flags & XCB_XKB_SA_MOVE_PTR_FLAG_NO_ACCELERATION)
+            action->ptr.flags |= ACTION_NO_ACCEL;
+        if (wire->moveptr.flags & XCB_XKB_SA_MOVE_PTR_FLAG_MOVE_ABSOLUTE_X)
+            action->ptr.flags |= ACTION_ABSOLUTE_X;
+        if (wire->moveptr.flags & XCB_XKB_SA_MOVE_PTR_FLAG_MOVE_ABSOLUTE_Y)
+            action->ptr.flags |= ACTION_ABSOLUTE_Y;
+
+        break;
+    case XCB_XKB_SA_TYPE_PTR_BTN:
+        action->type = ACTION_TYPE_PTR_BUTTON;
+
+        action->btn.count = wire->ptrbtn.count;
+        action->btn.button = wire->ptrbtn.button;
+        action->btn.flags = 0;
+
+        break;
+    case XCB_XKB_SA_TYPE_LOCK_PTR_BTN:
+        action->type = ACTION_TYPE_PTR_LOCK;
+
+        action->btn.button = wire->lockptrbtn.button;
+
+        if (wire->lockptrbtn.flags & XCB_XKB_SA_ISO_LOCK_FLAG_NO_LOCK)
+            action->btn.flags |= ACTION_LOCK_NO_LOCK;
+        if (wire->lockptrbtn.flags & XCB_XKB_SA_ISO_LOCK_FLAG_NO_UNLOCK)
+            action->btn.flags |= ACTION_LOCK_NO_UNLOCK;
+
+        break;
+    case XCB_XKB_SA_TYPE_SET_PTR_DFLT:
+        action->type = ACTION_TYPE_PTR_DEFAULT;
+
+        action->dflt.value = wire->setptrdflt.value;
+
+        if (wire->setptrdflt.flags & XCB_XKB_SA_SET_PTR_DFLT_FLAG_DFLT_BTN_ABSOLUTE)
+            action->dflt.flags |= ACTION_ABSOLUTE_SWITCH;
+
+        break;
+    case XCB_XKB_SA_TYPE_TERMINATE:
+        action->type = ACTION_TYPE_TERMINATE;
+
+        break;
+    case XCB_XKB_SA_TYPE_SWITCH_SCREEN:
+        action->type = ACTION_TYPE_SWITCH_VT;
+
+        action->screen.screen = wire->switchscreen.newScreen;
+
+        if (wire->switchscreen.flags & XCB_XKB_SWITCH_SCREEN_FLAG_APPLICATION)
+            action->screen.flags |= ACTION_SAME_SCREEN;
+        if (wire->switchscreen.flags & XCB_XKB_SWITCH_SCREEN_FLAG_ABSOLUTE)
+            action->screen.flags |= ACTION_ABSOLUTE_SWITCH;
+
+        break;
+    case XCB_XKB_SA_TYPE_SET_CONTROLS:
+        action->type = ACTION_TYPE_CTRL_SET;
+        {
+            const uint16_t mask = (wire->setcontrols.boolCtrlsLow |
+                                   (wire->setcontrols.boolCtrlsHigh << 8));
+            action->ctrls.ctrls = translate_controls_mask(mask);
+        }
+        break;
+    case XCB_XKB_SA_TYPE_LOCK_CONTROLS:
+        action->type = ACTION_TYPE_CTRL_LOCK;
+        {
+            const uint16_t mask = (wire->lockcontrols.boolCtrlsLow |
+                                   (wire->lockcontrols.boolCtrlsHigh << 8));
+            action->ctrls.ctrls = translate_controls_mask(mask);
+        }
+        break;
+
+    case XCB_XKB_SA_TYPE_NO_ACTION:
+    /* We don't support these. */
+    case XCB_XKB_SA_TYPE_ISO_LOCK:
+    case XCB_XKB_SA_TYPE_REDIRECT_KEY:
+    case XCB_XKB_SA_TYPE_ACTION_MESSAGE:
+    case XCB_XKB_SA_TYPE_DEVICE_BTN:
+    case XCB_XKB_SA_TYPE_LOCK_DEVICE_BTN:
+    case XCB_XKB_SA_TYPE_DEVICE_VALUATOR:
+        action->type = ACTION_TYPE_NONE;
+        break;
+    }
+}
+
+static bool
+get_types(struct xkb_keymap *keymap, xcb_connection_t *conn,
+          xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
+{
+    int types_length = xcb_xkb_get_map_map_types_rtrn_length(reply, map);
+    xcb_xkb_key_type_iterator_t types_iter =
+        xcb_xkb_get_map_map_types_rtrn_iterator(reply, map);
+
+    FAIL_UNLESS(reply->firstType == 0);
+
+    keymap->num_types = reply->nTypes;
+    ALLOC_OR_FAIL(keymap->types, keymap->num_types);
+
+    for (int i = 0; i < types_length; i++) {
+        xcb_xkb_key_type_t *wire_type = types_iter.data;
+        struct xkb_key_type *type = &keymap->types[i];
+
+        FAIL_UNLESS(wire_type->numLevels > 0);
+
+        type->mods.mods = translate_mods(wire_type->mods_mods,
+                                         wire_type->mods_vmods, 0);
+        type->mods.mask = translate_mods(wire_type->mods_mask, 0, 0);
+        type->num_levels = wire_type->numLevels;
+
+        {
+            int entries_length = xcb_xkb_key_type_map_length(wire_type);
+            xcb_xkb_kt_map_entry_iterator_t entries_iter =
+                xcb_xkb_key_type_map_iterator(wire_type);
+
+            type->num_entries = wire_type->nMapEntries;
+            ALLOC_OR_FAIL(type->entries, type->num_entries);
+
+            for (int j = 0; j < entries_length; j++) {
+                xcb_xkb_kt_map_entry_t *wire_entry = entries_iter.data;
+                struct xkb_key_type_entry *entry = &type->entries[j];
+
+                FAIL_UNLESS(wire_entry->level < type->num_levels);
+
+                entry->level = wire_entry->level;
+                entry->mods.mods = translate_mods(wire_entry->mods_mods,
+                                                  wire_entry->mods_vmods, 0);
+                entry->mods.mask = translate_mods(wire_entry->mods_mask, 0, 0);
+
+                xcb_xkb_kt_map_entry_next(&entries_iter);
+            }
+        }
+
+        {
+            int preserves_length = xcb_xkb_key_type_preserve_length(wire_type);
+            xcb_xkb_mod_def_iterator_t preserves_iter =
+                xcb_xkb_key_type_preserve_iterator(wire_type);
+
+            FAIL_UNLESS(preserves_length <= type->num_entries);
+
+            for (int j = 0; j < preserves_length; j++) {
+                xcb_xkb_mod_def_t *wire_preserve = preserves_iter.data;
+                struct xkb_key_type_entry *entry = &type->entries[j];
+
+                entry->preserve.mods = translate_mods(wire_preserve->realMods,
+                                                      wire_preserve->vmods, 0);
+                entry->preserve.mask = translate_mods(wire_preserve->mask, 0, 0);
+
+                xcb_xkb_mod_def_next(&preserves_iter);
+            }
+        }
+
+        xcb_xkb_key_type_next(&types_iter);
+    }
+
+    return true;
+
+fail:
+    return false;
+}
+
+static bool
+get_sym_maps(struct xkb_keymap *keymap, xcb_connection_t *conn,
+             xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
+{
+    int sym_maps_length = xcb_xkb_get_map_map_syms_rtrn_length(reply, map);
+    xcb_xkb_key_sym_map_iterator_t sym_maps_iter =
+        xcb_xkb_get_map_map_syms_rtrn_iterator(reply, map);
+
+    FAIL_UNLESS(reply->minKeyCode <= reply->maxKeyCode);
+    FAIL_UNLESS(reply->firstKeySym >= reply->minKeyCode);
+    FAIL_UNLESS(reply->firstKeySym + reply->nKeySyms <= reply->maxKeyCode + 1);
+
+    keymap->min_key_code = reply->minKeyCode;
+    keymap->max_key_code = reply->maxKeyCode;
+
+    ALLOC_OR_FAIL(keymap->keys, keymap->max_key_code + 1);
+
+    for (xkb_keycode_t kc = keymap->min_key_code; kc <= keymap->max_key_code; kc++)
+        keymap->keys[kc].keycode = kc;
+
+    for (int i = 0; i < sym_maps_length; i++) {
+        xcb_xkb_key_sym_map_t *wire_sym_map = sym_maps_iter.data;
+        struct xkb_key *key = &keymap->keys[reply->firstKeySym + i];
+
+        key->num_groups = wire_sym_map->groupInfo & 0x0f;
+        FAIL_UNLESS(key->num_groups <= ARRAY_SIZE(wire_sym_map->kt_index));
+        ALLOC_OR_FAIL(key->groups, key->num_groups);
+
+        for (int j = 0; j < key->num_groups; j++) {
+            FAIL_UNLESS(wire_sym_map->kt_index[j] < keymap->num_types);
+            key->groups[j].type = &keymap->types[wire_sym_map->kt_index[j]];
+
+            ALLOC_OR_FAIL(key->groups[j].levels, key->groups[j].type->num_levels);
+        }
+
+        key->out_of_range_group_number = (wire_sym_map->groupInfo & 0x30) >> 4;
+
+        FAIL_UNLESS(key->out_of_range_group_number <= key->num_groups);
+
+        if (wire_sym_map->groupInfo & XCB_XKB_GROUPS_WRAP_CLAMP_INTO_RANGE)
+            key->out_of_range_group_action = RANGE_SATURATE;
+        else if (wire_sym_map->groupInfo & XCB_XKB_GROUPS_WRAP_REDIRECT_INTO_RANGE)
+            key->out_of_range_group_action = RANGE_REDIRECT;
+        else
+            key->out_of_range_group_action = RANGE_WRAP;
+
+        {
+            int syms_length = xcb_xkb_key_sym_map_syms_length(wire_sym_map);
+            xcb_keysym_t *syms_iter = xcb_xkb_key_sym_map_syms(wire_sym_map);
+
+            FAIL_UNLESS(syms_length == wire_sym_map->width * key->num_groups);
+
+            for (int j = 0; j < syms_length; j++) {
+                xcb_keysym_t wire_keysym = *syms_iter;
+                const xkb_layout_index_t group = j / wire_sym_map->width;
+                const xkb_level_index_t level = j % wire_sym_map->width;
+
+                if (level < key->groups[group].type->num_levels &&
+                    wire_keysym != XKB_KEY_NoSymbol) {
+                    key->groups[group].levels[level].num_syms = 1;
+                    key->groups[group].levels[level].u.sym = wire_keysym;
+                }
+
+                syms_iter++;
+            }
+        }
+
+        xcb_xkb_key_sym_map_next(&sym_maps_iter);
+    }
+
+    return true;
+
+fail:
+    return false;
+}
+
+static bool
+get_actions(struct xkb_keymap *keymap, xcb_connection_t *conn,
+            xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
+{
+    int acts_count_length =
+        xcb_xkb_get_map_map_acts_rtrn_count_length(reply, map);
+    uint8_t *acts_count_iter = xcb_xkb_get_map_map_acts_rtrn_count(map);
+    xcb_xkb_action_iterator_t acts_iter =
+        xcb_xkb_get_map_map_acts_rtrn_acts_iterator(reply, map);
+    xcb_xkb_key_sym_map_iterator_t sym_maps_iter =
+        xcb_xkb_get_map_map_syms_rtrn_iterator(reply, map);
+
+    FAIL_UNLESS(reply->firstKeyAction == keymap->min_key_code);
+    FAIL_UNLESS(reply->firstKeyAction + reply->nKeyActions ==
+                keymap->max_key_code + 1);
+
+    for (int i = 0; i < acts_count_length; i++) {
+        xcb_xkb_key_sym_map_t *wire_sym_map = sym_maps_iter.data;
+        uint8_t wire_count = *acts_count_iter;
+        struct xkb_key *key = &keymap->keys[reply->firstKeyAction + i];
+
+        for (int j = 0; j < wire_count; j++) {
+            xcb_xkb_action_t *wire_action = acts_iter.data;
+            const xkb_layout_index_t group = j / wire_sym_map->width;
+            const xkb_level_index_t level = j % wire_sym_map->width;
+
+            if (level < key->groups[group].type->num_levels) {
+                union xkb_action *action =
+                    &key->groups[group].levels[level].action;
+
+                translate_action(action, wire_action);
+            }
+
+            xcb_xkb_action_next(&acts_iter);
+        }
+
+        acts_count_iter++;
+        xcb_xkb_key_sym_map_next(&sym_maps_iter);
+    }
+
+    return true;
+
+fail:
+    return false;
+}
+
+static bool
+get_vmods(struct xkb_keymap *keymap, xcb_connection_t *conn,
+          xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
+{
+    uint8_t *iter = xcb_xkb_get_map_map_vmods_rtrn(map);
+
+    darray_resize0(keymap->mods,
+                   NUM_REAL_MODS + msb_pos(reply->virtualMods));
+
+    for (int i = 0; i < NUM_VMODS; i++) {
+        if (reply->virtualMods & (1 << i)) {
+            uint8_t wire = *iter;
+            struct xkb_mod *mod = &darray_item(keymap->mods, NUM_REAL_MODS + i);
+
+            mod->type = MOD_VIRT;
+            mod->mapping = translate_mods(wire, 0, 0);
+
+            iter++;
+        }
+    }
+
+    return true;
+}
+
+static bool
+get_explicits(struct xkb_keymap *keymap, xcb_connection_t *conn,
+              xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
+{
+    int length = xcb_xkb_get_map_map_explicit_rtrn_length(reply, map);
+    xcb_xkb_set_explicit_iterator_t iter =
+        xcb_xkb_get_map_map_explicit_rtrn_iterator(reply, map);
+
+    for (int i = 0; i < length; i++) {
+        xcb_xkb_set_explicit_t *wire = iter.data;
+        struct xkb_key *key = &keymap->keys[wire->keycode];
+
+        FAIL_UNLESS(wire->keycode >= keymap->min_key_code &&
+                    wire->keycode <= keymap->max_key_code);
+
+        if ((wire->explicit & XCB_XKB_EXPLICIT_KEY_TYPE_1) &&
+            key->num_groups > 0)
+            key->groups[0].explicit_type = true;
+        if ((wire->explicit & XCB_XKB_EXPLICIT_KEY_TYPE_2) &&
+            key->num_groups > 1)
+            key->groups[1].explicit_type = true;
+        if ((wire->explicit & XCB_XKB_EXPLICIT_KEY_TYPE_3) &&
+            key->num_groups > 2)
+            key->groups[2].explicit_type = true;
+        if ((wire->explicit & XCB_XKB_EXPLICIT_KEY_TYPE_4) &&
+            key->num_groups > 3)
+            key->groups[3].explicit_type = true;
+        if (wire->explicit & XCB_XKB_EXPLICIT_INTERPRET)
+            key->explicit |= EXPLICIT_INTERP;
+        if (wire->explicit & XCB_XKB_EXPLICIT_AUTO_REPEAT)
+            key->explicit |= EXPLICIT_REPEAT;
+        if (wire->explicit & XCB_XKB_EXPLICIT_V_MOD_MAP)
+            key->explicit |= EXPLICIT_VMODMAP;
+
+        xcb_xkb_set_explicit_next(&iter);
+    }
+
+    return true;
+
+fail:
+    return false;
+}
+
+static bool
+get_modmaps(struct xkb_keymap *keymap, xcb_connection_t *conn,
+            xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
+{
+    int length = xcb_xkb_get_map_map_modmap_rtrn_length(reply, map);
+    xcb_xkb_key_mod_map_iterator_t iter =
+        xcb_xkb_get_map_map_modmap_rtrn_iterator(reply, map);
+
+    for (int i = 0; i < length; i++) {
+        xcb_xkb_key_mod_map_t *wire = iter.data;
+        struct xkb_key *key = &keymap->keys[wire->keycode];
+
+        FAIL_UNLESS(wire->keycode >= keymap->min_key_code &&
+                    wire->keycode <= keymap->max_key_code);
+
+        key->modmap = wire->mods;
+
+        xcb_xkb_key_mod_map_next(&iter);
+    }
+
+    return true;
+
+fail:
+    return false;
+}
+
+static bool
+get_vmodmaps(struct xkb_keymap *keymap, xcb_connection_t *conn,
+             xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
+{
+    int length = xcb_xkb_get_map_map_vmodmap_rtrn_length(reply, map);
+    xcb_xkb_key_v_mod_map_iterator_t iter =
+        xcb_xkb_get_map_map_vmodmap_rtrn_iterator(reply, map);
+
+    for (int i = 0; i < length; i++) {
+        xcb_xkb_key_v_mod_map_t *wire = iter.data;
+        struct xkb_key *key = &keymap->keys[wire->keycode];
+
+        FAIL_UNLESS(wire->keycode >= keymap->min_key_code &&
+                    wire->keycode <= keymap->max_key_code);
+
+        key->vmodmap = translate_mods(0, wire->vmods, 0);
+
+        xcb_xkb_key_v_mod_map_next(&iter);
+    }
+
+    return true;
+
+fail:
+    return false;
+}
+
+static bool
+get_map(struct xkb_keymap *keymap, xcb_connection_t *conn, uint16_t device_id)
+{
+    static const xcb_xkb_map_part_t required_components =
+        (XCB_XKB_MAP_PART_KEY_TYPES |
+         XCB_XKB_MAP_PART_KEY_SYMS |
+         XCB_XKB_MAP_PART_MODIFIER_MAP |
+         XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS |
+         XCB_XKB_MAP_PART_KEY_ACTIONS |
+         XCB_XKB_MAP_PART_VIRTUAL_MODS |
+         XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP);
+
+    xcb_xkb_get_map_cookie_t cookie =
+        xcb_xkb_get_map(conn, device_id, required_components,
+                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+    xcb_xkb_get_map_reply_t *reply = xcb_xkb_get_map_reply(conn, cookie, NULL);
+    xcb_xkb_get_map_map_t map;
+
+    FAIL_IF_BAD_REPLY(reply, "XkbGetMap");
+
+    if ((reply->present & required_components) != required_components)
+        goto fail;
+
+    xcb_xkb_get_map_map_unpack(xcb_xkb_get_map_map(reply),
+                               reply->nTypes,
+                               reply->nKeySyms,
+                               reply->nKeyActions,
+                               reply->totalActions,
+                               reply->totalKeyBehaviors,
+                               reply->virtualMods,
+                               reply->totalKeyExplicit,
+                               reply->totalModMapKeys,
+                               reply->totalVModMapKeys,
+                               reply->present,
+                               &map);
+
+    if (!get_types(keymap, conn, reply, &map) ||
+        !get_sym_maps(keymap, conn, reply, &map) ||
+        !get_actions(keymap, conn, reply, &map) ||
+        !get_vmods(keymap, conn, reply, &map) ||
+        !get_explicits(keymap, conn, reply, &map) ||
+        !get_modmaps(keymap, conn, reply, &map) ||
+        !get_vmodmaps(keymap, conn, reply, &map))
+        goto fail;
+
+    free(reply);
+    return true;
+
+fail:
+    free(reply);
+    return false;
+}
+
+static bool
+get_indicators(struct xkb_keymap *keymap, xcb_connection_t *conn,
+               xcb_xkb_get_indicator_map_reply_t *reply)
+{
+    xcb_xkb_indicator_map_iterator_t iter =
+        xcb_xkb_get_indicator_map_maps_iterator(reply);
+
+    darray_resize0(keymap->leds, msb_pos(reply->which));
+
+    for (int i = 0; i < NUM_INDICATORS; i++) {
+        if (reply->which & (1 << i)) {
+            xcb_xkb_indicator_map_t *wire = iter.data;
+            struct xkb_led *led = &darray_item(keymap->leds, i);
+
+            if (wire->whichGroups & XCB_XKB_IM_GROUPS_WHICH_USE_BASE)
+                led->which_groups |= XKB_STATE_LAYOUT_DEPRESSED;
+            if (wire->whichGroups & XCB_XKB_IM_GROUPS_WHICH_USE_LATCHED)
+                led->which_groups |= XKB_STATE_LAYOUT_LATCHED;
+            if (wire->whichGroups & XCB_XKB_IM_GROUPS_WHICH_USE_LOCKED)
+                led->which_groups |= XKB_STATE_LAYOUT_LOCKED;
+            if (wire->whichGroups & XCB_XKB_IM_GROUPS_WHICH_USE_EFFECTIVE)
+                led->which_groups |= XKB_STATE_LAYOUT_EFFECTIVE;
+            if (wire->whichGroups & XCB_XKB_IM_GROUPS_WHICH_USE_COMPAT)
+                led->which_groups |= XKB_STATE_LAYOUT_EFFECTIVE;
+
+            led->groups = wire->groups;
+
+            if (wire->whichMods & XCB_XKB_IM_MODS_WHICH_USE_BASE)
+                led->which_mods |= XKB_STATE_MODS_DEPRESSED;
+            if (wire->whichMods & XCB_XKB_IM_MODS_WHICH_USE_LATCHED)
+                led->which_mods |= XKB_STATE_MODS_LATCHED;
+            if (wire->whichMods & XCB_XKB_IM_MODS_WHICH_USE_LOCKED)
+                led->which_mods |= XKB_STATE_MODS_LOCKED;
+            if (wire->whichMods & XCB_XKB_IM_MODS_WHICH_USE_EFFECTIVE)
+                led->which_mods |= XKB_STATE_MODS_EFFECTIVE;
+            if (wire->whichMods & XCB_XKB_IM_MODS_WHICH_USE_COMPAT)
+                led->which_mods |= XKB_STATE_MODS_EFFECTIVE;
+
+            led->mods.mods = translate_mods(wire->realMods, wire->vmods, 0);
+            led->mods.mask = translate_mods(wire->mods, 0, 0);
+
+            led->ctrls = translate_controls_mask(wire->ctrls);
+
+            xcb_xkb_indicator_map_next(&iter);
+        }
+    }
+
+    return true;
+}
+
+static bool
+get_indicator_map(struct xkb_keymap *keymap, xcb_connection_t *conn,
+                  uint16_t device_id)
+{
+    xcb_xkb_get_indicator_map_cookie_t cookie =
+        xcb_xkb_get_indicator_map(conn, device_id, ALL_INDICATORS_MASK);
+    xcb_xkb_get_indicator_map_reply_t *reply =
+        xcb_xkb_get_indicator_map_reply(conn, cookie, NULL);
+
+    FAIL_IF_BAD_REPLY(reply, "XkbGetIndicatorMap");
+
+    if (!get_indicators(keymap, conn, reply))
+        goto fail;
+
+    free(reply);
+    return true;
+
+fail:
+    free(reply);
+    return false;
+}
+
+static bool
+get_sym_interprets(struct xkb_keymap *keymap, xcb_connection_t *conn,
+                   xcb_xkb_get_compat_map_reply_t *reply)
+{
+    int length = xcb_xkb_get_compat_map_si_rtrn_length(reply);
+    xcb_xkb_sym_interpret_iterator_t iter =
+        xcb_xkb_get_compat_map_si_rtrn_iterator(reply);
+
+    FAIL_UNLESS(reply->firstSIRtrn == 0);
+    FAIL_UNLESS(reply->nSIRtrn == reply->nTotalSI);
+
+    keymap->num_sym_interprets = reply->nSIRtrn;
+    ALLOC_OR_FAIL(keymap->sym_interprets, keymap->num_sym_interprets);
+
+    for (int i = 0; i < length; i++) {
+        xcb_xkb_sym_interpret_t *wire = iter.data;
+        struct xkb_sym_interpret *sym_interpret = &keymap->sym_interprets[i];
+
+        sym_interpret->sym = wire->sym;
+
+        switch (wire->match & XCB_XKB_SYM_INTERP_MATCH_OP_MASK) {
+        case XCB_XKB_SYM_INTERPRET_MATCH_NONE_OF:
+            sym_interpret->match = MATCH_NONE;
+            break;
+        case XCB_XKB_SYM_INTERPRET_MATCH_ANY_OF_OR_NONE:
+            sym_interpret->match = MATCH_ANY_OR_NONE;
+            break;
+        case XCB_XKB_SYM_INTERPRET_MATCH_ANY_OF:
+            sym_interpret->match = MATCH_ANY;
+            break;
+        case XCB_XKB_SYM_INTERPRET_MATCH_ALL_OF:
+            sym_interpret->match = MATCH_ALL;
+            break;
+        case XCB_XKB_SYM_INTERPRET_MATCH_EXACTLY:
+            sym_interpret->match = MATCH_EXACTLY;
+            break;
+        }
+
+        sym_interpret->level_one_only =
+            !!(wire->match & XCB_XKB_SYM_INTERP_MATCH_LEVEL_ONE_ONLY);
+        sym_interpret->mods = wire->mods;
+
+        if (wire->virtualMod == NO_MODIFIER)
+            sym_interpret->virtual_mod = XKB_MOD_INVALID;
+        else
+            sym_interpret->virtual_mod = NUM_REAL_MODS + wire->virtualMod;
+
+        sym_interpret->repeat = !!(wire->flags & 0x01);
+        translate_action(&sym_interpret->action,
+                         (xcb_xkb_action_t *) &wire->action);
+
+        xcb_xkb_sym_interpret_next(&iter);
+    }
+
+    return true;
+
+fail:
+    return false;
+}
+
+static bool
+get_compat_map(struct xkb_keymap *keymap, xcb_connection_t *conn,
+               uint16_t device_id)
+{
+    xcb_xkb_get_compat_map_cookie_t cookie =
+        xcb_xkb_get_compat_map(conn, device_id, 0, true, 0, 0);
+    xcb_xkb_get_compat_map_reply_t *reply =
+        xcb_xkb_get_compat_map_reply(conn, cookie, NULL);
+
+    FAIL_IF_BAD_REPLY(reply, "XkbGetCompatMap");
+
+    if (!get_sym_interprets(keymap, conn, reply))
+        goto fail;
+
+    free(reply);
+    return true;
+
+fail:
+    free(reply);
+    return false;
+}
+
+static bool
+get_type_names(struct xkb_keymap *keymap, xcb_connection_t *conn,
+               xcb_xkb_get_names_reply_t *reply,
+               xcb_xkb_get_names_value_list_t *list)
+{
+    int key_type_names_length =
+        xcb_xkb_get_names_value_list_type_names_length(reply, list);
+    xcb_atom_t *key_type_names_iter =
+        xcb_xkb_get_names_value_list_type_names(list);
+    int n_levels_per_type_length =
+        xcb_xkb_get_names_value_list_n_levels_per_type_length(reply, list);
+    uint8_t *n_levels_per_type_iter =
+        xcb_xkb_get_names_value_list_n_levels_per_type(list);
+    xcb_atom_t *kt_level_names_iter =
+        xcb_xkb_get_names_value_list_kt_level_names(list);
+
+    FAIL_UNLESS(reply->nTypes == keymap->num_types);
+    FAIL_UNLESS(key_type_names_length == n_levels_per_type_length);
+
+    for (int i = 0; i < key_type_names_length; i++) {
+        xcb_atom_t wire_type_name = *key_type_names_iter;
+        uint8_t wire_num_levels = *n_levels_per_type_iter;
+        struct xkb_key_type *type = &keymap->types[i];
+
+        /* Levels must have names. */
+        FAIL_UNLESS(type->num_levels == wire_num_levels);
+
+        ALLOC_OR_FAIL(type->level_names, type->num_levels);
+
+        if (!adopt_atom(keymap->ctx, conn, wire_type_name, &type->name))
+            goto fail;
+
+        if (!adopt_atoms(keymap->ctx, conn,
+                         kt_level_names_iter, type->level_names,
+                         wire_num_levels))
+            goto fail;
+
+        kt_level_names_iter += wire_num_levels;
+        key_type_names_iter++;
+        n_levels_per_type_iter++;
+    }
+
+    return true;
+
+fail:
+    return false;
+}
+
+static bool
+get_indicator_names(struct xkb_keymap *keymap, xcb_connection_t *conn,
+                    xcb_xkb_get_names_reply_t *reply,
+                    xcb_xkb_get_names_value_list_t *list)
+{
+    xcb_atom_t *iter = xcb_xkb_get_names_value_list_indicator_names(list);
+
+    FAIL_UNLESS(msb_pos(reply->indicators) <= darray_size(keymap->leds));
+
+    for (int i = 0; i < NUM_INDICATORS; i++) {
+        if (reply->indicators & (1 << i)) {
+            xcb_atom_t wire = *iter;
+            struct xkb_led *led = &darray_item(keymap->leds, i);
+
+            if (!adopt_atom(keymap->ctx, conn, wire, &led->name))
+                return false;
+
+            iter++;
+        }
+    }
+
+    return true;
+
+fail:
+    return false;
+}
+
+static bool
+get_vmod_names(struct xkb_keymap *keymap, xcb_connection_t *conn,
+               xcb_xkb_get_names_reply_t *reply,
+               xcb_xkb_get_names_value_list_t *list)
+{
+    xcb_atom_t *iter = xcb_xkb_get_names_value_list_virtual_mod_names(list);
+
+    /*
+     * GetMap's reply->virtualMods is always 0xffff. This one really
+     * tells us which vmods exist (a vmod must have a name), so we fix
+     * up the size here.
+     */
+    darray_resize0(keymap->mods, NUM_REAL_MODS + msb_pos(reply->virtualMods));
+
+    for (int i = 0; i < NUM_VMODS; i++) {
+        if (reply->virtualMods & (1 << i)) {
+            xcb_atom_t wire = *iter;
+            struct xkb_mod *mod = &darray_item(keymap->mods, NUM_REAL_MODS + i);
+
+            if (!adopt_atom(keymap->ctx, conn, wire, &mod->name))
+                return false;
+
+            iter++;
+        }
+    }
+
+    return true;
+}
+
+static bool
+get_group_names(struct xkb_keymap *keymap, xcb_connection_t *conn,
+                xcb_xkb_get_names_reply_t *reply,
+                xcb_xkb_get_names_value_list_t *list)
+{
+    int length = xcb_xkb_get_names_value_list_groups_length(reply, list);
+    xcb_atom_t *iter = xcb_xkb_get_names_value_list_groups(list);
+
+    keymap->num_group_names = msb_pos(reply->groupNames);
+    ALLOC_OR_FAIL(keymap->group_names, keymap->num_group_names);
+
+    if (!adopt_atoms(keymap->ctx, conn,
+                     iter, keymap->group_names, length))
+        goto fail;
+
+    return true;
+
+fail:
+    return false;
+}
+
+static bool
+get_key_names(struct xkb_keymap *keymap, xcb_connection_t *conn,
+              xcb_xkb_get_names_reply_t *reply,
+              xcb_xkb_get_names_value_list_t *list)
+{
+    int length = xcb_xkb_get_names_value_list_key_names_length(reply, list);
+    xcb_xkb_key_name_iterator_t iter =
+        xcb_xkb_get_names_value_list_key_names_iterator(reply, list);
+
+    FAIL_UNLESS(reply->minKeyCode == keymap->min_key_code);
+    FAIL_UNLESS(reply->maxKeyCode == keymap->max_key_code);
+    FAIL_UNLESS(reply->firstKey == keymap->min_key_code);
+    FAIL_UNLESS(reply->firstKey + reply->nKeys - 1 == keymap->max_key_code);
+
+    for (int i = 0; i < length; i++) {
+        xcb_xkb_key_name_t *wire = iter.data;
+        xkb_atom_t *key_name = &keymap->keys[reply->firstKey + i].name;
+
+        if (wire->name[0] == '\0') {
+            *key_name = XKB_ATOM_NONE;
+        }
+        else {
+            *key_name = xkb_atom_intern(keymap->ctx, wire->name,
+                                        strnlen(wire->name,
+                                                XCB_XKB_CONST_KEY_NAME_LENGTH));
+            if (!*key_name)
+                return false;
+        }
+
+        xcb_xkb_key_name_next(&iter);
+    }
+
+    return true;
+
+fail:
+    return false;
+}
+
+static bool
+get_aliases(struct xkb_keymap *keymap, xcb_connection_t *conn,
+            xcb_xkb_get_names_reply_t *reply,
+            xcb_xkb_get_names_value_list_t *list)
+{
+    int length = xcb_xkb_get_names_value_list_key_aliases_length(reply, list);
+    xcb_xkb_key_alias_iterator_t iter =
+        xcb_xkb_get_names_value_list_key_aliases_iterator(reply, list);
+
+    keymap->num_key_aliases = reply->nKeyAliases;
+    ALLOC_OR_FAIL(keymap->key_aliases, keymap->num_key_aliases);
+
+    for (int i = 0; i < length; i++) {
+        xcb_xkb_key_alias_t *wire = iter.data;
+        struct xkb_key_alias *alias = &keymap->key_aliases[i];
+
+        alias->real =
+            xkb_atom_intern(keymap->ctx, wire->real,
+                            strnlen(wire->real, XCB_XKB_CONST_KEY_NAME_LENGTH));
+        alias->alias =
+            xkb_atom_intern(keymap->ctx, wire->alias,
+                            strnlen(wire->alias, XCB_XKB_CONST_KEY_NAME_LENGTH));
+        if (!alias->real || !alias->alias)
+            goto fail;
+
+        xcb_xkb_key_alias_next(&iter);
+    }
+
+    return true;
+
+fail:
+    return false;
+}
+
+static bool
+get_names(struct xkb_keymap *keymap, xcb_connection_t *conn,
+          uint16_t device_id)
+{
+    static const xcb_xkb_name_detail_t required_names =
+        (XCB_XKB_NAME_DETAIL_KEYCODES |
+         XCB_XKB_NAME_DETAIL_SYMBOLS |
+         XCB_XKB_NAME_DETAIL_TYPES |
+         XCB_XKB_NAME_DETAIL_COMPAT |
+         XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES |
+         XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES |
+         XCB_XKB_NAME_DETAIL_INDICATOR_NAMES |
+         XCB_XKB_NAME_DETAIL_KEY_NAMES |
+         XCB_XKB_NAME_DETAIL_KEY_ALIASES |
+         XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES |
+         XCB_XKB_NAME_DETAIL_GROUP_NAMES);
+
+    xcb_xkb_get_names_cookie_t cookie =
+        xcb_xkb_get_names(conn, device_id, required_names);
+    xcb_xkb_get_names_reply_t *reply =
+        xcb_xkb_get_names_reply(conn, cookie, NULL);
+    xcb_xkb_get_names_value_list_t list;
+
+    FAIL_IF_BAD_REPLY(reply, "XkbGetNames");
+
+    if ((reply->which & required_names) != required_names)
+        goto fail;
+
+    xcb_xkb_get_names_value_list_unpack(xcb_xkb_get_names_value_list(reply),
+                                        reply->nTypes,
+                                        reply->indicators,
+                                        reply->virtualMods,
+                                        reply->groupNames,
+                                        reply->nKeys,
+                                        reply->nKeyAliases,
+                                        reply->nRadioGroups,
+                                        reply->which,
+                                        &list);
+
+    if (!get_atom_name(conn, list.keycodesName, &keymap->keycodes_section_name) ||
+        !get_atom_name(conn, list.symbolsName, &keymap->symbols_section_name) ||
+        !get_atom_name(conn, list.typesName, &keymap->types_section_name) ||
+        !get_atom_name(conn, list.compatName, &keymap->compat_section_name) ||
+        !get_type_names(keymap, conn, reply, &list) ||
+        !get_indicator_names(keymap, conn, reply, &list) ||
+        !get_vmod_names(keymap, conn, reply, &list) ||
+        !get_group_names(keymap, conn, reply, &list) ||
+        !get_key_names(keymap, conn, reply, &list) ||
+        !get_aliases(keymap, conn, reply, &list))
+        goto fail;
+
+    XkbEscapeMapName(keymap->keycodes_section_name);
+    XkbEscapeMapName(keymap->symbols_section_name);
+    XkbEscapeMapName(keymap->types_section_name);
+    XkbEscapeMapName(keymap->compat_section_name);
+
+    free(reply);
+    return true;
+
+fail:
+    free(reply);
+    return false;
+}
+
+static bool
+get_controls(struct xkb_keymap *keymap, xcb_connection_t *conn,
+             uint16_t device_id)
+{
+    xcb_xkb_get_controls_cookie_t cookie =
+        xcb_xkb_get_controls(conn, device_id);
+    xcb_xkb_get_controls_reply_t *reply =
+        xcb_xkb_get_controls_reply(conn, cookie, NULL);
+
+    FAIL_IF_BAD_REPLY(reply, "XkbGetControls");
+
+    keymap->enabled_ctrls = translate_controls_mask(reply->enabledControls);
+    keymap->num_groups = reply->numGroups;
+
+    FAIL_UNLESS(keymap->max_key_code < XCB_XKB_CONST_PER_KEY_BIT_ARRAY_SIZE * 8);
+
+    for (int i = keymap->min_key_code; i <= keymap->max_key_code; i++)
+        keymap->keys[i].repeats = !!(reply->perKeyRepeat[i / 8] & (1 << (i % 8)));
+
+    free(reply);
+    return true;
+
+fail:
+    free(reply);
+    return false;
+}
+
+XKB_EXPORT struct xkb_keymap *
+xkb_x11_keymap_new_from_device(struct xkb_context *ctx,
+                               xcb_connection_t *conn,
+                               int32_t device_id,
+                               enum xkb_keymap_compile_flags flags)
+{
+    struct xkb_keymap *keymap;
+    const enum xkb_keymap_format format = XKB_KEYMAP_FORMAT_TEXT_V1;
+
+    if (flags & ~(XKB_MAP_COMPILE_PLACEHOLDER)) {
+        log_err_func(ctx, "unrecognized flags: %#x\n", flags);
+        return NULL;
+    }
+
+    if (device_id < 0 || device_id > 255) {
+        log_err_func(ctx, "illegal device ID: %d\n", device_id);
+        return NULL;
+    }
+
+    keymap = xkb_keymap_new(ctx, format, flags);
+    if (!keymap)
+        return NULL;
+
+    if (!get_map(keymap, conn, device_id) ||
+        !get_indicator_map(keymap, conn, device_id) ||
+        !get_compat_map(keymap, conn, device_id) ||
+        !get_names(keymap, conn, device_id) ||
+        !get_controls(keymap, conn, device_id)) {
+        xkb_keymap_unref(keymap);
+        return NULL;
+    }
+
+    return keymap;
+}
diff --git a/src/3rdparty/xkbcommon/src/x11/x11-priv.h b/src/3rdparty/xkbcommon/src/x11/x11-priv.h
new file mode 100644
index 0000000000..03f9ee6710
--- /dev/null
+++ b/src/3rdparty/xkbcommon/src/x11/x11-priv.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright © 2013 Ran Benita
+ *
+ * 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 _XKBCOMMON_X11_PRIV_H
+#define _XKBCOMMON_X11_PRIV_H
+
+#include <xcb/xkb.h>
+
+#include "xkbcommon/xkbcommon-x11.h"
+#include "keymap.h"
+
+/* Get a strdup'd name of an X atom. */
+bool
+get_atom_name(xcb_connection_t *conn, xcb_atom_t atom, char **out);
+
+/*
+ * Make a xkb_atom_t's from X atoms (prefer to send as many as possible
+ * at once, to avoid many roundtrips).
+ *
+ * TODO: We can make this more flexible, such that @to doesn't have to
+ *       be sequential. Then we can convert most adopt_atom() calls to
+ *       adopt_atoms().
+ *       Atom caching would also likely be useful for avoiding quite a
+ *       few requests.
+ */
+bool
+adopt_atoms(struct xkb_context *ctx, xcb_connection_t *conn,
+            const xcb_atom_t *from, xkb_atom_t *to, size_t count);
+
+bool
+adopt_atom(struct xkb_context *ctx, xcb_connection_t *conn, xcb_atom_t atom,
+           xkb_atom_t *out);
+
+#endif
diff --git a/src/3rdparty/xkbcommon/src/x11/x11-state.c b/src/3rdparty/xkbcommon/src/x11/x11-state.c
new file mode 100644
index 0000000000..da7dcc23c2
--- /dev/null
+++ b/src/3rdparty/xkbcommon/src/x11/x11-state.c
@@ -0,0 +1,71 @@
+/*
+ * Copyright © 2013 Ran Benita
+ *
+ * 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.
+ */
+
+#include "x11-priv.h"
+
+static bool
+update_initial_state(struct xkb_state *state, xcb_connection_t *conn,
+                     uint16_t device_id)
+{
+    xcb_xkb_get_state_cookie_t cookie =
+        xcb_xkb_get_state(conn, device_id);
+    xcb_xkb_get_state_reply_t *reply =
+        xcb_xkb_get_state_reply(conn, cookie, NULL);
+
+    if (!reply)
+        return false;
+
+    xkb_state_update_mask(state,
+                          reply->baseMods,
+                          reply->latchedMods,
+                          reply->lockedMods,
+                          reply->baseGroup,
+                          reply->latchedGroup,
+                          reply->lockedGroup);
+
+    free(reply);
+    return true;
+}
+
+XKB_EXPORT struct xkb_state *
+xkb_x11_state_new_from_device(struct xkb_keymap *keymap,
+                              xcb_connection_t *conn, int32_t device_id)
+{
+    struct xkb_state *state;
+
+    if (device_id < 0 || device_id > 255) {
+        log_err_func(keymap->ctx, "illegal device ID: %d", device_id);
+        return NULL;
+    }
+
+    state = xkb_state_new(keymap);
+    if (!state)
+        return NULL;
+
+    if (!update_initial_state(state, conn, device_id)) {
+        xkb_state_unref(state);
+        return NULL;
+    }
+
+    return state;
+}
diff --git a/src/3rdparty/xkbcommon/src/xkb-keymap.c b/src/3rdparty/xkbcommon/src/xkb-keymap.c
index 3df183a64f..7d991d535d 100644
--- a/src/3rdparty/xkbcommon/src/xkb-keymap.c
+++ b/src/3rdparty/xkbcommon/src/xkb-keymap.c
@@ -53,26 +53,6 @@
 #include "keymap.h"
 #include "text.h"
 
-static struct xkb_keymap *
-xkb_keymap_new(struct xkb_context *ctx,
-               enum xkb_keymap_format format,
-               enum xkb_keymap_compile_flags flags)
-{
-    struct xkb_keymap *keymap;
-
-    keymap = calloc(1, sizeof(*keymap));
-    if (!keymap)
-        return NULL;
-
-    keymap->refcnt = 1;
-    keymap->ctx = xkb_context_ref(ctx);
-
-    keymap->format = format;
-    keymap->flags = flags;
-
-    return keymap;
-}
-
 XKB_EXPORT struct xkb_keymap *
 xkb_keymap_ref(struct xkb_keymap *keymap)
 {
@@ -83,30 +63,34 @@ xkb_keymap_ref(struct xkb_keymap *keymap)
 XKB_EXPORT void
 xkb_keymap_unref(struct xkb_keymap *keymap)
 {
-    unsigned int i, j;
-    struct xkb_key *key;
-
     if (!keymap || --keymap->refcnt > 0)
         return;
 
     if (keymap->keys) {
+        struct xkb_key *key;
         xkb_foreach_key(key, keymap) {
-            for (i = 0; i < key->num_groups; i++) {
-                for (j = 0; j < XkbKeyGroupWidth(key, i); j++)
-                    if (key->groups[i].levels[j].num_syms > 1)
-                        free(key->groups[i].levels[j].u.syms);
-                free(key->groups[i].levels);
+            if (key->groups) {
+                for (unsigned i = 0; i < key->num_groups; i++) {
+                    if (key->groups[i].levels) {
+                        for (unsigned j = 0; j < XkbKeyGroupWidth(key, i); j++)
+                            if (key->groups[i].levels[j].num_syms > 1)
+                                free(key->groups[i].levels[j].u.syms);
+                        free(key->groups[i].levels);
+                    }
+                }
+                free(key->groups);
             }
-            free(key->groups);
         }
         free(keymap->keys);
     }
-    for (i = 0; i < keymap->num_types; i++) {
-        free(keymap->types[i].entries);
-        free(keymap->types[i].level_names);
+    if (keymap->types) {
+        for (unsigned i = 0; i < keymap->num_types; i++) {
+            free(keymap->types[i].entries);
+            free(keymap->types[i].level_names);
+        }
+        free(keymap->types);
     }
-    free(keymap->types);
-    darray_free(keymap->sym_interprets);
+    free(keymap->sym_interprets);
     free(keymap->key_aliases);
     free(keymap->group_names);
     darray_free(keymap->mods);
@@ -190,35 +174,8 @@ xkb_keymap_new_from_string(struct xkb_context *ctx,
                            enum xkb_keymap_format format,
                            enum xkb_keymap_compile_flags flags)
 {
-    struct xkb_keymap *keymap;
-    const struct xkb_keymap_format_ops *ops;
-
-    ops = get_keymap_format_ops(format);
-    if (!ops || !ops->keymap_new_from_string) {
-        log_err_func(ctx, "unsupported keymap format: %d\n", format);
-        return NULL;
-    }
-
-    if (flags & ~(XKB_MAP_COMPILE_PLACEHOLDER)) {
-        log_err_func(ctx, "unrecognized flags: %#x\n", flags);
-        return NULL;
-    }
-
-    if (!string) {
-        log_err_func1(ctx, "no string specified\n");
-        return NULL;
-    }
-
-    keymap = xkb_keymap_new(ctx, format, flags);
-    if (!keymap)
-        return NULL;
-
-    if (!ops->keymap_new_from_string(keymap, string)) {
-        xkb_keymap_unref(keymap);
-        return NULL;
-    }
-
-    return keymap;
+    return xkb_keymap_new_from_buffer(ctx, string, strlen(string),
+                                      format, flags);
 }
 
 XKB_EXPORT struct xkb_keymap *
@@ -250,7 +207,7 @@ xkb_keymap_new_from_buffer(struct xkb_context *ctx,
     if (!keymap)
         return NULL;
 
-    if (!ops->keymap_new_from_buffer(keymap, buffer, length)) {
+    if (!ops->keymap_new_from_string(keymap, buffer, length)) {
         xkb_keymap_unref(keymap);
         return NULL;
     }
@@ -512,44 +469,38 @@ err:
     return 0;
 }
 
-/**
- * Simple boolean specifying whether or not the key should repeat.
- */
-XKB_EXPORT int
-xkb_keymap_key_repeats(struct xkb_keymap *keymap, xkb_keycode_t kc)
+XKB_EXPORT xkb_keycode_t
+xkb_keymap_min_keycode(struct xkb_keymap *keymap)
 {
-    const struct xkb_key *key = XkbKey(keymap, kc);
-
-    if (!key)
-        return 0;
+    return keymap->min_key_code;
+}
 
-    return key->repeats;
+XKB_EXPORT xkb_keycode_t
+xkb_keymap_max_keycode(struct xkb_keymap *keymap)
+{
+    return keymap->max_key_code;
 }
 
-struct xkb_key *
-XkbKeyByName(struct xkb_keymap *keymap, xkb_atom_t name, bool use_aliases)
+XKB_EXPORT void
+xkb_keymap_key_for_each(struct xkb_keymap *keymap, xkb_keymap_key_iter_t iter,
+                        void *data)
 {
     struct xkb_key *key;
 
     xkb_foreach_key(key, keymap)
-        if (key->name == name)
-            return key;
-
-    if (use_aliases) {
-        xkb_atom_t new_name = XkbResolveKeyAlias(keymap, name);
-        if (new_name != XKB_ATOM_NONE)
-            return XkbKeyByName(keymap, new_name, false);
-    }
-
-    return NULL;
+        iter(keymap, key->keycode, data);
 }
 
-xkb_atom_t
-XkbResolveKeyAlias(struct xkb_keymap *keymap, xkb_atom_t name)
+/**
+ * Simple boolean specifying whether or not the key should repeat.
+ */
+XKB_EXPORT int
+xkb_keymap_key_repeats(struct xkb_keymap *keymap, xkb_keycode_t kc)
 {
-    for (unsigned i = 0; i < keymap->num_key_aliases; i++)
-        if (keymap->key_aliases[i].alias == name)
-            return keymap->key_aliases[i].real;
+    const struct xkb_key *key = XkbKey(keymap, kc);
 
-    return XKB_ATOM_NONE;
+    if (!key)
+        return 0;
+
+    return key->repeats;
 }
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/action.c b/src/3rdparty/xkbcommon/src/xkbcomp/action.c
index 88323f9952..2bd0bd1589 100644
--- a/src/3rdparty/xkbcommon/src/xkbcomp/action.c
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/action.c
@@ -56,18 +56,22 @@
 #include "expr.h"
 #include "action.h"
 
-static const ExprDef constTrue = {
-    .common = { .type = STMT_EXPR, .next = NULL },
-    .op = EXPR_VALUE,
-    .value_type = EXPR_TYPE_BOOLEAN,
-    .value = { .ival = 1 },
+static const ExprBoolean constTrue = {
+    .expr = {
+        .common = { .type = STMT_EXPR, .next = NULL },
+        .op = EXPR_VALUE,
+        .value_type = EXPR_TYPE_BOOLEAN,
+    },
+    .set = true,
 };
 
-static const ExprDef constFalse = {
-    .common = { .type = STMT_EXPR, .next = NULL },
-    .op = EXPR_VALUE,
-    .value_type = EXPR_TYPE_BOOLEAN,
-    .value = { .ival = 0 },
+static const ExprBoolean constFalse = {
+    .expr = {
+        .common = { .type = STMT_EXPR, .next = NULL },
+        .op = EXPR_VALUE,
+        .value_type = EXPR_TYPE_BOOLEAN,
+    },
+    .set = false,
 };
 
 enum action_field {
@@ -214,17 +218,6 @@ ReportActionNotArray(struct xkb_keymap *keymap, enum xkb_action_type action,
     return false;
 }
 
-static inline bool
-ReportNotFound(struct xkb_keymap *keymap, enum xkb_action_type action,
-               enum action_field field, const char *what, const char *bad)
-{
-    log_err(keymap->ctx,
-            "%s named %s not found; "
-            "Ignoring the %s field of an %s action\n",
-            what, bad, fieldText(field), ActionTypeText(action));
-    return false;
-}
-
 static bool
 HandleNoAction(struct xkb_keymap *keymap, union xkb_action *action,
                enum action_field field, const ExprDef *array_ndx,
@@ -265,9 +258,9 @@ CheckModifierField(struct xkb_keymap *keymap, enum xkb_action_type action,
                    const ExprDef *value, enum xkb_action_flags *flags_inout,
                    xkb_mod_mask_t *mods_rtrn)
 {
-    if (value->op == EXPR_IDENT) {
+    if (value->expr.op == EXPR_IDENT) {
         const char *valStr;
-        valStr = xkb_atom_text(keymap->ctx, value->value.str);
+        valStr = xkb_atom_text(keymap->ctx, value->ident.ident);
         if (valStr && (istreq(valStr, "usemodmapmods") ||
                        istreq(valStr, "modmapmods"))) {
 
@@ -367,9 +360,9 @@ CheckGroupField(struct xkb_keymap *keymap, unsigned action,
 {
     const ExprDef *spec;
 
-    if (value->op == EXPR_NEGATE || value->op == EXPR_UNARY_PLUS) {
+    if (value->expr.op == EXPR_NEGATE || value->expr.op == EXPR_UNARY_PLUS) {
         *flags_inout &= ~ACTION_ABSOLUTE_SWITCH;
-        spec = value->value.child;
+        spec = value->unary.child;
     }
     else {
         *flags_inout |= ACTION_ABSOLUTE_SWITCH;
@@ -380,9 +373,9 @@ CheckGroupField(struct xkb_keymap *keymap, unsigned action,
         return ReportMismatch(keymap, action, ACTION_FIELD_GROUP,
                               "integer (range 1..8)");
 
-    if (value->op == EXPR_NEGATE)
+    if (value->expr.op == EXPR_NEGATE)
         *grp_rtrn = -*grp_rtrn;
-    else if (value->op != EXPR_UNARY_PLUS)
+    else if (value->expr.op != EXPR_UNARY_PLUS)
         (*grp_rtrn)--;
 
     return true;
@@ -464,18 +457,14 @@ HandleMovePtr(struct xkb_keymap *keymap, union xkb_action *action,
               const ExprDef *value)
 {
     struct xkb_pointer_action *act = &action->ptr;
-    bool absolute;
 
     if (array_ndx && (field == ACTION_FIELD_X || field == ACTION_FIELD_Y))
         return ReportActionNotArray(keymap, action->type, field);
 
     if (field == ACTION_FIELD_X || field == ACTION_FIELD_Y) {
         int val;
-
-        if (value->op == EXPR_NEGATE || value->op == EXPR_UNARY_PLUS)
-            absolute = false;
-        else
-            absolute = true;
+        const bool absolute = (value->expr.op != EXPR_NEGATE &&
+                               value->expr.op != EXPR_UNARY_PLUS);
 
         if (!ExprResolveInteger(keymap->ctx, value, &val))
             return ReportMismatch(keymap, action->type, field, "integer");
@@ -613,9 +602,10 @@ HandleSetPtrDflt(struct xkb_keymap *keymap, union xkb_action *action,
         if (array_ndx)
             return ReportActionNotArray(keymap, action->type, field);
 
-        if (value->op == EXPR_NEGATE || value->op == EXPR_UNARY_PLUS) {
+        if (value->expr.op == EXPR_NEGATE ||
+            value->expr.op == EXPR_UNARY_PLUS) {
             act->flags &= ~ACTION_ABSOLUTE_SWITCH;
-            button = value->value.child;
+            button = value->unary.child;
         }
         else {
             act->flags |= ACTION_ABSOLUTE_SWITCH;
@@ -639,7 +629,7 @@ HandleSetPtrDflt(struct xkb_keymap *keymap, union xkb_action *action,
             return false;
         }
 
-        act->value = (value->op == EXPR_NEGATE ? -btn: btn);
+        act->value = (value->expr.op == EXPR_NEGATE ? -btn: btn);
         return true;
     }
 
@@ -660,9 +650,10 @@ HandleSwitchScreen(struct xkb_keymap *keymap, union xkb_action *action,
         if (array_ndx)
             return ReportActionNotArray(keymap, action->type, field);
 
-        if (value->op == EXPR_NEGATE || value->op == EXPR_UNARY_PLUS) {
+        if (value->expr.op == EXPR_NEGATE ||
+            value->expr.op == EXPR_UNARY_PLUS) {
             act->flags &= ~ACTION_ABSOLUTE_SWITCH;
-            scrn = value->value.child;
+            scrn = value->unary.child;
         }
         else {
             act->flags |= ACTION_ABSOLUTE_SWITCH;
@@ -680,7 +671,7 @@ HandleSwitchScreen(struct xkb_keymap *keymap, union xkb_action *action,
             return false;
         }
 
-        act->screen = (value->op == EXPR_NEGATE ? -val : val);
+        act->screen = (value->expr.op == EXPR_NEGATE ? -val : val);
         return true;
     }
     else if (field == ACTION_FIELD_SAME) {
@@ -861,13 +852,13 @@ HandleActionDef(ExprDef *def, struct xkb_keymap *keymap,
     const char *str;
     unsigned handler_type;
 
-    if (def->op != EXPR_ACTION_DECL) {
+    if (def->expr.op != EXPR_ACTION_DECL) {
         log_err(keymap->ctx, "Expected an action definition, found %s\n",
-                expr_op_type_to_string(def->op));
+                expr_op_type_to_string(def->expr.op));
         return false;
     }
 
-    str = xkb_atom_text(keymap->ctx, def->value.action.name);
+    str = xkb_atom_text(keymap->ctx, def->action.name);
     if (!stringToAction(str, &handler_type)) {
         log_err(keymap->ctx, "Unknown action %s\n", str);
         return false;
@@ -885,24 +876,24 @@ HandleActionDef(ExprDef *def, struct xkb_keymap *keymap,
      * particular instance, e.g. "modifiers" and "clearLocks" in:
      *     SetMods(modifiers=Alt,clearLocks);
      */
-    for (arg = def->value.action.args; arg != NULL;
+    for (arg = def->action.args; arg != NULL;
          arg = (ExprDef *) arg->common.next) {
         const ExprDef *value;
         ExprDef *field, *arrayRtrn;
         const char *elemRtrn, *fieldRtrn;
         enum action_field fieldNdx;
 
-        if (arg->op == EXPR_ASSIGN) {
-            field = arg->value.binary.left;
-            value = arg->value.binary.right;
+        if (arg->expr.op == EXPR_ASSIGN) {
+            field = arg->binary.left;
+            value = arg->binary.right;
         }
-        else if (arg->op == EXPR_NOT || arg->op == EXPR_INVERT) {
-            field = arg->value.child;
-            value = &constFalse;
+        else if (arg->expr.op == EXPR_NOT || arg->expr.op == EXPR_INVERT) {
+            field = arg->unary.child;
+            value = (const ExprDef *) &constFalse;
         }
         else {
             field = arg;
-            value = &constTrue;
+            value = (const ExprDef *) &constTrue;
         }
 
         if (!ExprResolveLhs(keymap->ctx, field, &elemRtrn, &fieldRtrn,
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/ast-build.c b/src/3rdparty/xkbcommon/src/xkbcomp/ast-build.c
index c9b7cb0a3e..d470884e78 100644
--- a/src/3rdparty/xkbcommon/src/xkbcomp/ast-build.c
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/ast-build.c
@@ -70,57 +70,173 @@ AppendStmt(ParseCommon *to, ParseCommon *append)
     return to;
 }
 
-ExprDef *
-ExprCreate(enum expr_op_type op, enum expr_value_type type)
+static ExprDef *
+ExprCreate(enum expr_op_type op, enum expr_value_type type, size_t size)
 {
-    ExprDef *expr = malloc(sizeof(*expr));
+    ExprDef *expr = malloc(size);
     if (!expr)
         return NULL;
 
     expr->common.type = STMT_EXPR;
     expr->common.next = NULL;
-    expr->op = op;
-    expr->value_type = type;
+    expr->expr.op = op;
+    expr->expr.value_type = type;
 
     return expr;
 }
 
+#define EXPR_CREATE(type_, name_, op_, value_type_) \
+    ExprDef *name_ = ExprCreate(op_, value_type_, sizeof(type_)); \
+    if (!name_) \
+        return NULL;
+
+ExprDef *
+ExprCreateString(xkb_atom_t str)
+{
+    EXPR_CREATE(ExprString, expr, EXPR_VALUE, EXPR_TYPE_STRING);
+    expr->string.str = str;
+    return expr;
+}
+
+ExprDef *
+ExprCreateInteger(int ival)
+{
+    EXPR_CREATE(ExprInteger, expr, EXPR_VALUE, EXPR_TYPE_INT);
+    expr->integer.ival = ival;
+    return expr;
+}
+
+ExprDef *
+ExprCreateBoolean(bool set)
+{
+    EXPR_CREATE(ExprBoolean, expr, EXPR_VALUE, EXPR_TYPE_BOOLEAN);
+    expr->boolean.set = set;
+    return expr;
+}
+
+ExprDef *
+ExprCreateKeyName(xkb_atom_t key_name)
+{
+    EXPR_CREATE(ExprKeyName, expr, EXPR_VALUE, EXPR_TYPE_KEYNAME);
+    expr->key_name.key_name = key_name;
+    return expr;
+}
+
+ExprDef *
+ExprCreateIdent(xkb_atom_t ident)
+{
+    EXPR_CREATE(ExprIdent, expr, EXPR_IDENT, EXPR_TYPE_UNKNOWN);
+    expr->ident.ident = ident;
+    return expr;
+}
+
 ExprDef *
 ExprCreateUnary(enum expr_op_type op, enum expr_value_type type,
                 ExprDef *child)
 {
-    ExprDef *expr = malloc(sizeof(*expr));
-    if (!expr)
-        return NULL;
+    EXPR_CREATE(ExprUnary, expr, op, type);
+    expr->unary.child = child;
+    return expr;
+}
 
-    expr->common.type = STMT_EXPR;
-    expr->common.next = NULL;
-    expr->op = op;
-    expr->value_type = type;
-    expr->value.child = child;
+ExprDef *
+ExprCreateBinary(enum expr_op_type op, ExprDef *left, ExprDef *right)
+{
+    EXPR_CREATE(ExprBinary, expr, op, EXPR_TYPE_UNKNOWN);
+
+    if (op == EXPR_ASSIGN || left->expr.value_type == EXPR_TYPE_UNKNOWN)
+        expr->expr.value_type = right->expr.value_type;
+    else if (left->expr.value_type == right->expr.value_type ||
+             right->expr.value_type == EXPR_TYPE_UNKNOWN)
+        expr->expr.value_type = left->expr.value_type;
+    expr->binary.left = left;
+    expr->binary.right = right;
 
     return expr;
 }
 
 ExprDef *
-ExprCreateBinary(enum expr_op_type op, ExprDef *left, ExprDef *right)
+ExprCreateFieldRef(xkb_atom_t element, xkb_atom_t field)
 {
-    ExprDef *expr = malloc(sizeof(*expr));
-    if (!expr)
-        return NULL;
+    EXPR_CREATE(ExprFieldRef, expr, EXPR_FIELD_REF, EXPR_TYPE_UNKNOWN);
+    expr->field_ref.element = element;
+    expr->field_ref.field = field;
+    return expr;
+}
 
-    expr->common.type = STMT_EXPR;
-    expr->common.next = NULL;
-    expr->op = op;
-    if (op == EXPR_ASSIGN || left->value_type == EXPR_TYPE_UNKNOWN)
-        expr->value_type = right->value_type;
-    else if (left->value_type == right->value_type ||
-             right->value_type == EXPR_TYPE_UNKNOWN)
-        expr->value_type = left->value_type;
-    else
-        expr->value_type = EXPR_TYPE_UNKNOWN;
-    expr->value.binary.left = left;
-    expr->value.binary.right = right;
+ExprDef *
+ExprCreateArrayRef(xkb_atom_t element, xkb_atom_t field, ExprDef *entry)
+{
+    EXPR_CREATE(ExprArrayRef, expr, EXPR_ARRAY_REF, EXPR_TYPE_UNKNOWN);
+    expr->array_ref.element = element;
+    expr->array_ref.field = field;
+    expr->array_ref.entry = entry;
+    return expr;
+}
+
+ExprDef *
+ExprCreateAction(xkb_atom_t name, ExprDef *args)
+{
+    EXPR_CREATE(ExprAction, expr, EXPR_ACTION_DECL, EXPR_TYPE_UNKNOWN);
+    expr->action.name = name;
+    expr->action.args = args;
+    return expr;
+}
+
+ExprDef *
+ExprCreateKeysymList(xkb_keysym_t sym)
+{
+    EXPR_CREATE(ExprKeysymList, expr, EXPR_KEYSYM_LIST, EXPR_TYPE_SYMBOLS);
+
+    darray_init(expr->keysym_list.syms);
+    darray_init(expr->keysym_list.symsMapIndex);
+    darray_init(expr->keysym_list.symsNumEntries);
+
+    darray_append(expr->keysym_list.syms, sym);
+    darray_append(expr->keysym_list.symsMapIndex, 0);
+    darray_append(expr->keysym_list.symsNumEntries, 1);
+
+    return expr;
+}
+
+ExprDef *
+ExprCreateMultiKeysymList(ExprDef *expr)
+{
+    size_t nLevels = darray_size(expr->keysym_list.symsMapIndex);
+
+    darray_resize(expr->keysym_list.symsMapIndex, 1);
+    darray_resize(expr->keysym_list.symsNumEntries, 1);
+    darray_item(expr->keysym_list.symsMapIndex, 0) = 0;
+    darray_item(expr->keysym_list.symsNumEntries, 0) = nLevels;
+
+    return expr;
+}
+
+ExprDef *
+ExprAppendKeysymList(ExprDef *expr, xkb_keysym_t sym)
+{
+    size_t nSyms = darray_size(expr->keysym_list.syms);
+
+    darray_append(expr->keysym_list.symsMapIndex, nSyms);
+    darray_append(expr->keysym_list.symsNumEntries, 1);
+    darray_append(expr->keysym_list.syms, sym);
+
+    return expr;
+}
+
+ExprDef *
+ExprAppendMultiKeysymList(ExprDef *expr, ExprDef *append)
+{
+    size_t nSyms = darray_size(expr->keysym_list.syms);
+    size_t numEntries = darray_size(append->keysym_list.syms);
+
+    darray_append(expr->keysym_list.symsMapIndex, nSyms);
+    darray_append(expr->keysym_list.symsNumEntries, numEntries);
+    darray_append_items(expr->keysym_list.syms,
+                        darray_mem(append->keysym_list.syms, 0), numEntries);
+
+    darray_resize(append->keysym_list.syms, 0);
+    FreeStmt(&append->common);
 
     return expr;
 }
@@ -186,22 +302,14 @@ VarCreate(ExprDef *name, ExprDef *value)
 }
 
 VarDef *
-BoolVarCreate(xkb_atom_t nameToken, unsigned set)
+BoolVarCreate(xkb_atom_t ident, bool set)
 {
-    ExprDef *name, *value;
-    VarDef *def;
-
-    name = ExprCreate(EXPR_IDENT, EXPR_TYPE_UNKNOWN);
-    name->value.str = nameToken;
-    value = ExprCreate(EXPR_VALUE, EXPR_TYPE_BOOLEAN);
-    value->value.uval = set;
-    def = VarCreate(name, value);
-
-    return def;
+    return VarCreate((ExprDef *) ExprCreateIdent(ident),
+                     (ExprDef *) ExprCreateBoolean(set));
 }
 
 InterpDef *
-InterpCreate(char *sym, ExprDef *match)
+InterpCreate(xkb_keysym_t sym, ExprDef *match)
 {
     InterpDef *def = malloc(sizeof(*def));
     if (!def)
@@ -232,7 +340,7 @@ KeyTypeCreate(xkb_atom_t name, VarDef *body)
 }
 
 SymbolsDef *
-SymbolsCreate(xkb_atom_t keyName, ExprDef *symbols)
+SymbolsCreate(xkb_atom_t keyName, VarDef *symbols)
 {
     SymbolsDef *def = malloc(sizeof(*def));
     if (!def)
@@ -312,83 +420,6 @@ LedNameCreate(int ndx, ExprDef *name, bool virtual)
     return def;
 }
 
-ExprDef *
-ActionCreate(xkb_atom_t name, ExprDef *args)
-{
-    ExprDef *act = malloc(sizeof(*act));
-    if (!act)
-        return NULL;
-
-    act->common.type = STMT_EXPR;
-    act->common.next = NULL;
-    act->op = EXPR_ACTION_DECL;
-    act->value.action.name = name;
-    act->value.action.args = args;
-
-    return act;
-}
-
-ExprDef *
-CreateKeysymList(char *sym)
-{
-    ExprDef *def;
-
-    def = ExprCreate(EXPR_KEYSYM_LIST, EXPR_TYPE_SYMBOLS);
-
-    darray_init(def->value.list.syms);
-    darray_init(def->value.list.symsMapIndex);
-    darray_init(def->value.list.symsNumEntries);
-
-    darray_append(def->value.list.syms, sym);
-    darray_append(def->value.list.symsMapIndex, 0);
-    darray_append(def->value.list.symsNumEntries, 1);
-
-    return def;
-}
-
-ExprDef *
-CreateMultiKeysymList(ExprDef *list)
-{
-    size_t nLevels = darray_size(list->value.list.symsMapIndex);
-
-    darray_resize(list->value.list.symsMapIndex, 1);
-    darray_resize(list->value.list.symsNumEntries, 1);
-    darray_item(list->value.list.symsMapIndex, 0) = 0;
-    darray_item(list->value.list.symsNumEntries, 0) = nLevels;
-
-    return list;
-}
-
-ExprDef *
-AppendKeysymList(ExprDef *list, char *sym)
-{
-    size_t nSyms = darray_size(list->value.list.syms);
-
-    darray_append(list->value.list.symsMapIndex, nSyms);
-    darray_append(list->value.list.symsNumEntries, 1);
-    darray_append(list->value.list.syms, sym);
-
-    return list;
-}
-
-ExprDef *
-AppendMultiKeysymList(ExprDef *list, ExprDef *append)
-{
-    size_t nSyms = darray_size(list->value.list.syms);
-    size_t numEntries = darray_size(append->value.list.syms);
-
-    darray_append(list->value.list.symsMapIndex, nSyms);
-    darray_append(list->value.list.symsNumEntries, numEntries);
-    darray_append_items(list->value.list.syms,
-                        darray_mem(append->value.list.syms, 0),
-                        numEntries);
-
-    darray_resize(append->value.list.syms, 0);
-    FreeStmt(&append->common);
-
-    return list;
-}
-
 static void
 FreeInclude(IncludeStmt *incl);
 
@@ -464,30 +495,6 @@ err:
     return NULL;
 }
 
-static void
-EscapeMapName(char *name)
-{
-    /*
-     * All latin-1 alphanumerics, plus parens, slash, minus, underscore and
-     * wildcards.
-     */
-    static const unsigned char legal[] = {
-        0x00, 0x00, 0x00, 0x00, 0x00, 0xa7, 0xff, 0x83,
-        0xfe, 0xff, 0xff, 0x87, 0xfe, 0xff, 0xff, 0x07,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff
-    };
-
-    if (!name)
-        return;
-
-    while (*name) {
-        if (!(legal[*name / 8] & (1 << (*name % 8))))
-            *name = '_';
-        name++;
-    }
-}
-
 XkbFile *
 XkbFileCreate(struct xkb_context *ctx, enum xkb_file_type type, char *name,
               ParseCommon *defs, enum xkb_map_flags flags)
@@ -498,7 +505,7 @@ XkbFileCreate(struct xkb_context *ctx, enum xkb_file_type type, char *name,
     if (!file)
         return NULL;
 
-    EscapeMapName(name);
+    XkbEscapeMapName(name);
     file->file_type = type;
     file->topName = strdup_safe(name);
     file->name = name;
@@ -549,18 +556,16 @@ err:
 static void
 FreeExpr(ExprDef *expr)
 {
-    char **sym;
-
     if (!expr)
         return;
 
-    switch (expr->op) {
+    switch (expr->expr.op) {
     case EXPR_ACTION_LIST:
     case EXPR_NEGATE:
     case EXPR_UNARY_PLUS:
     case EXPR_NOT:
     case EXPR_INVERT:
-        FreeStmt(&expr->value.child->common);
+        FreeStmt(&expr->unary.child->common);
         break;
 
     case EXPR_DIVIDE:
@@ -568,24 +573,22 @@ FreeExpr(ExprDef *expr)
     case EXPR_SUBTRACT:
     case EXPR_MULTIPLY:
     case EXPR_ASSIGN:
-        FreeStmt(&expr->value.binary.left->common);
-        FreeStmt(&expr->value.binary.right->common);
+        FreeStmt(&expr->binary.left->common);
+        FreeStmt(&expr->binary.right->common);
         break;
 
     case EXPR_ACTION_DECL:
-        FreeStmt(&expr->value.action.args->common);
+        FreeStmt(&expr->action.args->common);
         break;
 
     case EXPR_ARRAY_REF:
-        FreeStmt(&expr->value.array.entry->common);
+        FreeStmt(&expr->array_ref.entry->common);
         break;
 
     case EXPR_KEYSYM_LIST:
-        darray_foreach(sym, expr->value.list.syms)
-            free(*sym);
-        darray_free(expr->value.list.syms);
-        darray_free(expr->value.list.symsMapIndex);
-        darray_free(expr->value.list.symsNumEntries);
+        darray_free(expr->keysym_list.syms);
+        darray_free(expr->keysym_list.symsMapIndex);
+        darray_free(expr->keysym_list.symsNumEntries);
         break;
 
     default:
@@ -640,7 +643,6 @@ FreeStmt(ParseCommon *stmt)
             FreeStmt(&u.keyType->body->common);
             break;
         case STMT_INTERP:
-            free(u.interp->sym);
             FreeStmt(&u.interp->match->common);
             FreeStmt(&u.interp->def->common);
             break;
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/ast-build.h b/src/3rdparty/xkbcommon/src/xkbcomp/ast-build.h
index 0ecd124145..8146b066d1 100644
--- a/src/3rdparty/xkbcommon/src/xkbcomp/ast-build.h
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/ast-build.h
@@ -31,7 +31,19 @@ ParseCommon *
 AppendStmt(ParseCommon *to, ParseCommon *append);
 
 ExprDef *
-ExprCreate(enum expr_op_type op, enum expr_value_type type);
+ExprCreateString(xkb_atom_t str);
+
+ExprDef *
+ExprCreateInteger(int ival);
+
+ExprDef *
+ExprCreateBoolean(bool set);
+
+ExprDef *
+ExprCreateKeyName(xkb_atom_t key_name);
+
+ExprDef *
+ExprCreateIdent(xkb_atom_t ident);
 
 ExprDef *
 ExprCreateUnary(enum expr_op_type op, enum expr_value_type type,
@@ -40,6 +52,27 @@ ExprCreateUnary(enum expr_op_type op, enum expr_value_type type,
 ExprDef *
 ExprCreateBinary(enum expr_op_type op, ExprDef *left, ExprDef *right);
 
+ExprDef *
+ExprCreateFieldRef(xkb_atom_t element, xkb_atom_t field);
+
+ExprDef *
+ExprCreateArrayRef(xkb_atom_t element, xkb_atom_t field, ExprDef *entry);
+
+ExprDef *
+ExprCreateAction(xkb_atom_t name, ExprDef *args);
+
+ExprDef *
+ExprCreateMultiKeysymList(ExprDef *list);
+
+ExprDef *
+ExprCreateKeysymList(xkb_keysym_t sym);
+
+ExprDef *
+ExprAppendMultiKeysymList(ExprDef *list, ExprDef *append);
+
+ExprDef *
+ExprAppendKeysymList(ExprDef *list, xkb_keysym_t sym);
+
 KeycodeDef *
 KeycodeCreate(xkb_atom_t name, int64_t value);
 
@@ -53,16 +86,16 @@ VarDef *
 VarCreate(ExprDef *name, ExprDef *value);
 
 VarDef *
-BoolVarCreate(xkb_atom_t nameToken, unsigned set);
+BoolVarCreate(xkb_atom_t ident, bool set);
 
 InterpDef *
-InterpCreate(char *sym, ExprDef *match);
+InterpCreate(xkb_keysym_t sym, ExprDef *match);
 
 KeyTypeDef *
 KeyTypeCreate(xkb_atom_t name, VarDef *body);
 
 SymbolsDef *
-SymbolsCreate(xkb_atom_t keyName, ExprDef *symbols);
+SymbolsCreate(xkb_atom_t keyName, VarDef *symbols);
 
 GroupCompatDef *
 GroupCompatCreate(int group, ExprDef *def);
@@ -76,27 +109,12 @@ LedMapCreate(xkb_atom_t name, VarDef *body);
 LedNameDef *
 LedNameCreate(int ndx, ExprDef *name, bool virtual);
 
-ExprDef *
-ActionCreate(xkb_atom_t name, ExprDef *args);
-
-ExprDef *
-CreateMultiKeysymList(ExprDef *list);
-
-ExprDef *
-CreateKeysymList(char *sym);
-
-ExprDef *
-AppendMultiKeysymList(ExprDef *list, ExprDef *append);
-
-ExprDef *
-AppendKeysymList(ExprDef *list, char *sym);
-
 IncludeStmt *
 IncludeCreate(struct xkb_context *ctx, char *str, enum merge_mode merge);
 
 XkbFile *
 XkbFileCreate(struct xkb_context *ctx, enum xkb_file_type type, char *name,
-              ParseCommon *defs, unsigned flags);
+              ParseCommon *defs, enum xkb_map_flags flags);
 
 void
 FreeStmt(ParseCommon *stmt);
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/ast.h b/src/3rdparty/xkbcommon/src/xkbcomp/ast.h
index c430a772ae..489b33193c 100644
--- a/src/3rdparty/xkbcommon/src/xkbcomp/ast.h
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/ast.h
@@ -143,9 +143,11 @@ expr_op_type_to_string(enum expr_op_type type);
 const char *
 expr_value_type_to_string(enum expr_value_type type);
 
-typedef struct _ParseCommon {
-    enum stmt_type type;
+/* This struct contains fields common to all other AST nodes. It is only
+ * ever embedded in other structs, so save some memory by packing it. */
+typedef struct ATTR_PACKED _ParseCommon  {
     struct _ParseCommon *next;
+    enum stmt_type type;
 } ParseCommon;
 
 typedef struct _IncludeStmt {
@@ -158,40 +160,92 @@ typedef struct _IncludeStmt {
     struct _IncludeStmt *next_incl;
 } IncludeStmt;
 
-typedef struct _Expr {
+typedef struct {
     ParseCommon common;
     enum expr_op_type op;
     enum expr_value_type value_type;
-    union {
-        struct {
-            struct _Expr *left;
-            struct _Expr *right;
-        } binary;
-        struct {
-            xkb_atom_t element;
-            xkb_atom_t field;
-        } field;
-        struct {
-            xkb_atom_t element;
-            xkb_atom_t field;
-            struct _Expr *entry;
-        } array;
-        struct {
-            xkb_atom_t name;
-            struct _Expr *args;
-        } action;
-        struct {
-            darray(char *) syms;
-            darray(int) symsMapIndex;
-            darray(unsigned int) symsNumEntries;
-        } list;
-        struct _Expr *child;
-        xkb_atom_t str;
-        unsigned uval;
-        int ival;
-        xkb_atom_t keyName;
-    } value;
-} ExprDef;
+} ExprCommon;
+
+typedef union ExprDef ExprDef;
+
+typedef struct {
+    ExprCommon expr;
+    xkb_atom_t ident;
+} ExprIdent;
+
+typedef struct {
+    ExprCommon expr;
+    xkb_atom_t str;
+} ExprString;
+
+typedef struct {
+    ExprCommon expr;
+    bool set;
+} ExprBoolean;
+
+typedef struct {
+    ExprCommon expr;
+    int ival;
+} ExprInteger;
+
+typedef struct {
+    ExprCommon expr;
+    xkb_atom_t key_name;
+} ExprKeyName;
+
+typedef struct {
+    ExprCommon expr;
+    ExprDef *left;
+    ExprDef *right;
+} ExprBinary;
+
+typedef struct {
+    ExprCommon expr;
+    ExprDef *child;
+} ExprUnary;
+
+typedef struct {
+    ExprCommon expr;
+    xkb_atom_t element;
+    xkb_atom_t field;
+} ExprFieldRef;
+
+typedef struct {
+    ExprCommon expr;
+    xkb_atom_t element;
+    xkb_atom_t field;
+    ExprDef *entry;
+} ExprArrayRef;
+
+typedef struct {
+    ExprCommon expr;
+    xkb_atom_t name;
+    ExprDef *args;
+} ExprAction;
+
+typedef struct {
+    ExprCommon expr;
+    darray(xkb_keysym_t) syms;
+    darray(int) symsMapIndex;
+    darray(unsigned int) symsNumEntries;
+} ExprKeysymList;
+
+union ExprDef {
+    ParseCommon common;
+    /* Maybe someday we can use C11 anonymous struct for ExprCommon here. */
+    ExprCommon expr;
+    ExprIdent ident;
+    ExprString string;
+    ExprBoolean boolean;
+    ExprInteger integer;
+    ExprKeyName key_name;
+    ExprBinary binary;
+    ExprUnary unary;
+    ExprFieldRef field_ref;
+    ExprArrayRef array_ref;
+    ExprAction action;
+    ExprKeysymList keysym_list;
+};
 
 typedef struct {
     ParseCommon common;
@@ -232,7 +286,7 @@ typedef struct {
     ParseCommon common;
     enum merge_mode merge;
     xkb_atom_t keyName;
-    ExprDef *symbols;
+    VarDef *symbols;
 } SymbolsDef;
 
 typedef struct {
@@ -252,7 +306,7 @@ typedef struct {
 typedef struct {
     ParseCommon common;
     enum merge_mode merge;
-    char *sym;
+    xkb_keysym_t sym;
     ExprDef *match;
     VarDef *def;
 } InterpDef;
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/compat.c b/src/3rdparty/xkbcommon/src/xkbcomp/compat.c
index 5682895430..fffb2d34b2 100644
--- a/src/3rdparty/xkbcommon/src/xkbcomp/compat.c
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/compat.c
@@ -432,19 +432,19 @@ ResolveStateAndPredicate(ExprDef *expr, enum xkb_match_operation *pred_rtrn,
     }
 
     *pred_rtrn = MATCH_EXACTLY;
-    if (expr->op == EXPR_ACTION_DECL) {
+    if (expr->expr.op == EXPR_ACTION_DECL) {
         const char *pred_txt = xkb_atom_text(info->keymap->ctx,
-                                             expr->value.action.name);
+                                             expr->action.name);
         if (!LookupString(symInterpretMatchMaskNames, pred_txt, pred_rtrn)) {
             log_err(info->keymap->ctx,
                     "Illegal modifier predicate \"%s\"; Ignored\n", pred_txt);
             return false;
         }
-        expr = expr->value.action.args;
+        expr = expr->action.args;
     }
-    else if (expr->op == EXPR_IDENT) {
+    else if (expr->expr.op == EXPR_IDENT) {
         const char *pred_txt = xkb_atom_text(info->keymap->ctx,
-                                             expr->value.str);
+                                             expr->ident.ident);
         if (pred_txt && istreq(pred_txt, "any")) {
             *pred_rtrn = MATCH_ANY;
             *mods_rtrn = MOD_REAL_MASK_ALL;
@@ -805,7 +805,7 @@ HandleInterpBody(CompatInfo *info, VarDef *def, SymInterpInfo *si)
     ExprDef *arrayNdx;
 
     for (; def; def = (VarDef *) def->common.next) {
-        if (def->name && def->name->op == EXPR_FIELD_REF) {
+        if (def->name && def->name->expr.op == EXPR_FIELD_REF) {
             log_err(info->keymap->ctx,
                     "Cannot set a global default value from within an interpret statement; "
                     "Move statements to the global file scope\n");
@@ -840,15 +840,7 @@ HandleInterpDef(CompatInfo *info, InterpDef *def, enum merge_mode merge)
 
     si = info->default_interp;
     si.merge = merge = (def->merge == MERGE_DEFAULT ? merge : def->merge);
-
-    if (!LookupKeysym(def->sym, &si.interp.sym)) {
-        log_err(info->keymap->ctx,
-                "Could not resolve keysym %s; "
-                "Symbol interpretation ignored\n",
-                def->sym);
-        return false;
-    }
-
+    si.interp.sym = def->sym;
     si.interp.match = pred;
     si.interp.mods = mods;
 
@@ -941,7 +933,7 @@ HandleCompatMapFile(CompatInfo *info, XkbFile *file, enum merge_mode merge)
             break;
         default:
             log_err(info->keymap->ctx,
-                    "Interpretation files may not include other types; "
+                    "Compat files may not include other types; "
                     "Ignoring %s\n", stmt_type_to_string(stmt->type));
             ok = false;
             break;
@@ -958,15 +950,21 @@ HandleCompatMapFile(CompatInfo *info, XkbFile *file, enum merge_mode merge)
     }
 }
 
+/* Temporary struct for CopyInterps. */
+struct collect {
+    darray(struct xkb_sym_interpret) sym_interprets;
+};
+
 static void
-CopyInterps(CompatInfo *info, bool needSymbol, enum xkb_match_operation pred)
+CopyInterps(CompatInfo *info, bool needSymbol, enum xkb_match_operation pred,
+            struct collect *collect)
 {
     SymInterpInfo *si;
 
     darray_foreach(si, info->interps)
         if (si->interp.match == pred &&
             (si->interp.sym != XKB_KEY_NoSymbol) == needSymbol)
-            darray_append(info->keymap->sym_interprets, si->interp);
+            darray_append(collect->sym_interprets, si->interp);
 }
 
 static void
@@ -1025,19 +1023,26 @@ static bool
 CopyCompatToKeymap(struct xkb_keymap *keymap, CompatInfo *info)
 {
     keymap->compat_section_name = strdup_safe(info->name);
+    XkbEscapeMapName(keymap->compat_section_name);
 
     if (!darray_empty(info->interps)) {
+        struct collect collect;
+        darray_init(collect.sym_interprets);
+
         /* Most specific to least specific. */
-        CopyInterps(info, true, MATCH_EXACTLY);
-        CopyInterps(info, true, MATCH_ALL);
-        CopyInterps(info, true, MATCH_NONE);
-        CopyInterps(info, true, MATCH_ANY);
-        CopyInterps(info, true, MATCH_ANY_OR_NONE);
-        CopyInterps(info, false, MATCH_EXACTLY);
-        CopyInterps(info, false, MATCH_ALL);
-        CopyInterps(info, false, MATCH_NONE);
-        CopyInterps(info, false, MATCH_ANY);
-        CopyInterps(info, false, MATCH_ANY_OR_NONE);
+        CopyInterps(info, true, MATCH_EXACTLY, &collect);
+        CopyInterps(info, true, MATCH_ALL, &collect);
+        CopyInterps(info, true, MATCH_NONE, &collect);
+        CopyInterps(info, true, MATCH_ANY, &collect);
+        CopyInterps(info, true, MATCH_ANY_OR_NONE, &collect);
+        CopyInterps(info, false, MATCH_EXACTLY, &collect);
+        CopyInterps(info, false, MATCH_ALL, &collect);
+        CopyInterps(info, false, MATCH_NONE, &collect);
+        CopyInterps(info, false, MATCH_ANY, &collect);
+        CopyInterps(info, false, MATCH_ANY_OR_NONE, &collect);
+
+        keymap->num_sym_interprets = darray_size(collect.sym_interprets);
+        keymap->sym_interprets = darray_mem(collect.sym_interprets, 0);
     }
 
     CopyLedMapDefs(info);
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/expr.c b/src/3rdparty/xkbcommon/src/xkbcomp/expr.c
index dc64d7891f..ba71208f7e 100644
--- a/src/3rdparty/xkbcommon/src/xkbcomp/expr.c
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/expr.c
@@ -37,26 +37,26 @@ ExprResolveLhs(struct xkb_context *ctx, const ExprDef *expr,
                const char **elem_rtrn, const char **field_rtrn,
                ExprDef **index_rtrn)
 {
-    switch (expr->op) {
+    switch (expr->expr.op) {
     case EXPR_IDENT:
         *elem_rtrn = NULL;
-        *field_rtrn = xkb_atom_text(ctx, expr->value.str);
+        *field_rtrn = xkb_atom_text(ctx, expr->ident.ident);
         *index_rtrn = NULL;
         return true;
     case EXPR_FIELD_REF:
-        *elem_rtrn = xkb_atom_text(ctx, expr->value.field.element);
-        *field_rtrn = xkb_atom_text(ctx, expr->value.field.field);
+        *elem_rtrn = xkb_atom_text(ctx, expr->field_ref.element);
+        *field_rtrn = xkb_atom_text(ctx, expr->field_ref.field);
         *index_rtrn = NULL;
         return true;
     case EXPR_ARRAY_REF:
-        *elem_rtrn = xkb_atom_text(ctx, expr->value.array.element);
-        *field_rtrn = xkb_atom_text(ctx, expr->value.array.field);
-        *index_rtrn = expr->value.array.entry;
+        *elem_rtrn = xkb_atom_text(ctx, expr->array_ref.element);
+        *field_rtrn = xkb_atom_text(ctx, expr->array_ref.field);
+        *index_rtrn = expr->array_ref.entry;
         return true;
     default:
         break;
     }
-    log_wsgo(ctx, "Unexpected operator %d in ResolveLhs\n", expr->op);
+    log_wsgo(ctx, "Unexpected operator %d in ResolveLhs\n", expr->expr.op);
     return false;
 }
 
@@ -127,19 +127,19 @@ ExprResolveBoolean(struct xkb_context *ctx, const ExprDef *expr,
     bool ok = false;
     const char *ident;
 
-    switch (expr->op) {
+    switch (expr->expr.op) {
     case EXPR_VALUE:
-        if (expr->value_type != EXPR_TYPE_BOOLEAN) {
+        if (expr->expr.value_type != EXPR_TYPE_BOOLEAN) {
             log_err(ctx,
                     "Found constant of type %s where boolean was expected\n",
-                    expr_value_type_to_string(expr->value_type));
+                    expr_value_type_to_string(expr->expr.value_type));
             return false;
         }
-        *set_rtrn = !!expr->value.ival;
+        *set_rtrn = expr->boolean.set;
         return true;
 
     case EXPR_IDENT:
-        ident = xkb_atom_text(ctx, expr->value.str);
+        ident = xkb_atom_text(ctx, expr->ident.ident);
         if (ident) {
             if (istreq(ident, "true") ||
                 istreq(ident, "yes") ||
@@ -154,14 +154,13 @@ ExprResolveBoolean(struct xkb_context *ctx, const ExprDef *expr,
                 return true;
             }
         }
-        log_err(ctx, "Identifier \"%s\" of type boolean is unknown\n",
-                xkb_atom_text(ctx, expr->value.str));
+        log_err(ctx, "Identifier \"%s\" of type boolean is unknown\n", ident);
         return false;
 
     case EXPR_FIELD_REF:
         log_err(ctx, "Default \"%s.%s\" of type boolean is unknown\n",
-                xkb_atom_text(ctx, expr->value.field.element),
-                xkb_atom_text(ctx, expr->value.field.field));
+                xkb_atom_text(ctx, expr->field_ref.element),
+                xkb_atom_text(ctx, expr->field_ref.field));
         return false;
 
     case EXPR_INVERT:
@@ -178,11 +177,12 @@ ExprResolveBoolean(struct xkb_context *ctx, const ExprDef *expr,
     case EXPR_NEGATE:
     case EXPR_UNARY_PLUS:
         log_err(ctx, "%s of boolean values not permitted\n",
-                expr_op_type_to_string(expr->op));
+                expr_op_type_to_string(expr->expr.op));
         break;
 
     default:
-        log_wsgo(ctx, "Unknown operator %d in ResolveBoolean\n", expr->op);
+        log_wsgo(ctx, "Unknown operator %d in ResolveBoolean\n",
+                 expr->expr.op);
         break;
     }
 
@@ -194,32 +194,28 @@ ExprResolveKeyCode(struct xkb_context *ctx, const ExprDef *expr,
                    xkb_keycode_t *kc)
 {
     xkb_keycode_t leftRtrn, rightRtrn;
-    ExprDef *left, *right;
 
-    switch (expr->op) {
+    switch (expr->expr.op) {
     case EXPR_VALUE:
-        if (expr->value_type != EXPR_TYPE_INT) {
+        if (expr->expr.value_type != EXPR_TYPE_INT) {
             log_err(ctx,
                     "Found constant of type %s where an int was expected\n",
-                    expr_value_type_to_string(expr->value_type));
+                    expr_value_type_to_string(expr->expr.value_type));
             return false;
         }
 
-        *kc = expr->value.uval;
+        *kc = (xkb_keycode_t) expr->integer.ival;
         return true;
 
     case EXPR_ADD:
     case EXPR_SUBTRACT:
     case EXPR_MULTIPLY:
     case EXPR_DIVIDE:
-        left = expr->value.binary.left;
-        right = expr->value.binary.right;
-
-        if (!ExprResolveKeyCode(ctx, left, &leftRtrn) ||
-            !ExprResolveKeyCode(ctx, right, &rightRtrn))
+        if (!ExprResolveKeyCode(ctx, expr->binary.left, &leftRtrn) ||
+            !ExprResolveKeyCode(ctx, expr->binary.right, &rightRtrn))
             return false;
 
-        switch (expr->op) {
+        switch (expr->expr.op) {
         case EXPR_ADD:
             *kc = leftRtrn + rightRtrn;
             break;
@@ -245,19 +241,18 @@ ExprResolveKeyCode(struct xkb_context *ctx, const ExprDef *expr,
         return true;
 
     case EXPR_NEGATE:
-        left = expr->value.child;
-        if (!ExprResolveKeyCode(ctx, left, &leftRtrn))
+        if (!ExprResolveKeyCode(ctx, expr->unary.child, &leftRtrn))
             return false;
 
         *kc = ~leftRtrn;
         return true;
 
     case EXPR_UNARY_PLUS:
-        left = expr->value.child;
-        return ExprResolveKeyCode(ctx, left, kc);
+        return ExprResolveKeyCode(ctx, expr->unary.child, kc);
 
     default:
-        log_wsgo(ctx, "Unknown operator %d in ResolveKeyCode\n", expr->op);
+        log_wsgo(ctx, "Unknown operator %d in ResolveKeyCode\n",
+                 expr->expr.op);
         break;
     }
 
@@ -284,25 +279,25 @@ ExprResolveIntegerLookup(struct xkb_context *ctx, const ExprDef *expr,
     unsigned u;
     ExprDef *left, *right;
 
-    switch (expr->op) {
+    switch (expr->expr.op) {
     case EXPR_VALUE:
-        if (expr->value_type != EXPR_TYPE_INT) {
+        if (expr->expr.value_type != EXPR_TYPE_INT) {
             log_err(ctx,
                     "Found constant of type %s where an int was expected\n",
-                    expr_value_type_to_string(expr->value_type));
+                    expr_value_type_to_string(expr->expr.value_type));
             return false;
         }
 
-        *val_rtrn = expr->value.ival;
+        *val_rtrn = expr->integer.ival;
         return true;
 
     case EXPR_IDENT:
         if (lookup)
-            ok = lookup(ctx, lookupPriv, expr->value.str, EXPR_TYPE_INT, &u);
+            ok = lookup(ctx, lookupPriv, expr->ident.ident, EXPR_TYPE_INT, &u);
 
         if (!ok)
             log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
-                    xkb_atom_text(ctx, expr->value.str));
+                    xkb_atom_text(ctx, expr->ident.ident));
         else
             *val_rtrn = (int) u;
 
@@ -310,21 +305,21 @@ ExprResolveIntegerLookup(struct xkb_context *ctx, const ExprDef *expr,
 
     case EXPR_FIELD_REF:
         log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
-                xkb_atom_text(ctx, expr->value.field.element),
-                xkb_atom_text(ctx, expr->value.field.field));
+                xkb_atom_text(ctx, expr->field_ref.element),
+                xkb_atom_text(ctx, expr->field_ref.field));
         return false;
 
     case EXPR_ADD:
     case EXPR_SUBTRACT:
     case EXPR_MULTIPLY:
     case EXPR_DIVIDE:
-        left = expr->value.binary.left;
-        right = expr->value.binary.right;
+        left = expr->binary.left;
+        right = expr->binary.right;
         if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv) ||
             !ExprResolveIntegerLookup(ctx, right, &r, lookup, lookupPriv))
             return false;
 
-        switch (expr->op) {
+        switch (expr->expr.op) {
         case EXPR_ADD:
             *val_rtrn = l + r;
             break;
@@ -357,20 +352,21 @@ ExprResolveIntegerLookup(struct xkb_context *ctx, const ExprDef *expr,
 
     case EXPR_INVERT:
     case EXPR_NEGATE:
-        left = expr->value.child;
+        left = expr->unary.child;
         if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv))
             return false;
 
-        *val_rtrn = (expr->op == EXPR_NEGATE ? -l : ~l);
+        *val_rtrn = (expr->expr.op == EXPR_NEGATE ? -l : ~l);
         return true;
 
     case EXPR_UNARY_PLUS:
-        left = expr->value.child;
+        left = expr->unary.child;
         return ExprResolveIntegerLookup(ctx, left, val_rtrn, lookup,
                                         lookupPriv);
 
     default:
-        log_wsgo(ctx, "Unknown operator %d in ResolveInteger\n", expr->op);
+        log_wsgo(ctx, "Unknown operator %d in ResolveInteger\n",
+                 expr->expr.op);
         break;
     }
 
@@ -445,26 +441,26 @@ bool
 ExprResolveString(struct xkb_context *ctx, const ExprDef *expr,
                   xkb_atom_t *val_rtrn)
 {
-    switch (expr->op) {
+    switch (expr->expr.op) {
     case EXPR_VALUE:
-        if (expr->value_type != EXPR_TYPE_STRING) {
+        if (expr->expr.value_type != EXPR_TYPE_STRING) {
             log_err(ctx, "Found constant of type %s, expected a string\n",
-                    expr_value_type_to_string(expr->value_type));
+                    expr_value_type_to_string(expr->expr.value_type));
             return false;
         }
 
-        *val_rtrn = expr->value.str;
+        *val_rtrn = expr->string.str;
         return true;
 
     case EXPR_IDENT:
         log_err(ctx, "Identifier \"%s\" of type string not found\n",
-                xkb_atom_text(ctx, expr->value.str));
+                xkb_atom_text(ctx, expr->ident.ident));
         return false;
 
     case EXPR_FIELD_REF:
         log_err(ctx, "Default \"%s.%s\" of type string not found\n",
-                xkb_atom_text(ctx, expr->value.field.element),
-                xkb_atom_text(ctx, expr->value.field.field));
+                xkb_atom_text(ctx, expr->field_ref.element),
+                xkb_atom_text(ctx, expr->field_ref.field));
         return false;
 
     case EXPR_ADD:
@@ -477,11 +473,12 @@ ExprResolveString(struct xkb_context *ctx, const ExprDef *expr,
     case EXPR_NOT:
     case EXPR_UNARY_PLUS:
         log_err(ctx, "%s of strings not permitted\n",
-                expr_op_type_to_string(expr->op));
+                expr_op_type_to_string(expr->expr.op));
         return false;
 
     default:
-        log_wsgo(ctx, "Unknown operator %d in ResolveString\n", expr->op);
+        log_wsgo(ctx, "Unknown operator %d in ResolveString\n",
+                 expr->expr.op);
         break;
     }
     return false;
@@ -491,16 +488,16 @@ bool
 ExprResolveEnum(struct xkb_context *ctx, const ExprDef *expr,
                 unsigned int *val_rtrn, const LookupEntry *values)
 {
-    if (expr->op != EXPR_IDENT) {
+    if (expr->expr.op != EXPR_IDENT) {
         log_err(ctx, "Found a %s where an enumerated value was expected\n",
-                expr_op_type_to_string(expr->op));
+                expr_op_type_to_string(expr->expr.op));
         return false;
     }
 
-    if (!SimpleLookup(ctx, values, expr->value.str, EXPR_TYPE_INT,
+    if (!SimpleLookup(ctx, values, expr->ident.ident, EXPR_TYPE_INT,
                       val_rtrn)) {
         log_err(ctx, "Illegal identifier %s; expected one of:\n",
-                xkb_atom_text(ctx, expr->value.str));
+                xkb_atom_text(ctx, expr->ident.ident));
         while (values && values->name)
         {
             log_err(ctx, "\t%s\n", values->name);
@@ -523,29 +520,29 @@ ExprResolveMaskLookup(struct xkb_context *ctx, const ExprDef *expr,
     ExprDef *left, *right;
     const char *bogus = NULL;
 
-    switch (expr->op) {
+    switch (expr->expr.op) {
     case EXPR_VALUE:
-        if (expr->value_type != EXPR_TYPE_INT) {
+        if (expr->expr.value_type != EXPR_TYPE_INT) {
             log_err(ctx,
                     "Found constant of type %s where a mask was expected\n",
-                    expr_value_type_to_string(expr->value_type));
+                    expr_value_type_to_string(expr->expr.value_type));
             return false;
         }
-        *val_rtrn = (unsigned int) expr->value.ival;
+        *val_rtrn = (unsigned int) expr->integer.ival;
         return true;
 
     case EXPR_IDENT:
-        ok = lookup(ctx, lookupPriv, expr->value.str, EXPR_TYPE_INT,
+        ok = lookup(ctx, lookupPriv, expr->ident.ident, EXPR_TYPE_INT,
                     val_rtrn);
         if (!ok)
             log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
-                    xkb_atom_text(ctx, expr->value.str));
+                    xkb_atom_text(ctx, expr->ident.ident));
         return ok;
 
     case EXPR_FIELD_REF:
         log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
-                xkb_atom_text(ctx, expr->value.field.element),
-                xkb_atom_text(ctx, expr->value.field.field));
+                xkb_atom_text(ctx, expr->field_ref.element),
+                xkb_atom_text(ctx, expr->field_ref.field));
         return false;
 
     case EXPR_ARRAY_REF:
@@ -563,13 +560,13 @@ ExprResolveMaskLookup(struct xkb_context *ctx, const ExprDef *expr,
     case EXPR_SUBTRACT:
     case EXPR_MULTIPLY:
     case EXPR_DIVIDE:
-        left = expr->value.binary.left;
-        right = expr->value.binary.right;
+        left = expr->binary.left;
+        right = expr->binary.right;
         if (!ExprResolveMaskLookup(ctx, left, &l, lookup, lookupPriv) ||
             !ExprResolveMaskLookup(ctx, right, &r, lookup, lookupPriv))
             return false;
 
-        switch (expr->op) {
+        switch (expr->expr.op) {
         case EXPR_ADD:
             *val_rtrn = l | r;
             break;
@@ -579,7 +576,7 @@ ExprResolveMaskLookup(struct xkb_context *ctx, const ExprDef *expr,
         case EXPR_MULTIPLY:
         case EXPR_DIVIDE:
             log_err(ctx, "Cannot %s masks; Illegal operation ignored\n",
-                    (expr->op == EXPR_DIVIDE ? "divide" : "multiply"));
+                    (expr->expr.op == EXPR_DIVIDE ? "divide" : "multiply"));
             return false;
         default:
             break;
@@ -592,7 +589,7 @@ ExprResolveMaskLookup(struct xkb_context *ctx, const ExprDef *expr,
         break;
 
     case EXPR_INVERT:
-        left = expr->value.child;
+        left = expr->unary.child;
         if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
             return false;
 
@@ -602,14 +599,15 @@ ExprResolveMaskLookup(struct xkb_context *ctx, const ExprDef *expr,
     case EXPR_UNARY_PLUS:
     case EXPR_NEGATE:
     case EXPR_NOT:
-        left = expr->value.child;
+        left = expr->unary.child;
         if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
             log_err(ctx, "The %s operator cannot be used with a mask\n",
-                    (expr->op == EXPR_NEGATE ? "-" : "!"));
+                    (expr->expr.op == EXPR_NEGATE ? "-" : "!"));
         return false;
 
     default:
-        log_wsgo(ctx, "Unknown operator %d in ResolveMask\n", expr->op);
+        log_wsgo(ctx, "Unknown operator %d in ResolveMask\n",
+                 expr->expr.op);
         break;
     }
 
@@ -638,9 +636,8 @@ ExprResolveKeySym(struct xkb_context *ctx, const ExprDef *expr,
 {
     int val;
 
-    if (expr->op == EXPR_IDENT) {
-        const char *str;
-        str = xkb_atom_text(ctx, expr->value.str);
+    if (expr->expr.op == EXPR_IDENT) {
+        const char *str = xkb_atom_text(ctx, expr->ident.ident);
         *sym_rtrn = xkb_keysym_from_name(str, 0);
         if (*sym_rtrn != XKB_KEY_NoSymbol)
             return true;
@@ -652,7 +649,7 @@ ExprResolveKeySym(struct xkb_context *ctx, const ExprDef *expr,
     if (val < 0 || val >= 10)
         return false;
 
-    *sym_rtrn = ((xkb_keysym_t) val) + '0';
+    *sym_rtrn = XKB_KEY_0 + (xkb_keysym_t) val;
     return true;
 }
 
@@ -661,16 +658,17 @@ ExprResolveMod(struct xkb_keymap *keymap, const ExprDef *def,
                enum mod_type mod_type, xkb_mod_index_t *ndx_rtrn)
 {
     xkb_mod_index_t ndx;
-    xkb_atom_t name = def->value.str;
+    xkb_atom_t name;
 
-    if (def->op != EXPR_IDENT) {
+    if (def->expr.op != EXPR_IDENT) {
         log_err(keymap->ctx,
                 "Cannot resolve virtual modifier: "
                 "found %s where a virtual modifier name was expected\n",
-                expr_op_type_to_string(def->op));
+                expr_op_type_to_string(def->expr.op));
         return false;
     }
 
+    name = def->ident.ident;
     ndx = ModNameToIndex(keymap, name, mod_type);
     if (ndx == XKB_MOD_INVALID) {
         log_err(keymap->ctx,
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/include.c b/src/3rdparty/xkbcommon/src/xkbcomp/include.c
index b4a4014635..dc3f1e49bd 100644
--- a/src/3rdparty/xkbcommon/src/xkbcomp/include.c
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/include.c
@@ -199,17 +199,34 @@ FindFileInXkbPath(struct xkb_context *ctx, const char *name,
 {
     unsigned int i;
     FILE *file = NULL;
-    char buf[PATH_MAX];
+    char *buf = NULL;
     const char *typeDir;
+    size_t buf_size = 0, typeDirLen, name_len;
 
     typeDir = DirectoryForInclude(type);
+    typeDirLen = strlen(typeDir);
+    name_len = strlen(name);
 
     for (i = 0; i < xkb_context_num_include_paths(ctx); i++) {
-        int ret = snprintf(buf, sizeof(buf), "%s/%s/%s",
-                           xkb_context_include_path_get(ctx, i),
-                           typeDir, name);
-        if (ret >= (ssize_t) sizeof(buf)) {
-            log_err(ctx, "File name (%s/%s/%s) too long\n",
+        size_t new_buf_size = strlen(xkb_context_include_path_get(ctx, i)) +
+                              typeDirLen + name_len + 3;
+        int ret;
+        if (new_buf_size > buf_size) {
+            void *buf_new = realloc(buf, new_buf_size);
+            if (buf_new) {
+                buf_size = new_buf_size;
+                buf = buf_new;
+            } else {
+                log_err(ctx, "Cannot realloc for name (%s/%s/%s)\n",
+                        xkb_context_include_path_get(ctx, i), typeDir, name);
+                continue;
+            }
+        }
+        ret = snprintf(buf, buf_size, "%s/%s/%s",
+                       xkb_context_include_path_get(ctx, i),
+                       typeDir, name);
+        if (ret < 0) {
+            log_err(ctx, "snprintf error (%s/%s/%s)\n",
                     xkb_context_include_path_get(ctx, i), typeDir, name);
             continue;
         }
@@ -242,11 +259,14 @@ FindFileInXkbPath(struct xkb_context *ctx, const char *name,
                         xkb_context_failed_include_path_get(ctx, i));
         }
 
+        free(buf);
         return NULL;
     }
 
     if (pathRtrn)
-        *pathRtrn = strdup(buf);
+        *pathRtrn = buf;
+    else
+        free(buf);
     return file;
 }
 
@@ -275,7 +295,7 @@ ProcessIncludeFile(struct xkb_context *ctx, IncludeStmt *stmt,
 
     if (xkb_file->file_type != file_type) {
         log_err(ctx,
-                "Include file wrong type (expected %s, got %s); "
+                "Include file of wrong type (expected %s, got %s); "
                 "Include file \"%s\" ignored\n",
                 xkb_file_type_to_string(file_type),
                 xkb_file_type_to_string(xkb_file->file_type), stmt->file);
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/keycodes.c b/src/3rdparty/xkbcommon/src/xkbcomp/keycodes.c
index edc54c94f3..59916b7266 100644
--- a/src/3rdparty/xkbcommon/src/xkbcomp/keycodes.c
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/keycodes.c
@@ -231,7 +231,10 @@ InitKeyNamesInfo(KeyNamesInfo *info, struct xkb_context *ctx)
 {
     memset(info, 0, sizeof(*info));
     info->ctx = ctx;
-    info->min_key_code = XKB_KEYCODE_MAX;
+    info->min_key_code = XKB_KEYCODE_INVALID;
+#if XKB_KEYCODE_INVALID < XKB_KEYCODE_MAX
+#error "Hey, you can't be changing stuff like that."
+#endif
 }
 
 static xkb_keycode_t
@@ -604,16 +607,28 @@ CopyKeyNamesToKeymap(struct xkb_keymap *keymap, KeyNamesInfo *info)
     unsigned i;
 
     keymap->keycodes_section_name = strdup_safe(info->name);
+    XkbEscapeMapName(keymap->keycodes_section_name);
 
-    keymap->min_key_code = info->min_key_code;
-    keymap->max_key_code = info->max_key_code;
+    if (info->min_key_code != XKB_KEYCODE_INVALID) {
+        keymap->min_key_code = info->min_key_code;
+        keymap->max_key_code = info->max_key_code;
+    }
+    else {
+        /*
+         * If the keymap has no keys, let's just use the safest pair
+         * we know.
+         */
+        keymap->min_key_code = 8;
+        keymap->max_key_code = 255;
+    }
 
-    /* Copy key names. */
-    keymap->keys = calloc(info->max_key_code + 1, sizeof(*keymap->keys));
-    for (kc = info->min_key_code; kc <= info->max_key_code; kc++) {
+    keymap->keys = calloc(keymap->max_key_code + 1, sizeof(*keymap->keys));
+    for (kc = keymap->min_key_code; kc <= keymap->max_key_code; kc++)
         keymap->keys[kc].keycode = kc;
+
+    /* Copy key names. */
+    for (kc = info->min_key_code; kc <= info->max_key_code; kc++)
         keymap->keys[kc].name = darray_item(info->key_names, kc);
-    }
 
     /*
      * Do some sanity checking on the aliases. We can't do it before
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/keymap-dump.c b/src/3rdparty/xkbcommon/src/xkbcomp/keymap-dump.c
index 034a8c1af3..6b4c266ec0 100644
--- a/src/3rdparty/xkbcommon/src/xkbcomp/keymap-dump.c
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/keymap-dump.c
@@ -157,17 +157,24 @@ write_keycodes(struct xkb_keymap *keymap, struct buf *buf)
     else
         write_buf(buf, "xkb_keycodes {\n");
 
+    /* xkbcomp and X11 really want to see keymaps with a minimum of 8, and
+     * a maximum of at least 255, else XWayland really starts hating life.
+     * If this is a problem and people really need strictly bounded keymaps,
+     * we should probably control this with a flag. */
+    write_buf(buf, "\tminimum = %u;\n", min(keymap->min_key_code, 8));
+    write_buf(buf, "\tmaximum = %u;\n", max(keymap->max_key_code, 255));
+
     xkb_foreach_key(key, keymap) {
         if (key->name == XKB_ATOM_NONE)
             continue;
 
-        write_buf(buf, "\t%-20s = %d;\n",
+        write_buf(buf, "\t%-20s = %u;\n",
                   KeyNameText(keymap->ctx, key->name), key->keycode);
     }
 
     darray_enumerate(idx, led, keymap->leds)
         if (led->name != XKB_ATOM_NONE)
-            write_buf(buf, "\tindicator %d = \"%s\";\n",
+            write_buf(buf, "\tindicator %u = \"%s\";\n",
                       idx + 1, xkb_atom_text(keymap->ctx, led->name));
 
 
@@ -212,7 +219,7 @@ write_types(struct xkb_keymap *keymap, struct buf *buf)
                 continue;
 
             str = ModMaskText(keymap, entry->mods.mods);
-            write_buf(buf, "\t\tmap[%s]= Level%d;\n",
+            write_buf(buf, "\t\tmap[%s]= Level%u;\n",
                       str, entry->level + 1);
 
             if (entry->preserve.mods)
@@ -222,7 +229,7 @@ write_types(struct xkb_keymap *keymap, struct buf *buf)
 
         for (xkb_level_index_t n = 0; n < type->num_levels; n++)
             if (type->level_names[n])
-                write_buf(buf, "\t\tlevel_name[Level%d]= \"%s\";\n", n + 1,
+                write_buf(buf, "\t\tlevel_name[Level%u]= \"%s\";\n", n + 1,
                           xkb_atom_text(keymap->ctx, type->level_names[n]));
 
         write_buf(buf, "\t};\n");
@@ -409,7 +416,6 @@ write_action(struct xkb_keymap *keymap, struct buf *buf,
 static bool
 write_compat(struct xkb_keymap *keymap, struct buf *buf)
 {
-    const struct xkb_sym_interpret *si;
     const struct xkb_led *led;
 
     if (keymap->compat_section_name)
@@ -423,7 +429,9 @@ write_compat(struct xkb_keymap *keymap, struct buf *buf)
     write_buf(buf, "\tinterpret.useModMapMods= AnyLevel;\n");
     write_buf(buf, "\tinterpret.repeat= False;\n");
 
-    darray_foreach(si, keymap->sym_interprets) {
+    for (int i = 0; i < keymap->num_sym_interprets; i++) {
+        const struct xkb_sym_interpret *si = &keymap->sym_interprets[i];
+
         write_buf(buf, "\tinterpret %s+%s(%s) {\n",
                   si->sym ? KeysymText(keymap->ctx, si->sym) : "Any",
                   SIMatchText(si->match),
@@ -610,7 +618,7 @@ write_symbols(struct xkb_keymap *keymap, struct buf *buf)
     for (group = 0; group < keymap->num_group_names; group++)
         if (keymap->group_names[group])
             write_buf(buf,
-                      "\tname[group%d]=\"%s\";\n", group + 1,
+                      "\tname[group%u]=\"%s\";\n", group + 1,
                       xkb_atom_text(keymap->ctx, keymap->group_names[group]));
     if (group > 0)
         write_buf(buf, "\n");
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/keymap.c b/src/3rdparty/xkbcommon/src/xkbcomp/keymap.c
index bed3930be9..549cf05da6 100644
--- a/src/3rdparty/xkbcommon/src/xkbcomp/keymap.c
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/keymap.c
@@ -78,7 +78,6 @@ static const struct xkb_sym_interpret *
 FindInterpForKey(struct xkb_keymap *keymap, const struct xkb_key *key,
                  xkb_layout_index_t group, xkb_level_index_t level)
 {
-    const struct xkb_sym_interpret *interp;
     const xkb_keysym_t *syms;
     int num_syms;
 
@@ -93,7 +92,9 @@ FindInterpForKey(struct xkb_keymap *keymap, const struct xkb_key *key,
      * sym_interprets array from the most specific to the least specific,
      * such that when we find a match we return immediately.
      */
-    darray_foreach(interp, keymap->sym_interprets) {
+    for (int i = 0; i < keymap->num_sym_interprets; i++) {
+        const struct xkb_sym_interpret *interp = &keymap->sym_interprets[i];
+
         xkb_mod_mask_t mods;
         bool found = false;
 
@@ -224,28 +225,6 @@ UpdateDerivedKeymapFields(struct xkb_keymap *keymap)
     return true;
 }
 
-static bool
-UpdateBuiltinKeymapFields(struct xkb_keymap *keymap)
-{
-    struct xkb_context *ctx = keymap->ctx;
-
-    /*
-     * Add predefined (AKA real, core, X11) modifiers.
-     * The order is important!
-     */
-    darray_appends_t(keymap->mods, struct xkb_mod,
-        { .name = xkb_atom_intern(ctx, "Shift"),   .type = MOD_REAL },
-        { .name = xkb_atom_intern(ctx, "Lock"),    .type = MOD_REAL },
-        { .name = xkb_atom_intern(ctx, "Control"), .type = MOD_REAL },
-        { .name = xkb_atom_intern(ctx, "Mod1"),    .type = MOD_REAL },
-        { .name = xkb_atom_intern(ctx, "Mod2"),    .type = MOD_REAL },
-        { .name = xkb_atom_intern(ctx, "Mod3"),    .type = MOD_REAL },
-        { .name = xkb_atom_intern(ctx, "Mod4"),    .type = MOD_REAL },
-        { .name = xkb_atom_intern(ctx, "Mod5"),    .type = MOD_REAL });
-
-    return true;
-}
-
 typedef bool (*compile_file_fn)(XkbFile *file,
                                 struct xkb_keymap *keymap,
                                 enum merge_mode merge);
@@ -311,9 +290,6 @@ CompileKeymap(XkbFile *file, struct xkb_keymap *keymap, enum merge_mode merge)
     if (!ok)
         return false;
 
-    if (!UpdateBuiltinKeymapFields(keymap))
-        return false;
-
     /* Compile sections. */
     for (type = FIRST_KEYMAP_FILE_TYPE;
          type <= LAST_KEYMAP_FILE_TYPE;
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/keywords.c b/src/3rdparty/xkbcommon/src/xkbcomp/keywords.c
new file mode 100644
index 0000000000..c19d66ffde
--- /dev/null
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/keywords.c
@@ -0,0 +1,349 @@
+/* ANSI-C code produced by gperf version 3.0.4 */
+/* Command-line: gperf  */
+/* Computed positions: -k'1-2,5' */
+
+#if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \
+      && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \
+      && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \
+      && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \
+      && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \
+      && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \
+      && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \
+      && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \
+      && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \
+      && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \
+      && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \
+      && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \
+      && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \
+      && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \
+      && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \
+      && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \
+      && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \
+      && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \
+      && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \
+      && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \
+      && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \
+      && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \
+      && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126))
+/* The character set is not based on ISO-646.  */
+#error "gperf generated tables don't work with this execution character set. Please report a bug to <bug-gnu-gperf@gnu.org>."
+#endif
+
+
+#include "xkbcomp-priv.h"
+#include "parser-priv.h"
+
+static unsigned int
+keyword_gperf_hash(const char *str, unsigned int len);
+
+static const struct keyword_tok *
+keyword_gperf_lookup(const char *str, unsigned int len);
+struct keyword_tok { int name; int tok; };
+#include <string.h>
+/* maximum key range = 70, duplicates = 0 */
+
+#ifndef GPERF_DOWNCASE
+#define GPERF_DOWNCASE 1
+static unsigned char gperf_downcase[256] =
+  {
+      0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,
+     15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,
+     30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,
+     45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,
+     60,  61,  62,  63,  64,  97,  98,  99, 100, 101, 102, 103, 104, 105, 106,
+    107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
+    122,  91,  92,  93,  94,  95,  96,  97,  98,  99, 100, 101, 102, 103, 104,
+    105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
+    120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
+    135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
+    150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164,
+    165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179,
+    180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,
+    195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209,
+    210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
+    225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
+    240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254,
+    255
+  };
+#endif
+
+#ifndef GPERF_CASE_STRCMP
+#define GPERF_CASE_STRCMP 1
+static int
+gperf_case_strcmp (register const char *s1, register const char *s2)
+{
+  for (;;)
+    {
+      unsigned char c1 = gperf_downcase[(unsigned char)*s1++];
+      unsigned char c2 = gperf_downcase[(unsigned char)*s2++];
+      if (c1 != 0 && c1 == c2)
+        continue;
+      return (int)c1 - (int)c2;
+    }
+}
+#endif
+
+#ifdef __GNUC__
+__inline
+#else
+#ifdef __cplusplus
+inline
+#endif
+#endif
+static unsigned int
+keyword_gperf_hash (register const char *str, register unsigned int len)
+{
+  static const unsigned char asso_values[] =
+    {
+      73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
+      73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
+      73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
+      73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
+      73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
+      73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
+      73, 73, 73, 73, 73,  0, 73,  5, 36,  0,
+      10,  1, 15, 15, 73,  0, 10, 20, 35, 20,
+      50, 73, 10, 10,  5,  0, 15, 73,  0, 15,
+      73, 73, 73, 73, 73, 73, 73,  0, 73,  5,
+      36,  0, 10,  1, 15, 15, 73,  0, 10, 20,
+      35, 20, 50, 73, 10, 10,  5,  0, 15, 73,
+       0, 15, 73, 73, 73, 73, 73, 73, 73, 73,
+      73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
+      73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
+      73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
+      73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
+      73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
+      73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
+      73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
+      73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
+      73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
+      73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
+      73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
+      73, 73, 73, 73, 73, 73, 73, 73, 73, 73,
+      73, 73, 73, 73, 73, 73
+    };
+  register int hval = len;
+
+  switch (hval)
+    {
+      default:
+        hval += asso_values[(unsigned char)str[4]];
+      /*FALLTHROUGH*/
+      case 4:
+      case 3:
+      case 2:
+        hval += asso_values[(unsigned char)str[1]];
+      /*FALLTHROUGH*/
+      case 1:
+        hval += asso_values[(unsigned char)str[0]];
+        break;
+    }
+  return hval;
+}
+
+struct stringpool_t
+  {
+    char stringpool_str3[sizeof("key")];
+    char stringpool_str4[sizeof("keys")];
+    char stringpool_str7[sizeof("augment")];
+    char stringpool_str9[sizeof("text")];
+    char stringpool_str10[sizeof("xkb_keymap")];
+    char stringpool_str11[sizeof("keypad_keys")];
+    char stringpool_str12[sizeof("xkb_keycodes")];
+    char stringpool_str13[sizeof("xkb_geometry")];
+    char stringpool_str14[sizeof("xkb_types")];
+    char stringpool_str15[sizeof("xkb_compat")];
+    char stringpool_str17[sizeof("replace")];
+    char stringpool_str19[sizeof("xkb_compat_map")];
+    char stringpool_str20[sizeof("xkb_layout")];
+    char stringpool_str21[sizeof("xkb_symbols")];
+    char stringpool_str22[sizeof("xkb_compatibility")];
+    char stringpool_str23[sizeof("xkb_semantics")];
+    char stringpool_str24[sizeof("type")];
+    char stringpool_str25[sizeof("alias")];
+    char stringpool_str26[sizeof("xkb_compatibility_map")];
+    char stringpool_str27[sizeof("alphanumeric_keys")];
+    char stringpool_str28[sizeof("function_keys")];
+    char stringpool_str29[sizeof("alternate")];
+    char stringpool_str30[sizeof("shape")];
+    char stringpool_str31[sizeof("action")];
+    char stringpool_str32[sizeof("section")];
+    char stringpool_str33[sizeof("row")];
+    char stringpool_str34[sizeof("logo")];
+    char stringpool_str35[sizeof("alternate_group")];
+    char stringpool_str36[sizeof("hidden")];
+    char stringpool_str37[sizeof("virtual")];
+    char stringpool_str42[sizeof("outline")];
+    char stringpool_str43[sizeof("default")];
+    char stringpool_str46[sizeof("modmap")];
+    char stringpool_str47[sizeof("virtual_modifiers")];
+    char stringpool_str52[sizeof("overlay")];
+    char stringpool_str53[sizeof("override")];
+    char stringpool_str57[sizeof("include")];
+    char stringpool_str62[sizeof("modifier_map")];
+    char stringpool_str63[sizeof("modifier_keys")];
+    char stringpool_str64[sizeof("indicator")];
+    char stringpool_str66[sizeof("group")];
+    char stringpool_str67[sizeof("mod_map")];
+    char stringpool_str69[sizeof("interpret")];
+    char stringpool_str71[sizeof("solid")];
+    char stringpool_str72[sizeof("partial")];
+  };
+static const struct stringpool_t stringpool_contents =
+  {
+    "key",
+    "keys",
+    "augment",
+    "text",
+    "xkb_keymap",
+    "keypad_keys",
+    "xkb_keycodes",
+    "xkb_geometry",
+    "xkb_types",
+    "xkb_compat",
+    "replace",
+    "xkb_compat_map",
+    "xkb_layout",
+    "xkb_symbols",
+    "xkb_compatibility",
+    "xkb_semantics",
+    "type",
+    "alias",
+    "xkb_compatibility_map",
+    "alphanumeric_keys",
+    "function_keys",
+    "alternate",
+    "shape",
+    "action",
+    "section",
+    "row",
+    "logo",
+    "alternate_group",
+    "hidden",
+    "virtual",
+    "outline",
+    "default",
+    "modmap",
+    "virtual_modifiers",
+    "overlay",
+    "override",
+    "include",
+    "modifier_map",
+    "modifier_keys",
+    "indicator",
+    "group",
+    "mod_map",
+    "interpret",
+    "solid",
+    "partial"
+  };
+#define stringpool ((const char *) &stringpool_contents)
+#ifdef __GNUC__
+__inline
+#if defined __GNUC_STDC_INLINE__ || defined __GNUC_GNU_INLINE__
+__attribute__ ((__gnu_inline__))
+#endif
+#endif
+const struct keyword_tok *
+keyword_gperf_lookup (register const char *str, register unsigned int len)
+{
+  enum
+    {
+      TOTAL_KEYWORDS = 45,
+      MIN_WORD_LENGTH = 3,
+      MAX_WORD_LENGTH = 21,
+      MIN_HASH_VALUE = 3,
+      MAX_HASH_VALUE = 72
+    };
+
+  static const struct keyword_tok wordlist[] =
+    {
+      {-1}, {-1}, {-1},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str3,                    KEY},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str4,                   KEYS},
+      {-1}, {-1},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str7,                AUGMENT},
+      {-1},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str9,                   TEXT},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str10,             XKB_KEYMAP},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str11,            KEYPAD_KEYS},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str12,           XKB_KEYCODES},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str13,           XKB_GEOMETRY},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str14,              XKB_TYPES},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str15,             XKB_COMPATMAP},
+      {-1},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str17,                REPLACE},
+      {-1},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str19,         XKB_COMPATMAP},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str20,             XKB_LAYOUT},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str21,            XKB_SYMBOLS},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str22,      XKB_COMPATMAP},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str23,          XKB_SEMANTICS},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str24,                   TYPE},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str25,                  ALIAS},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str26,  XKB_COMPATMAP},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str27,      ALPHANUMERIC_KEYS},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str28,          FUNCTION_KEYS},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str29,              ALTERNATE},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str30,                  SHAPE},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str31,                 ACTION_TOK},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str32,                SECTION},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str33,                    ROW},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str34,                   LOGO},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str35,        ALTERNATE_GROUP},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str36,                 HIDDEN},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str37,                VIRTUAL},
+      {-1}, {-1}, {-1}, {-1},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str42,                OUTLINE},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str43,                DEFAULT},
+      {-1}, {-1},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str46,                 MODIFIER_MAP},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str47,      VIRTUAL_MODS},
+      {-1}, {-1}, {-1}, {-1},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str52,                OVERLAY},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str53,               OVERRIDE},
+      {-1}, {-1}, {-1},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str57,                INCLUDE},
+      {-1}, {-1}, {-1}, {-1},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str62,           MODIFIER_MAP},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str63,          MODIFIER_KEYS},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str64,              INDICATOR},
+      {-1},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str66,                  GROUP},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str67,                MODIFIER_MAP},
+      {-1},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str69,              INTERPRET},
+      {-1},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str71,                  SOLID},
+      {(int)(long)&((struct stringpool_t *)0)->stringpool_str72,                PARTIAL}
+    };
+
+  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
+    {
+      register int key = keyword_gperf_hash (str, len);
+
+      if (key <= MAX_HASH_VALUE && key >= 0)
+        {
+          register int o = wordlist[key].name;
+          if (o >= 0)
+            {
+              register const char *s = o + stringpool;
+
+              if ((((unsigned char)*str ^ (unsigned char)*s) & ~32) == 0 && !gperf_case_strcmp (str, s))
+                return &wordlist[key];
+            }
+        }
+    }
+  return 0;
+}
+
+
+int
+keyword_to_token(const char *string)
+{
+    const struct keyword_tok *kt;
+    kt = keyword_gperf_lookup(string, strlen(string));
+    if (!kt)
+        return -1;
+    return kt->tok;
+}
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/parser-priv.h b/src/3rdparty/xkbcommon/src/xkbcomp/parser-priv.h
index 2e02db66a8..05e725eb00 100644
--- a/src/3rdparty/xkbcommon/src/xkbcomp/parser-priv.h
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/parser-priv.h
@@ -27,21 +27,24 @@
 #ifndef XKBCOMP_PARSER_PRIV_H
 #define XKBCOMP_PARSER_PRIV_H
 
-struct scanner_extra;
+struct scanner;
 struct parser_param;
 
-#pragma GCC diagnostic ignored "-Wredundant-decls"
-#pragma GCC diagnostic push
 #include "parser.h"
-#pragma GCC diagnostic pop
+
+int
+scanner_error(struct scanner *scanner, const char *msg);
 
 void
-scanner_error(YYLTYPE *loc, void *scanner, const char *msg);
+scanner_warn(struct scanner *s, const char *msg);
 
 int
-_xkbcommon_lex(YYSTYPE *val, YYLTYPE *loc, void *scanner);
+_xkbcommon_lex(YYSTYPE *yylval, struct scanner *scanner);
 
 XkbFile *
 parse(struct xkb_context *ctx, void *scanner, const char *map);
 
+int
+keyword_to_token(const char *string);
+
 #endif
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/parser.c b/src/3rdparty/xkbcommon/src/xkbcomp/parser.c
index e1280e9180..26bbf30be8 100644
--- a/src/3rdparty/xkbcommon/src/xkbcomp/parser.c
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/parser.c
@@ -59,7 +59,7 @@
 #define YYPULL 1
 
 /* Using locations.  */
-#define YYLSP_NEEDED 1
+#define YYLSP_NEEDED 0
 
 /* Substitute the variable and function names.  */
 #define yyparse         _xkbcommon_parse
@@ -69,12 +69,12 @@
 #define yychar          _xkbcommon_char
 #define yydebug         _xkbcommon_debug
 #define yynerrs         _xkbcommon_nerrs
-#define yylloc          _xkbcommon_lloc
+
 
 /* Copy the first part of user declarations.  */
 
 /* Line 268 of yacc.c  */
-#line 27 "parser.y"
+#line 33 "parser.y"
 
 #include "xkbcomp-priv.h"
 #include "ast-build.h"
@@ -88,16 +88,52 @@ struct parser_param {
 };
 
 static void
-_xkbcommon_error(struct YYLTYPE *loc, struct parser_param *param, const char *msg)
+parser_error(struct parser_param *param, const char *msg)
 {
-    scanner_error(loc, param->scanner, msg);
+    scanner_error(param->scanner, msg);
+}
+
+static void
+parser_warn(struct parser_param *param, const char *msg)
+{
+    scanner_warn(param->scanner, msg);
+}
+
+static void
+_xkbcommon_error(struct parser_param *param, const char *msg)
+{
+    parser_error(param, msg);
+}
+
+static bool
+resolve_keysym(const char *str, xkb_keysym_t *sym_rtrn)
+{
+    xkb_keysym_t sym;
+
+    if (!str || istreq(str, "any") || istreq(str, "nosymbol")) {
+        *sym_rtrn = XKB_KEY_NoSymbol;
+        return true;
+    }
+
+    if (istreq(str, "none") || istreq(str, "voidsymbol")) {
+        *sym_rtrn = XKB_KEY_VoidSymbol;
+        return true;
+    }
+
+    sym = xkb_keysym_from_name(str, XKB_KEYSYM_NO_FLAGS);
+    if (sym != XKB_KEY_NoSymbol) {
+        *sym_rtrn = sym;
+        return true;
+    }
+
+    return false;
 }
 
 #define scanner param->scanner
 
 
 /* Line 268 of yacc.c  */
-#line 101 "src/xkbcomp/parser.c"
+#line 137 "src/xkbcomp/parser.c"
 
 /* Enabling traces.  */
 #ifndef YYDEBUG
@@ -262,16 +298,16 @@ typedef union YYSTYPE
 {
 
 /* Line 293 of yacc.c  */
-#line 127 "parser.y"
+#line 167 "parser.y"
 
         int              ival;
-        unsigned         uval;
         int64_t          num;
         enum xkb_file_type file_type;
         char            *str;
         xkb_atom_t      sval;
         enum merge_mode merge;
         enum xkb_map_flags mapFlags;
+        xkb_keysym_t    keysym;
         ParseCommon     *any;
         ExprDef         *expr;
         VarDef          *var;
@@ -291,32 +327,19 @@ typedef union YYSTYPE
 
 
 /* Line 293 of yacc.c  */
-#line 295 "src/xkbcomp/parser.c"
+#line 331 "src/xkbcomp/parser.c"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 # define YYSTYPE_IS_DECLARED 1
 #endif
 
-#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
-typedef struct YYLTYPE
-{
-  int first_line;
-  int first_column;
-  int last_line;
-  int last_column;
-} YYLTYPE;
-# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
-# define YYLTYPE_IS_DECLARED 1
-# define YYLTYPE_IS_TRIVIAL 1
-#endif
-
 
 /* Copy the second part of user declarations.  */
 
 
 /* Line 343 of yacc.c  */
-#line 320 "src/xkbcomp/parser.c"
+#line 343 "src/xkbcomp/parser.c"
 
 #ifdef short
 # undef short
@@ -474,15 +497,13 @@ void free (void *); /* INFRINGES ON USER NAME SPACE */
 
 #if (! defined yyoverflow \
      && (! defined __cplusplus \
-	 || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
-	     && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+	 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 
 /* A type that is properly aligned for any stack member.  */
 union yyalloc
 {
   yytype_int16 yyss_alloc;
   YYSTYPE yyvs_alloc;
-  YYLTYPE yyls_alloc;
 };
 
 /* The size of the maximum gap between one aligned stack and the next.  */
@@ -491,8 +512,8 @@ union yyalloc
 /* The size of an array large to enough to hold all stacks, each with
    N elements.  */
 # define YYSTACK_BYTES(N) \
-     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
-      + 2 * YYSTACK_GAP_MAXIMUM)
+     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
+      + YYSTACK_GAP_MAXIMUM)
 
 # define YYCOPY_NEEDED 1
 
@@ -677,25 +698,25 @@ static const yytype_int16 yyrhs[] =
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const yytype_uint16 yyrline[] =
 {
-       0,   198,   198,   200,   202,   206,   212,   213,   214,   217,
-     224,   228,   243,   244,   245,   246,   247,   250,   251,   254,
-     255,   258,   259,   260,   261,   262,   263,   264,   265,   268,
-     270,   273,   278,   283,   288,   293,   298,   303,   308,   313,
-     318,   323,   328,   329,   330,   331,   338,   340,   342,   346,
-     350,   354,   358,   360,   364,   366,   370,   376,   378,   382,
-     384,   388,   394,   400,   402,   404,   407,   408,   409,   410,
-     411,   414,   416,   420,   424,   428,   432,   434,   438,   440,
-     444,   448,   449,   452,   454,   456,   458,   460,   464,   465,
-     468,   469,   473,   474,   477,   479,   483,   487,   488,   491,
-     494,   496,   500,   502,   504,   508,   510,   514,   518,   522,
-     523,   524,   525,   528,   529,   532,   534,   536,   538,   540,
-     542,   544,   546,   548,   550,   552,   556,   557,   560,   561,
-     562,   563,   564,   574,   575,   578,   580,   584,   586,   588,
-     590,   592,   594,   598,   600,   602,   604,   606,   608,   610,
-     612,   616,   618,   622,   626,   633,   641,   650,   661,   668,
-     675,   679,   688,   689,   692,   694,   696,   698,   702,   706,
-     707,   708,   722,   723,   726,   727,   730,   733,   736,   739,
-     740,   743,   746,   747,   750
+       0,   238,   238,   240,   242,   246,   252,   253,   254,   257,
+     264,   268,   283,   284,   285,   286,   287,   290,   291,   294,
+     295,   298,   299,   300,   301,   302,   303,   304,   305,   308,
+     310,   313,   318,   323,   328,   333,   338,   343,   348,   353,
+     358,   363,   368,   369,   370,   371,   378,   380,   382,   386,
+     390,   394,   398,   400,   404,   406,   410,   416,   418,   422,
+     424,   428,   434,   440,   442,   444,   447,   448,   449,   450,
+     451,   454,   456,   460,   464,   468,   472,   474,   478,   480,
+     484,   488,   489,   492,   494,   496,   498,   500,   504,   505,
+     508,   509,   513,   514,   517,   519,   523,   527,   528,   531,
+     534,   536,   540,   542,   544,   548,   550,   554,   558,   562,
+     563,   564,   565,   568,   569,   572,   574,   576,   578,   580,
+     582,   584,   586,   588,   590,   592,   596,   597,   600,   601,
+     602,   603,   604,   614,   615,   618,   620,   624,   626,   628,
+     630,   632,   634,   638,   640,   642,   644,   646,   648,   650,
+     652,   656,   658,   662,   666,   668,   670,   672,   676,   678,
+     680,   682,   686,   687,   690,   692,   694,   696,   700,   704,
+     710,   711,   725,   726,   729,   730,   733,   736,   739,   742,
+     743,   746,   749,   750,   753
 };
 #endif
 
@@ -1148,7 +1169,7 @@ do								\
     }								\
   else								\
     {								\
-      yyerror (&yylloc, param, YY_("syntax error: cannot back up")); \
+      yyerror (param, YY_("syntax error: cannot back up")); \
       YYERROR;							\
     }								\
 while (YYID (0))
@@ -1184,28 +1205,19 @@ while (YYID (0))
 #endif
 
 
-/* YY_LOCATION_PRINT -- Print the location on the stream.
-   This macro was not mandated originally: define only if we know
-   we won't break user code: when these are the locations we know.  */
+/* This macro is provided for backward compatibility. */
 
 #ifndef YY_LOCATION_PRINT
-# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
-#  define YY_LOCATION_PRINT(File, Loc)			\
-     fprintf (File, "%d.%d-%d.%d",			\
-	      (Loc).first_line, (Loc).first_column,	\
-	      (Loc).last_line,  (Loc).last_column)
-# else
-#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
-# endif
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
 #endif
 
 
 /* YYLEX -- calling `yylex' with the right arguments.  */
 
 #ifdef YYLEX_PARAM
-# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
+# define YYLEX yylex (&yylval, YYLEX_PARAM)
 #else
-# define YYLEX yylex (&yylval, &yylloc, scanner)
+# define YYLEX yylex (&yylval, scanner)
 #endif
 
 /* Enable debugging if requested.  */
@@ -1228,7 +1240,7 @@ do {									  \
     {									  \
       YYFPRINTF (stderr, "%s ", Title);					  \
       yy_symbol_print (stderr,						  \
-		  Type, Value, Location, param); \
+		  Type, Value, param); \
       YYFPRINTF (stderr, "\n");						  \
     }									  \
 } while (YYID (0))
@@ -1242,20 +1254,18 @@ do {									  \
 #if (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 static void
-yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct parser_param *param)
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_param *param)
 #else
 static void
-yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, param)
+yy_symbol_value_print (yyoutput, yytype, yyvaluep, param)
     FILE *yyoutput;
     int yytype;
     YYSTYPE const * const yyvaluep;
-    YYLTYPE const * const yylocationp;
     struct parser_param *param;
 #endif
 {
   if (!yyvaluep)
     return;
-  YYUSE (yylocationp);
   YYUSE (param);
 # ifdef YYPRINT
   if (yytype < YYNTOKENS)
@@ -1278,14 +1288,13 @@ yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, param)
 #if (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 static void
-yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct parser_param *param)
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_param *param)
 #else
 static void
-yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, param)
+yy_symbol_print (yyoutput, yytype, yyvaluep, param)
     FILE *yyoutput;
     int yytype;
     YYSTYPE const * const yyvaluep;
-    YYLTYPE const * const yylocationp;
     struct parser_param *param;
 #endif
 {
@@ -1294,9 +1303,7 @@ yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, param)
   else
     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
 
-  YY_LOCATION_PRINT (yyoutput, *yylocationp);
-  YYFPRINTF (yyoutput, ": ");
-  yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, param);
+  yy_symbol_value_print (yyoutput, yytype, yyvaluep, param);
   YYFPRINTF (yyoutput, ")");
 }
 
@@ -1339,12 +1346,11 @@ do {								\
 #if (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 static void
-yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, struct parser_param *param)
+yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_param *param)
 #else
 static void
-yy_reduce_print (yyvsp, yylsp, yyrule, param)
+yy_reduce_print (yyvsp, yyrule, param)
     YYSTYPE *yyvsp;
-    YYLTYPE *yylsp;
     int yyrule;
     struct parser_param *param;
 #endif
@@ -1360,7 +1366,7 @@ yy_reduce_print (yyvsp, yylsp, yyrule, param)
       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
 		       &(yyvsp[(yyi + 1) - (yynrhs)])
-		       , &(yylsp[(yyi + 1) - (yynrhs)])		       , param);
+		       		       , param);
       YYFPRINTF (stderr, "\n");
     }
 }
@@ -1368,7 +1374,7 @@ yy_reduce_print (yyvsp, yylsp, yyrule, param)
 # define YY_REDUCE_PRINT(Rule)		\
 do {					\
   if (yydebug)				\
-    yy_reduce_print (yyvsp, yylsp, Rule, param); \
+    yy_reduce_print (yyvsp, Rule, param); \
 } while (YYID (0))
 
 /* Nonzero means print parse trace.  It is left uninitialized so that
@@ -1645,19 +1651,17 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
 #if (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 static void
-yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, struct parser_param *param)
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_param *param)
 #else
 static void
-yydestruct (yymsg, yytype, yyvaluep, yylocationp, param)
+yydestruct (yymsg, yytype, yyvaluep, param)
     const char *yymsg;
     int yytype;
     YYSTYPE *yyvaluep;
-    YYLTYPE *yylocationp;
     struct parser_param *param;
 #endif
 {
   YYUSE (yyvaluep);
-  YYUSE (yylocationp);
   YYUSE (param);
 
   if (!yymsg)
@@ -1721,9 +1725,6 @@ int yychar;
 /* The semantic value of the lookahead symbol.  */
 YYSTYPE yylval;
 
-/* Location data for the lookahead symbol.  */
-YYLTYPE yylloc;
-
     /* Number of syntax errors so far.  */
     int yynerrs;
 
@@ -1734,7 +1735,6 @@ YYLTYPE yylloc;
     /* The stacks and their tools:
        `yyss': related to states.
        `yyvs': related to semantic values.
-       `yyls': related to locations.
 
        Refer to the stacks thru separate pointers, to allow yyoverflow
        to reallocate them elsewhere.  */
@@ -1749,14 +1749,6 @@ YYLTYPE yylloc;
     YYSTYPE *yyvs;
     YYSTYPE *yyvsp;
 
-    /* The location stack.  */
-    YYLTYPE yylsa[YYINITDEPTH];
-    YYLTYPE *yyls;
-    YYLTYPE *yylsp;
-
-    /* The locations where the error started and ended.  */
-    YYLTYPE yyerror_range[3];
-
     YYSIZE_T yystacksize;
 
   int yyn;
@@ -1766,7 +1758,6 @@ YYLTYPE yylloc;
   /* The variables used to return semantic value and location from the
      action routines.  */
   YYSTYPE yyval;
-  YYLTYPE yyloc;
 
 #if YYERROR_VERBOSE
   /* Buffer for error messages, and its allocated size.  */
@@ -1775,7 +1766,7 @@ YYLTYPE yylloc;
   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
 #endif
 
-#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
+#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
 
   /* The number of symbols on the RHS of the reduced rule.
      Keep to zero when no symbol should be popped.  */
@@ -1784,7 +1775,6 @@ YYLTYPE yylloc;
   yytoken = 0;
   yyss = yyssa;
   yyvs = yyvsa;
-  yyls = yylsa;
   yystacksize = YYINITDEPTH;
 
   YYDPRINTF ((stderr, "Starting parse\n"));
@@ -1800,13 +1790,6 @@ YYLTYPE yylloc;
      The wasted elements are never initialized.  */
   yyssp = yyss;
   yyvsp = yyvs;
-  yylsp = yyls;
-
-#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
-  /* Initialize the default location before parsing starts.  */
-  yylloc.first_line   = yylloc.last_line   = 1;
-  yylloc.first_column = yylloc.last_column = 1;
-#endif
 
   goto yysetstate;
 
@@ -1833,7 +1816,6 @@ YYLTYPE yylloc;
 	   memory.  */
 	YYSTYPE *yyvs1 = yyvs;
 	yytype_int16 *yyss1 = yyss;
-	YYLTYPE *yyls1 = yyls;
 
 	/* Each stack pointer address is followed by the size of the
 	   data in use in that stack, in bytes.  This used to be a
@@ -1842,10 +1824,8 @@ YYLTYPE yylloc;
 	yyoverflow (YY_("memory exhausted"),
 		    &yyss1, yysize * sizeof (*yyssp),
 		    &yyvs1, yysize * sizeof (*yyvsp),
-		    &yyls1, yysize * sizeof (*yylsp),
 		    &yystacksize);
 
-	yyls = yyls1;
 	yyss = yyss1;
 	yyvs = yyvs1;
       }
@@ -1868,7 +1848,6 @@ YYLTYPE yylloc;
 	  goto yyexhaustedlab;
 	YYSTACK_RELOCATE (yyss_alloc, yyss);
 	YYSTACK_RELOCATE (yyvs_alloc, yyvs);
-	YYSTACK_RELOCATE (yyls_alloc, yyls);
 #  undef YYSTACK_RELOCATE
 	if (yyss1 != yyssa)
 	  YYSTACK_FREE (yyss1);
@@ -1878,7 +1857,6 @@ YYLTYPE yylloc;
 
       yyssp = yyss + yysize - 1;
       yyvsp = yyvs + yysize - 1;
-      yylsp = yyls + yysize - 1;
 
       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
 		  (unsigned long int) yystacksize));
@@ -1954,7 +1932,7 @@ yybackup:
 
   yystate = yyn;
   *++yyvsp = yylval;
-  *++yylsp = yylloc;
+
   goto yynewstate;
 
 
@@ -1985,64 +1963,63 @@ yyreduce:
      GCC warning that YYVAL may be used uninitialized.  */
   yyval = yyvsp[1-yylen];
 
-  /* Default location.  */
-  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
+
   YY_REDUCE_PRINT (yyn);
   switch (yyn)
     {
         case 2:
 
 /* Line 1806 of yacc.c  */
-#line 199 "parser.y"
+#line 239 "parser.y"
     { (yyval.file) = param->rtrn = (yyvsp[(1) - (1)].file); param->more_maps = true; }
     break;
 
   case 3:
 
 /* Line 1806 of yacc.c  */
-#line 201 "parser.y"
+#line 241 "parser.y"
     { (yyval.file) = param->rtrn = (yyvsp[(1) - (1)].file); param->more_maps = true; YYACCEPT; }
     break;
 
   case 4:
 
 /* Line 1806 of yacc.c  */
-#line 203 "parser.y"
+#line 243 "parser.y"
     { (yyval.file) = param->rtrn = NULL; param->more_maps = false; }
     break;
 
   case 5:
 
 /* Line 1806 of yacc.c  */
-#line 209 "parser.y"
+#line 249 "parser.y"
     { (yyval.file) = XkbFileCreate(param->ctx, (yyvsp[(2) - (7)].file_type), (yyvsp[(3) - (7)].str), &(yyvsp[(5) - (7)].file)->common, (yyvsp[(1) - (7)].mapFlags)); }
     break;
 
   case 6:
 
 /* Line 1806 of yacc.c  */
-#line 212 "parser.y"
+#line 252 "parser.y"
     { (yyval.file_type) = FILE_TYPE_KEYMAP; }
     break;
 
   case 7:
 
 /* Line 1806 of yacc.c  */
-#line 213 "parser.y"
+#line 253 "parser.y"
     { (yyval.file_type) = FILE_TYPE_KEYMAP; }
     break;
 
   case 8:
 
 /* Line 1806 of yacc.c  */
-#line 214 "parser.y"
+#line 254 "parser.y"
     { (yyval.file_type) = FILE_TYPE_KEYMAP; }
     break;
 
   case 9:
 
 /* Line 1806 of yacc.c  */
-#line 218 "parser.y"
+#line 258 "parser.y"
     {
                             if (!(yyvsp[(2) - (2)].file))
                                 (yyval.file) = (yyvsp[(1) - (2)].file);
@@ -2054,14 +2031,14 @@ yyreduce:
   case 10:
 
 /* Line 1806 of yacc.c  */
-#line 225 "parser.y"
+#line 265 "parser.y"
     { (yyval.file) = (yyvsp[(1) - (1)].file); }
     break;
 
   case 11:
 
 /* Line 1806 of yacc.c  */
-#line 231 "parser.y"
+#line 271 "parser.y"
     {
                             if ((yyvsp[(2) - (7)].file_type) == FILE_TYPE_GEOMETRY) {
                                 free((yyvsp[(3) - (7)].str));
@@ -2077,140 +2054,140 @@ yyreduce:
   case 12:
 
 /* Line 1806 of yacc.c  */
-#line 243 "parser.y"
+#line 283 "parser.y"
     { (yyval.file_type) = FILE_TYPE_KEYCODES; }
     break;
 
   case 13:
 
 /* Line 1806 of yacc.c  */
-#line 244 "parser.y"
+#line 284 "parser.y"
     { (yyval.file_type) = FILE_TYPE_TYPES; }
     break;
 
   case 14:
 
 /* Line 1806 of yacc.c  */
-#line 245 "parser.y"
+#line 285 "parser.y"
     { (yyval.file_type) = FILE_TYPE_COMPAT; }
     break;
 
   case 15:
 
 /* Line 1806 of yacc.c  */
-#line 246 "parser.y"
+#line 286 "parser.y"
     { (yyval.file_type) = FILE_TYPE_SYMBOLS; }
     break;
 
   case 16:
 
 /* Line 1806 of yacc.c  */
-#line 247 "parser.y"
+#line 287 "parser.y"
     { (yyval.file_type) = FILE_TYPE_GEOMETRY; }
     break;
 
   case 17:
 
 /* Line 1806 of yacc.c  */
-#line 250 "parser.y"
+#line 290 "parser.y"
     { (yyval.mapFlags) = (yyvsp[(1) - (1)].mapFlags); }
     break;
 
   case 18:
 
 /* Line 1806 of yacc.c  */
-#line 251 "parser.y"
+#line 291 "parser.y"
     { (yyval.mapFlags) = 0; }
     break;
 
   case 19:
 
 /* Line 1806 of yacc.c  */
-#line 254 "parser.y"
+#line 294 "parser.y"
     { (yyval.mapFlags) = ((yyvsp[(1) - (2)].mapFlags) | (yyvsp[(2) - (2)].mapFlags)); }
     break;
 
   case 20:
 
 /* Line 1806 of yacc.c  */
-#line 255 "parser.y"
+#line 295 "parser.y"
     { (yyval.mapFlags) = (yyvsp[(1) - (1)].mapFlags); }
     break;
 
   case 21:
 
 /* Line 1806 of yacc.c  */
-#line 258 "parser.y"
+#line 298 "parser.y"
     { (yyval.mapFlags) = MAP_IS_PARTIAL; }
     break;
 
   case 22:
 
 /* Line 1806 of yacc.c  */
-#line 259 "parser.y"
+#line 299 "parser.y"
     { (yyval.mapFlags) = MAP_IS_DEFAULT; }
     break;
 
   case 23:
 
 /* Line 1806 of yacc.c  */
-#line 260 "parser.y"
+#line 300 "parser.y"
     { (yyval.mapFlags) = MAP_IS_HIDDEN; }
     break;
 
   case 24:
 
 /* Line 1806 of yacc.c  */
-#line 261 "parser.y"
+#line 301 "parser.y"
     { (yyval.mapFlags) = MAP_HAS_ALPHANUMERIC; }
     break;
 
   case 25:
 
 /* Line 1806 of yacc.c  */
-#line 262 "parser.y"
+#line 302 "parser.y"
     { (yyval.mapFlags) = MAP_HAS_MODIFIER; }
     break;
 
   case 26:
 
 /* Line 1806 of yacc.c  */
-#line 263 "parser.y"
+#line 303 "parser.y"
     { (yyval.mapFlags) = MAP_HAS_KEYPAD; }
     break;
 
   case 27:
 
 /* Line 1806 of yacc.c  */
-#line 264 "parser.y"
+#line 304 "parser.y"
     { (yyval.mapFlags) = MAP_HAS_FN; }
     break;
 
   case 28:
 
 /* Line 1806 of yacc.c  */
-#line 265 "parser.y"
+#line 305 "parser.y"
     { (yyval.mapFlags) = MAP_IS_ALTGR; }
     break;
 
   case 29:
 
 /* Line 1806 of yacc.c  */
-#line 269 "parser.y"
+#line 309 "parser.y"
     { (yyval.any) = AppendStmt((yyvsp[(1) - (2)].any), (yyvsp[(2) - (2)].any)); }
     break;
 
   case 30:
 
 /* Line 1806 of yacc.c  */
-#line 270 "parser.y"
+#line 310 "parser.y"
     { (yyval.any) = NULL; }
     break;
 
   case 31:
 
 /* Line 1806 of yacc.c  */
-#line 274 "parser.y"
+#line 314 "parser.y"
     {
                             (yyvsp[(2) - (2)].var)->merge = (yyvsp[(1) - (2)].merge);
                             (yyval.any) = &(yyvsp[(2) - (2)].var)->common;
@@ -2220,7 +2197,7 @@ yyreduce:
   case 32:
 
 /* Line 1806 of yacc.c  */
-#line 279 "parser.y"
+#line 319 "parser.y"
     {
                             (yyvsp[(2) - (2)].vmod)->merge = (yyvsp[(1) - (2)].merge);
                             (yyval.any) = &(yyvsp[(2) - (2)].vmod)->common;
@@ -2230,7 +2207,7 @@ yyreduce:
   case 33:
 
 /* Line 1806 of yacc.c  */
-#line 284 "parser.y"
+#line 324 "parser.y"
     {
                             (yyvsp[(2) - (2)].interp)->merge = (yyvsp[(1) - (2)].merge);
                             (yyval.any) = &(yyvsp[(2) - (2)].interp)->common;
@@ -2240,7 +2217,7 @@ yyreduce:
   case 34:
 
 /* Line 1806 of yacc.c  */
-#line 289 "parser.y"
+#line 329 "parser.y"
     {
                             (yyvsp[(2) - (2)].keyCode)->merge = (yyvsp[(1) - (2)].merge);
                             (yyval.any) = &(yyvsp[(2) - (2)].keyCode)->common;
@@ -2250,7 +2227,7 @@ yyreduce:
   case 35:
 
 /* Line 1806 of yacc.c  */
-#line 294 "parser.y"
+#line 334 "parser.y"
     {
                             (yyvsp[(2) - (2)].keyAlias)->merge = (yyvsp[(1) - (2)].merge);
                             (yyval.any) = &(yyvsp[(2) - (2)].keyAlias)->common;
@@ -2260,7 +2237,7 @@ yyreduce:
   case 36:
 
 /* Line 1806 of yacc.c  */
-#line 299 "parser.y"
+#line 339 "parser.y"
     {
                             (yyvsp[(2) - (2)].keyType)->merge = (yyvsp[(1) - (2)].merge);
                             (yyval.any) = &(yyvsp[(2) - (2)].keyType)->common;
@@ -2270,7 +2247,7 @@ yyreduce:
   case 37:
 
 /* Line 1806 of yacc.c  */
-#line 304 "parser.y"
+#line 344 "parser.y"
     {
                             (yyvsp[(2) - (2)].syms)->merge = (yyvsp[(1) - (2)].merge);
                             (yyval.any) = &(yyvsp[(2) - (2)].syms)->common;
@@ -2280,7 +2257,7 @@ yyreduce:
   case 38:
 
 /* Line 1806 of yacc.c  */
-#line 309 "parser.y"
+#line 349 "parser.y"
     {
                             (yyvsp[(2) - (2)].modMask)->merge = (yyvsp[(1) - (2)].merge);
                             (yyval.any) = &(yyvsp[(2) - (2)].modMask)->common;
@@ -2290,7 +2267,7 @@ yyreduce:
   case 39:
 
 /* Line 1806 of yacc.c  */
-#line 314 "parser.y"
+#line 354 "parser.y"
     {
                             (yyvsp[(2) - (2)].groupCompat)->merge = (yyvsp[(1) - (2)].merge);
                             (yyval.any) = &(yyvsp[(2) - (2)].groupCompat)->common;
@@ -2300,7 +2277,7 @@ yyreduce:
   case 40:
 
 /* Line 1806 of yacc.c  */
-#line 319 "parser.y"
+#line 359 "parser.y"
     {
                             (yyvsp[(2) - (2)].ledMap)->merge = (yyvsp[(1) - (2)].merge);
                             (yyval.any) = &(yyvsp[(2) - (2)].ledMap)->common;
@@ -2310,7 +2287,7 @@ yyreduce:
   case 41:
 
 /* Line 1806 of yacc.c  */
-#line 324 "parser.y"
+#line 364 "parser.y"
     {
                             (yyvsp[(2) - (2)].ledName)->merge = (yyvsp[(1) - (2)].merge);
                             (yyval.any) = &(yyvsp[(2) - (2)].ledName)->common;
@@ -2320,28 +2297,28 @@ yyreduce:
   case 42:
 
 /* Line 1806 of yacc.c  */
-#line 328 "parser.y"
+#line 368 "parser.y"
     { (yyval.any) = NULL; }
     break;
 
   case 43:
 
 /* Line 1806 of yacc.c  */
-#line 329 "parser.y"
+#line 369 "parser.y"
     { (yyval.any) = NULL; }
     break;
 
   case 44:
 
 /* Line 1806 of yacc.c  */
-#line 330 "parser.y"
+#line 370 "parser.y"
     { (yyval.any) = NULL; }
     break;
 
   case 45:
 
 /* Line 1806 of yacc.c  */
-#line 332 "parser.y"
+#line 372 "parser.y"
     {
                             (yyval.any) = &IncludeCreate(param->ctx, (yyvsp[(2) - (2)].str), (yyvsp[(1) - (2)].merge))->common;
                             free((yyvsp[(2) - (2)].str));
@@ -2351,609 +2328,609 @@ yyreduce:
   case 46:
 
 /* Line 1806 of yacc.c  */
-#line 339 "parser.y"
+#line 379 "parser.y"
     { (yyval.var) = VarCreate((yyvsp[(1) - (4)].expr), (yyvsp[(3) - (4)].expr)); }
     break;
 
   case 47:
 
 /* Line 1806 of yacc.c  */
-#line 341 "parser.y"
-    { (yyval.var) = BoolVarCreate((yyvsp[(1) - (2)].sval), 1); }
+#line 381 "parser.y"
+    { (yyval.var) = BoolVarCreate((yyvsp[(1) - (2)].sval), true); }
     break;
 
   case 48:
 
 /* Line 1806 of yacc.c  */
-#line 343 "parser.y"
-    { (yyval.var) = BoolVarCreate((yyvsp[(2) - (3)].sval), 0); }
+#line 383 "parser.y"
+    { (yyval.var) = BoolVarCreate((yyvsp[(2) - (3)].sval), false); }
     break;
 
   case 49:
 
 /* Line 1806 of yacc.c  */
-#line 347 "parser.y"
+#line 387 "parser.y"
     { (yyval.keyCode) = KeycodeCreate((yyvsp[(1) - (4)].sval), (yyvsp[(3) - (4)].num)); }
     break;
 
   case 50:
 
 /* Line 1806 of yacc.c  */
-#line 351 "parser.y"
+#line 391 "parser.y"
     { (yyval.keyAlias) = KeyAliasCreate((yyvsp[(2) - (5)].sval), (yyvsp[(4) - (5)].sval)); }
     break;
 
   case 51:
 
 /* Line 1806 of yacc.c  */
-#line 355 "parser.y"
+#line 395 "parser.y"
     { (yyval.vmod) = (yyvsp[(2) - (3)].vmod); }
     break;
 
   case 52:
 
 /* Line 1806 of yacc.c  */
-#line 359 "parser.y"
+#line 399 "parser.y"
     { (yyval.vmod) = (VModDef *)AppendStmt(&(yyvsp[(1) - (3)].vmod)->common, &(yyvsp[(3) - (3)].vmod)->common); }
     break;
 
   case 53:
 
 /* Line 1806 of yacc.c  */
-#line 361 "parser.y"
+#line 401 "parser.y"
     { (yyval.vmod) = (yyvsp[(1) - (1)].vmod); }
     break;
 
   case 54:
 
 /* Line 1806 of yacc.c  */
-#line 365 "parser.y"
+#line 405 "parser.y"
     { (yyval.vmod) = VModCreate((yyvsp[(1) - (1)].sval), NULL); }
     break;
 
   case 55:
 
 /* Line 1806 of yacc.c  */
-#line 367 "parser.y"
+#line 407 "parser.y"
     { (yyval.vmod) = VModCreate((yyvsp[(1) - (3)].sval), (yyvsp[(3) - (3)].expr)); }
     break;
 
   case 56:
 
 /* Line 1806 of yacc.c  */
-#line 373 "parser.y"
+#line 413 "parser.y"
     { (yyvsp[(2) - (6)].interp)->def = (yyvsp[(4) - (6)].var); (yyval.interp) = (yyvsp[(2) - (6)].interp); }
     break;
 
   case 57:
 
 /* Line 1806 of yacc.c  */
-#line 377 "parser.y"
-    { (yyval.interp) = InterpCreate((yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].expr)); }
+#line 417 "parser.y"
+    { (yyval.interp) = InterpCreate((yyvsp[(1) - (3)].keysym), (yyvsp[(3) - (3)].expr)); }
     break;
 
   case 58:
 
 /* Line 1806 of yacc.c  */
-#line 379 "parser.y"
-    { (yyval.interp) = InterpCreate((yyvsp[(1) - (1)].str), NULL); }
+#line 419 "parser.y"
+    { (yyval.interp) = InterpCreate((yyvsp[(1) - (1)].keysym), NULL); }
     break;
 
   case 59:
 
 /* Line 1806 of yacc.c  */
-#line 383 "parser.y"
+#line 423 "parser.y"
     { (yyval.var) = (VarDef *)AppendStmt(&(yyvsp[(1) - (2)].var)->common, &(yyvsp[(2) - (2)].var)->common); }
     break;
 
   case 60:
 
 /* Line 1806 of yacc.c  */
-#line 385 "parser.y"
+#line 425 "parser.y"
     { (yyval.var) = (yyvsp[(1) - (1)].var); }
     break;
 
   case 61:
 
 /* Line 1806 of yacc.c  */
-#line 391 "parser.y"
+#line 431 "parser.y"
     { (yyval.keyType) = KeyTypeCreate((yyvsp[(2) - (6)].sval), (yyvsp[(4) - (6)].var)); }
     break;
 
   case 62:
 
 /* Line 1806 of yacc.c  */
-#line 397 "parser.y"
-    { (yyval.syms) = SymbolsCreate((yyvsp[(2) - (6)].sval), (ExprDef *)(yyvsp[(4) - (6)].var)); }
+#line 437 "parser.y"
+    { (yyval.syms) = SymbolsCreate((yyvsp[(2) - (6)].sval), (yyvsp[(4) - (6)].var)); }
     break;
 
   case 63:
 
 /* Line 1806 of yacc.c  */
-#line 401 "parser.y"
+#line 441 "parser.y"
     { (yyval.var) = (VarDef *)AppendStmt(&(yyvsp[(1) - (3)].var)->common, &(yyvsp[(3) - (3)].var)->common); }
     break;
 
   case 64:
 
 /* Line 1806 of yacc.c  */
-#line 403 "parser.y"
+#line 443 "parser.y"
     { (yyval.var) = (yyvsp[(1) - (1)].var); }
     break;
 
   case 65:
 
 /* Line 1806 of yacc.c  */
-#line 404 "parser.y"
+#line 444 "parser.y"
     { (yyval.var) = NULL; }
     break;
 
   case 66:
 
 /* Line 1806 of yacc.c  */
-#line 407 "parser.y"
+#line 447 "parser.y"
     { (yyval.var) = VarCreate((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
     break;
 
   case 67:
 
 /* Line 1806 of yacc.c  */
-#line 408 "parser.y"
+#line 448 "parser.y"
     { (yyval.var) = VarCreate((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
     break;
 
   case 68:
 
 /* Line 1806 of yacc.c  */
-#line 409 "parser.y"
-    { (yyval.var) = BoolVarCreate((yyvsp[(1) - (1)].sval), 1); }
+#line 449 "parser.y"
+    { (yyval.var) = BoolVarCreate((yyvsp[(1) - (1)].sval), true); }
     break;
 
   case 69:
 
 /* Line 1806 of yacc.c  */
-#line 410 "parser.y"
-    { (yyval.var) = BoolVarCreate((yyvsp[(2) - (2)].sval), 0); }
+#line 450 "parser.y"
+    { (yyval.var) = BoolVarCreate((yyvsp[(2) - (2)].sval), false); }
     break;
 
   case 70:
 
 /* Line 1806 of yacc.c  */
-#line 411 "parser.y"
+#line 451 "parser.y"
     { (yyval.var) = VarCreate(NULL, (yyvsp[(1) - (1)].expr)); }
     break;
 
   case 71:
 
 /* Line 1806 of yacc.c  */
-#line 415 "parser.y"
+#line 455 "parser.y"
     { (yyval.expr) = (yyvsp[(2) - (3)].expr); }
     break;
 
   case 72:
 
 /* Line 1806 of yacc.c  */
-#line 417 "parser.y"
+#line 457 "parser.y"
     { (yyval.expr) = ExprCreateUnary(EXPR_ACTION_LIST, EXPR_TYPE_ACTION, (yyvsp[(2) - (3)].expr)); }
     break;
 
   case 73:
 
 /* Line 1806 of yacc.c  */
-#line 421 "parser.y"
+#line 461 "parser.y"
     { (yyval.groupCompat) = GroupCompatCreate((yyvsp[(2) - (5)].ival), (yyvsp[(4) - (5)].expr)); }
     break;
 
   case 74:
 
 /* Line 1806 of yacc.c  */
-#line 425 "parser.y"
+#line 465 "parser.y"
     { (yyval.modMask) = ModMapCreate((yyvsp[(2) - (6)].sval), (yyvsp[(4) - (6)].expr)); }
     break;
 
   case 75:
 
 /* Line 1806 of yacc.c  */
-#line 429 "parser.y"
+#line 469 "parser.y"
     { (yyval.ledMap) = LedMapCreate((yyvsp[(2) - (6)].sval), (yyvsp[(4) - (6)].var)); }
     break;
 
   case 76:
 
 /* Line 1806 of yacc.c  */
-#line 433 "parser.y"
+#line 473 "parser.y"
     { (yyval.ledName) = LedNameCreate((yyvsp[(2) - (5)].ival), (yyvsp[(4) - (5)].expr), false); }
     break;
 
   case 77:
 
 /* Line 1806 of yacc.c  */
-#line 435 "parser.y"
+#line 475 "parser.y"
     { (yyval.ledName) = LedNameCreate((yyvsp[(3) - (6)].ival), (yyvsp[(5) - (6)].expr), true); }
     break;
 
   case 78:
 
 /* Line 1806 of yacc.c  */
-#line 439 "parser.y"
+#line 479 "parser.y"
     { (yyval.geom) = NULL; }
     break;
 
   case 79:
 
 /* Line 1806 of yacc.c  */
-#line 441 "parser.y"
+#line 481 "parser.y"
     { (yyval.geom) = NULL; }
     break;
 
   case 80:
 
 /* Line 1806 of yacc.c  */
-#line 445 "parser.y"
+#line 485 "parser.y"
     { (yyval.geom) = NULL; }
     break;
 
   case 81:
 
 /* Line 1806 of yacc.c  */
-#line 448 "parser.y"
+#line 488 "parser.y"
     { (yyval.geom) = NULL;}
     break;
 
   case 82:
 
 /* Line 1806 of yacc.c  */
-#line 449 "parser.y"
+#line 489 "parser.y"
     { (yyval.geom) = NULL; }
     break;
 
   case 83:
 
 /* Line 1806 of yacc.c  */
-#line 453 "parser.y"
+#line 493 "parser.y"
     { (yyval.geom) = NULL; }
     break;
 
   case 84:
 
 /* Line 1806 of yacc.c  */
-#line 455 "parser.y"
+#line 495 "parser.y"
     { FreeStmt(&(yyvsp[(1) - (1)].var)->common); (yyval.geom) = NULL; }
     break;
 
   case 85:
 
 /* Line 1806 of yacc.c  */
-#line 457 "parser.y"
+#line 497 "parser.y"
     { (yyval.geom) = NULL; }
     break;
 
   case 86:
 
 /* Line 1806 of yacc.c  */
-#line 459 "parser.y"
+#line 499 "parser.y"
     { FreeStmt(&(yyvsp[(1) - (1)].ledMap)->common); (yyval.geom) = NULL; }
     break;
 
   case 87:
 
 /* Line 1806 of yacc.c  */
-#line 461 "parser.y"
+#line 501 "parser.y"
     { (yyval.geom) = NULL; }
     break;
 
   case 88:
 
 /* Line 1806 of yacc.c  */
-#line 464 "parser.y"
+#line 504 "parser.y"
     { (yyval.geom) = NULL;}
     break;
 
   case 89:
 
 /* Line 1806 of yacc.c  */
-#line 465 "parser.y"
+#line 505 "parser.y"
     { (yyval.geom) = NULL; }
     break;
 
   case 90:
 
 /* Line 1806 of yacc.c  */
-#line 468 "parser.y"
+#line 508 "parser.y"
     { (yyval.geom) = NULL; }
     break;
 
   case 91:
 
 /* Line 1806 of yacc.c  */
-#line 470 "parser.y"
+#line 510 "parser.y"
     { FreeStmt(&(yyvsp[(1) - (1)].var)->common); (yyval.geom) = NULL; }
     break;
 
   case 92:
 
 /* Line 1806 of yacc.c  */
-#line 473 "parser.y"
+#line 513 "parser.y"
     { (yyval.geom) = NULL; }
     break;
 
   case 93:
 
 /* Line 1806 of yacc.c  */
-#line 474 "parser.y"
+#line 514 "parser.y"
     { (yyval.geom) = NULL; }
     break;
 
   case 94:
 
 /* Line 1806 of yacc.c  */
-#line 478 "parser.y"
+#line 518 "parser.y"
     { (yyval.geom) = NULL; }
     break;
 
   case 95:
 
 /* Line 1806 of yacc.c  */
-#line 480 "parser.y"
+#line 520 "parser.y"
     { FreeStmt(&(yyvsp[(2) - (3)].expr)->common); (yyval.geom) = NULL; }
     break;
 
   case 96:
 
 /* Line 1806 of yacc.c  */
-#line 484 "parser.y"
+#line 524 "parser.y"
     { (yyval.geom) = NULL; }
     break;
 
   case 97:
 
 /* Line 1806 of yacc.c  */
-#line 487 "parser.y"
+#line 527 "parser.y"
     { (yyval.geom) = NULL; }
     break;
 
   case 98:
 
 /* Line 1806 of yacc.c  */
-#line 488 "parser.y"
+#line 528 "parser.y"
     { (yyval.geom) = NULL; }
     break;
 
   case 99:
 
 /* Line 1806 of yacc.c  */
-#line 491 "parser.y"
+#line 531 "parser.y"
     { (yyval.geom) = NULL; }
     break;
 
   case 100:
 
 /* Line 1806 of yacc.c  */
-#line 495 "parser.y"
+#line 535 "parser.y"
     { (yyval.geom) = NULL;}
     break;
 
   case 101:
 
 /* Line 1806 of yacc.c  */
-#line 497 "parser.y"
+#line 537 "parser.y"
     { (yyval.geom) = NULL; }
     break;
 
   case 102:
 
 /* Line 1806 of yacc.c  */
-#line 501 "parser.y"
+#line 541 "parser.y"
     { (yyval.geom) = NULL; }
     break;
 
   case 103:
 
 /* Line 1806 of yacc.c  */
-#line 503 "parser.y"
+#line 543 "parser.y"
     { (yyval.geom) = NULL; }
     break;
 
   case 104:
 
 /* Line 1806 of yacc.c  */
-#line 505 "parser.y"
+#line 545 "parser.y"
     { FreeStmt(&(yyvsp[(3) - (3)].expr)->common); (yyval.geom) = NULL; }
     break;
 
   case 105:
 
 /* Line 1806 of yacc.c  */
-#line 509 "parser.y"
+#line 549 "parser.y"
     { (yyval.expr) = NULL; }
     break;
 
   case 106:
 
 /* Line 1806 of yacc.c  */
-#line 511 "parser.y"
+#line 551 "parser.y"
     { (yyval.expr) = NULL; }
     break;
 
   case 107:
 
 /* Line 1806 of yacc.c  */
-#line 515 "parser.y"
+#line 555 "parser.y"
     { (yyval.expr) = NULL; }
     break;
 
   case 108:
 
 /* Line 1806 of yacc.c  */
-#line 519 "parser.y"
+#line 559 "parser.y"
     { FreeStmt(&(yyvsp[(4) - (6)].var)->common); (yyval.geom) = NULL; }
     break;
 
   case 109:
 
 /* Line 1806 of yacc.c  */
-#line 522 "parser.y"
-    { (yyval.uval) = 0; }
+#line 562 "parser.y"
+    { (yyval.ival) = 0; }
     break;
 
   case 110:
 
 /* Line 1806 of yacc.c  */
-#line 523 "parser.y"
-    { (yyval.uval) = 0; }
+#line 563 "parser.y"
+    { (yyval.ival) = 0; }
     break;
 
   case 111:
 
 /* Line 1806 of yacc.c  */
-#line 524 "parser.y"
-    { (yyval.uval) = 0; }
+#line 564 "parser.y"
+    { (yyval.ival) = 0; }
     break;
 
   case 112:
 
 /* Line 1806 of yacc.c  */
-#line 525 "parser.y"
-    { (yyval.uval) = 0; }
+#line 565 "parser.y"
+    { (yyval.ival) = 0; }
     break;
 
   case 113:
 
 /* Line 1806 of yacc.c  */
-#line 528 "parser.y"
+#line 568 "parser.y"
     { (yyval.sval) = (yyvsp[(1) - (1)].sval); }
     break;
 
   case 114:
 
 /* Line 1806 of yacc.c  */
-#line 529 "parser.y"
+#line 569 "parser.y"
     { (yyval.sval) = (yyvsp[(1) - (1)].sval); }
     break;
 
   case 115:
 
 /* Line 1806 of yacc.c  */
-#line 533 "parser.y"
-    { (yyval.sval) = xkb_atom_intern(param->ctx, "action"); }
+#line 573 "parser.y"
+    { (yyval.sval) = xkb_atom_intern_literal(param->ctx, "action"); }
     break;
 
   case 116:
 
 /* Line 1806 of yacc.c  */
-#line 535 "parser.y"
-    { (yyval.sval) = xkb_atom_intern(param->ctx, "interpret"); }
+#line 575 "parser.y"
+    { (yyval.sval) = xkb_atom_intern_literal(param->ctx, "interpret"); }
     break;
 
   case 117:
 
 /* Line 1806 of yacc.c  */
-#line 537 "parser.y"
-    { (yyval.sval) = xkb_atom_intern(param->ctx, "type"); }
+#line 577 "parser.y"
+    { (yyval.sval) = xkb_atom_intern_literal(param->ctx, "type"); }
     break;
 
   case 118:
 
 /* Line 1806 of yacc.c  */
-#line 539 "parser.y"
-    { (yyval.sval) = xkb_atom_intern(param->ctx, "key"); }
+#line 579 "parser.y"
+    { (yyval.sval) = xkb_atom_intern_literal(param->ctx, "key"); }
     break;
 
   case 119:
 
 /* Line 1806 of yacc.c  */
-#line 541 "parser.y"
-    { (yyval.sval) = xkb_atom_intern(param->ctx, "group"); }
+#line 581 "parser.y"
+    { (yyval.sval) = xkb_atom_intern_literal(param->ctx, "group"); }
     break;
 
   case 120:
 
 /* Line 1806 of yacc.c  */
-#line 543 "parser.y"
-    {(yyval.sval) = xkb_atom_intern(param->ctx, "modifier_map");}
+#line 583 "parser.y"
+    {(yyval.sval) = xkb_atom_intern_literal(param->ctx, "modifier_map");}
     break;
 
   case 121:
 
 /* Line 1806 of yacc.c  */
-#line 545 "parser.y"
-    { (yyval.sval) = xkb_atom_intern(param->ctx, "indicator"); }
+#line 585 "parser.y"
+    { (yyval.sval) = xkb_atom_intern_literal(param->ctx, "indicator"); }
     break;
 
   case 122:
 
 /* Line 1806 of yacc.c  */
-#line 547 "parser.y"
+#line 587 "parser.y"
     { (yyval.sval) = XKB_ATOM_NONE; }
     break;
 
   case 123:
 
 /* Line 1806 of yacc.c  */
-#line 549 "parser.y"
+#line 589 "parser.y"
     { (yyval.sval) = XKB_ATOM_NONE; }
     break;
 
   case 124:
 
 /* Line 1806 of yacc.c  */
-#line 551 "parser.y"
+#line 591 "parser.y"
     { (yyval.sval) = XKB_ATOM_NONE; }
     break;
 
   case 125:
 
 /* Line 1806 of yacc.c  */
-#line 553 "parser.y"
+#line 593 "parser.y"
     { (yyval.sval) = XKB_ATOM_NONE; }
     break;
 
   case 126:
 
 /* Line 1806 of yacc.c  */
-#line 556 "parser.y"
+#line 596 "parser.y"
     { (yyval.merge) = (yyvsp[(1) - (1)].merge); }
     break;
 
   case 127:
 
 /* Line 1806 of yacc.c  */
-#line 557 "parser.y"
+#line 597 "parser.y"
     { (yyval.merge) = MERGE_DEFAULT; }
     break;
 
   case 128:
 
 /* Line 1806 of yacc.c  */
-#line 560 "parser.y"
+#line 600 "parser.y"
     { (yyval.merge) = MERGE_DEFAULT; }
     break;
 
   case 129:
 
 /* Line 1806 of yacc.c  */
-#line 561 "parser.y"
+#line 601 "parser.y"
     { (yyval.merge) = MERGE_AUGMENT; }
     break;
 
   case 130:
 
 /* Line 1806 of yacc.c  */
-#line 562 "parser.y"
+#line 602 "parser.y"
     { (yyval.merge) = MERGE_OVERRIDE; }
     break;
 
   case 131:
 
 /* Line 1806 of yacc.c  */
-#line 563 "parser.y"
+#line 603 "parser.y"
     { (yyval.merge) = MERGE_REPLACE; }
     break;
 
   case 132:
 
 /* Line 1806 of yacc.c  */
-#line 565 "parser.y"
+#line 605 "parser.y"
     {
                     /*
                      * This used to be MERGE_ALT_FORM. This functionality was
@@ -2966,324 +2943,286 @@ yyreduce:
   case 133:
 
 /* Line 1806 of yacc.c  */
-#line 574 "parser.y"
+#line 614 "parser.y"
     { (yyval.expr) = (yyvsp[(1) - (1)].expr); }
     break;
 
   case 134:
 
 /* Line 1806 of yacc.c  */
-#line 575 "parser.y"
+#line 615 "parser.y"
     { (yyval.expr) = NULL; }
     break;
 
   case 135:
 
 /* Line 1806 of yacc.c  */
-#line 579 "parser.y"
+#line 619 "parser.y"
     { (yyval.expr) = (ExprDef *)AppendStmt(&(yyvsp[(1) - (3)].expr)->common, &(yyvsp[(3) - (3)].expr)->common); }
     break;
 
   case 136:
 
 /* Line 1806 of yacc.c  */
-#line 581 "parser.y"
+#line 621 "parser.y"
     { (yyval.expr) = (yyvsp[(1) - (1)].expr); }
     break;
 
   case 137:
 
 /* Line 1806 of yacc.c  */
-#line 585 "parser.y"
+#line 625 "parser.y"
     { (yyval.expr) = ExprCreateBinary(EXPR_DIVIDE, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
     break;
 
   case 138:
 
 /* Line 1806 of yacc.c  */
-#line 587 "parser.y"
+#line 627 "parser.y"
     { (yyval.expr) = ExprCreateBinary(EXPR_ADD, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
     break;
 
   case 139:
 
 /* Line 1806 of yacc.c  */
-#line 589 "parser.y"
+#line 629 "parser.y"
     { (yyval.expr) = ExprCreateBinary(EXPR_SUBTRACT, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
     break;
 
   case 140:
 
 /* Line 1806 of yacc.c  */
-#line 591 "parser.y"
+#line 631 "parser.y"
     { (yyval.expr) = ExprCreateBinary(EXPR_MULTIPLY, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
     break;
 
   case 141:
 
 /* Line 1806 of yacc.c  */
-#line 593 "parser.y"
+#line 633 "parser.y"
     { (yyval.expr) = ExprCreateBinary(EXPR_ASSIGN, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
     break;
 
   case 142:
 
 /* Line 1806 of yacc.c  */
-#line 595 "parser.y"
+#line 635 "parser.y"
     { (yyval.expr) = (yyvsp[(1) - (1)].expr); }
     break;
 
   case 143:
 
 /* Line 1806 of yacc.c  */
-#line 599 "parser.y"
-    { (yyval.expr) = ExprCreateUnary(EXPR_NEGATE, (yyvsp[(2) - (2)].expr)->value_type, (yyvsp[(2) - (2)].expr)); }
+#line 639 "parser.y"
+    { (yyval.expr) = ExprCreateUnary(EXPR_NEGATE, (yyvsp[(2) - (2)].expr)->expr.value_type, (yyvsp[(2) - (2)].expr)); }
     break;
 
   case 144:
 
 /* Line 1806 of yacc.c  */
-#line 601 "parser.y"
-    { (yyval.expr) = ExprCreateUnary(EXPR_UNARY_PLUS, (yyvsp[(2) - (2)].expr)->value_type, (yyvsp[(2) - (2)].expr)); }
+#line 641 "parser.y"
+    { (yyval.expr) = ExprCreateUnary(EXPR_UNARY_PLUS, (yyvsp[(2) - (2)].expr)->expr.value_type, (yyvsp[(2) - (2)].expr)); }
     break;
 
   case 145:
 
 /* Line 1806 of yacc.c  */
-#line 603 "parser.y"
+#line 643 "parser.y"
     { (yyval.expr) = ExprCreateUnary(EXPR_NOT, EXPR_TYPE_BOOLEAN, (yyvsp[(2) - (2)].expr)); }
     break;
 
   case 146:
 
 /* Line 1806 of yacc.c  */
-#line 605 "parser.y"
-    { (yyval.expr) = ExprCreateUnary(EXPR_INVERT, (yyvsp[(2) - (2)].expr)->value_type, (yyvsp[(2) - (2)].expr)); }
+#line 645 "parser.y"
+    { (yyval.expr) = ExprCreateUnary(EXPR_INVERT, (yyvsp[(2) - (2)].expr)->expr.value_type, (yyvsp[(2) - (2)].expr)); }
     break;
 
   case 147:
 
 /* Line 1806 of yacc.c  */
-#line 607 "parser.y"
+#line 647 "parser.y"
     { (yyval.expr) = (yyvsp[(1) - (1)].expr);  }
     break;
 
   case 148:
 
 /* Line 1806 of yacc.c  */
-#line 609 "parser.y"
-    { (yyval.expr) = ActionCreate((yyvsp[(1) - (4)].sval), (yyvsp[(3) - (4)].expr)); }
+#line 649 "parser.y"
+    { (yyval.expr) = ExprCreateAction((yyvsp[(1) - (4)].sval), (yyvsp[(3) - (4)].expr)); }
     break;
 
   case 149:
 
 /* Line 1806 of yacc.c  */
-#line 611 "parser.y"
+#line 651 "parser.y"
     { (yyval.expr) = (yyvsp[(1) - (1)].expr);  }
     break;
 
   case 150:
 
 /* Line 1806 of yacc.c  */
-#line 613 "parser.y"
+#line 653 "parser.y"
     { (yyval.expr) = (yyvsp[(2) - (3)].expr);  }
     break;
 
   case 151:
 
 /* Line 1806 of yacc.c  */
-#line 617 "parser.y"
+#line 657 "parser.y"
     { (yyval.expr) = (ExprDef *)AppendStmt(&(yyvsp[(1) - (3)].expr)->common, &(yyvsp[(3) - (3)].expr)->common); }
     break;
 
   case 152:
 
 /* Line 1806 of yacc.c  */
-#line 619 "parser.y"
+#line 659 "parser.y"
     { (yyval.expr) = (yyvsp[(1) - (1)].expr); }
     break;
 
   case 153:
 
 /* Line 1806 of yacc.c  */
-#line 623 "parser.y"
-    { (yyval.expr) = ActionCreate((yyvsp[(1) - (4)].sval), (yyvsp[(3) - (4)].expr)); }
+#line 663 "parser.y"
+    { (yyval.expr) = ExprCreateAction((yyvsp[(1) - (4)].sval), (yyvsp[(3) - (4)].expr)); }
     break;
 
   case 154:
 
 /* Line 1806 of yacc.c  */
-#line 627 "parser.y"
-    {
-                            ExprDef *expr;
-                            expr = ExprCreate(EXPR_IDENT, EXPR_TYPE_UNKNOWN);
-                            expr->value.str = (yyvsp[(1) - (1)].sval);
-                            (yyval.expr) = expr;
-                        }
+#line 667 "parser.y"
+    { (yyval.expr) = ExprCreateIdent((yyvsp[(1) - (1)].sval)); }
     break;
 
   case 155:
 
 /* Line 1806 of yacc.c  */
-#line 634 "parser.y"
-    {
-                            ExprDef *expr;
-                            expr = ExprCreate(EXPR_FIELD_REF, EXPR_TYPE_UNKNOWN);
-                            expr->value.field.element = (yyvsp[(1) - (3)].sval);
-                            expr->value.field.field = (yyvsp[(3) - (3)].sval);
-                            (yyval.expr) = expr;
-                        }
+#line 669 "parser.y"
+    { (yyval.expr) = ExprCreateFieldRef((yyvsp[(1) - (3)].sval), (yyvsp[(3) - (3)].sval)); }
     break;
 
   case 156:
 
 /* Line 1806 of yacc.c  */
-#line 642 "parser.y"
-    {
-                            ExprDef *expr;
-                            expr = ExprCreate(EXPR_ARRAY_REF, EXPR_TYPE_UNKNOWN);
-                            expr->value.array.element = XKB_ATOM_NONE;
-                            expr->value.array.field = (yyvsp[(1) - (4)].sval);
-                            expr->value.array.entry = (yyvsp[(3) - (4)].expr);
-                            (yyval.expr) = expr;
-                        }
+#line 671 "parser.y"
+    { (yyval.expr) = ExprCreateArrayRef(XKB_ATOM_NONE, (yyvsp[(1) - (4)].sval), (yyvsp[(3) - (4)].expr)); }
     break;
 
   case 157:
 
 /* Line 1806 of yacc.c  */
-#line 651 "parser.y"
-    {
-                            ExprDef *expr;
-                            expr = ExprCreate(EXPR_ARRAY_REF, EXPR_TYPE_UNKNOWN);
-                            expr->value.array.element = (yyvsp[(1) - (6)].sval);
-                            expr->value.array.field = (yyvsp[(3) - (6)].sval);
-                            expr->value.array.entry = (yyvsp[(5) - (6)].expr);
-                            (yyval.expr) = expr;
-                        }
+#line 673 "parser.y"
+    { (yyval.expr) = ExprCreateArrayRef((yyvsp[(1) - (6)].sval), (yyvsp[(3) - (6)].sval), (yyvsp[(5) - (6)].expr)); }
     break;
 
   case 158:
 
 /* Line 1806 of yacc.c  */
-#line 662 "parser.y"
-    {
-                            ExprDef *expr;
-                            expr = ExprCreate(EXPR_VALUE, EXPR_TYPE_STRING);
-                            expr->value.str = (yyvsp[(1) - (1)].sval);
-                            (yyval.expr) = expr;
-                        }
+#line 677 "parser.y"
+    { (yyval.expr) = ExprCreateString((yyvsp[(1) - (1)].sval)); }
     break;
 
   case 159:
 
 /* Line 1806 of yacc.c  */
-#line 669 "parser.y"
-    {
-                            ExprDef *expr;
-                            expr = ExprCreate(EXPR_VALUE, EXPR_TYPE_INT);
-                            expr->value.ival = (yyvsp[(1) - (1)].ival);
-                            (yyval.expr) = expr;
-                        }
+#line 679 "parser.y"
+    { (yyval.expr) = ExprCreateInteger((yyvsp[(1) - (1)].ival)); }
     break;
 
   case 160:
 
 /* Line 1806 of yacc.c  */
-#line 676 "parser.y"
-    {
-                            (yyval.expr) = NULL;
-                        }
+#line 681 "parser.y"
+    { (yyval.expr) = NULL; }
     break;
 
   case 161:
 
 /* Line 1806 of yacc.c  */
-#line 680 "parser.y"
-    {
-                            ExprDef *expr;
-                            expr = ExprCreate(EXPR_VALUE, EXPR_TYPE_KEYNAME);
-                            expr->value.keyName = (yyvsp[(1) - (1)].sval);
-                            (yyval.expr) = expr;
-                        }
+#line 683 "parser.y"
+    { (yyval.expr) = ExprCreateKeyName((yyvsp[(1) - (1)].sval)); }
     break;
 
   case 162:
 
 /* Line 1806 of yacc.c  */
-#line 688 "parser.y"
+#line 686 "parser.y"
     { (yyval.expr) = (yyvsp[(1) - (1)].expr); }
     break;
 
   case 163:
 
 /* Line 1806 of yacc.c  */
-#line 689 "parser.y"
+#line 687 "parser.y"
     { (yyval.expr) = NULL; }
     break;
 
   case 164:
 
 /* Line 1806 of yacc.c  */
-#line 693 "parser.y"
-    { (yyval.expr) = AppendKeysymList((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].str)); }
+#line 691 "parser.y"
+    { (yyval.expr) = ExprAppendKeysymList((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].keysym)); }
     break;
 
   case 165:
 
 /* Line 1806 of yacc.c  */
-#line 695 "parser.y"
-    { (yyval.expr) = AppendMultiKeysymList((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
+#line 693 "parser.y"
+    { (yyval.expr) = ExprAppendMultiKeysymList((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
     break;
 
   case 166:
 
 /* Line 1806 of yacc.c  */
-#line 697 "parser.y"
-    { (yyval.expr) = CreateKeysymList((yyvsp[(1) - (1)].str)); }
+#line 695 "parser.y"
+    { (yyval.expr) = ExprCreateKeysymList((yyvsp[(1) - (1)].keysym)); }
     break;
 
   case 167:
 
 /* Line 1806 of yacc.c  */
-#line 699 "parser.y"
-    { (yyval.expr) = CreateMultiKeysymList((yyvsp[(1) - (1)].expr)); }
+#line 697 "parser.y"
+    { (yyval.expr) = ExprCreateMultiKeysymList((yyvsp[(1) - (1)].expr)); }
     break;
 
   case 168:
 
 /* Line 1806 of yacc.c  */
-#line 703 "parser.y"
+#line 701 "parser.y"
     { (yyval.expr) = (yyvsp[(2) - (3)].expr); }
     break;
 
   case 169:
 
 /* Line 1806 of yacc.c  */
-#line 706 "parser.y"
-    { (yyval.str) = (yyvsp[(1) - (1)].str); }
+#line 705 "parser.y"
+    {
+                            if (!resolve_keysym((yyvsp[(1) - (1)].str), &(yyval.keysym)))
+                                parser_warn(param, "unrecognized keysym");
+                            free((yyvsp[(1) - (1)].str));
+                        }
     break;
 
   case 170:
 
 /* Line 1806 of yacc.c  */
-#line 707 "parser.y"
-    { (yyval.str) = strdup("section"); }
+#line 710 "parser.y"
+    { (yyval.keysym) = XKB_KEY_section; }
     break;
 
   case 171:
 
 /* Line 1806 of yacc.c  */
-#line 709 "parser.y"
+#line 712 "parser.y"
     {
-                            if ((yyvsp[(1) - (1)].ival) < 10) {      /* XK_0 .. XK_9 */
-                                (yyval.str) = malloc(2);
-                                (yyval.str)[0] = (yyvsp[(1) - (1)].ival) + '0';
-                                (yyval.str)[1] = '\0';
+                            if ((yyvsp[(1) - (1)].ival) < 10) {      /* XKB_KEY_0 .. XKB_KEY_9 */
+                                (yyval.keysym) = XKB_KEY_0 + (yyvsp[(1) - (1)].ival);
                             }
                             else {
-                                (yyval.str) = malloc(17);
-                                snprintf((yyval.str), 17, "0x%x", (yyvsp[(1) - (1)].ival));
+                                char buf[17];
+                                snprintf(buf, sizeof(buf), "0x%x", (yyvsp[(1) - (1)].ival));
+                                if (!resolve_keysym(buf, &(yyval.keysym)))
+                                    parser_warn(param, "unrecognized keysym");
                             }
                         }
     break;
@@ -3291,98 +3230,98 @@ yyreduce:
   case 172:
 
 /* Line 1806 of yacc.c  */
-#line 722 "parser.y"
+#line 725 "parser.y"
     { (yyval.ival) = -(yyvsp[(2) - (2)].ival); }
     break;
 
   case 173:
 
 /* Line 1806 of yacc.c  */
-#line 723 "parser.y"
+#line 726 "parser.y"
     { (yyval.ival) = (yyvsp[(1) - (1)].ival); }
     break;
 
   case 174:
 
 /* Line 1806 of yacc.c  */
-#line 726 "parser.y"
+#line 729 "parser.y"
     { (yyval.ival) = (yyvsp[(1) - (1)].num); }
     break;
 
   case 175:
 
 /* Line 1806 of yacc.c  */
-#line 727 "parser.y"
+#line 730 "parser.y"
     { (yyval.ival) = (yyvsp[(1) - (1)].num); }
     break;
 
   case 176:
 
 /* Line 1806 of yacc.c  */
-#line 730 "parser.y"
+#line 733 "parser.y"
     { (yyval.ival) = 0; }
     break;
 
   case 177:
 
 /* Line 1806 of yacc.c  */
-#line 733 "parser.y"
+#line 736 "parser.y"
     { (yyval.ival) = (yyvsp[(1) - (1)].num); }
     break;
 
   case 178:
 
 /* Line 1806 of yacc.c  */
-#line 736 "parser.y"
+#line 739 "parser.y"
     { (yyval.num) = (yyvsp[(1) - (1)].num); }
     break;
 
   case 179:
 
 /* Line 1806 of yacc.c  */
-#line 739 "parser.y"
+#line 742 "parser.y"
     { (yyval.sval) = xkb_atom_steal(param->ctx, (yyvsp[(1) - (1)].str)); }
     break;
 
   case 180:
 
 /* Line 1806 of yacc.c  */
-#line 740 "parser.y"
-    { (yyval.sval) = xkb_atom_intern(param->ctx, "default"); }
+#line 743 "parser.y"
+    { (yyval.sval) = xkb_atom_intern_literal(param->ctx, "default"); }
     break;
 
   case 181:
 
 /* Line 1806 of yacc.c  */
-#line 743 "parser.y"
+#line 746 "parser.y"
     { (yyval.sval) = xkb_atom_steal(param->ctx, (yyvsp[(1) - (1)].str)); }
     break;
 
   case 182:
 
 /* Line 1806 of yacc.c  */
-#line 746 "parser.y"
+#line 749 "parser.y"
     { (yyval.str) = (yyvsp[(1) - (1)].str); }
     break;
 
   case 183:
 
 /* Line 1806 of yacc.c  */
-#line 747 "parser.y"
+#line 750 "parser.y"
     { (yyval.str) = NULL; }
     break;
 
   case 184:
 
 /* Line 1806 of yacc.c  */
-#line 750 "parser.y"
+#line 753 "parser.y"
     { (yyval.str) = (yyvsp[(1) - (1)].str); }
     break;
 
 
 
 /* Line 1806 of yacc.c  */
-#line 3386 "src/xkbcomp/parser.c"
+#line 3325 "src/xkbcomp/parser.c"
       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires
@@ -3403,7 +3342,6 @@ yyreduce:
   YY_STACK_PRINT (yyss, yyssp);
 
   *++yyvsp = yyval;
-  *++yylsp = yyloc;
 
   /* Now `shift' the result of the reduction.  Determine what state
      that goes to, based on the state we popped back to and the rule
@@ -3433,7 +3371,7 @@ yyerrlab:
     {
       ++yynerrs;
 #if ! YYERROR_VERBOSE
-      yyerror (&yylloc, param, YY_("syntax error"));
+      yyerror (param, YY_("syntax error"));
 #else
 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
                                         yyssp, yytoken)
@@ -3460,7 +3398,7 @@ yyerrlab:
                 yymsgp = yymsg;
               }
           }
-        yyerror (&yylloc, param, yymsgp);
+        yyerror (param, yymsgp);
         if (yysyntax_error_status == 2)
           goto yyexhaustedlab;
       }
@@ -3468,7 +3406,7 @@ yyerrlab:
 #endif
     }
 
-  yyerror_range[1] = yylloc;
+
 
   if (yyerrstatus == 3)
     {
@@ -3484,7 +3422,7 @@ yyerrlab:
       else
 	{
 	  yydestruct ("Error: discarding",
-		      yytoken, &yylval, &yylloc, param);
+		      yytoken, &yylval, param);
 	  yychar = YYEMPTY;
 	}
     }
@@ -3505,7 +3443,6 @@ yyerrorlab:
   if (/*CONSTCOND*/ 0)
      goto yyerrorlab;
 
-  yyerror_range[1] = yylsp[1-yylen];
   /* Do not reclaim the symbols of the rule which action triggered
      this YYERROR.  */
   YYPOPSTACK (yylen);
@@ -3539,9 +3476,9 @@ yyerrlab1:
       if (yyssp == yyss)
 	YYABORT;
 
-      yyerror_range[1] = *yylsp;
+
       yydestruct ("Error: popping",
-		  yystos[yystate], yyvsp, yylsp, param);
+		  yystos[yystate], yyvsp, param);
       YYPOPSTACK (1);
       yystate = *yyssp;
       YY_STACK_PRINT (yyss, yyssp);
@@ -3549,11 +3486,6 @@ yyerrlab1:
 
   *++yyvsp = yylval;
 
-  yyerror_range[2] = yylloc;
-  /* Using YYLLOC is tempting, but would change the location of
-     the lookahead.  YYLOC is available though.  */
-  YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
-  *++yylsp = yyloc;
 
   /* Shift the error token.  */
   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
@@ -3581,7 +3513,7 @@ yyabortlab:
 | yyexhaustedlab -- memory exhaustion comes here.  |
 `-------------------------------------------------*/
 yyexhaustedlab:
-  yyerror (&yylloc, param, YY_("memory exhausted"));
+  yyerror (param, YY_("memory exhausted"));
   yyresult = 2;
   /* Fall through.  */
 #endif
@@ -3593,7 +3525,7 @@ yyreturn:
          user semantic actions for why this is necessary.  */
       yytoken = YYTRANSLATE (yychar);
       yydestruct ("Cleanup: discarding lookahead",
-                  yytoken, &yylval, &yylloc, param);
+                  yytoken, &yylval, param);
     }
   /* Do not reclaim the symbols of the rule which action triggered
      this YYABORT or YYACCEPT.  */
@@ -3602,7 +3534,7 @@ yyreturn:
   while (yyssp != yyss)
     {
       yydestruct ("Cleanup: popping",
-		  yystos[*yyssp], yyvsp, yylsp, param);
+		  yystos[*yyssp], yyvsp, param);
       YYPOPSTACK (1);
     }
 #ifndef yyoverflow
@@ -3620,7 +3552,7 @@ yyreturn:
 
 
 /* Line 2067 of yacc.c  */
-#line 753 "parser.y"
+#line 756 "parser.y"
 
 
 #undef scanner
@@ -3628,12 +3560,12 @@ yyreturn:
 XkbFile *
 parse(struct xkb_context *ctx, void *scanner, const char *map)
 {
-    struct parser_param param;
     int ret;
     XkbFile *first = NULL;
-
-    param.scanner = scanner;
-    param.ctx = ctx;
+    struct parser_param param = {
+        .scanner = scanner,
+        .ctx = ctx,
+    };
 
     /*
      * If we got a specific map, we look for it exclusively and return
@@ -3672,3 +3604,5 @@ parse(struct xkb_context *ctx, void *scanner, const char *map)
     return first;
 }
 
+#define scanner param->scanner
+
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/parser.h b/src/3rdparty/xkbcommon/src/xkbcomp/parser.h
index fba3f4ebd0..f85a2bad85 100644
--- a/src/3rdparty/xkbcommon/src/xkbcomp/parser.h
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/parser.h
@@ -175,16 +175,16 @@ typedef union YYSTYPE
 {
 
 /* Line 2068 of yacc.c  */
-#line 127 "parser.y"
+#line 167 "parser.y"
 
         int              ival;
-        unsigned         uval;
         int64_t          num;
         enum xkb_file_type file_type;
         char            *str;
         xkb_atom_t      sval;
         enum merge_mode merge;
         enum xkb_map_flags mapFlags;
+        xkb_keysym_t    keysym;
         ParseCommon     *any;
         ExprDef         *expr;
         VarDef          *var;
@@ -213,18 +213,4 @@ typedef union YYSTYPE
 
 
 
-#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
-typedef struct YYLTYPE
-{
-  int first_line;
-  int first_column;
-  int last_line;
-  int last_column;
-} YYLTYPE;
-# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
-# define YYLTYPE_IS_DECLARED 1
-# define YYLTYPE_IS_TRIVIAL 1
-#endif
-
-
 
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/rules.c b/src/3rdparty/xkbcommon/src/xkbcomp/rules.c
index 3f717600fd..de82d96119 100644
--- a/src/3rdparty/xkbcommon/src/xkbcomp/rules.c
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/rules.c
@@ -47,16 +47,10 @@
  * DEALINGS IN THE SOFTWARE.
  */
 
-#include <ctype.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
 #include "xkbcomp-priv.h"
 #include "rules.h"
 #include "include.h"
+#include "scanner-utils.h"
 
 /*
  * The rules file
@@ -138,25 +132,6 @@
 
 /* Scanner / Lexer */
 
-/* Point to some substring in the file; used to avoid copying. */
-struct sval {
-    const char *start;
-    unsigned int len;
-};
-typedef darray(struct sval) darray_sval;
-
-static inline bool
-svaleq(struct sval s1, struct sval s2)
-{
-    return s1.len == s2.len && strncmp(s1.start, s2.start, s1.len) == 0;
-}
-
-static inline bool
-svaleq_prefix(struct sval s1, struct sval s2)
-{
-    return s1.len <= s2.len && strncmp(s1.start, s2.start, s1.len) == 0;
-}
-
 /* Values returned with some tokens, like yylval. */
 union lvalue {
     struct sval string;
@@ -170,15 +145,6 @@ struct location {
     int line, column;
 };
 
-struct scanner {
-    const char *s;
-    size_t pos;
-    size_t len;
-    int line, column;
-    const char *file_name;
-    struct xkb_context *ctx;
-};
-
 enum rules_token {
     TOK_END_OF_FILE = 0,
     TOK_END_OF_LINE,
@@ -190,81 +156,20 @@ enum rules_token {
     TOK_ERROR
 };
 
-static void
-scanner_init(struct scanner *s, struct xkb_context *ctx,
-             const char *string, size_t len, const char *file_name)
-{
-    s->s = string;
-    s->len = len;
-    s->pos = 0;
-    s->line = s->column = 1;
-    s->file_name = file_name;
-    s->ctx = ctx;
-}
-
 /* C99 is stupid. Just use the 1 variant when there are no args. */
 #define scanner_error1(scanner, loc, msg) \
-    log_warn(scanner->ctx, "rules/%s:%d:%d: " msg "\n", \
-             scanner->file_name, loc->line, loc->column)
+    log_warn((scanner)->ctx, "rules/%s:%d:%d: %s\n", \
+             (scanner)->file_name, (loc)->line, (loc)->column, msg)
 #define scanner_error(scanner, loc, fmt, ...) \
-    log_warn(scanner->ctx, "rules/%s:%d:%d: " fmt "\n", \
-             scanner->file_name, loc->line, loc->column, __VA_ARGS__)
-
-static char
-peek(struct scanner *s)
-{
-    return s->pos < s->len ? s->s[s->pos] : '\0';
-}
-
-static bool
-eof(struct scanner *s)
-{
-    return peek(s) == '\0';
-}
-
-static bool
-eol(struct scanner *s)
-{
-    return peek(s) == '\n';
-}
+    log_warn((scanner)->ctx, "rules/%s:%d:%d: " fmt "\n", \
+             (scanner)->file_name, (loc)->line, (loc)->column, __VA_ARGS__)
 
-static char
-next(struct scanner *s)
+static inline bool
+is_ident(char ch)
 {
-    if (eof(s))
-        return '\0';
-    if (eol(s)) {
-        s->line++;
-        s->column = 1;
-    }
-    else {
-        s->column++;
-    }
-    return s->s[s->pos++];
+    return is_graph(ch) && ch != '\\';
 }
 
-static bool
-chr(struct scanner *s, char ch)
-{
-    if (peek(s) != ch)
-        return false;
-    s->pos++; s->column++;
-    return true;
-}
-
-static bool
-str(struct scanner *s, const char *string, size_t len)
-{
-    if (s->len - s->pos < len)
-        return false;
-    if (strncasecmp(s->s + s->pos, string, len) != 0)
-        return false;
-    s->pos += len; s->column += len;
-    return true;
-}
-
-#define lit(s, literal) str(s, literal, sizeof(literal) - 1)
-
 static enum rules_token
 lex(struct scanner *s, union lvalue *val, struct location *loc)
 {
@@ -310,7 +215,7 @@ skip_more_whitespace_and_comments:
     if (chr(s, '$')) {
         val->string.start = s->s + s->pos;
         val->string.len = 0;
-        while (isgraph(peek(s))) {
+        while (is_ident(peek(s))) {
             next(s);
             val->string.len++;
         }
@@ -323,10 +228,10 @@ skip_more_whitespace_and_comments:
     }
 
     /* Identifier. */
-    if (isgraph(peek(s))) {
+    if (is_ident(peek(s))) {
         val->string.start = s->s + s->pos;
         val->string.len = 0;
-        while (isgraph(peek(s))) {
+        while (is_ident(peek(s))) {
             next(s);
             val->string.len++;
         }
@@ -440,8 +345,8 @@ struct matcher {
 static struct sval
 strip_spaces(struct sval v)
 {
-    while (v.len > 0 && isspace(v.start[0])) { v.len--; v.start++; }
-    while (v.len > 0 && isspace(v.start[v.len - 1])) v.len--;
+    while (v.len > 0 && is_space(v.start[0])) { v.len--; v.start++; }
+    while (v.len > 0 && is_space(v.start[v.len - 1])) v.len--;
     return v;
 }
 
@@ -449,7 +354,6 @@ static darray_sval
 split_comma_separated_string(const char *s)
 {
     darray_sval arr = darray_new();
-    struct sval val = { NULL, 0 };
 
     /*
      * Make sure the array returned by this function always includes at
@@ -457,12 +361,13 @@ split_comma_separated_string(const char *s)
      */
 
     if (!s) {
+        struct sval val = { NULL, 0 };
         darray_append(arr, val);
         return arr;
     }
 
     while (true) {
-        val.start = s; val.len = 0;
+        struct sval val = { s, 0 };
         while (*s != '\0' && *s != ',') { s++; val.len++; }
         darray_append(arr, strip_spaces(val));
         if (*s == '\0') break;
@@ -482,7 +387,7 @@ matcher_new(struct xkb_context *ctx,
 
     m->ctx = ctx;
     m->rmlvo.model.start = rmlvo->model;
-    m->rmlvo.model.len = rmlvo->model ? strlen(rmlvo->model) : 0;
+    m->rmlvo.model.len = strlen_safe(rmlvo->model);
     m->rmlvo.layouts = split_comma_separated_string(rmlvo->layout);
     m->rmlvo.variants = split_comma_separated_string(rmlvo->variant);
     m->rmlvo.options = split_comma_separated_string(rmlvo->options);
@@ -505,15 +410,10 @@ matcher_free(struct matcher *m)
     free(m);
 }
 
-/* C99 is stupid. Just use the 1 variant when there are no args. */
 #define matcher_error1(matcher, msg) \
-    log_warn(matcher->ctx, "rules/%s:%d:%d: " msg "\n", \
-             matcher->scanner.file_name, matcher->loc.line, \
-             matcher->loc.column)
+    scanner_error1(&(matcher)->scanner, &(matcher)->loc, msg)
 #define matcher_error(matcher, fmt, ...) \
-    log_warn(matcher->ctx, "rules/%s:%d:%d: " fmt "\n", \
-             matcher->scanner.file_name, matcher->loc.line, \
-             matcher->loc.column, __VA_ARGS__)
+    scanner_error(&(matcher)->scanner, &(matcher)->loc, fmt, __VA_ARGS__)
 
 static void
 matcher_group_start_new(struct matcher *m, struct sval name)
@@ -532,10 +432,9 @@ matcher_group_add_element(struct matcher *m, struct sval element)
 static void
 matcher_mapping_start_new(struct matcher *m)
 {
-    unsigned int i;
-    for (i = 0; i < _MLVO_NUM_ENTRIES; i++)
+    for (unsigned i = 0; i < _MLVO_NUM_ENTRIES; i++)
         m->mapping.mlvo_at_pos[i] = -1;
-    for (i = 0; i < _KCCGST_NUM_ENTRIES; i++)
+    for (unsigned i = 0; i < _KCCGST_NUM_ENTRIES; i++)
         m->mapping.kccgst_at_pos[i] = -1;
     m->mapping.layout_idx = m->mapping.variant_idx = XKB_LAYOUT_INVALID;
     m->mapping.num_mlvo = m->mapping.num_kccgst = 0;
@@ -551,7 +450,7 @@ extract_layout_index(const char *s, size_t max_len, xkb_layout_index_t *out)
     *out = XKB_LAYOUT_INVALID;
     if (max_len < 3)
         return -1;
-    if (s[0] != '[' || !isdigit(s[1]) || s[2] != ']')
+    if (s[0] != '[' || !is_digit(s[1]) || s[2] != ']')
         return -1;
     if (s[1] - '0' < 1 || s[1] - '0' > XKB_MAX_GROUPS)
         return -1;
@@ -565,8 +464,6 @@ matcher_mapping_set_mlvo(struct matcher *m, struct sval ident)
 {
     enum rules_mlvo mlvo;
     struct sval mlvo_sval;
-    xkb_layout_index_t idx;
-    int consumed;
 
     for (mlvo = 0; mlvo < _MLVO_NUM_ENTRIES; mlvo++) {
         mlvo_sval = rules_mlvo_svals[mlvo];
@@ -596,8 +493,9 @@ matcher_mapping_set_mlvo(struct matcher *m, struct sval ident)
 
     /* If there are leftovers still, it must be an index. */
     if (mlvo_sval.len < ident.len) {
-        consumed = extract_layout_index(ident.start + mlvo_sval.len,
-                                       ident.len - mlvo_sval.len, &idx);
+        xkb_layout_index_t idx;
+        int consumed = extract_layout_index(ident.start + mlvo_sval.len,
+                                            ident.len - mlvo_sval.len, &idx);
         if ((int) (ident.len - mlvo_sval.len) != consumed) {
             matcher_error(m,
                           "invalid mapping:\" %.*s\" may only be followed by a valid group index; "
@@ -822,14 +720,8 @@ static bool
 append_expanded_kccgst_value(struct matcher *m, darray_char *to,
                              struct sval value)
 {
-    unsigned int i;
-    size_t original_size = darray_size(*to);
+    const size_t original_size = darray_size(*to);
     const char *s = value.start;
-    xkb_layout_index_t idx;
-    int consumed;
-    enum rules_mlvo mlv;
-    struct sval expanded;
-    char pfx, sfx;
 
     /*
      * Appending  bar to  foo ->  foo (not an error if this happens)
@@ -847,7 +739,12 @@ append_expanded_kccgst_value(struct matcher *m, darray_char *to,
      * Some ugly hand-lexing here, but going through the scanner is more
      * trouble than it's worth, and the format is ugly on its own merit.
      */
-    for (i = 0; i < value.len; ) {
+    for (unsigned i = 0; i < value.len; ) {
+        enum rules_mlvo mlv;
+        xkb_layout_index_t idx;
+        char pfx, sfx;
+        struct sval expanded;
+
         /* Check if that's a start of an expansion. */
         if (s[i] != '%') {
             /* Just a normal character. */
@@ -876,22 +773,19 @@ append_expanded_kccgst_value(struct matcher *m, darray_char *to,
 
         /* Check for index. */
         idx = XKB_LAYOUT_INVALID;
-        if (i < value.len) {
-            if (s[i] == '[') {
-                if (mlv != MLVO_LAYOUT && mlv != MLVO_VARIANT) {
-                    matcher_error1(m,
-                                   "invalid index in %%-expansion; "
-                                   "may only index layout or variant");
-                    goto error;
-                }
-
-                consumed = extract_layout_index(s + i, value.len - i, &idx);
-                if (consumed == -1) goto error;
-                i += consumed;
-            }
-            else {
-                idx = XKB_LAYOUT_INVALID;
+        if (i < value.len && s[i] == '[') {
+            int consumed;
+
+            if (mlv != MLVO_LAYOUT && mlv != MLVO_VARIANT) {
+                matcher_error1(m,
+                                "invalid index in %%-expansion; "
+                                "may only index layout or variant");
+                goto error;
             }
+
+            consumed = extract_layout_index(s + i, value.len - i, &idx);
+            if (consumed == -1) goto error;
+            i += consumed;
         }
 
         /* Check for suffix, if there supposed to be one. */
@@ -959,37 +853,31 @@ matcher_rule_verify(struct matcher *m)
 static void
 matcher_rule_apply_if_matches(struct matcher *m)
 {
-    unsigned int i;
-    enum rules_mlvo mlvo;
-    enum rules_kccgst kccgst;
-    struct sval value, *option;
-    enum mlvo_match_type match_type;
-    bool matched = false;
-    xkb_layout_index_t idx;
-
-    for (i = 0; i < m->mapping.num_mlvo; i++) {
-        mlvo = m->mapping.mlvo_at_pos[i];
-        value = m->rule.mlvo_value_at_pos[i];
-        match_type = m->rule.match_type_at_pos[i];
+    for (unsigned i = 0; i < m->mapping.num_mlvo; i++) {
+        enum rules_mlvo mlvo = m->mapping.mlvo_at_pos[i];
+        struct sval value = m->rule.mlvo_value_at_pos[i];
+        enum mlvo_match_type match_type = m->rule.match_type_at_pos[i];
+        bool matched = false;
 
         if (mlvo == MLVO_MODEL) {
             matched = match_value(m, value, m->rmlvo.model, match_type);
         }
         else if (mlvo == MLVO_LAYOUT) {
-            idx = m->mapping.layout_idx;
+            xkb_layout_index_t idx = m->mapping.layout_idx;
             idx = (idx == XKB_LAYOUT_INVALID ? 0 : idx);
             matched = match_value(m, value,
                                   darray_item(m->rmlvo.layouts, idx),
                                   match_type);
         }
         else if (mlvo == MLVO_VARIANT) {
-            idx = m->mapping.layout_idx;
+            xkb_layout_index_t idx = m->mapping.layout_idx;
             idx = (idx == XKB_LAYOUT_INVALID ? 0 : idx);
             matched = match_value(m, value,
                                   darray_item(m->rmlvo.variants, idx),
                                   match_type);
         }
         else if (mlvo == MLVO_OPTION) {
+            struct sval *option;
             darray_foreach(option, m->rmlvo.options) {
                 matched = match_value(m, value, *option, match_type);
                 if (matched)
@@ -1001,9 +889,9 @@ matcher_rule_apply_if_matches(struct matcher *m)
             return;
     }
 
-    for (i = 0; i < m->mapping.num_kccgst; i++) {
-        kccgst = m->mapping.kccgst_at_pos[i];
-        value = m->rule.kccgst_value_at_pos[i];
+    for (unsigned i = 0; i < m->mapping.num_kccgst; i++) {
+        enum rules_kccgst kccgst = m->mapping.kccgst_at_pos[i];
+        struct sval value = m->rule.kccgst_value_at_pos[i];
         append_expanded_kccgst_value(m, &m->kccgst[kccgst], value);
     }
 
@@ -1193,36 +1081,27 @@ xkb_components_from_rules(struct xkb_context *ctx,
     bool ret = false;
     FILE *file;
     char *path;
-    int fd;
-    struct stat stat_buf;
-    char *string;
+    const char *string;
+    size_t size;
     struct matcher *matcher;
 
     file = FindFileInXkbPath(ctx, rmlvo->rules, FILE_TYPE_RULES, &path);
     if (!file)
         goto err_out;
 
-    fd = fileno(file);
-
-    if (fstat(fd, &stat_buf) != 0) {
-        log_err(ctx, "Couldn't stat rules file\n");
-        goto err_file;
-    }
-
-    string = mmap(NULL, stat_buf.st_size, PROT_READ, MAP_SHARED, fd, 0);
-    if (string == MAP_FAILED) {
-        log_err(ctx, "Couldn't mmap rules file (%lld bytes)\n",
-                (long long) stat_buf.st_size);
+    ret = map_file(file, &string, &size);
+    if (!ret) {
+        log_err(ctx, "Couldn't read rules file: %s\n", strerror(errno));
         goto err_file;
     }
 
     matcher = matcher_new(ctx, rmlvo);
-    ret = matcher_match(matcher, string, stat_buf.st_size, rmlvo->rules, out);
+    ret = matcher_match(matcher, string, size, rmlvo->rules, out);
     if (!ret)
         log_err(ctx, "No components returned from XKB rules \"%s\"\n", path);
     matcher_free(matcher);
 
-    munmap(string, stat_buf.st_size);
+    unmap_file(string, size);
 err_file:
     free(path);
     fclose(file);
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/scanner-utils.h b/src/3rdparty/xkbcommon/src/xkbcomp/scanner-utils.h
new file mode 100644
index 0000000000..7e21b00662
--- /dev/null
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/scanner-utils.h
@@ -0,0 +1,145 @@
+/*
+ * Copyright © 2012 Ran Benita <ran234@gmail.com>
+ *
+ * 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 XKBCOMP_SCANNER_UTILS_H
+#define XKBCOMP_SCANNER_UTILS_H
+
+/* Point to some substring in the file; used to avoid copying. */
+struct sval {
+    const char *start;
+    unsigned int len;
+};
+typedef darray(struct sval) darray_sval;
+
+static inline bool
+svaleq(struct sval s1, struct sval s2)
+{
+    return s1.len == s2.len && strncmp(s1.start, s2.start, s1.len) == 0;
+}
+
+static inline bool
+svaleq_prefix(struct sval s1, struct sval s2)
+{
+    return s1.len <= s2.len && strncmp(s1.start, s2.start, s1.len) == 0;
+}
+
+struct scanner {
+    const char *s;
+    size_t pos;
+    size_t len;
+    char buf[1024];
+    size_t buf_pos;
+    int line, column;
+    /* The line/column of the start of the current token. */
+    int token_line, token_column;
+    const char *file_name;
+    struct xkb_context *ctx;
+};
+
+static inline void
+scanner_init(struct scanner *s, struct xkb_context *ctx,
+             const char *string, size_t len, const char *file_name)
+{
+    s->s = string;
+    s->len = len;
+    s->pos = 0;
+    s->line = s->column = 1;
+    s->token_line = s->token_column = 1;
+    s->file_name = file_name;
+    s->ctx = ctx;
+}
+
+static inline char
+peek(struct scanner *s)
+{
+    return s->pos < s->len ? s->s[s->pos] : '\0';
+}
+
+static inline bool
+eof(struct scanner *s)
+{
+    return s->pos >= s->len;
+}
+
+static inline bool
+eol(struct scanner *s)
+{
+    return peek(s) == '\n';
+}
+
+static inline char
+next(struct scanner *s)
+{
+    if (eof(s))
+        return '\0';
+    if (eol(s)) {
+        s->line++;
+        s->column = 1;
+    }
+    else {
+        s->column++;
+    }
+    return s->s[s->pos++];
+}
+
+static inline bool
+chr(struct scanner *s, char ch)
+{
+    if (peek(s) != ch)
+        return false;
+    s->pos++; s->column++;
+    return true;
+}
+
+static inline bool
+str(struct scanner *s, const char *string, size_t len)
+{
+    if (s->len - s->pos < len)
+        return false;
+    if (strncasecmp(s->s + s->pos, string, len) != 0)
+        return false;
+    s->pos += len; s->column += len;
+    return true;
+}
+
+#define lit(s, literal) str(s, literal, sizeof(literal) - 1)
+
+static inline bool
+buf_append(struct scanner *s, char ch)
+{
+    if (s->buf_pos + 1 >= sizeof(s->buf))
+        return false;
+    s->buf[s->buf_pos++] = ch;
+    return true;
+}
+
+static inline bool
+oct(struct scanner *s, uint8_t *out)
+{
+    int i;
+    for (i = 0, *out = 0; peek(s) >= '0' && peek(s) <= '7' && i < 3; i++)
+        *out = *out * 8 + next(s) - '0';
+    return i > 0;
+}
+
+#endif
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/scanner.c b/src/3rdparty/xkbcommon/src/xkbcomp/scanner.c
index 4731107b85..48df488547 100644
--- a/src/3rdparty/xkbcommon/src/xkbcomp/scanner.c
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/scanner.c
@@ -1,2861 +1,219 @@
-#line 2 "src/xkbcomp/scanner.c"
-
-#line 4 "src/xkbcomp/scanner.c"
-
-#define  YY_INT_ALIGNED short int
-
-/* A lexical scanner generated by flex */
-
-#define FLEX_SCANNER
-#define YY_FLEX_MAJOR_VERSION 2
-#define YY_FLEX_MINOR_VERSION 5
-#define YY_FLEX_SUBMINOR_VERSION 35
-#if YY_FLEX_SUBMINOR_VERSION > 0
-#define FLEX_BETA
-#endif
-
-/* First, we deal with  platform-specific or compiler-specific issues. */
-
-/* begin standard C headers. */
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
-#include <stdlib.h>
-
-/* end standard C headers. */
-
-/* flex integer type definitions */
-
-#ifndef FLEXINT_H
-#define FLEXINT_H
-
-/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
-
-#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-
-/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
- * if you want the limit (max/min) macros for int types. 
- */
-#ifndef __STDC_LIMIT_MACROS
-#define __STDC_LIMIT_MACROS 1
-#endif
-
-#include <inttypes.h>
-typedef int8_t flex_int8_t;
-typedef uint8_t flex_uint8_t;
-typedef int16_t flex_int16_t;
-typedef uint16_t flex_uint16_t;
-typedef int32_t flex_int32_t;
-typedef uint32_t flex_uint32_t;
-#else
-typedef signed char flex_int8_t;
-typedef short int flex_int16_t;
-typedef int flex_int32_t;
-typedef unsigned char flex_uint8_t; 
-typedef unsigned short int flex_uint16_t;
-typedef unsigned int flex_uint32_t;
-
-/* Limits of integral types. */
-#ifndef INT8_MIN
-#define INT8_MIN               (-128)
-#endif
-#ifndef INT16_MIN
-#define INT16_MIN              (-32767-1)
-#endif
-#ifndef INT32_MIN
-#define INT32_MIN              (-2147483647-1)
-#endif
-#ifndef INT8_MAX
-#define INT8_MAX               (127)
-#endif
-#ifndef INT16_MAX
-#define INT16_MAX              (32767)
-#endif
-#ifndef INT32_MAX
-#define INT32_MAX              (2147483647)
-#endif
-#ifndef UINT8_MAX
-#define UINT8_MAX              (255U)
-#endif
-#ifndef UINT16_MAX
-#define UINT16_MAX             (65535U)
-#endif
-#ifndef UINT32_MAX
-#define UINT32_MAX             (4294967295U)
-#endif
-
-#endif /* ! C99 */
-
-#endif /* ! FLEXINT_H */
-
-#ifdef __cplusplus
-
-/* The "const" storage-class-modifier is valid. */
-#define YY_USE_CONST
-
-#else	/* ! __cplusplus */
-
-/* C99 requires __STDC__ to be defined as 1. */
-#if defined (__STDC__)
-
-#define YY_USE_CONST
-
-#endif	/* defined (__STDC__) */
-#endif	/* ! __cplusplus */
-
-#ifdef YY_USE_CONST
-#define yyconst const
-#else
-#define yyconst
-#endif
-
-/* Returned upon end-of-file. */
-#define YY_NULL 0
-
-/* Promotes a possibly negative, possibly signed char to an unsigned
- * integer for use as an array index.  If the signed char is negative,
- * we want to instead treat it as an 8-bit unsigned char, hence the
- * double cast.
- */
-#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
-
-/* An opaque pointer. */
-#ifndef YY_TYPEDEF_YY_SCANNER_T
-#define YY_TYPEDEF_YY_SCANNER_T
-typedef void* yyscan_t;
-#endif
-
-/* For convenience, these vars (plus the bison vars far below)
-   are macros in the reentrant scanner. */
-#define yyin yyg->yyin_r
-#define yyout yyg->yyout_r
-#define yyextra yyg->yyextra_r
-#define yyleng yyg->yyleng_r
-#define yytext yyg->yytext_r
-#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
-#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
-#define yy_flex_debug yyg->yy_flex_debug_r
-
-/* Enter a start condition.  This macro really ought to take a parameter,
- * but we do it the disgusting crufty way forced on us by the ()-less
- * definition of BEGIN.
- */
-#define BEGIN yyg->yy_start = 1 + 2 *
-
-/* Translate the current start state into a value that can be later handed
- * to BEGIN to return to the state.  The YYSTATE alias is for lex
- * compatibility.
- */
-#define YY_START ((yyg->yy_start - 1) / 2)
-#define YYSTATE YY_START
-
-/* Action number for EOF rule of a given start state. */
-#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
-
-/* Special action meaning "start processing a new file". */
-#define YY_NEW_FILE _xkbcommon_restart(yyin ,yyscanner )
-
-#define YY_END_OF_BUFFER_CHAR 0
-
-/* Size of default input buffer. */
-#ifndef YY_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k.
- * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
- * Ditto for the __ia64__ case accordingly.
- */
-#define YY_BUF_SIZE 32768
-#else
-#define YY_BUF_SIZE 16384
-#endif /* __ia64__ */
-#endif
-
-/* The state buf must be large enough to hold one state per character in the main buffer.
- */
-#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
-
-#ifndef YY_TYPEDEF_YY_BUFFER_STATE
-#define YY_TYPEDEF_YY_BUFFER_STATE
-typedef struct yy_buffer_state *YY_BUFFER_STATE;
-#endif
-
-#define EOB_ACT_CONTINUE_SCAN 0
-#define EOB_ACT_END_OF_FILE 1
-#define EOB_ACT_LAST_MATCH 2
-
-    /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
-     *       access to the local variable yy_act. Since yyless() is a macro, it would break
-     *       existing scanners that call yyless() from OUTSIDE _xkbcommon_lex. 
-     *       One obvious solution it to make yy_act a global. I tried that, and saw
-     *       a 5% performance hit in a non-yylineno scanner, because yy_act is
-     *       normally declared as a register variable-- so it is not worth it.
-     */
-    #define  YY_LESS_LINENO(n) \
-            do { \
-                int yyl;\
-                for ( yyl = n; yyl < yyleng; ++yyl )\
-                    if ( yytext[yyl] == '\n' )\
-                        --yylineno;\
-            }while(0)
-    
-/* Return all but the first "n" matched characters back to the input stream. */
-#define yyless(n) \
-	do \
-		{ \
-		/* Undo effects of setting up yytext. */ \
-        int yyless_macro_arg = (n); \
-        YY_LESS_LINENO(yyless_macro_arg);\
-		*yy_cp = yyg->yy_hold_char; \
-		YY_RESTORE_YY_MORE_OFFSET \
-		yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
-		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
-		} \
-	while ( 0 )
-
-#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
-
-#ifndef YY_TYPEDEF_YY_SIZE_T
-#define YY_TYPEDEF_YY_SIZE_T
-typedef size_t yy_size_t;
-#endif
-
-#ifndef YY_STRUCT_YY_BUFFER_STATE
-#define YY_STRUCT_YY_BUFFER_STATE
-struct yy_buffer_state
-	{
-	FILE *yy_input_file;
-
-	char *yy_ch_buf;		/* input buffer */
-	char *yy_buf_pos;		/* current position in input buffer */
-
-	/* Size of input buffer in bytes, not including room for EOB
-	 * characters.
-	 */
-	yy_size_t yy_buf_size;
-
-	/* Number of characters read into yy_ch_buf, not including EOB
-	 * characters.
-	 */
-	int yy_n_chars;
-
-	/* Whether we "own" the buffer - i.e., we know we created it,
-	 * and can realloc() it to grow it, and should free() it to
-	 * delete it.
-	 */
-	int yy_is_our_buffer;
-
-	/* Whether this is an "interactive" input source; if so, and
-	 * if we're using stdio for input, then we want to use getc()
-	 * instead of fread(), to make sure we stop fetching input after
-	 * each newline.
-	 */
-	int yy_is_interactive;
-
-	/* Whether we're considered to be at the beginning of a line.
-	 * If so, '^' rules will be active on the next match, otherwise
-	 * not.
-	 */
-	int yy_at_bol;
-
-    int yy_bs_lineno; /**< The line count. */
-    int yy_bs_column; /**< The column count. */
-    
-	/* Whether to try to fill the input buffer when we reach the
-	 * end of it.
-	 */
-	int yy_fill_buffer;
-
-	int yy_buffer_status;
-
-#define YY_BUFFER_NEW 0
-#define YY_BUFFER_NORMAL 1
-	/* When an EOF's been seen but there's still some text to process
-	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
-	 * shouldn't try reading from the input source any more.  We might
-	 * still have a bunch of tokens to match, though, because of
-	 * possible backing-up.
-	 *
-	 * When we actually see the EOF, we change the status to "new"
-	 * (via _xkbcommon_restart()), so that the user can continue scanning by
-	 * just pointing yyin at a new input file.
-	 */
-#define YY_BUFFER_EOF_PENDING 2
-
-	};
-#endif /* !YY_STRUCT_YY_BUFFER_STATE */
-
-/* We provide macros for accessing buffer states in case in the
- * future we want to put the buffer states in a more general
- * "scanner state".
+/*
+ * Copyright © 2012 Ran Benita <ran234@gmail.com>
  *
- * Returns the top of the stack, or NULL.
- */
-#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
-                          ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
-                          : NULL)
-
-/* Same as previous macro, but useful when we know that the buffer stack is not
- * NULL or when we need an lvalue. For internal use only.
- */
-#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
-
-void _xkbcommon_restart (FILE *input_file ,yyscan_t yyscanner );
-void _xkbcommon__switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
-YY_BUFFER_STATE _xkbcommon__create_buffer (FILE *file,int size ,yyscan_t yyscanner );
-void _xkbcommon__delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
-void _xkbcommon__flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
-void _xkbcommon_push_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
-void _xkbcommon_pop_buffer_state (yyscan_t yyscanner );
-
-static void _xkbcommon_ensure_buffer_stack (yyscan_t yyscanner );
-static void _xkbcommon__load_buffer_state (yyscan_t yyscanner );
-static void _xkbcommon__init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
-
-#define YY_FLUSH_BUFFER _xkbcommon__flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
-
-YY_BUFFER_STATE _xkbcommon__scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
-YY_BUFFER_STATE _xkbcommon__scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
-YY_BUFFER_STATE _xkbcommon__scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
-
-void *_xkbcommon_alloc (yy_size_t ,yyscan_t yyscanner );
-void *_xkbcommon_realloc (void *,yy_size_t ,yyscan_t yyscanner );
-void _xkbcommon_free (void * ,yyscan_t yyscanner );
-
-#define yy_new_buffer _xkbcommon__create_buffer
-
-#define yy_set_interactive(is_interactive) \
-	{ \
-	if ( ! YY_CURRENT_BUFFER ){ \
-        _xkbcommon_ensure_buffer_stack (yyscanner); \
-		YY_CURRENT_BUFFER_LVALUE =    \
-            _xkbcommon__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
-	} \
-	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
-	}
-
-#define yy_set_bol(at_bol) \
-	{ \
-	if ( ! YY_CURRENT_BUFFER ){\
-        _xkbcommon_ensure_buffer_stack (yyscanner); \
-		YY_CURRENT_BUFFER_LVALUE =    \
-            _xkbcommon__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
-	} \
-	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
-	}
-
-#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
-
-/* Begin user sect3 */
-
-#define _xkbcommon_wrap(n) 1
-#define YY_SKIP_YYWRAP
-
-typedef unsigned char YY_CHAR;
-
-typedef int yy_state_type;
-
-#define yytext_ptr yytext_r
-
-static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
-static yy_state_type yy_try_NUL_trans (yy_state_type current_state  ,yyscan_t yyscanner);
-static int yy_get_next_buffer (yyscan_t yyscanner );
-static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
-
-/* Done after the current pattern has been matched and before the
- * corresponding action - sets up yytext.
- */
-#define YY_DO_BEFORE_ACTION \
-	yyg->yytext_ptr = yy_bp; \
-	yyleng = (size_t) (yy_cp - yy_bp); \
-	yyg->yy_hold_char = *yy_cp; \
-	*yy_cp = '\0'; \
-	yyg->yy_c_buf_p = yy_cp;
-
-#define YY_NUM_RULES 83
-#define YY_END_OF_BUFFER 84
-/* This struct is not used in this scanner,
-   but its presence is necessary. */
-struct yy_trans_info
-	{
-	flex_int32_t yy_verify;
-	flex_int32_t yy_nxt;
-	};
-static yyconst flex_int16_t yy_accept[336] =
-    {   0,
-        0,    0,    0,    0,   84,   82,   81,   81,   79,    3,
-        2,   72,   73,   69,   66,   77,   67,   76,   68,   63,
-       63,   78,   82,   65,   61,   61,   61,   61,   61,   61,
-       61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
-       61,   74,   75,   70,   71,   80,   14,   83,    4,   14,
-       81,    2,    1,    0,   63,    0,    0,   61,   61,   61,
-       61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
-       61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
-       61,    5,    6,   10,   13,   11,    7,    9,    8,   12,
-        1,   64,   62,   15,   61,   61,   61,   61,   61,   61,
-
-       61,   61,   61,   61,   61,   61,   39,   61,   61,   61,
-       61,   61,   61,   47,   61,   61,   61,   61,   61,   61,
-       61,    5,   61,   61,   61,   61,   61,   61,   61,   61,
-       61,   61,   61,   61,   61,   48,   54,   61,   61,   61,
-       61,   61,   61,   61,   61,   61,   61,   51,   36,   61,
-       61,    5,   61,   40,   61,   61,   61,   61,   61,   41,
-       61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
-       61,   61,   61,   61,   46,   53,   61,   61,   61,   61,
-       61,   61,   61,   38,   61,   61,   61,   61,   61,   34,
-       61,   61,   61,   61,   61,   42,   61,   61,   61,   61,
-
-       61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
-       61,   61,   61,   29,   33,   61,   27,   61,   61,   61,
-       61,   43,   52,   50,   61,   32,   30,   49,   55,   61,
-       61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
-       61,   61,   61,   28,   61,   61,   61,   61,   61,   61,
-       61,   61,   61,   61,   31,   61,   45,   37,   61,   61,
-       61,   61,   61,   61,   61,   61,   61,   61,   18,   61,
-       61,   61,   61,   61,   61,   61,   20,   61,   61,   16,
-       26,   61,   61,   61,   61,   61,   58,   61,   61,   61,
-       61,   61,   61,   61,   61,   19,   61,   61,   61,   61,
-
-       44,   61,   61,   61,   24,   17,   61,   61,   61,   59,
-       57,   61,   61,   61,   25,   61,   61,   61,   61,   21,
-       61,   60,   61,   61,   61,   61,   61,   56,   35,   22,
-       61,   61,   61,   23,    0
-    } ;
-
-static yyconst flex_int32_t yy_ec[256] =
-    {   0,
-        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
-        2,    1,    2,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    2,    4,    5,    6,    1,    1,    1,    1,    7,
-        8,    9,   10,   11,   12,   13,   14,   15,   16,   16,
-       16,   16,   16,   16,   16,   17,   17,    1,   18,   19,
-       20,   21,    1,    1,   22,   23,   24,   25,   26,   27,
-       28,   29,   30,   31,   32,   33,   34,   35,   36,   37,
-       31,   38,   39,   40,   41,   42,   43,   44,   45,   31,
-       46,   47,   48,    1,   49,    1,   50,   51,   52,   53,
-
-       54,   55,   56,   57,   58,   31,   59,   60,   61,   62,
-       63,   64,   31,   65,   66,   67,   68,   69,   70,   71,
-       72,   31,   73,    1,   74,   75,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1
-    } ;
-
-static yyconst flex_int32_t yy_meta[76] =
-    {   0,
-        1,    1,    2,    1,    1,    1,    1,    1,    1,    3,
-        1,    3,    1,    1,    4,    4,    4,    1,    1,    1,
-        1,    4,    4,    4,    4,    4,    4,    5,    5,    5,
-        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
-        5,    5,    5,    5,    5,    1,    1,    1,    5,    4,
-        4,    4,    4,    4,    4,    5,    5,    5,    5,    5,
-        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
-        5,    5,    1,    1,    1
-    } ;
-
-static yyconst flex_int16_t yy_base[342] =
-    {   0,
-        0,    0,   73,   74,  263,  695,   78,   80,  695,  695,
-        0,  695,  695,  695,  695,  695,  695,  695,  203,   71,
-       76,  695,    0,  695,   66,    0,   59,   54,   58,   67,
-       65,   75,   67,   68,   64,   86,   83,  109,   98,   81,
-       82,  695,  695,  695,  695,  695,  695,  695,  695,  158,
-      114,    0,    0,  132,  138,    0,  158,    0,  100,  128,
-      100,  123,  109,  124,  136,  166,  131,  141,  152,  140,
-      156,  150,  157,  156,  159,  179,  171,  164,  177,  178,
-      179,  221,  229,  695,  695,  695,  695,  695,  695,  695,
-        0,  232,    0,  695,  192,  202,  199,  206,  200,  217,
-
-      216,  201,  226,  220,  224,  229,  220,  222,  232,  231,
-      227,  230,  238,    0,  232,  236,  244,  236,  251,  247,
-      115,  279,  252,  250,  256,  263,  278,  266,  268,  272,
-      284,  271,  289,  279,  296,    0,    0,  292,  298,  288,
-      293,  292,  296,  305,  301,  307,  312,    0,    0,  288,
-      342,  347,  305,    0,  307,  310,  315,  320,  313,    0,
-      323,  335,  346,  336,  351,  348,  346,  357,  349,  364,
-      357,  367,  366,  356,    0,    0,  371,  359,  371,  373,
-      381,  379,  367,    0,  372,  394,  380,  383,  390,    0,
-      402,  390,  394,  113,  408,    0,  399,  411,  396,  413,
-
-      409,  417,  410,  413,  414,  413,  407,  409,  421,  424,
-      423,  427,  424,    0,    0,  432,    0,  434,  448,  445,
-      440,    0,    0,    0,  454,    0,    0,    0,  110,  446,
-      450,  462,  453,  468,  469,  467,  472,  473,  108,  457,
-      461,  477,   63,    0,  472,  485,  483,  476,  491,  474,
-      482,  483,  485,  487,   61,  497,    0,    0,  485,  500,
-      500,  498,  500,  518,  508,  507,  508,  516,    0,  520,
-      525,  528,  519,  529,  538,  537,  538,  526,  540,    0,
-        0,  539,  534,  546,  539,  534,    0,  535,  547,  556,
-      566,  558,  548,  556,  575,    0,   53,  565,  563,  564,
-
-        0,  578,  578,  587,    0,    0,  573,  581,  574,    0,
-        0,  580,  583,  581,    0,  595,  586,  598,  595,    0,
-      586,    0,  594,  594,  596,  602,  599,    0,    0,   49,
-      612,  604,  610,    0,  695,  674,  679,  682,  684,  689,
-       90
-    } ;
-
-static yyconst flex_int16_t yy_def[342] =
-    {   0,
-      335,    1,  336,  336,  335,  335,  335,  335,  335,  335,
-      337,  335,  335,  335,  335,  335,  335,  335,  335,  335,
-      335,  335,  338,  335,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  335,  335,  335,  335,  335,  335,  335,  335,  335,
-      335,  337,  340,  335,  335,  341,  338,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  335,  335,  335,  335,  335,  335,  335,  335,  335,
-      340,  335,  341,  335,  339,  339,  339,  339,  339,  339,
-
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  335,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  335,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,  339,  339,  339,  339,  339,  339,
-      339,  339,  339,  339,    0,  335,  335,  335,  335,  335,
-      335
-    } ;
-
-static yyconst flex_int16_t yy_nxt[771] =
-    {   0,
-        6,    7,    8,    9,   10,   11,   12,   13,   14,   15,
-       16,   17,   18,   19,   20,   21,   21,   22,   23,   24,
-        6,   25,   26,   26,   27,   26,   28,   29,   30,   31,
-       26,   32,   33,   34,   26,   35,   36,   37,   38,   39,
-       26,   40,   26,   41,   26,   42,    6,   43,   26,   25,
-       26,   26,   27,   26,   28,   29,   30,   31,   32,   33,
-       34,   26,   35,   36,   37,   38,   39,   26,   40,   26,
-       41,   26,   44,   45,   46,   48,   48,   49,   49,   51,
-       51,   51,   51,   54,   62,   55,   55,   55,   54,   59,
-       55,   55,   55,   93,   63,   64,   65,  331,   60,   66,
-
-       67,  308,   68,   69,   70,   71,   61,   72,   73,  271,
-       80,  260,   62,   81,   56,   51,   51,   59,   74,   50,
-       50,   63,   64,   78,   65,   60,   66,   99,   67,   68,
-       69,   70,   71,   61,   75,   72,   73,   76,   80,   95,
-       81,   56,   79,  101,   77,   74,   92,   92,   92,  100,
-       54,   78,   55,   55,   55,   99,  256,   96,  245,  102,
-      103,  220,   75,  151,   97,   76,   95,   98,  108,   79,
-      101,   77,   82,   82,   83,  107,  109,  100,   94,  110,
-       84,  111,  115,   85,   86,   96,  102,  112,  103,  104,
-      105,   97,   87,  113,   98,   88,  108,   89,  114,   90,
-
-      116,  121,  107,  117,  109,  106,  110,  118,   84,  111,
-      115,   85,   86,  119,  112,  120,   53,  104,  105,   87,
-      113,  123,   88,  124,   89,  114,   90,  125,  116,  121,
-      117,  126,  106,  127,  118,  122,  122,   83,  128,  129,
-      119,  130,  120,   83,   83,   83,   92,   92,   92,  123,
-      131,  124,  132,  133,  134,  125,  135,  137,  136,  126,
-      127,  138,  335,  141,  142,  139,  128,  129,  130,  143,
-      144,  145,  146,  147,  335,  148,  149,  155,  131,  132,
-      140,  133,  134,  135,  137,  136,  150,  153,  154,  138,
-      141,  142,  139,  152,  152,   83,  143,  144,  145,  146,
-
-      156,  147,  148,  157,  149,  155,  158,  159,  160,  161,
-      335,  162,  163,  150,  153,  154,  164,  165,  166,  167,
-      335,  168,  169,  335,  170,  172,  173,  156,  177,  171,
-      174,  157,  175,  158,  159,  160,  176,  161,  162,  184,
-      163,  185,  189,  164,  186,  165,  166,  167,  168,  187,
-      169,  170,  188,  172,  173,  177,  171,  190,  174,  191,
-      175,   83,   83,   83,  176,  178,  184,  192,  185,  179,
-      189,  186,  193,  180,  181,  194,  187,  195,  197,  188,
-      182,  183,  196,  198,  190,  199,  200,  191,  201,  202,
-      335,  203,  204,  178,  205,  192,  206,  179,  207,  193,
-
-      180,  181,  208,  194,  209,  195,  197,  182,  183,  196,
-      198,  211,  212,  199,  200,  213,  201,  202,  203,  214,
-      204,  205,  215,  210,  206,  216,  207,  217,  335,  218,
-      208,  219,  209,  221,  335,  222,  223,  225,  211,  212,
-      224,  226,  227,  213,  228,  229,  214,  230,  231,  215,
-      210,  232,  216,  233,  234,  217,  218,  235,  219,  236,
-      237,  221,  222,  238,  223,  225,  239,  224,  226,  240,
-      227,  228,  229,  241,  230,  231,  242,  243,  232,  244,
-      233,  234,  246,  247,  235,  248,  236,  237,  250,  251,
-      238,  252,  253,  239,  257,  249,  240,  254,  255,  335,
-
-      258,  241,  259,  242,  243,  261,  262,  244,  263,  246,
-      247,  264,  265,  248,  266,  250,  267,  251,  268,  252,
-      253,  257,  249,  269,  270,  254,  255,  258,  272,  273,
-      259,  274,  261,  275,  262,  276,  263,  277,  264,  278,
-      265,  266,  279,  267,  280,  268,  281,  282,  283,  284,
-      269,  270,  285,  286,  288,  272,  273,  287,  274,  289,
-      275,  290,  276,  293,  277,  294,  278,  291,  295,  297,
-      279,  280,  296,  281,  282,  283,  298,  284,  299,  300,
-      285,  286,  288,  301,  287,  302,  292,  289,  303,  290,
-      293,  304,  305,  294,  306,  291,  295,  297,  307,  296,
-
-      309,  310,  311,  298,  312,  299,  300,  313,  314,  318,
-      301,  315,  316,  302,  317,  319,  303,  320,  304,  305,
-      321,  306,  322,  323,  324,  333,  307,  309,  310,  311,
-      325,  326,  312,  327,  328,  313,  314,  318,  315,  316,
-      329,  317,  319,  330,  320,  332,  334,  335,  321,  322,
-      335,  323,  324,  333,  335,  335,  335,  325,  326,  335,
-      327,  328,  335,  335,  335,  335,  335,  329,  335,  335,
-      330,  335,  332,  334,   47,   47,   47,   47,   47,   52,
-      335,   52,   52,   52,   57,   57,   57,   58,   58,   91,
-      335,   91,   91,   91,    5,  335,  335,  335,  335,  335,
-
-      335,  335,  335,  335,  335,  335,  335,  335,  335,  335,
-      335,  335,  335,  335,  335,  335,  335,  335,  335,  335,
-      335,  335,  335,  335,  335,  335,  335,  335,  335,  335,
-      335,  335,  335,  335,  335,  335,  335,  335,  335,  335,
-      335,  335,  335,  335,  335,  335,  335,  335,  335,  335,
-      335,  335,  335,  335,  335,  335,  335,  335,  335,  335,
-      335,  335,  335,  335,  335,  335,  335,  335,  335,  335
-    } ;
-
-static yyconst flex_int16_t yy_chk[771] =
-    {   0,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    3,    4,    3,    4,    7,
-        7,    8,    8,   20,   27,   20,   20,   20,   21,   25,
-       21,   21,   21,  341,   28,   29,   30,  330,   25,   31,
-
-       32,  297,   33,   34,   35,   35,   25,   36,   37,  255,
-       40,  243,   27,   41,   20,   51,   51,   25,   37,    3,
-        4,   28,   29,   39,   30,   25,   31,   61,   32,   33,
-       34,   35,   35,   25,   38,   36,   37,   38,   40,   59,
-       41,   20,   39,   63,   38,   37,   54,   54,   54,   62,
-       55,   39,   55,   55,   55,   61,  239,   60,  229,   64,
-       65,  194,   38,  121,   60,   38,   59,   60,   68,   39,
-       63,   38,   50,   50,   50,   67,   69,   62,   57,   70,
-       50,   71,   75,   50,   50,   60,   64,   72,   65,   66,
-       66,   60,   50,   73,   60,   50,   68,   50,   74,   50,
-
-       76,   81,   67,   77,   69,   66,   70,   78,   50,   71,
-       75,   50,   50,   79,   72,   80,   19,   66,   66,   50,
-       73,   95,   50,   96,   50,   74,   50,   97,   76,   81,
-       77,   98,   66,   99,   78,   82,   82,   82,  100,  101,
-       79,  102,   80,   83,   83,   83,   92,   92,   92,   95,
-      103,   96,  104,  105,  106,   97,  107,  108,  107,   98,
-       99,  109,    5,  110,  111,  109,  100,  101,  102,  112,
-      113,  115,  116,  117,    0,  118,  119,  125,  103,  104,
-      109,  105,  106,  107,  108,  107,  120,  123,  124,  109,
-      110,  111,  109,  122,  122,  122,  112,  113,  115,  116,
-
-      126,  117,  118,  127,  119,  125,  128,  129,  130,  131,
-        0,  132,  133,  120,  123,  124,  134,  135,  138,  139,
-        0,  140,  141,    0,  142,  143,  144,  126,  150,  142,
-      145,  127,  146,  128,  129,  130,  147,  131,  132,  153,
-      133,  155,  159,  134,  156,  135,  138,  139,  140,  157,
-      141,  142,  158,  143,  144,  150,  142,  161,  145,  162,
-      146,  152,  152,  152,  147,  151,  153,  163,  155,  151,
-      159,  156,  164,  151,  151,  165,  157,  166,  168,  158,
-      151,  151,  167,  169,  161,  170,  171,  162,  172,  173,
-        0,  174,  177,  151,  178,  163,  179,  151,  180,  164,
-
-      151,  151,  181,  165,  182,  166,  168,  151,  151,  167,
-      169,  183,  185,  170,  171,  186,  172,  173,  174,  187,
-      177,  178,  188,  182,  179,  189,  180,  191,    0,  192,
-      181,  193,  182,  195,    0,  197,  198,  200,  183,  185,
-      199,  201,  202,  186,  203,  204,  187,  205,  206,  188,
-      182,  207,  189,  208,  209,  191,  192,  210,  193,  211,
-      212,  195,  197,  213,  198,  200,  216,  199,  201,  218,
-      202,  203,  204,  219,  205,  206,  220,  221,  207,  225,
-      208,  209,  230,  231,  210,  232,  211,  212,  233,  234,
-      213,  235,  236,  216,  240,  232,  218,  237,  238,    0,
-
-      241,  219,  242,  220,  221,  245,  246,  225,  247,  230,
-      231,  248,  249,  232,  250,  233,  251,  234,  252,  235,
-      236,  240,  232,  253,  254,  237,  238,  241,  256,  259,
-      242,  260,  245,  260,  246,  261,  247,  262,  248,  263,
-      249,  250,  264,  251,  265,  252,  266,  267,  268,  270,
-      253,  254,  271,  272,  274,  256,  259,  273,  260,  275,
-      260,  276,  261,  278,  262,  279,  263,  277,  282,  284,
-      264,  265,  283,  266,  267,  268,  285,  270,  286,  288,
-      271,  272,  274,  289,  273,  290,  277,  275,  291,  276,
-      278,  292,  293,  279,  294,  277,  282,  284,  295,  283,
-
-      298,  299,  300,  285,  302,  286,  288,  303,  304,  312,
-      289,  307,  308,  290,  309,  313,  291,  314,  292,  293,
-      316,  294,  317,  318,  319,  332,  295,  298,  299,  300,
-      321,  323,  302,  324,  325,  303,  304,  312,  307,  308,
-      326,  309,  313,  327,  314,  331,  333,    0,  316,  317,
-        0,  318,  319,  332,    0,    0,    0,  321,  323,    0,
-      324,  325,    0,    0,    0,    0,    0,  326,    0,    0,
-      327,    0,  331,  333,  336,  336,  336,  336,  336,  337,
-        0,  337,  337,  337,  338,  338,  338,  339,  339,  340,
-        0,  340,  340,  340,  335,  335,  335,  335,  335,  335,
-
-      335,  335,  335,  335,  335,  335,  335,  335,  335,  335,
-      335,  335,  335,  335,  335,  335,  335,  335,  335,  335,
-      335,  335,  335,  335,  335,  335,  335,  335,  335,  335,
-      335,  335,  335,  335,  335,  335,  335,  335,  335,  335,
-      335,  335,  335,  335,  335,  335,  335,  335,  335,  335,
-      335,  335,  335,  335,  335,  335,  335,  335,  335,  335,
-      335,  335,  335,  335,  335,  335,  335,  335,  335,  335
-    } ;
-
-/* Table of booleans, true if rule could match eol. */
-static yyconst flex_int32_t yy_rule_can_match_eol[84] =
-    {   0,
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-    0, 1, 0, 0,     };
-
-/* The intent behind this definition is that it'll catch
- * any uses of REJECT which flex missed.
+ * 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.
  */
-#define REJECT reject_used_but_not_detected
-#define yymore() yymore_used_but_not_detected
-#define YY_MORE_ADJ 0
-#define YY_RESTORE_YY_MORE_OFFSET
-#line 1 "scanner.l"
-/************************************************************
- Copyright (c) 1994 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.
 
- ********************************************************/
-#line 28 "scanner.l"
 #include "xkbcomp-priv.h"
 #include "parser-priv.h"
-
-#pragma GCC diagnostic ignored "-Wmissing-noreturn"
-#pragma GCC diagnostic ignored "-Wredundant-decls"
-#pragma GCC diagnostic push
-
-struct scanner_extra {
-    struct xkb_context *ctx;
-    const char *file_name;
-    char scanBuf[1024];
-    char *s;
-};
+#include "scanner-utils.h"
 
 static void
-scanner_error_extra(struct YYLTYPE *loc, struct scanner_extra *extra,
-                    const char *msg);
-
-#define YY_USER_ACTION {                \
-        yylloc->first_line = yylineno;  \
-        yylloc->last_line = yylineno;   \
-}
-
-#define APPEND_S(ch) do {                                               \
-    if (yyextra->s - yyextra->scanBuf >= sizeof(yyextra->scanBuf) - 1)  \
-        return ERROR_TOK;                                               \
-    *yyextra->s++ = ch;                                                 \
-} while (0)
-#define YY_NO_UNISTD_H 1
-#define YY_NO_INPUT 1
-
-#line 803 "src/xkbcomp/scanner.c"
-
-#define INITIAL 0
-#define S_STR 1
-
-#ifndef YY_NO_UNISTD_H
-/* Special case for "unistd.h", since it is non-ANSI. We include it way
- * down here because we want the user's section 1 to have been scanned first.
- * The user has a chance to override it with an option.
- */
-#include <unistd.h>
-#endif
-
-#define YY_EXTRA_TYPE struct scanner_extra *
-
-/* Holds the entire state of the reentrant scanner. */
-struct yyguts_t
-    {
-
-    /* User-defined. Not touched by flex. */
-    YY_EXTRA_TYPE yyextra_r;
-
-    /* The rest are the same as the globals declared in the non-reentrant scanner. */
-    FILE *yyin_r, *yyout_r;
-    size_t yy_buffer_stack_top; /**< index of top of stack. */
-    size_t yy_buffer_stack_max; /**< capacity of stack. */
-    YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
-    char yy_hold_char;
-    int yy_n_chars;
-    int yyleng_r;
-    char *yy_c_buf_p;
-    int yy_init;
-    int yy_start;
-    int yy_did_buffer_switch_on_eof;
-    int yy_start_stack_ptr;
-    int yy_start_stack_depth;
-    int *yy_start_stack;
-    yy_state_type yy_last_accepting_state;
-    char* yy_last_accepting_cpos;
-
-    int yylineno_r;
-    int yy_flex_debug_r;
-
-    char *yytext_r;
-    int yy_more_flag;
-    int yy_more_len;
-
-    YYSTYPE * yylval_r;
-
-    YYLTYPE * yylloc_r;
-
-    }; /* end struct yyguts_t */
-
-static int yy_init_globals (yyscan_t yyscanner );
-
-    /* This must go here because YYSTYPE and YYLTYPE are included
-     * from bison output in section 1.*/
-    #    define yylval yyg->yylval_r
-    
-    #    define yylloc yyg->yylloc_r
-    
-int _xkbcommon_lex_init (yyscan_t* scanner);
-
-int _xkbcommon_lex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
-
-/* Accessor methods to globals.
-   These are made visible to non-reentrant scanners for convenience. */
-
-int _xkbcommon_lex_destroy (yyscan_t yyscanner );
-
-int _xkbcommon_get_debug (yyscan_t yyscanner );
-
-void _xkbcommon_set_debug (int debug_flag ,yyscan_t yyscanner );
-
-YY_EXTRA_TYPE _xkbcommon_get_extra (yyscan_t yyscanner );
-
-void _xkbcommon_set_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
-
-FILE *_xkbcommon_get_in (yyscan_t yyscanner );
-
-void _xkbcommon_set_in  (FILE * in_str ,yyscan_t yyscanner );
-
-FILE *_xkbcommon_get_out (yyscan_t yyscanner );
-
-void _xkbcommon_set_out  (FILE * out_str ,yyscan_t yyscanner );
-
-int _xkbcommon_get_leng (yyscan_t yyscanner );
-
-char *_xkbcommon_get_text (yyscan_t yyscanner );
-
-int _xkbcommon_get_lineno (yyscan_t yyscanner );
-
-void _xkbcommon_set_lineno (int line_number ,yyscan_t yyscanner );
-
-YYSTYPE * _xkbcommon_get_lval (yyscan_t yyscanner );
-
-void _xkbcommon_set_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
-
-       YYLTYPE *_xkbcommon_get_lloc (yyscan_t yyscanner );
-    
-        void _xkbcommon_set_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner );
-    
-/* Macros after this point can all be overridden by user definitions in
- * section 1.
- */
-
-#ifndef YY_SKIP_YYWRAP
-#ifdef __cplusplus
-extern "C" int _xkbcommon_wrap (yyscan_t yyscanner );
-#else
-extern int _xkbcommon_wrap (yyscan_t yyscanner );
-#endif
-#endif
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
-#endif
-
-#ifndef YY_NO_INPUT
-
-#ifdef __cplusplus
-static int yyinput (yyscan_t yyscanner );
-#else
-static int input (yyscan_t yyscanner );
-#endif
-
-#endif
-
-/* Amount of stuff to slurp up with each read. */
-#ifndef YY_READ_BUF_SIZE
-#ifdef __ia64__
-/* On IA-64, the buffer size is 16k, not 8k */
-#define YY_READ_BUF_SIZE 16384
-#else
-#define YY_READ_BUF_SIZE 8192
-#endif /* __ia64__ */
-#endif
-
-/* Copy whatever the last rule matched to the standard output. */
-#ifndef ECHO
-/* This used to be an fputs(), but since the string might contain NUL's,
- * we now use fwrite().
- */
-#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
-#endif
-
-/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
- * is returned in "result".
- */
-#ifndef YY_INPUT
-#define YY_INPUT(buf,result,max_size) \
-	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
-		{ \
-		int c = '*'; \
-		size_t n; \
-		for ( n = 0; n < max_size && \
-			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
-			buf[n] = (char) c; \
-		if ( c == '\n' ) \
-			buf[n++] = (char) c; \
-		if ( c == EOF && ferror( yyin ) ) \
-			YY_FATAL_ERROR( "input in flex scanner failed" ); \
-		result = n; \
-		} \
-	else \
-		{ \
-		errno=0; \
-		while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
-			{ \
-			if( errno != EINTR) \
-				{ \
-				YY_FATAL_ERROR( "input in flex scanner failed" ); \
-				break; \
-				} \
-			errno=0; \
-			clearerr(yyin); \
-			} \
-		}\
-\
-
-#endif
-
-/* No semi-colon after return; correct usage is to write "yyterminate();" -
- * we don't want an extra ';' after the "return" because that will cause
- * some compilers to complain about unreachable statements.
- */
-#ifndef yyterminate
-#define yyterminate() return YY_NULL
-#endif
-
-/* Number of entries by which start-condition stack grows. */
-#ifndef YY_START_STACK_INCR
-#define YY_START_STACK_INCR 25
-#endif
-
-/* Report a fatal error. */
-#ifndef YY_FATAL_ERROR
-#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
-#endif
-
-/* end tables serialization structures and prototypes */
-
-/* Default declaration of generated scanner - a define so the user can
- * easily add parameters.
- */
-#ifndef YY_DECL
-#define YY_DECL_IS_OURS 1
-
-extern int _xkbcommon_lex \
-               (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner);
-
-#define YY_DECL int _xkbcommon_lex \
-               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
-#endif /* !YY_DECL */
-
-/* Code executed at the beginning of each rule, after yytext and yyleng
- * have been set up.
- */
-#ifndef YY_USER_ACTION
-#define YY_USER_ACTION
-#endif
-
-/* Code executed at the end of each rule. */
-#ifndef YY_BREAK
-#define YY_BREAK break;
-#endif
-
-#define YY_RULE_SETUP \
-	YY_USER_ACTION
-
-/** The main scanner function which does all the work.
- */
-YY_DECL
-{
-	register yy_state_type yy_current_state;
-	register char *yy_cp, *yy_bp;
-	register int yy_act;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-#line 69 "scanner.l"
-
-
-#line 1049 "src/xkbcomp/scanner.c"
-
-    yylval = yylval_param;
-
-    yylloc = yylloc_param;
-
-	if ( !yyg->yy_init )
-		{
-		yyg->yy_init = 1;
-
-#ifdef YY_USER_INIT
-		YY_USER_INIT;
-#endif
-
-		if ( ! yyg->yy_start )
-			yyg->yy_start = 1;	/* first start state */
-
-		if ( ! yyin )
-			yyin = stdin;
-
-		if ( ! yyout )
-			yyout = stdout;
-
-		if ( ! YY_CURRENT_BUFFER ) {
-			_xkbcommon_ensure_buffer_stack (yyscanner);
-			YY_CURRENT_BUFFER_LVALUE =
-				_xkbcommon__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
-		}
-
-		_xkbcommon__load_buffer_state(yyscanner );
-		}
-
-	while ( 1 )		/* loops until end-of-file is reached */
-		{
-		yy_cp = yyg->yy_c_buf_p;
-
-		/* Support of yytext. */
-		*yy_cp = yyg->yy_hold_char;
-
-		/* yy_bp points to the position in yy_ch_buf of the start of
-		 * the current run.
-		 */
-		yy_bp = yy_cp;
-
-		yy_current_state = yyg->yy_start;
-yy_match:
-		do
-			{
-			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
-			if ( yy_accept[yy_current_state] )
-				{
-				yyg->yy_last_accepting_state = yy_current_state;
-				yyg->yy_last_accepting_cpos = yy_cp;
-				}
-			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-				{
-				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 336 )
-					yy_c = yy_meta[(unsigned int) yy_c];
-				}
-			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-			++yy_cp;
-			}
-		while ( yy_current_state != 335 );
-		yy_cp = yyg->yy_last_accepting_cpos;
-		yy_current_state = yyg->yy_last_accepting_state;
-
-yy_find_action:
-		yy_act = yy_accept[yy_current_state];
-
-		YY_DO_BEFORE_ACTION;
-
-		if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
-			{
-			int yyl;
-			for ( yyl = 0; yyl < yyleng; ++yyl )
-				if ( yytext[yyl] == '\n' )
-					   
-    do{ yylineno++;
-        yycolumn=0;
-    }while(0)
-;
-			}
-
-do_action:	/* This label is used only to access EOF actions. */
-
-		switch ( yy_act )
-	{ /* beginning of action switch */
-			case 0: /* must back up */
-			/* undo the effects of YY_DO_BEFORE_ACTION */
-			*yy_cp = yyg->yy_hold_char;
-			yy_cp = yyg->yy_last_accepting_cpos;
-			yy_current_state = yyg->yy_last_accepting_state;
-			goto yy_find_action;
-
-case 1:
-YY_RULE_SETUP
-#line 71 "scanner.l"
-
-	YY_BREAK
-case 2:
-YY_RULE_SETUP
-#line 72 "scanner.l"
-
-	YY_BREAK
-case 3:
-YY_RULE_SETUP
-#line 74 "scanner.l"
-yyextra->s = yyextra->scanBuf; BEGIN(S_STR);
-	YY_BREAK
-case 4:
-YY_RULE_SETUP
-#line 76 "scanner.l"
-{
-                        BEGIN(INITIAL);
-                        *yyextra->s = '\0';
-                        yylval->str = strdup(yyextra->scanBuf);
-                        return STRING;
-                    }
-	YY_BREAK
-case 5:
-YY_RULE_SETUP
-#line 83 "scanner.l"
-{
-                        /* octal escape sequence */
-                        unsigned int result;
-
-                        (void) sscanf( yytext + 1, "%o", &result );
-
-                        if (result > 0xff) {
-                            scanner_error_extra(yylloc, yyextra,
-                                                "Illegal octal escape");
-                            return ERROR_TOK;
-                        }
-
-                        APPEND_S(result);
-                    }
-	YY_BREAK
-case 6:
-YY_RULE_SETUP
-#line 98 "scanner.l"
-{
-                        scanner_error_extra(yylloc, yyextra,
-                                            "Illegal octal escape");
-                        return ERROR_TOK;
-                    }
-	YY_BREAK
-case 7:
-YY_RULE_SETUP
-#line 104 "scanner.l"
-APPEND_S('\n');
-	YY_BREAK
-case 8:
-YY_RULE_SETUP
-#line 105 "scanner.l"
-APPEND_S('\t');
-	YY_BREAK
-case 9:
-YY_RULE_SETUP
-#line 106 "scanner.l"
-APPEND_S('\r');
-	YY_BREAK
-case 10:
-YY_RULE_SETUP
-#line 107 "scanner.l"
-APPEND_S('\b');
-	YY_BREAK
-case 11:
-YY_RULE_SETUP
-#line 108 "scanner.l"
-APPEND_S('\f');
-	YY_BREAK
-case 12:
-YY_RULE_SETUP
-#line 109 "scanner.l"
-APPEND_S('\v');
-	YY_BREAK
-case 13:
-YY_RULE_SETUP
-#line 110 "scanner.l"
-APPEND_S('\033');
-	YY_BREAK
-case 14:
-YY_RULE_SETUP
-#line 112 "scanner.l"
-APPEND_S(yytext[0]);
-	YY_BREAK
-case 15:
-YY_RULE_SETUP
-#line 114 "scanner.l"
-{
-                        /* We don't want the brackets. */
-                        yytext[yyleng - 1] = '\0';
-                        yytext++;
-                        yylval->sval = xkb_atom_intern(yyextra->ctx, yytext);
-                        return KEYNAME;
-                    }
-	YY_BREAK
-case 16:
-YY_RULE_SETUP
-#line 122 "scanner.l"
-return XKB_KEYMAP;
-	YY_BREAK
-case 17:
-YY_RULE_SETUP
-#line 123 "scanner.l"
-return XKB_KEYCODES;
-	YY_BREAK
-case 18:
-YY_RULE_SETUP
-#line 124 "scanner.l"
-return XKB_TYPES;
-	YY_BREAK
-case 19:
-YY_RULE_SETUP
-#line 125 "scanner.l"
-return XKB_SYMBOLS;
-	YY_BREAK
-case 20:
-YY_RULE_SETUP
-#line 126 "scanner.l"
-return XKB_COMPATMAP;
-	YY_BREAK
-case 21:
-YY_RULE_SETUP
-#line 127 "scanner.l"
-return XKB_COMPATMAP;
-	YY_BREAK
-case 22:
-YY_RULE_SETUP
-#line 128 "scanner.l"
-return XKB_COMPATMAP;
-	YY_BREAK
-case 23:
-YY_RULE_SETUP
-#line 129 "scanner.l"
-return XKB_COMPATMAP;
-	YY_BREAK
-case 24:
-YY_RULE_SETUP
-#line 130 "scanner.l"
-return XKB_GEOMETRY;
-	YY_BREAK
-case 25:
-YY_RULE_SETUP
-#line 131 "scanner.l"
-return XKB_SEMANTICS;
-	YY_BREAK
-case 26:
-YY_RULE_SETUP
-#line 132 "scanner.l"
-return XKB_LAYOUT;
-	YY_BREAK
-case 27:
-YY_RULE_SETUP
-#line 133 "scanner.l"
-return INCLUDE;
-	YY_BREAK
-case 28:
-YY_RULE_SETUP
-#line 134 "scanner.l"
-return OVERRIDE;
-	YY_BREAK
-case 29:
-YY_RULE_SETUP
-#line 135 "scanner.l"
-return AUGMENT;
-	YY_BREAK
-case 30:
-YY_RULE_SETUP
-#line 136 "scanner.l"
-return REPLACE;
-	YY_BREAK
-case 31:
-YY_RULE_SETUP
-#line 137 "scanner.l"
-return ALTERNATE;
-	YY_BREAK
-case 32:
-YY_RULE_SETUP
-#line 138 "scanner.l"
-return PARTIAL;
-	YY_BREAK
-case 33:
-YY_RULE_SETUP
-#line 139 "scanner.l"
-return DEFAULT;
-	YY_BREAK
-case 34:
-YY_RULE_SETUP
-#line 140 "scanner.l"
-return HIDDEN;
-	YY_BREAK
-case 35:
-YY_RULE_SETUP
-#line 141 "scanner.l"
-return VIRTUAL_MODS;
-	YY_BREAK
-case 36:
-YY_RULE_SETUP
-#line 142 "scanner.l"
-return TYPE;
-	YY_BREAK
-case 37:
-YY_RULE_SETUP
-#line 143 "scanner.l"
-return INTERPRET;
-	YY_BREAK
-case 38:
-YY_RULE_SETUP
-#line 144 "scanner.l"
-return ACTION_TOK;
-	YY_BREAK
-case 39:
-YY_RULE_SETUP
-#line 145 "scanner.l"
-return KEY;
-	YY_BREAK
-case 40:
-YY_RULE_SETUP
-#line 146 "scanner.l"
-return ALIAS;
-	YY_BREAK
-case 41:
-YY_RULE_SETUP
-#line 147 "scanner.l"
-return GROUP;
-	YY_BREAK
-case 42:
-YY_RULE_SETUP
-#line 148 "scanner.l"
-return MODIFIER_MAP;
-	YY_BREAK
-case 43:
-YY_RULE_SETUP
-#line 149 "scanner.l"
-return MODIFIER_MAP;
-	YY_BREAK
-case 44:
-YY_RULE_SETUP
-#line 150 "scanner.l"
-return MODIFIER_MAP;
-	YY_BREAK
-case 45:
-YY_RULE_SETUP
-#line 151 "scanner.l"
-return INDICATOR;
-	YY_BREAK
-case 46:
-YY_RULE_SETUP
-#line 152 "scanner.l"
-return SHAPE;
-	YY_BREAK
-case 47:
-YY_RULE_SETUP
-#line 153 "scanner.l"
-return ROW;
-	YY_BREAK
-case 48:
-YY_RULE_SETUP
-#line 154 "scanner.l"
-return KEYS;
-	YY_BREAK
-case 49:
-YY_RULE_SETUP
-#line 155 "scanner.l"
-return SECTION;
-	YY_BREAK
-case 50:
-YY_RULE_SETUP
-#line 156 "scanner.l"
-return OVERLAY;
-	YY_BREAK
-case 51:
-YY_RULE_SETUP
-#line 157 "scanner.l"
-return TEXT;
-	YY_BREAK
-case 52:
-YY_RULE_SETUP
-#line 158 "scanner.l"
-return OUTLINE;
-	YY_BREAK
-case 53:
-YY_RULE_SETUP
-#line 159 "scanner.l"
-return SOLID;
-	YY_BREAK
-case 54:
-YY_RULE_SETUP
-#line 160 "scanner.l"
-return LOGO;
-	YY_BREAK
-case 55:
-YY_RULE_SETUP
-#line 161 "scanner.l"
-return VIRTUAL;
-	YY_BREAK
-case 56:
-YY_RULE_SETUP
-#line 162 "scanner.l"
-return ALPHANUMERIC_KEYS;
-	YY_BREAK
-case 57:
-YY_RULE_SETUP
-#line 163 "scanner.l"
-return MODIFIER_KEYS;
-	YY_BREAK
-case 58:
-YY_RULE_SETUP
-#line 164 "scanner.l"
-return KEYPAD_KEYS;
-	YY_BREAK
-case 59:
-YY_RULE_SETUP
-#line 165 "scanner.l"
-return FUNCTION_KEYS;
-	YY_BREAK
-case 60:
-YY_RULE_SETUP
-#line 166 "scanner.l"
-return ALTERNATE_GROUP;
-	YY_BREAK
-case 61:
-YY_RULE_SETUP
-#line 168 "scanner.l"
-yylval->str = strdup(yytext); return IDENT;
-	YY_BREAK
-case 62:
-#line 171 "scanner.l"
-case 63:
-YY_RULE_SETUP
-#line 171 "scanner.l"
-{
-                            char *end;
-                            yylval->num = strtoul(yytext, &end, 0);
-
-                            return INTEGER;
-                        }
-	YY_BREAK
-case 64:
-YY_RULE_SETUP
-#line 177 "scanner.l"
-{
-                            char *end;
-                            yylval->num = strtod(yytext, &end);
-
-                            return FLOAT;
-                        }
-	YY_BREAK
-case 65:
-YY_RULE_SETUP
-#line 184 "scanner.l"
-return EQUALS;
-	YY_BREAK
-case 66:
-YY_RULE_SETUP
-#line 185 "scanner.l"
-return PLUS;
-	YY_BREAK
-case 67:
-YY_RULE_SETUP
-#line 186 "scanner.l"
-return MINUS;
-	YY_BREAK
-case 68:
-YY_RULE_SETUP
-#line 187 "scanner.l"
-return DIVIDE;
-	YY_BREAK
-case 69:
-YY_RULE_SETUP
-#line 188 "scanner.l"
-return TIMES;
-	YY_BREAK
-case 70:
-YY_RULE_SETUP
-#line 189 "scanner.l"
-return OBRACE;
-	YY_BREAK
-case 71:
-YY_RULE_SETUP
-#line 190 "scanner.l"
-return CBRACE;
-	YY_BREAK
-case 72:
-YY_RULE_SETUP
-#line 191 "scanner.l"
-return OPAREN;
-	YY_BREAK
-case 73:
-YY_RULE_SETUP
-#line 192 "scanner.l"
-return CPAREN;
-	YY_BREAK
-case 74:
-YY_RULE_SETUP
-#line 193 "scanner.l"
-return OBRACKET;
-	YY_BREAK
-case 75:
-YY_RULE_SETUP
-#line 194 "scanner.l"
-return CBRACKET;
-	YY_BREAK
-case 76:
-YY_RULE_SETUP
-#line 195 "scanner.l"
-return DOT;
-	YY_BREAK
-case 77:
-YY_RULE_SETUP
-#line 196 "scanner.l"
-return COMMA;
-	YY_BREAK
-case 78:
-YY_RULE_SETUP
-#line 197 "scanner.l"
-return SEMI;
-	YY_BREAK
-case 79:
-YY_RULE_SETUP
-#line 198 "scanner.l"
-return EXCLAM;
-	YY_BREAK
-case 80:
-YY_RULE_SETUP
-#line 199 "scanner.l"
-return INVERT;
-	YY_BREAK
-case 81:
-/* rule 81 can match eol */
-YY_RULE_SETUP
-#line 201 "scanner.l"
-
-	YY_BREAK
-case YY_STATE_EOF(INITIAL):
-case YY_STATE_EOF(S_STR):
-#line 203 "scanner.l"
-return END_OF_FILE;
-	YY_BREAK
-case 82:
-YY_RULE_SETUP
-#line 205 "scanner.l"
-return ERROR_TOK;
-	YY_BREAK
-case 83:
-YY_RULE_SETUP
-#line 207 "scanner.l"
-ECHO;
-	YY_BREAK
-#line 1600 "src/xkbcomp/scanner.c"
-
-	case YY_END_OF_BUFFER:
-		{
-		/* Amount of text matched not including the EOB char. */
-		int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
-
-		/* Undo the effects of YY_DO_BEFORE_ACTION. */
-		*yy_cp = yyg->yy_hold_char;
-		YY_RESTORE_YY_MORE_OFFSET
-
-		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
-			{
-			/* We're scanning a new file or input source.  It's
-			 * possible that this happened because the user
-			 * just pointed yyin at a new source and called
-			 * _xkbcommon_lex().  If so, then we have to assure
-			 * consistency between YY_CURRENT_BUFFER and our
-			 * globals.  Here is the right place to do so, because
-			 * this is the first action (other than possibly a
-			 * back-up) that will match for the new input source.
-			 */
-			yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
-			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
-			}
-
-		/* Note that here we test for yy_c_buf_p "<=" to the position
-		 * of the first EOB in the buffer, since yy_c_buf_p will
-		 * already have been incremented past the NUL character
-		 * (since all states make transitions on EOB to the
-		 * end-of-buffer state).  Contrast this with the test
-		 * in input().
-		 */
-		if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
-			{ /* This was really a NUL. */
-			yy_state_type yy_next_state;
-
-			yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
-
-			yy_current_state = yy_get_previous_state( yyscanner );
-
-			/* Okay, we're now positioned to make the NUL
-			 * transition.  We couldn't have
-			 * yy_get_previous_state() go ahead and do it
-			 * for us because it doesn't know how to deal
-			 * with the possibility of jamming (and we don't
-			 * want to build jamming into it because then it
-			 * will run more slowly).
-			 */
-
-			yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
-
-			yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
-
-			if ( yy_next_state )
-				{
-				/* Consume the NUL. */
-				yy_cp = ++yyg->yy_c_buf_p;
-				yy_current_state = yy_next_state;
-				goto yy_match;
-				}
-
-			else
-				{
-				yy_cp = yyg->yy_last_accepting_cpos;
-				yy_current_state = yyg->yy_last_accepting_state;
-				goto yy_find_action;
-				}
-			}
-
-		else switch ( yy_get_next_buffer( yyscanner ) )
-			{
-			case EOB_ACT_END_OF_FILE:
-				{
-				yyg->yy_did_buffer_switch_on_eof = 0;
-
-				if ( _xkbcommon_wrap(yyscanner ) )
-					{
-					/* Note: because we've taken care in
-					 * yy_get_next_buffer() to have set up
-					 * yytext, we can now set up
-					 * yy_c_buf_p so that if some total
-					 * hoser (like flex itself) wants to
-					 * call the scanner after we return the
-					 * YY_NULL, it'll still work - another
-					 * YY_NULL will get returned.
-					 */
-					yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
-
-					yy_act = YY_STATE_EOF(YY_START);
-					goto do_action;
-					}
-
-				else
-					{
-					if ( ! yyg->yy_did_buffer_switch_on_eof )
-						YY_NEW_FILE;
-					}
-				break;
-				}
-
-			case EOB_ACT_CONTINUE_SCAN:
-				yyg->yy_c_buf_p =
-					yyg->yytext_ptr + yy_amount_of_matched_text;
-
-				yy_current_state = yy_get_previous_state( yyscanner );
-
-				yy_cp = yyg->yy_c_buf_p;
-				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
-				goto yy_match;
-
-			case EOB_ACT_LAST_MATCH:
-				yyg->yy_c_buf_p =
-				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
-
-				yy_current_state = yy_get_previous_state( yyscanner );
-
-				yy_cp = yyg->yy_c_buf_p;
-				yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
-				goto yy_find_action;
-			}
-		break;
-		}
-
-	default:
-		YY_FATAL_ERROR(
-			"fatal flex scanner internal error--no action found" );
-	} /* end of action switch */
-		} /* end of scanning one token */
-} /* end of _xkbcommon_lex */
-
-/* yy_get_next_buffer - try to read in a new buffer
- *
- * Returns a code representing an action:
- *	EOB_ACT_LAST_MATCH -
- *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
- *	EOB_ACT_END_OF_FILE - end of file
- */
-static int yy_get_next_buffer (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
-	register char *source = yyg->yytext_ptr;
-	register int number_to_move, i;
-	int ret_val;
-
-	if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
-		YY_FATAL_ERROR(
-		"fatal flex scanner internal error--end of buffer missed" );
-
-	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
-		{ /* Don't try to fill the buffer, so this is an EOF. */
-		if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
-			{
-			/* We matched a single character, the EOB, so
-			 * treat this as a final EOF.
-			 */
-			return EOB_ACT_END_OF_FILE;
-			}
-
-		else
-			{
-			/* We matched some text prior to the EOB, first
-			 * process it.
-			 */
-			return EOB_ACT_LAST_MATCH;
-			}
-		}
-
-	/* Try to read more data. */
-
-	/* First move last chars to start of buffer. */
-	number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
-
-	for ( i = 0; i < number_to_move; ++i )
-		*(dest++) = *(source++);
-
-	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
-		/* don't do the read, it's not guaranteed to return an EOF,
-		 * just force an EOF
-		 */
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
-
-	else
-		{
-			int num_to_read =
-			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
-
-		while ( num_to_read <= 0 )
-			{ /* Not enough room in the buffer - grow it. */
-
-			/* just a shorter name for the current buffer */
-			YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
-
-			int yy_c_buf_p_offset =
-				(int) (yyg->yy_c_buf_p - b->yy_ch_buf);
-
-			if ( b->yy_is_our_buffer )
-				{
-				int new_size = b->yy_buf_size * 2;
-
-				if ( new_size <= 0 )
-					b->yy_buf_size += b->yy_buf_size / 8;
-				else
-					b->yy_buf_size *= 2;
-
-				b->yy_ch_buf = (char *)
-					/* Include room in for 2 EOB chars. */
-					_xkbcommon_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
-				}
-			else
-				/* Can't grow it, we don't own it. */
-				b->yy_ch_buf = 0;
-
-			if ( ! b->yy_ch_buf )
-				YY_FATAL_ERROR(
-				"fatal error - scanner input buffer overflow" );
-
-			yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
-
-			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
-						number_to_move - 1;
-
-			}
-
-		if ( num_to_read > YY_READ_BUF_SIZE )
-			num_to_read = YY_READ_BUF_SIZE;
-
-		/* Read in more data. */
-		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-			yyg->yy_n_chars, (size_t) num_to_read );
-
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
-		}
-
-	if ( yyg->yy_n_chars == 0 )
-		{
-		if ( number_to_move == YY_MORE_ADJ )
-			{
-			ret_val = EOB_ACT_END_OF_FILE;
-			_xkbcommon_restart(yyin  ,yyscanner);
-			}
-
-		else
-			{
-			ret_val = EOB_ACT_LAST_MATCH;
-			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
-				YY_BUFFER_EOF_PENDING;
-			}
-		}
-
-	else
-		ret_val = EOB_ACT_CONTINUE_SCAN;
-
-	if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
-		/* Extend the array by 50%, plus the number we really need. */
-		yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
-		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) _xkbcommon_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
-		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
-			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
-	}
-
-	yyg->yy_n_chars += number_to_move;
-	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
-	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
-
-	yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
-
-	return ret_val;
-}
-
-/* yy_get_previous_state - get the state just before the EOB char was reached */
-
-    static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
-{
-	register yy_state_type yy_current_state;
-	register char *yy_cp;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	yy_current_state = yyg->yy_start;
-
-	for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
-		{
-		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
-		if ( yy_accept[yy_current_state] )
-			{
-			yyg->yy_last_accepting_state = yy_current_state;
-			yyg->yy_last_accepting_cpos = yy_cp;
-			}
-		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-			{
-			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 336 )
-				yy_c = yy_meta[(unsigned int) yy_c];
-			}
-		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-		}
-
-	return yy_current_state;
-}
-
-/* yy_try_NUL_trans - try to make a transition on the NUL character
- *
- * synopsis
- *	next_state = yy_try_NUL_trans( current_state );
- */
-    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
-{
-	register int yy_is_jam;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
-	register char *yy_cp = yyg->yy_c_buf_p;
-
-	register YY_CHAR yy_c = 1;
-	if ( yy_accept[yy_current_state] )
-		{
-		yyg->yy_last_accepting_state = yy_current_state;
-		yyg->yy_last_accepting_cpos = yy_cp;
-		}
-	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-		{
-		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 336 )
-			yy_c = yy_meta[(unsigned int) yy_c];
-		}
-	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-	yy_is_jam = (yy_current_state == 335);
-
-	return yy_is_jam ? 0 : yy_current_state;
-}
-
-#ifndef YY_NO_INPUT
-#ifdef __cplusplus
-    static int yyinput (yyscan_t yyscanner)
-#else
-    static int input  (yyscan_t yyscanner)
-#endif
-
-{
-	int c;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	*yyg->yy_c_buf_p = yyg->yy_hold_char;
-
-	if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
-		{
-		/* yy_c_buf_p now points to the character we want to return.
-		 * If this occurs *before* the EOB characters, then it's a
-		 * valid NUL; if not, then we've hit the end of the buffer.
-		 */
-		if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
-			/* This was really a NUL. */
-			*yyg->yy_c_buf_p = '\0';
-
-		else
-			{ /* need more input */
-			int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
-			++yyg->yy_c_buf_p;
-
-			switch ( yy_get_next_buffer( yyscanner ) )
-				{
-				case EOB_ACT_LAST_MATCH:
-					/* This happens because yy_g_n_b()
-					 * sees that we've accumulated a
-					 * token and flags that we need to
-					 * try matching the token before
-					 * proceeding.  But for input(),
-					 * there's no matching to consider.
-					 * So convert the EOB_ACT_LAST_MATCH
-					 * to EOB_ACT_END_OF_FILE.
-					 */
-
-					/* Reset buffer status. */
-					_xkbcommon_restart(yyin ,yyscanner);
-
-					/*FALLTHROUGH*/
-
-				case EOB_ACT_END_OF_FILE:
-					{
-					if ( _xkbcommon_wrap(yyscanner ) )
-						return EOF;
-
-					if ( ! yyg->yy_did_buffer_switch_on_eof )
-						YY_NEW_FILE;
-#ifdef __cplusplus
-					return yyinput(yyscanner);
-#else
-					return input(yyscanner);
-#endif
-					}
-
-				case EOB_ACT_CONTINUE_SCAN:
-					yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
-					break;
-				}
-			}
-		}
-
-	c = *(unsigned char *) yyg->yy_c_buf_p;	/* cast for 8-bit char's */
-	*yyg->yy_c_buf_p = '\0';	/* preserve yytext */
-	yyg->yy_hold_char = *++yyg->yy_c_buf_p;
-
-	if ( c == '\n' )
-		   
-    do{ yylineno++;
-        yycolumn=0;
-    }while(0)
-;
-
-	return c;
-}
-#endif	/* ifndef YY_NO_INPUT */
-
-/** Immediately switch to a different input stream.
- * @param input_file A readable stream.
- * @param yyscanner The scanner object.
- * @note This function does not reset the start condition to @c INITIAL .
- */
-    void _xkbcommon_restart  (FILE * input_file , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	if ( ! YY_CURRENT_BUFFER ){
-        _xkbcommon_ensure_buffer_stack (yyscanner);
-		YY_CURRENT_BUFFER_LVALUE =
-            _xkbcommon__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
-	}
-
-	_xkbcommon__init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
-	_xkbcommon__load_buffer_state(yyscanner );
-}
-
-/** Switch to a different input buffer.
- * @param new_buffer The new input buffer.
- * @param yyscanner The scanner object.
- */
-    void _xkbcommon__switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
+scanner_log(enum xkb_log_level level, struct scanner *s, const char *msg)
 {
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	/* TODO. We should be able to replace this entire function body
-	 * with
-	 *		_xkbcommon_pop_buffer_state();
-	 *		_xkbcommon_push_buffer_state(new_buffer);
-     */
-	_xkbcommon_ensure_buffer_stack (yyscanner);
-	if ( YY_CURRENT_BUFFER == new_buffer )
-		return;
-
-	if ( YY_CURRENT_BUFFER )
-		{
-		/* Flush out information for old buffer. */
-		*yyg->yy_c_buf_p = yyg->yy_hold_char;
-		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
-		}
-
-	YY_CURRENT_BUFFER_LVALUE = new_buffer;
-	_xkbcommon__load_buffer_state(yyscanner );
-
-	/* We don't actually know whether we did this switch during
-	 * EOF (_xkbcommon_wrap()) processing, but the only time this flag
-	 * is looked at is after _xkbcommon_wrap() is called, so it's safe
-	 * to go ahead and always set it.
-	 */
-	yyg->yy_did_buffer_switch_on_eof = 1;
+    xkb_log(s->ctx, level, 0,  "%s:%d:%d: %s\n", s->file_name,
+            s->token_line, s->token_column, msg);
 }
 
-static void _xkbcommon__load_buffer_state  (yyscan_t yyscanner)
+int
+scanner_error(struct scanner *s, const char *msg)
 {
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-	yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
-	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
-	yyg->yy_hold_char = *yyg->yy_c_buf_p;
+    scanner_log(XKB_LOG_LEVEL_ERROR, s, msg);
+    return ERROR_TOK;
 }
 
-/** Allocate and initialize an input buffer state.
- * @param file A readable stream.
- * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
- * @param yyscanner The scanner object.
- * @return the allocated buffer state.
- */
-    YY_BUFFER_STATE _xkbcommon__create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
-{
-	YY_BUFFER_STATE b;
-    
-	b = (YY_BUFFER_STATE) _xkbcommon_alloc(sizeof( struct yy_buffer_state ) ,yyscanner );
-	if ( ! b )
-		YY_FATAL_ERROR( "out of dynamic memory in _xkbcommon__create_buffer()" );
-
-	b->yy_buf_size = size;
-
-	/* yy_ch_buf has to be 2 characters longer than the size given because
-	 * we need to put in 2 end-of-buffer characters.
-	 */
-	b->yy_ch_buf = (char *) _xkbcommon_alloc(b->yy_buf_size + 2 ,yyscanner );
-	if ( ! b->yy_ch_buf )
-		YY_FATAL_ERROR( "out of dynamic memory in _xkbcommon__create_buffer()" );
-
-	b->yy_is_our_buffer = 1;
-
-	_xkbcommon__init_buffer(b,file ,yyscanner);
-
-	return b;
-}
-
-/** Destroy the buffer.
- * @param b a buffer created with _xkbcommon__create_buffer()
- * @param yyscanner The scanner object.
- */
-    void _xkbcommon__delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
+void
+scanner_warn(struct scanner *s, const char *msg)
 {
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	if ( ! b )
-		return;
-
-	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
-		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
-
-	if ( b->yy_is_our_buffer )
-		_xkbcommon_free((void *) b->yy_ch_buf ,yyscanner );
-
-	_xkbcommon_free((void *) b ,yyscanner );
+    scanner_log(XKB_LOG_LEVEL_WARNING, s, msg);
 }
 
-/* Initializes or reinitializes a buffer.
- * This function is sometimes called more than once on the same buffer,
- * such as during a _xkbcommon_restart() or at EOF.
- */
-    static void _xkbcommon__init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
-
+static bool
+number(struct scanner *s, int64_t *out, int *out_tok)
 {
-	int oerrno = errno;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	_xkbcommon__flush_buffer(b ,yyscanner);
+    bool is_float = false, is_hex = false;
+    const char *start = s->s + s->pos;
+    char *end;
 
-	b->yy_input_file = file;
-	b->yy_fill_buffer = 1;
-
-    /* If b is the current buffer, then _xkbcommon__init_buffer was _probably_
-     * called from _xkbcommon_restart() or through yy_get_next_buffer.
-     * In that case, we don't want to reset the lineno or column.
-     */
-    if (b != YY_CURRENT_BUFFER){
-        b->yy_bs_lineno = 1;
-        b->yy_bs_column = 0;
+    if (lit(s, "0x")) {
+        while (is_xdigit(peek(s))) next(s);
+        is_hex = true;
     }
+    else {
+        while (is_digit(peek(s))) next(s);
+        is_float = chr(s, '.');
+        while (is_digit(peek(s))) next(s);
+    }
+    if (s->s + s->pos == start)
+        return false;
 
-        b->yy_is_interactive = 0;
-    
-	errno = oerrno;
-}
-
-/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
- * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
- * @param yyscanner The scanner object.
- */
-    void _xkbcommon__flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	if ( ! b )
-		return;
-
-	b->yy_n_chars = 0;
-
-	/* We always need two end-of-buffer characters.  The first causes
-	 * a transition to the end-of-buffer state.  The second causes
-	 * a jam in that state.
-	 */
-	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
-	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
-
-	b->yy_buf_pos = &b->yy_ch_buf[0];
-
-	b->yy_at_bol = 1;
-	b->yy_buffer_status = YY_BUFFER_NEW;
-
-	if ( b == YY_CURRENT_BUFFER )
-		_xkbcommon__load_buffer_state(yyscanner );
-}
-
-/** Pushes the new state onto the stack. The new state becomes
- *  the current state. This function will allocate the stack
- *  if necessary.
- *  @param new_buffer The new state.
- *  @param yyscanner The scanner object.
- */
-void _xkbcommon_push_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	if (new_buffer == NULL)
-		return;
-
-	_xkbcommon_ensure_buffer_stack(yyscanner);
-
-	/* This block is copied from _xkbcommon__switch_to_buffer. */
-	if ( YY_CURRENT_BUFFER )
-		{
-		/* Flush out information for old buffer. */
-		*yyg->yy_c_buf_p = yyg->yy_hold_char;
-		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
-		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
-		}
-
-	/* Only push if top exists. Otherwise, replace top. */
-	if (YY_CURRENT_BUFFER)
-		yyg->yy_buffer_stack_top++;
-	YY_CURRENT_BUFFER_LVALUE = new_buffer;
-
-	/* copied from _xkbcommon__switch_to_buffer. */
-	_xkbcommon__load_buffer_state(yyscanner );
-	yyg->yy_did_buffer_switch_on_eof = 1;
-}
-
-/** Removes and deletes the top of the stack, if present.
- *  The next element becomes the new top.
- *  @param yyscanner The scanner object.
- */
-void _xkbcommon_pop_buffer_state (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-	if (!YY_CURRENT_BUFFER)
-		return;
-
-	_xkbcommon__delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
-	YY_CURRENT_BUFFER_LVALUE = NULL;
-	if (yyg->yy_buffer_stack_top > 0)
-		--yyg->yy_buffer_stack_top;
-
-	if (YY_CURRENT_BUFFER) {
-		_xkbcommon__load_buffer_state(yyscanner );
-		yyg->yy_did_buffer_switch_on_eof = 1;
-	}
-}
-
-/* Allocates the stack if it does not exist.
- *  Guarantees space for at least one push.
- */
-static void _xkbcommon_ensure_buffer_stack (yyscan_t yyscanner)
-{
-	int num_to_alloc;
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-	if (!yyg->yy_buffer_stack) {
-
-		/* First allocation is just for 2 elements, since we don't know if this
-		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
-		 * immediate realloc on the next call.
-         */
-		num_to_alloc = 1;
-		yyg->yy_buffer_stack = (struct yy_buffer_state**)_xkbcommon_alloc
-								(num_to_alloc * sizeof(struct yy_buffer_state*)
-								, yyscanner);
-		if ( ! yyg->yy_buffer_stack )
-			YY_FATAL_ERROR( "out of dynamic memory in _xkbcommon_ensure_buffer_stack()" );
-								  
-		memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
-				
-		yyg->yy_buffer_stack_max = num_to_alloc;
-		yyg->yy_buffer_stack_top = 0;
-		return;
-	}
-
-	if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
-
-		/* Increase the buffer to prepare for a possible push. */
-		int grow_size = 8 /* arbitrary grow size */;
-
-		num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
-		yyg->yy_buffer_stack = (struct yy_buffer_state**)_xkbcommon_realloc
-								(yyg->yy_buffer_stack,
-								num_to_alloc * sizeof(struct yy_buffer_state*)
-								, yyscanner);
-		if ( ! yyg->yy_buffer_stack )
-			YY_FATAL_ERROR( "out of dynamic memory in _xkbcommon_ensure_buffer_stack()" );
-
-		/* zero only the new slots.*/
-		memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
-		yyg->yy_buffer_stack_max = num_to_alloc;
-	}
-}
-
-/** Setup the input buffer state to scan directly from a user-specified character buffer.
- * @param base the character buffer
- * @param size the size in bytes of the character buffer
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object. 
- */
-YY_BUFFER_STATE _xkbcommon__scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
-{
-	YY_BUFFER_STATE b;
-    
-	if ( size < 2 ||
-	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
-	     base[size-1] != YY_END_OF_BUFFER_CHAR )
-		/* They forgot to leave room for the EOB's. */
-		return 0;
-
-	b = (YY_BUFFER_STATE) _xkbcommon_alloc(sizeof( struct yy_buffer_state ) ,yyscanner );
-	if ( ! b )
-		YY_FATAL_ERROR( "out of dynamic memory in _xkbcommon__scan_buffer()" );
-
-	b->yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
-	b->yy_buf_pos = b->yy_ch_buf = base;
-	b->yy_is_our_buffer = 0;
-	b->yy_input_file = 0;
-	b->yy_n_chars = b->yy_buf_size;
-	b->yy_is_interactive = 0;
-	b->yy_at_bol = 1;
-	b->yy_fill_buffer = 0;
-	b->yy_buffer_status = YY_BUFFER_NEW;
-
-	_xkbcommon__switch_to_buffer(b ,yyscanner );
-
-	return b;
-}
-
-/** Setup the input buffer state to scan a string. The next call to _xkbcommon_lex() will
- * scan from a @e copy of @a str.
- * @param yystr a NUL-terminated string to scan
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object.
- * @note If you want to scan bytes that may contain NUL values, then use
- *       _xkbcommon__scan_bytes() instead.
- */
-YY_BUFFER_STATE _xkbcommon__scan_string (yyconst char * yystr , yyscan_t yyscanner)
-{
-    
-	return _xkbcommon__scan_bytes(yystr,strlen(yystr) ,yyscanner);
-}
-
-/** Setup the input buffer state to scan the given bytes. The next call to _xkbcommon_lex() will
- * scan from a @e copy of @a bytes.
- * @param yybytes the byte buffer to scan
- * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
- * @param yyscanner The scanner object.
- * @return the newly allocated buffer state object.
- */
-YY_BUFFER_STATE _xkbcommon__scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
-{
-	YY_BUFFER_STATE b;
-	char *buf;
-	yy_size_t n;
-	int i;
-    
-	/* Get memory for full buffer, including space for trailing EOB's. */
-	n = _yybytes_len + 2;
-	buf = (char *) _xkbcommon_alloc(n ,yyscanner );
-	if ( ! buf )
-		YY_FATAL_ERROR( "out of dynamic memory in _xkbcommon__scan_bytes()" );
-
-	for ( i = 0; i < _yybytes_len; ++i )
-		buf[i] = yybytes[i];
-
-	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
-
-	b = _xkbcommon__scan_buffer(buf,n ,yyscanner);
-	if ( ! b )
-		YY_FATAL_ERROR( "bad buffer in _xkbcommon__scan_bytes()" );
-
-	/* It's okay to grow etc. this buffer, and we should throw it
-	 * away when we're done.
-	 */
-	b->yy_is_our_buffer = 1;
-
-	return b;
-}
-
-#ifndef YY_EXIT_FAILURE
-#define YY_EXIT_FAILURE 2
-#endif
-
-static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
-{
-    	(void) fprintf( stderr, "%s\n", msg );
-	exit( YY_EXIT_FAILURE );
-}
-
-/* Redefine yyless() so it works in section 3 code. */
-
-#undef yyless
-#define yyless(n) \
-	do \
-		{ \
-		/* Undo effects of setting up yytext. */ \
-        int yyless_macro_arg = (n); \
-        YY_LESS_LINENO(yyless_macro_arg);\
-		yytext[yyleng] = yyg->yy_hold_char; \
-		yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
-		yyg->yy_hold_char = *yyg->yy_c_buf_p; \
-		*yyg->yy_c_buf_p = '\0'; \
-		yyleng = yyless_macro_arg; \
-		} \
-	while ( 0 )
-
-/* Accessor  methods (get/set functions) to struct members. */
-
-/** Get the user-defined data for this scanner.
- * @param yyscanner The scanner object.
- */
-YY_EXTRA_TYPE _xkbcommon_get_extra  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yyextra;
-}
-
-/** Get the current line number.
- * @param yyscanner The scanner object.
- */
-int _xkbcommon_get_lineno  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    
-        if (! YY_CURRENT_BUFFER)
-            return 0;
-    
-    return yylineno;
-}
-
-/** Get the current column number.
- * @param yyscanner The scanner object.
- */
-int _xkbcommon_get_column  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    
-        if (! YY_CURRENT_BUFFER)
-            return 0;
-    
-    return yycolumn;
-}
-
-/** Get the input stream.
- * @param yyscanner The scanner object.
- */
-FILE *_xkbcommon_get_in  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yyin;
-}
-
-/** Get the output stream.
- * @param yyscanner The scanner object.
- */
-FILE *_xkbcommon_get_out  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yyout;
-}
-
-/** Get the length of the current token.
- * @param yyscanner The scanner object.
- */
-int _xkbcommon_get_leng  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yyleng;
-}
-
-/** Get the current token.
- * @param yyscanner The scanner object.
- */
-
-char *_xkbcommon_get_text  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yytext;
-}
-
-/** Set the user-defined data. This data is never touched by the scanner.
- * @param user_defined The data to be associated with this scanner.
- * @param yyscanner The scanner object.
- */
-void _xkbcommon_set_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yyextra = user_defined ;
-}
-
-/** Set the current line number.
- * @param line_number
- * @param yyscanner The scanner object.
- */
-void _xkbcommon_set_lineno (int  line_number , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-        /* lineno is only valid if an input buffer exists. */
-        if (! YY_CURRENT_BUFFER )
-           yy_fatal_error( "_xkbcommon_set_lineno called with no buffer" , yyscanner); 
-    
-    yylineno = line_number;
-}
-
-/** Set the current column.
- * @param line_number
- * @param yyscanner The scanner object.
- */
-void _xkbcommon_set_column (int  column_no , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-        /* column is only valid if an input buffer exists. */
-        if (! YY_CURRENT_BUFFER )
-           yy_fatal_error( "_xkbcommon_set_column called with no buffer" , yyscanner); 
-    
-    yycolumn = column_no;
-}
-
-/** Set the input stream. This does not discard the current
- * input buffer.
- * @param in_str A readable stream.
- * @param yyscanner The scanner object.
- * @see _xkbcommon__switch_to_buffer
- */
-void _xkbcommon_set_in (FILE *  in_str , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yyin = in_str ;
-}
-
-void _xkbcommon_set_out (FILE *  out_str , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yyout = out_str ;
-}
-
-int _xkbcommon_get_debug  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yy_flex_debug;
-}
-
-void _xkbcommon_set_debug (int  bdebug , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yy_flex_debug = bdebug ;
-}
-
-/* Accessor methods for yylval and yylloc */
-
-YYSTYPE * _xkbcommon_get_lval  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yylval;
-}
-
-void _xkbcommon_set_lval (YYSTYPE *  yylval_param , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yylval = yylval_param;
+    errno = 0;
+    if (is_hex)
+        *out = strtoul(start, &end, 16);
+    else if (is_float)
+        *out = strtod(start, &end);
+    else
+        *out = strtoul(start, &end, 10);
+    if (errno != 0 || s->s + s->pos != end)
+        *out_tok = ERROR_TOK;
+    else
+        *out_tok = (is_float ? FLOAT : INTEGER);
+    return true;
 }
 
-YYLTYPE *_xkbcommon_get_lloc  (yyscan_t yyscanner)
+int
+_xkbcommon_lex(YYSTYPE *yylval, struct scanner *s)
 {
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    return yylloc;
-}
-    
-void _xkbcommon_set_lloc (YYLTYPE *  yylloc_param , yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    yylloc = yylloc_param;
-}
-    
-/* User-visible API */
+    int tok;
 
-/* _xkbcommon_lex_init is special because it creates the scanner itself, so it is
- * the ONLY reentrant function that doesn't take the scanner as the last argument.
- * That's why we explicitly handle the declaration, instead of using our macros.
- */
-
-int _xkbcommon_lex_init(yyscan_t* ptr_yy_globals)
+skip_more_whitespace_and_comments:
+    /* Skip spaces. */
+    while (is_space(peek(s))) next(s);
 
-{
-    if (ptr_yy_globals == NULL){
-        errno = EINVAL;
-        return 1;
+    /* Skip comments. */
+    if (lit(s, "//") || chr(s, '#')) {
+        while (!eof(s) && !eol(s)) next(s);
+        goto skip_more_whitespace_and_comments;
     }
 
-    *ptr_yy_globals = (yyscan_t) _xkbcommon_alloc ( sizeof( struct yyguts_t ), NULL );
-
-    if (*ptr_yy_globals == NULL){
-        errno = ENOMEM;
-        return 1;
+    /* See if we're done. */
+    if (eof(s)) return END_OF_FILE;
+
+    /* New token. */
+    s->token_line = s->line;
+    s->token_column = s->column;
+    s->buf_pos = 0;
+
+    /* String literal. */
+    if (chr(s, '\"')) {
+        while (!eof(s) && !eol(s) && peek(s) != '\"') {
+            if (chr(s, '\\')) {
+                uint8_t o;
+                if      (chr(s, '\\')) buf_append(s, '\\');
+                else if (chr(s, 'n'))  buf_append(s, '\n');
+                else if (chr(s, 't'))  buf_append(s, '\t');
+                else if (chr(s, 'r'))  buf_append(s, '\r');
+                else if (chr(s, 'b'))  buf_append(s, '\b');
+                else if (chr(s, 'f'))  buf_append(s, '\f');
+                else if (chr(s, 'v'))  buf_append(s, '\v');
+                else if (chr(s, 'e'))  buf_append(s, '\033');
+                else if (oct(s, &o))   buf_append(s, (char) o);
+                else {
+                    scanner_warn(s, "unknown escape sequence in string literal");
+                    /* Ignore. */
+                }
+            } else {
+                buf_append(s, next(s));
+            }
+        }
+        if (!buf_append(s, '\0') || !chr(s, '\"'))
+            return scanner_error(s, "unterminated string literal");
+        yylval->str = strdup(s->buf);
+        if (!yylval->str)
+            return scanner_error(s, "scanner out of memory");
+        return STRING;
     }
 
-    /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
-    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
-
-    return yy_init_globals ( *ptr_yy_globals );
-}
-
-/* _xkbcommon_lex_init_extra has the same functionality as _xkbcommon_lex_init, but follows the
- * convention of taking the scanner as the last argument. Note however, that
- * this is a *pointer* to a scanner, as it will be allocated by this call (and
- * is the reason, too, why this function also must handle its own declaration).
- * The user defined value in the first argument will be available to _xkbcommon_alloc in
- * the yyextra field.
- */
-
-int _xkbcommon_lex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
-
-{
-    struct yyguts_t dummy_yyguts;
-
-    _xkbcommon_set_extra (yy_user_defined, &dummy_yyguts);
-
-    if (ptr_yy_globals == NULL){
-        errno = EINVAL;
-        return 1;
+    /* Key name literal. */
+    if (chr(s, '<')) {
+        while (is_graph(peek(s)) && peek(s) != '>')
+            buf_append(s, next(s));
+        if (!buf_append(s, '\0') || !chr(s, '>'))
+            return scanner_error(s, "unterminated key name literal");
+        /* Empty key name literals are allowed. */
+        yylval->sval = xkb_atom_intern(s->ctx, s->buf, s->buf_pos - 1);
+        return KEYNAME;
     }
-	
-    *ptr_yy_globals = (yyscan_t) _xkbcommon_alloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
-	
-    if (*ptr_yy_globals == NULL){
-        errno = ENOMEM;
-        return 1;
-    }
-    
-    /* By setting to 0xAA, we expose bugs in
-    yy_init_globals. Leave at 0x00 for releases. */
-    memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
-    
-    _xkbcommon_set_extra (yy_user_defined, *ptr_yy_globals);
-    
-    return yy_init_globals ( *ptr_yy_globals );
-}
-
-static int yy_init_globals (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-    /* Initialization is the same as for the non-reentrant scanner.
-     * This function is called from _xkbcommon_lex_destroy(), so don't allocate here.
-     */
-
-    yyg->yy_buffer_stack = 0;
-    yyg->yy_buffer_stack_top = 0;
-    yyg->yy_buffer_stack_max = 0;
-    yyg->yy_c_buf_p = (char *) 0;
-    yyg->yy_init = 0;
-    yyg->yy_start = 0;
-
-    yyg->yy_start_stack_ptr = 0;
-    yyg->yy_start_stack_depth = 0;
-    yyg->yy_start_stack =  NULL;
-
-/* Defined in main.c */
-#ifdef YY_STDINIT
-    yyin = stdin;
-    yyout = stdout;
-#else
-    yyin = (FILE *) 0;
-    yyout = (FILE *) 0;
-#endif
-
-    /* For future reference: Set errno on error, since we are called by
-     * _xkbcommon_lex_init()
-     */
-    return 0;
-}
-
-/* _xkbcommon_lex_destroy is for both reentrant and non-reentrant scanners. */
-int _xkbcommon_lex_destroy  (yyscan_t yyscanner)
-{
-    struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
-
-    /* Pop the buffer stack, destroying each element. */
-	while(YY_CURRENT_BUFFER){
-		_xkbcommon__delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
-		YY_CURRENT_BUFFER_LVALUE = NULL;
-		_xkbcommon_pop_buffer_state(yyscanner);
-	}
-
-	/* Destroy the stack itself. */
-	_xkbcommon_free(yyg->yy_buffer_stack ,yyscanner);
-	yyg->yy_buffer_stack = NULL;
-
-    /* Destroy the start condition stack. */
-        _xkbcommon_free(yyg->yy_start_stack ,yyscanner );
-        yyg->yy_start_stack = NULL;
-
-    /* Reset the globals. This is important in a non-reentrant scanner so the next time
-     * _xkbcommon_lex() is called, initialization will occur. */
-    yy_init_globals( yyscanner);
-
-    /* Destroy the main struct (reentrant only). */
-    _xkbcommon_free ( yyscanner , yyscanner );
-    yyscanner = NULL;
-    return 0;
-}
 
-/*
- * Internal utility routines.
- */
-
-#ifndef yytext_ptr
-static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
-{
-	register int i;
-	for ( i = 0; i < n; ++i )
-		s1[i] = s2[i];
-}
-#endif
-
-#ifdef YY_NEED_STRLEN
-static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
-{
-	register int n;
-	for ( n = 0; s[n]; ++n )
-		;
-
-	return n;
-}
-#endif
-
-void *_xkbcommon_alloc (yy_size_t  size , yyscan_t yyscanner)
-{
-	return (void *) malloc( size );
-}
-
-void *_xkbcommon_realloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
-{
-	/* The cast to (char *) in the following accommodates both
-	 * implementations that use char* generic pointers, and those
-	 * that use void* generic pointers.  It works with the latter
-	 * because both ANSI C and C++ allow castless assignment from
-	 * any pointer type to void*, and deal with argument conversions
-	 * as though doing an assignment.
-	 */
-	return (void *) realloc( (char *) ptr, size );
-}
-
-void _xkbcommon_free (void * ptr , yyscan_t yyscanner)
-{
-	free( (char *) ptr );	/* see _xkbcommon_realloc() for (char *) cast */
-}
-
-#define YYTABLES_NAME "yytables"
-
-#line 207 "scanner.l"
-
-
-
-#pragma GCC diagnostic pop
-
-static void
-scanner_error_extra(struct YYLTYPE *loc, struct scanner_extra *extra,
-                    const char *msg)
-{
-    log_err(extra->ctx, "%s: line %d of %s\n", msg,
-            loc->first_line,
-            extra->file_name ? extra->file_name : "(unknown)");
-}
-
-void
-scanner_error(struct YYLTYPE *loc, void *scanner, const char *msg)
-{
-    struct scanner_extra *extra = _xkbcommon_get_extra(scanner);
-    scanner_error_extra(loc, extra, msg);
-}
-
-static bool
-init_scanner(yyscan_t *scanner, struct scanner_extra *extra,
-             struct xkb_context *ctx, const char *file_name)
-{
-    memset(extra, 0, sizeof(*extra));
-
-    if (_xkbcommon_lex_init_extra(extra,scanner) != 0)
-        return false;
-
-    extra->ctx = ctx;
-    extra->file_name = file_name;
-
-    return true;
-}
-
-static void
-clear_scanner(yyscan_t scanner)
-{
-    _xkbcommon_lex_destroy(scanner);
-}
-
-XkbFile *
-XkbParseString(struct xkb_context *ctx, const char *string,
-               const char *file_name)
-{
-    yyscan_t scanner;
-    struct scanner_extra extra;
-    YY_BUFFER_STATE state;
-    XkbFile *xkb_file;
-
-    if (!init_scanner(&scanner, &extra, ctx, file_name))
-        return NULL;
-
-    state = _xkbcommon__scan_string(string,scanner);
-
-    xkb_file = parse(ctx, scanner, NULL);
+    /* Operators and punctuation. */
+    if (chr(s, ';')) return SEMI;
+    if (chr(s, '{')) return OBRACE;
+    if (chr(s, '}')) return CBRACE;
+    if (chr(s, '=')) return EQUALS;
+    if (chr(s, '[')) return OBRACKET;
+    if (chr(s, ']')) return CBRACKET;
+    if (chr(s, '(')) return OPAREN;
+    if (chr(s, ')')) return CPAREN;
+    if (chr(s, '.')) return DOT;
+    if (chr(s, ',')) return COMMA;
+    if (chr(s, '+')) return PLUS;
+    if (chr(s, '-')) return MINUS;
+    if (chr(s, '*')) return TIMES;
+    if (chr(s, '/')) return DIVIDE;
+    if (chr(s, '!')) return EXCLAM;
+    if (chr(s, '~')) return INVERT;
+
+    /* Identifier. */
+    if (is_alpha(peek(s)) || peek(s) == '_') {
+        s->buf_pos = 0;
+        while (is_alnum(peek(s)) || peek(s) == '_')
+            buf_append(s, next(s));
+        if (!buf_append(s, '\0'))
+            return scanner_error(s, "identifier too long");
+
+        /* Keyword. */
+        tok = keyword_to_token(s->buf);
+        if (tok != -1) return tok;
+
+        yylval->str = strdup(s->buf);
+        if (!yylval->str)
+            return scanner_error(s, "scanner out of memory");
+        return IDENT;
+    }
 
-    _xkbcommon__delete_buffer(state,scanner);
-    clear_scanner(scanner);
+    /* Number literal (hexadecimal / decimal / float). */
+    if (number(s, &yylval->num, &tok)) {
+        if (tok == ERROR_TOK)
+            return scanner_error(s, "malformed number literal");
+        return tok;
+    }
 
-    return xkb_file;
+    return scanner_error(s, "unrecognized token");
 }
 
-/*
- * _xkbcommon__scan_buffer() requires the last two bytes of \buf to be 0. These two bytes
- * are not scanned. Other zero bytes in the buffer are scanned normally, though.
- * Due to these terminating zeroes, \length must be greater than 2.
- * Furthermore, the buffer must be writable and you cannot make any assumptions
- * about it after the scanner finished.
- * All this must be guaranteed by the caller of this function!
- */
 XkbFile *
-XkbParseBuffer(struct xkb_context *ctx, char *buf, size_t length,
-               const char *file_name)
+XkbParseString(struct xkb_context *ctx, const char *string, size_t len,
+               const char *file_name, const char *map)
 {
-    yyscan_t scanner;
-    struct scanner_extra extra;
-    YY_BUFFER_STATE state;
-    XkbFile *xkb_file;
-
-    if (!init_scanner(&scanner, &extra, ctx, file_name))
-        return NULL;
-
-    xkb_file = NULL;
-    state = _xkbcommon__scan_buffer(buf,length,scanner);
-    if (state) {
-        xkb_file = parse(ctx, scanner, NULL);
-        _xkbcommon__delete_buffer(state,scanner);
-    }
-
-    clear_scanner(scanner);
-
-    return xkb_file;
+    struct scanner scanner;
+    scanner_init(&scanner, ctx, string, len, file_name);
+    return parse(ctx, &scanner, map);
 }
 
 XkbFile *
 XkbParseFile(struct xkb_context *ctx, FILE *file,
              const char *file_name, const char *map)
 {
-    yyscan_t scanner;
-    struct scanner_extra extra;
-    YY_BUFFER_STATE state;
+    bool ok;
     XkbFile *xkb_file;
+    const char *string;
+    size_t size;
 
-    if (!init_scanner(&scanner, &extra, ctx, file_name))
+    ok = map_file(file, &string, &size);
+    if (!ok) {
+        log_err(ctx, "Couldn't read XKB file %s: %s\n",
+                file_name, strerror(errno));
         return NULL;
+    }
 
-    state = _xkbcommon__create_buffer(file,YY_BUF_SIZE,scanner);
-    _xkbcommon__switch_to_buffer(state,scanner);
-
-    xkb_file = parse(ctx, scanner, map);
-
-    _xkbcommon__delete_buffer(state,scanner);
-    clear_scanner(scanner);
-
+    xkb_file = XkbParseString(ctx, string, size, file_name, map);
+    unmap_file(string, size);
     return xkb_file;
 }
-
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/symbols.c b/src/3rdparty/xkbcommon/src/xkbcomp/symbols.c
index a2970f5004..56cce431da 100644
--- a/src/3rdparty/xkbcommon/src/xkbcomp/symbols.c
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/symbols.c
@@ -143,7 +143,7 @@ InitKeyInfo(struct xkb_context *ctx, KeyInfo *keyi)
 {
     memset(keyi, 0, sizeof(*keyi));
     keyi->merge = MERGE_OVERRIDE;
-    keyi->name = xkb_atom_intern(ctx, "*");
+    keyi->name = xkb_atom_intern_literal(ctx, "*");
     keyi->out_of_range_group_action = RANGE_WRAP;
 }
 
@@ -177,7 +177,7 @@ typedef struct {
     KeyInfo default_key;
     ActionsInfo *actions;
     darray(xkb_atom_t) group_names;
-    darray(ModMapEntry) modMaps;
+    darray(ModMapEntry) modmaps;
 
     struct xkb_keymap *keymap;
 } SymbolsInfo;
@@ -203,7 +203,7 @@ ClearSymbolsInfo(SymbolsInfo *info)
         ClearKeyInfo(keyi);
     darray_free(info->keys);
     darray_free(info->group_names);
-    darray_free(info->modMaps);
+    darray_free(info->modmaps);
     ClearKeyInfo(&info->default_key);
 }
 
@@ -437,7 +437,7 @@ AddModMapEntry(SymbolsInfo *info, ModMapEntry *new)
     ModMapEntry *old;
     bool clobber = (new->merge != MERGE_AUGMENT);
 
-    darray_foreach(old, info->modMaps) {
+    darray_foreach(old, info->modmaps) {
         xkb_mod_index_t use, ignore;
 
         if ((new->haveSymbol != old->haveSymbol) ||
@@ -470,7 +470,7 @@ AddModMapEntry(SymbolsInfo *info, ModMapEntry *new)
         return true;
     }
 
-    darray_append(info->modMaps, *new);
+    darray_append(info->modmaps, *new);
     return true;
 }
 
@@ -517,7 +517,7 @@ MergeIncludedSymbols(SymbolsInfo *into, SymbolsInfo *from,
             into->errorCount++;
     }
 
-    darray_foreach(mm, from->modMaps) {
+    darray_foreach(mm, from->modmaps) {
         mm->merge = (merge == MERGE_DEFAULT ? mm->merge : merge);
         if (!AddModMapEntry(into, mm))
             into->errorCount++;
@@ -626,30 +626,6 @@ GetGroupIndex(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
     return true;
 }
 
-bool
-LookupKeysym(const char *str, xkb_keysym_t *sym_rtrn)
-{
-    xkb_keysym_t sym;
-
-    if (!str || istreq(str, "any") || istreq(str, "nosymbol")) {
-        *sym_rtrn = XKB_KEY_NoSymbol;
-        return 1;
-    }
-
-    if (istreq(str, "none") || istreq(str, "voidsymbol")) {
-        *sym_rtrn = XKB_KEY_VoidSymbol;
-        return 1;
-    }
-
-    sym = xkb_keysym_from_name(str, 0);
-    if (sym != XKB_KEY_NoSymbol) {
-        *sym_rtrn = sym;
-        return 1;
-    }
-
-    return 0;
-}
-
 static bool
 AddSymbolsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
                 ExprDef *value)
@@ -670,11 +646,11 @@ AddSymbolsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
         return true;
     }
 
-    if (value->op != EXPR_KEYSYM_LIST) {
+    if (value->expr.op != EXPR_KEYSYM_LIST) {
         log_err(info->keymap->ctx,
                 "Expected a list of symbols, found %s; "
                 "Ignoring symbols for group %u of %s\n",
-                expr_op_type_to_string(value->op), ndx + 1,
+                expr_op_type_to_string(value->expr.op), ndx + 1,
                 KeyInfoText(info, keyi));
         return false;
     }
@@ -687,7 +663,7 @@ AddSymbolsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
         return false;
     }
 
-    nLevels = darray_size(value->value.list.symsMapIndex);
+    nLevels = darray_size(value->keysym_list.symsMapIndex);
     if (darray_size(groupi->levels) < nLevels)
         darray_resize0(groupi->levels, nLevels);
 
@@ -697,34 +673,14 @@ AddSymbolsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
         unsigned int sym_index;
         struct xkb_level *leveli = &darray_item(groupi->levels, i);
 
-        sym_index = darray_item(value->value.list.symsMapIndex, i);
-        leveli->num_syms = darray_item(value->value.list.symsNumEntries, i);
+        sym_index = darray_item(value->keysym_list.symsMapIndex, i);
+        leveli->num_syms = darray_item(value->keysym_list.symsNumEntries, i);
         if (leveli->num_syms > 1)
             leveli->u.syms = calloc(leveli->num_syms, sizeof(*leveli->u.syms));
 
         for (j = 0; j < leveli->num_syms; j++) {
-            char *sym_name = darray_item(value->value.list.syms,
-                                         sym_index + j);
-            xkb_keysym_t keysym;
-
-            if (!LookupKeysym(sym_name, &keysym)) {
-                const char *group_name = "unnamed";
-
-                if (ndx < darray_size(info->group_names) &&
-                    darray_item(info->group_names, ndx))
-                    group_name = xkb_atom_text(info->keymap->ctx,
-                                               darray_item(info->group_names,
-                                                           ndx));
-
-                log_warn(info->keymap->ctx,
-                         "Could not resolve keysym %s for key %s, group %u (%s), level %u\n",
-                         sym_name, KeyInfoText(info, keyi), ndx + 1,
-                         group_name, i);
-
-                ClearLevelInfo(leveli);
-                leveli->num_syms = 0;
-                break;
-            }
+            xkb_keysym_t keysym = darray_item(value->keysym_list.syms,
+                                              sym_index + j);
 
             if (leveli->num_syms == 1) {
                 if (keysym == XKB_KEY_NoSymbol)
@@ -750,7 +706,6 @@ AddActionsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
     GroupInfo *groupi;
     unsigned int nActs;
     ExprDef *act;
-    union xkb_action *toAct;
 
     if (!GetGroupIndex(info, keyi, arrayNdx, ACTIONS, &ndx))
         return false;
@@ -762,11 +717,11 @@ AddActionsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
         return true;
     }
 
-    if (value->op != EXPR_ACTION_LIST) {
+    if (value->expr.op != EXPR_ACTION_LIST) {
         log_wsgo(info->keymap->ctx,
                  "Bad expression type (%d) for action list value; "
                  "Ignoring actions for group %u of %s\n",
-                 value->op, ndx, KeyInfoText(info, keyi));
+                 value->expr.op, ndx, KeyInfoText(info, keyi));
         return false;
     }
 
@@ -778,7 +733,7 @@ AddActionsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
     }
 
     nActs = 0;
-    for (act = value->value.child; act; act = (ExprDef *) act->common.next)
+    for (act = value->unary.child; act; act = (ExprDef *) act->common.next)
         nActs++;
 
     if (darray_size(groupi->levels) < nActs)
@@ -786,9 +741,9 @@ AddActionsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
 
     groupi->defined |= GROUP_FIELD_ACTS;
 
-    act = value->value.child;
+    act = value->unary.child;
     for (i = 0; i < nActs; i++) {
-        toAct = &darray_item(groupi->levels, i).action;
+        union xkb_action *toAct = &darray_item(groupi->levels, i).action;
 
         if (!HandleActionDef(act, info->keymap, toAct, info->actions))
             log_err(info->keymap->ctx,
@@ -866,7 +821,7 @@ SetSymbolsField(SymbolsInfo *info, KeyInfo *keyi, const char *field,
             log_err(info->keymap->ctx,
                     "Expected a virtual modifier mask, found %s; "
                     "Ignoring virtual modifiers definition for key %s\n",
-                    expr_op_type_to_string(value->op),
+                    expr_op_type_to_string(value->expr.op),
                     KeyInfoText(info, keyi));
         }
     }
@@ -1082,7 +1037,7 @@ HandleSymbolsBody(SymbolsInfo *info, VarDef *def, KeyInfo *keyi)
     ExprDef *arrayNdx;
 
     for (; def; def = (VarDef *) def->common.next) {
-        if (def->name && def->name->op == EXPR_FIELD_REF) {
+        if (def->name && def->name->expr.op == EXPR_FIELD_REF) {
             log_err(info->keymap->ctx,
                     "Cannot set a global default value from within a key statement; "
                     "Move statements to the global file scope\n");
@@ -1090,7 +1045,7 @@ HandleSymbolsBody(SymbolsInfo *info, VarDef *def, KeyInfo *keyi)
         }
 
         if (!def->name) {
-            if (!def->value || def->value->op == EXPR_KEYSYM_LIST)
+            if (!def->value || def->value->expr.op == EXPR_KEYSYM_LIST)
                 field = "symbols";
             else
                 field = "actions";
@@ -1158,7 +1113,7 @@ HandleSymbolsDef(SymbolsInfo *info, SymbolsDef *stmt)
     keyi.merge = stmt->merge;
     keyi.name = stmt->keyName;
 
-    if (!HandleSymbolsBody(info, (VarDef *) stmt->symbols, &keyi)) {
+    if (!HandleSymbolsBody(info, stmt->symbols, &keyi)) {
         info->errorCount++;
         return false;
     }
@@ -1196,13 +1151,15 @@ HandleModMapDef(SymbolsInfo *info, ModMapDef *def)
 
     ok = true;
     tmp.modifier = ndx;
+    tmp.merge = def->merge;
 
     for (key = def->keys; key != NULL; key = (ExprDef *) key->common.next) {
         xkb_keysym_t sym;
 
-        if (key->op == EXPR_VALUE && key->value_type == EXPR_TYPE_KEYNAME) {
+        if (key->expr.op == EXPR_VALUE &&
+            key->expr.value_type == EXPR_TYPE_KEYNAME) {
             tmp.haveSymbol = false;
-            tmp.u.keyName = key->value.keyName;
+            tmp.u.keyName = key->key_name.key_name;
         }
         else if (ExprResolveKeySym(ctx, key, &sym)) {
             tmp.haveSymbol = true;
@@ -1248,7 +1205,7 @@ HandleSymbolsFile(SymbolsInfo *info, XkbFile *file, enum merge_mode merge)
             break;
         default:
             log_err(info->keymap->ctx,
-                    "Interpretation files may not include other types; "
+                    "Symbols files may not include other types; "
                     "Ignoring %s\n", stmt_type_to_string(stmt->type));
             ok = false;
             break;
@@ -1339,19 +1296,19 @@ FindAutomaticType(struct xkb_context *ctx, GroupInfo *groupi)
         darray_item(groupi->levels, level).u.syms[0])
 
     if (width == 1 || width <= 0)
-        return xkb_atom_intern(ctx, "ONE_LEVEL");
+        return xkb_atom_intern_literal(ctx, "ONE_LEVEL");
 
     sym0 = GET_SYM(0);
     sym1 = GET_SYM(1);
 
     if (width == 2) {
         if (xkb_keysym_is_lower(sym0) && xkb_keysym_is_upper(sym1))
-            return xkb_atom_intern(ctx, "ALPHABETIC");
+            return xkb_atom_intern_literal(ctx, "ALPHABETIC");
 
         if (xkb_keysym_is_keypad(sym0) || xkb_keysym_is_keypad(sym1))
-            return xkb_atom_intern(ctx, "KEYPAD");
+            return xkb_atom_intern_literal(ctx, "KEYPAD");
 
-        return xkb_atom_intern(ctx, "TWO_LEVEL");
+        return xkb_atom_intern_literal(ctx, "TWO_LEVEL");
     }
 
     if (width <= 4) {
@@ -1360,15 +1317,15 @@ FindAutomaticType(struct xkb_context *ctx, GroupInfo *groupi)
             sym3 = (width == 4 ? GET_SYM(3) : XKB_KEY_NoSymbol);
 
             if (xkb_keysym_is_lower(sym2) && xkb_keysym_is_upper(sym3))
-                return xkb_atom_intern(ctx, "FOUR_LEVEL_ALPHABETIC");
+                return xkb_atom_intern_literal(ctx, "FOUR_LEVEL_ALPHABETIC");
 
-            return xkb_atom_intern(ctx, "FOUR_LEVEL_SEMIALPHABETIC");
+            return xkb_atom_intern_literal(ctx, "FOUR_LEVEL_SEMIALPHABETIC");
         }
 
         if (xkb_keysym_is_keypad(sym0) || xkb_keysym_is_keypad(sym1))
-            return xkb_atom_intern(ctx, "FOUR_LEVEL_KEYPAD");
+            return xkb_atom_intern_literal(ctx, "FOUR_LEVEL_KEYPAD");
 
-        return xkb_atom_intern(ctx, "FOUR_LEVEL");
+        return xkb_atom_intern_literal(ctx, "FOUR_LEVEL");
     }
 
     return XKB_ATOM_NONE;
@@ -1570,9 +1527,9 @@ CopySymbolsToKeymap(struct xkb_keymap *keymap, SymbolsInfo *info)
 {
     KeyInfo *keyi;
     ModMapEntry *mm;
-    struct xkb_key *key;
 
     keymap->symbols_section_name = strdup_safe(info->name);
+    XkbEscapeMapName(keymap->symbols_section_name);
 
     keymap->num_group_names = darray_size(info->group_names);
     keymap->group_names = darray_mem(info->group_names, 0);
@@ -1583,6 +1540,8 @@ CopySymbolsToKeymap(struct xkb_keymap *keymap, SymbolsInfo *info)
             info->errorCount++;
 
     if (xkb_context_get_log_verbosity(keymap->ctx) > 3) {
+        struct xkb_key *key;
+
         xkb_foreach_key(key, keymap) {
             if (key->name == XKB_ATOM_NONE)
                 continue;
@@ -1594,7 +1553,7 @@ CopySymbolsToKeymap(struct xkb_keymap *keymap, SymbolsInfo *info)
         }
     }
 
-    darray_foreach(mm, info->modMaps)
+    darray_foreach(mm, info->modmaps)
         if (!CopyModMapDef(info, mm))
             info->errorCount++;
 
@@ -1618,9 +1577,6 @@ CompileSymbols(XkbFile *file, struct xkb_keymap *keymap,
 
     HandleSymbolsFile(&info, file, merge);
 
-    if (darray_empty(info.keys))
-        goto err_info;
-
     if (info.errorCount != 0)
         goto err_info;
 
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/types.c b/src/3rdparty/xkbcommon/src/xkbcomp/types.c
index 1eb1b73205..5b7ccbb4db 100644
--- a/src/3rdparty/xkbcommon/src/xkbcomp/types.c
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/types.c
@@ -197,16 +197,6 @@ ReportTypeBadType(KeyTypesInfo *info, KeyTypeInfo *type,
                          TypeTxt(info, type), wanted);
 }
 
-static inline bool
-ReportTypeBadWidth(KeyTypesInfo *info, const char *type, int has, int needs)
-{
-    log_err(info->keymap->ctx,
-            "Key type \"%s\" has %d levels, must have %d; "
-            "Illegal type definition ignored\n",
-            type, has, needs);
-    return false;
-}
-
 /***====================================================================***/
 
 static void
@@ -775,6 +765,7 @@ static bool
 CopyKeyTypesToKeymap(struct xkb_keymap *keymap, KeyTypesInfo *info)
 {
     keymap->types_section_name = strdup_safe(info->name);
+    XkbEscapeMapName(keymap->types_section_name);
 
     keymap->num_types = darray_size(info->types);
     if (keymap->num_types == 0)
@@ -793,7 +784,7 @@ CopyKeyTypesToKeymap(struct xkb_keymap *keymap, KeyTypesInfo *info)
         type->num_levels = 1;
         type->entries = NULL;
         type->num_entries = 0;
-        type->name = xkb_atom_intern(keymap->ctx, "default");
+        type->name = xkb_atom_intern_literal(keymap->ctx, "default");
         type->level_names = NULL;
 
         return true;
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/xkbcomp-priv.h b/src/3rdparty/xkbcommon/src/xkbcomp/xkbcomp-priv.h
index 4d421b5f2f..6cb774da17 100644
--- a/src/3rdparty/xkbcommon/src/xkbcomp/xkbcomp-priv.h
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/xkbcomp-priv.h
@@ -45,12 +45,9 @@ XkbParseFile(struct xkb_context *ctx, FILE *file,
              const char *file_name, const char *map);
 
 XkbFile *
-XkbParseString(struct xkb_context *ctx, const char *string,
-               const char *file_name);
-
-XkbFile *
-XkbParseBuffer(struct xkb_context *ctx, char *buf, size_t length,
-               const char *file_name);
+XkbParseString(struct xkb_context *ctx,
+               const char *string, size_t len,
+               const char *file_name, const char *map);
 
 void
 FreeXkbFile(XkbFile *file);
@@ -79,9 +76,6 @@ bool
 CompileKeymap(XkbFile *file, struct xkb_keymap *keymap,
               enum merge_mode merge);
 
-bool
-LookupKeysym(const char *str, xkb_keysym_t *sym_rtrn);
-
 /***====================================================================***/
 
 static inline bool
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/xkbcomp.c b/src/3rdparty/xkbcommon/src/xkbcomp/xkbcomp.c
index b9a1b5ffa6..007e3f73e8 100644
--- a/src/3rdparty/xkbcommon/src/xkbcomp/xkbcomp.c
+++ b/src/3rdparty/xkbcommon/src/xkbcomp/xkbcomp.c
@@ -97,12 +97,13 @@ text_v1_keymap_new_from_names(struct xkb_keymap *keymap,
 }
 
 static bool
-text_v1_keymap_new_from_string(struct xkb_keymap *keymap, const char *string)
+text_v1_keymap_new_from_string(struct xkb_keymap *keymap,
+                               const char *string, size_t len)
 {
     bool ok;
     XkbFile *xkb_file;
 
-    xkb_file = XkbParseString(keymap->ctx, string, "(input string)");
+    xkb_file = XkbParseString(keymap->ctx, string, len, "(input string)", NULL);
     if (!xkb_file) {
         log_err(keymap->ctx, "Failed to parse input xkb string\n");
         return NULL;
@@ -114,38 +115,6 @@ text_v1_keymap_new_from_string(struct xkb_keymap *keymap, const char *string)
 }
 
 static bool
-text_v1_keymap_new_from_buffer(struct xkb_keymap *keymap,
-                               const char *buffer, size_t length)
-{
-    bool ok;
-    XkbFile *xkb_file;
-    char *buf;
-
-    buf = malloc(length + 2);
-    if (!buf) {
-        log_err(keymap->ctx, "Cannot allocate memory for keymap\n");
-        return NULL;
-    }
-
-    /* yy_scan_buffer requires two terminating zero bytes */
-    memcpy(buf, buffer, length);
-    buf[length] = 0;
-    buf[length + 1] = 0;
-
-    xkb_file = XkbParseBuffer(keymap->ctx, buf, length + 2, "input");
-    if (!xkb_file) {
-        log_err(keymap->ctx, "Failed to parse input xkb file\n");
-        free(buf);
-        return NULL;
-    }
-
-    ok = compile_keymap_file(keymap, xkb_file);
-    FreeXkbFile(xkb_file);
-    free(buf);
-    return ok;
-}
-
-static bool
 text_v1_keymap_new_from_file(struct xkb_keymap *keymap, FILE *file)
 {
     bool ok;
@@ -165,7 +134,6 @@ text_v1_keymap_new_from_file(struct xkb_keymap *keymap, FILE *file)
 const struct xkb_keymap_format_ops text_v1_keymap_format_ops = {
     .keymap_new_from_names = text_v1_keymap_new_from_names,
     .keymap_new_from_string = text_v1_keymap_new_from_string,
-    .keymap_new_from_buffer = text_v1_keymap_new_from_buffer,
     .keymap_new_from_file = text_v1_keymap_new_from_file,
     .keymap_get_as_string = text_v1_keymap_get_as_string,
 };
diff --git a/src/3rdparty/xkbcommon/xkbcommon/xkbcommon-keysyms.h b/src/3rdparty/xkbcommon/xkbcommon/xkbcommon-keysyms.h
index 253ea59ceb..69c582e45f 100644
--- a/src/3rdparty/xkbcommon/xkbcommon/xkbcommon-keysyms.h
+++ b/src/3rdparty/xkbcommon/xkbcommon/xkbcommon-keysyms.h
@@ -418,6 +418,12 @@ SOFTWARE.
 #define XKB_KEY_dead_belowcomma               0xfe6e
 #define XKB_KEY_dead_currency                 0xfe6f
 
+/* extra dead elements for German T3 layout */
+#define XKB_KEY_dead_lowline                  0xfe90
+#define XKB_KEY_dead_aboveverticalline        0xfe91
+#define XKB_KEY_dead_belowverticalline        0xfe92
+#define XKB_KEY_dead_longsolidusoverlay       0xfe93
+
 /* dead vowels for universal syllable entry */
 #define XKB_KEY_dead_a                        0xfe80
 #define XKB_KEY_dead_A                        0xfe81
@@ -2652,6 +2658,8 @@ SOFTWARE.
 #define XKB_KEY_XF86TouchpadOn	0x1008FFB0   /* The touchpad got switched on */
 #define XKB_KEY_XF86TouchpadOff	0x1008FFB1   /* The touchpad got switched off */
 
+#define XKB_KEY_XF86AudioMicMute	0x1008FFB2   /* Mute the Mic from the system */
+
 /* Keys for special action keys (hot keys) */
 /* Virtual terminals on some operating systems */
 #define XKB_KEY_XF86Switch_VT_1	0x1008FE01
diff --git a/src/3rdparty/xkbcommon/xkbcommon/xkbcommon-names.h b/src/3rdparty/xkbcommon/xkbcommon/xkbcommon-names.h
index db071d8a2a..ecb551ff10 100644
--- a/src/3rdparty/xkbcommon/xkbcommon/xkbcommon-names.h
+++ b/src/3rdparty/xkbcommon/xkbcommon/xkbcommon-names.h
@@ -35,6 +35,7 @@
 #define XKB_MOD_NAME_CAPS       "Lock"
 #define XKB_MOD_NAME_CTRL       "Control"
 #define XKB_MOD_NAME_ALT        "Mod1"
+#define XKB_MOD_NAME_NUM        "Mod2"
 #define XKB_MOD_NAME_LOGO       "Mod4"
 
 #define XKB_LED_NAME_CAPS       "Caps Lock"
diff --git a/src/3rdparty/xkbcommon/xkbcommon/xkbcommon-x11.h b/src/3rdparty/xkbcommon/xkbcommon/xkbcommon-x11.h
new file mode 100644
index 0000000000..4ec9b649c7
--- /dev/null
+++ b/src/3rdparty/xkbcommon/xkbcommon/xkbcommon-x11.h
@@ -0,0 +1,166 @@
+/*
+ * Copyright © 2013 Ran Benita
+ *
+ * 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 _XKBCOMMON_X11_H
+#define _XKBCOMMON_X11_H
+
+#include <xcb/xcb.h>
+#include <xkbcommon/xkbcommon.h>
+
+/**
+ * @file
+ * libxkbcommon-x11 API - Additional X11 support for xkbcommon.
+ */
+
+/**
+ * @defgroup x11 X11 support
+ * Additional X11 support for xkbcommon.
+ *
+ * @{
+ */
+
+/**
+ * The minimal compatible major version of the XKB X11 extension which
+ * this library can use.
+ */
+#define XKB_X11_MIN_MAJOR_XKB_VERSION 1
+/**
+ * The minimal compatible minor version of the XKB X11 extension which
+ * this library can use (for the minimal major version).
+ */
+#define XKB_X11_MIN_MINOR_XKB_VERSION 0
+
+/** Flags for the xkb_x11_setup_xkb_extension() function. */
+enum xkb_x11_setup_xkb_extension_flags {
+    /** Do not apply any flags. */
+    XKB_X11_SETUP_XKB_EXTENSION_NO_FLAGS = 0
+};
+
+/**
+ * Setup the XKB X11 extension for this X client.
+ *
+ * The xkbcommon-x11 library uses various XKB requests.  Before doing so,
+ * an X client must notify the server that it will be using the extension.
+ * This function (or an XCB equivalent) must be called before any other
+ * function in this library is used.
+ *
+ * Some X servers may not support or disable the XKB extension.  If you
+ * want to support such servers, you need to use a different fallback.
+ *
+ * You may call this function several times; it is idempotent.
+ *
+ * @param connection
+ *     An XCB connection to the X server.
+ * @param major_xkb_version, minor_xkb_version
+ *     The XKB extension version to request.  To operate correctly, you
+ *     must have (major_xkb_version, minor_xkb_version) >=
+ *     (XKB_X11_MIN_MAJOR_XKB_VERSION, XKB_X11_MIN_MINOR_XKB_VERSION),
+ *     though this is not enforced.
+ * @param flags
+ *     Optional flags, or 0.
+ * @param[out] major_xkb_version_out, minor_xkb_version_out
+ *     Backfilled with the compatible XKB extension version numbers picked
+ *     by the server.  Can be NULL.
+ * @param[out] base_event_out
+ *     Backfilled with the XKB base (also known as first) event code, needed
+ *     to distinguish XKB events.  Can be NULL.
+ * @param[out] base_error_out
+ *     Backfilled with the XKB base (also known as first) error code, needed
+ *     to distinguish XKB errors.  Can be NULL.
+ *
+ * @returns 1 on success, or 0 on failure.
+ */
+int
+xkb_x11_setup_xkb_extension(xcb_connection_t *connection,
+                            uint16_t major_xkb_version,
+                            uint16_t minor_xkb_version,
+                            enum xkb_x11_setup_xkb_extension_flags flags,
+                            uint16_t *major_xkb_version_out,
+                            uint16_t *minor_xkb_version_out,
+                            uint8_t *base_event_out,
+                            uint8_t *base_error_out);
+
+/**
+ * Get the keyboard device ID of the core X11 keyboard.
+ *
+ * @param connection An XCB connection to the X server.
+ *
+ * @returns A device ID which may be used with other xkb_x11_* functions,
+ *          or -1 on failure.
+ */
+int32_t
+xkb_x11_get_core_keyboard_device_id(xcb_connection_t *connection);
+
+/**
+ * Create a keymap from an X11 keyboard device.
+ *
+ * This function queries the X server with various requests, fetches the
+ * details of the active keymap on a keyboard device, and creates an
+ * xkb_keymap from these details.
+ *
+ * @param context
+ *     The context in which to create the keymap.
+ * @param connection
+ *     An XCB connection to the X server.
+ * @param device_id
+ *     An XInput 1 device ID (in the range 0-255) with input class KEY.
+ *     Passing values outside of this range is an error.
+ * @param flags
+ *     Optional flags for the keymap, or 0.
+ *
+ * @returns A keymap retrieved from the X server, or NULL on failure.
+ *
+ * @memberof xkb_keymap
+ */
+struct xkb_keymap *
+xkb_x11_keymap_new_from_device(struct xkb_context *context,
+                               xcb_connection_t *connection,
+                               int32_t device_id,
+                               enum xkb_keymap_compile_flags flags);
+
+/**
+ * Create a new keyboard state object from an X11 keyboard device.
+ *
+ * This function is the same as xkb_state_new(), only pre-initialized
+ * with the state of the device at the time this function is called.
+ *
+ * @param keymap
+ *     The keymap for which to create the state.
+ * @param connection
+ *     An XCB connection to the X server.
+ * @param device_id
+ *     An XInput 1 device ID (in the range 0-255) with input class KEY.
+ *     Passing values outside of this range is an error.
+ *
+ * @returns A new keyboard state object, or NULL on failure.
+ *
+ * @memberof xkb_state
+ */
+struct xkb_state *
+xkb_x11_state_new_from_device(struct xkb_keymap *keymap,
+                              xcb_connection_t *connection,
+                              int32_t device_id);
+
+/** @} */
+
+#endif
diff --git a/src/3rdparty/xkbcommon/xkbcommon/xkbcommon.h b/src/3rdparty/xkbcommon/xkbcommon/xkbcommon.h
index a2aecfbb2a..cc9262ff89 100644
--- a/src/3rdparty/xkbcommon/xkbcommon/xkbcommon.h
+++ b/src/3rdparty/xkbcommon/xkbcommon/xkbcommon.h
@@ -197,7 +197,7 @@ typedef uint32_t xkb_keysym_t;
  * layout</em> is active.  These may be different alphabets, different key
  * arrangements, etc.
  *
- * Layout indexes are consecutive.  The first layout has index 0.
+ * Layout indices are consecutive.  The first layout has index 0.
  *
  * Each layout is not required to have a name, and the names are not
  * guaranteed to be unique (though they are usually provided and unique).
@@ -209,13 +209,20 @@ typedef uint32_t xkb_keysym_t;
  * @sa xkb_keymap_num_layouts() xkb_keymap_num_layouts_for_key()
  */
 typedef uint32_t xkb_layout_index_t;
-/** A mask of layout indexes. */
+/** A mask of layout indices. */
 typedef uint32_t xkb_layout_mask_t;
 
 /**
  * Index of a shift level.
  *
- * @todo Explain what are shift levels.
+ * Any key, in any layout, can have several <em>shift levels</em>.  Each
+ * shift level can assign different keysyms to the key.  The shift level
+ * to use is chosen according to the current keyboard state; for example,
+ * if no keys are pressed, the first level may be used; if the Left Shift
+ * key is pressed, the second; if Num Lock is pressed, the third; and
+ * many such combinations are possible (see xkb_mod_index_t).
+ *
+ * Level indices are consecutive.  The first level has index 0.
  */
 typedef uint32_t xkb_level_index_t;
 
@@ -233,7 +240,7 @@ typedef uint32_t xkb_level_index_t;
  * consulted; this detemines the correct shift level to use within the
  * currently active layout (see xkb_level_index_t).
  *
- * Modifier indexes are consecutive.  The first modifier has index 0.
+ * Modifier indices are consecutive.  The first modifier has index 0.
  *
  * Each modifier must have a name, and the names are unique.  Therefore, it
  * is safe to use the name as a unique identifier for a modifier.  The names
@@ -243,15 +250,17 @@ typedef uint32_t xkb_level_index_t;
  * @sa xkb_keymap_num_mods()
  */
 typedef uint32_t xkb_mod_index_t;
-/** A mask of modifier indexes. */
+/** A mask of modifier indices. */
 typedef uint32_t xkb_mod_mask_t;
 
 /**
  * Index of a keyboard LED.
  *
- * @todo Explain what are LEDs.
+ * LEDs are logical objects which may be @e active or @e inactive.  They
+ * typically correspond to the lights on the keyboard. Their state is
+ * determined by the current keyboard state.
  *
- * LED indexes are non-consecutive.  The first LED has index 0.
+ * LED indices are non-consecutive.  The first LED has index 0.
  *
  * Each LED must have a name, and the names are unique. Therefore,
  * it is safe to use the name as a unique identifier for a LED.  The names
@@ -261,7 +270,7 @@ typedef uint32_t xkb_mod_mask_t;
  * @warning A given keymap may specify an exact index for a given LED.
  * Therefore, LED indexing is not necessarily sequential, as opposed to
  * modifiers and layouts.  This means that when iterating over the LEDs
- * in a keymap using e.g. xkb_keymap_num_leds(), some indexes might be
+ * in a keymap using e.g. xkb_keymap_num_leds(), some indices might be
  * invalid.  Given such an index, functions like xkb_keymap_led_get_name()
  * will return NULL, and xkb_state_led_index_is_active() will return -1.
  *
@@ -270,7 +279,7 @@ typedef uint32_t xkb_mod_mask_t;
  * @sa xkb_keymap_num_leds()
  */
 typedef uint32_t xkb_led_index_t;
-/** A mask of LED indexes. */
+/** A mask of LED indices. */
 typedef uint32_t xkb_led_mask_t;
 
 #define XKB_KEYCODE_INVALID (0xffffffff)
@@ -351,6 +360,8 @@ xkb_keysym_get_name(xkb_keysym_t keysym, char *buffer, size_t size);
 
 /** Flags for xkb_keysym_from_name(). */
 enum xkb_keysym_flags {
+    /** Do not apply any flags. */
+    XKB_KEYSYM_NO_FLAGS = 0,
     /** Find keysym by case-insensitive search. */
     XKB_KEYSYM_CASE_INSENSITIVE = (1 << 0)
 };
@@ -416,6 +427,8 @@ xkb_keysym_to_utf32(xkb_keysym_t keysym);
 
 /** Flags for context creation. */
 enum xkb_context_flags {
+    /** Do not apply any context flags. */
+    XKB_CONTEXT_NO_FLAGS = 0,
     /** Create this context with an empty include path. */
     XKB_CONTEXT_NO_DEFAULT_INCLUDES = (1 << 0),
     /** Don't take RMLVO names from the environment. */
@@ -667,6 +680,8 @@ xkb_context_set_log_fn(struct xkb_context *context,
 
 /** Flags for keymap compilation. */
 enum xkb_keymap_compile_flags {
+    /** Do not apply any flags. */
+    XKB_MAP_COMPILE_NO_FLAGS = 0,
     /** Apparently you can't have empty enums.  What a drag. */
     XKB_MAP_COMPILE_PLACEHOLDER = 0
 };
@@ -812,6 +827,46 @@ xkb_keymap_get_as_string(struct xkb_keymap *keymap,
  */
 
 /**
+ * Get the minimum keycode in the keymap.
+ *
+ * @sa xkb_keycode_t
+ * @memberof xkb_keymap
+ */
+xkb_keycode_t
+xkb_keymap_min_keycode(struct xkb_keymap *keymap);
+
+/**
+ * Get the maximum keycode in the keymap.
+ *
+ * @sa xkb_keycode_t
+ * @memberof xkb_keymap
+ */
+xkb_keycode_t
+xkb_keymap_max_keycode(struct xkb_keymap *keymap);
+
+/**
+ * The iterator used by xkb_keymap_key_for_each().
+ *
+ * @sa xkb_keymap_key_for_each
+ * @memberof xkb_keymap
+ */
+typedef void
+(*xkb_keymap_key_iter_t)(struct xkb_keymap *keymap, xkb_keycode_t key,
+                         void *data);
+
+/**
+ * Run a specified function for every valid keycode in the keymap.  If a
+ * keymap is sparse, this function may be called fewer than
+ * (max_keycode - min_keycode + 1) times.
+ *
+ * @sa xkb_keymap_min_keycode() xkb_keymap_max_keycode() xkb_keycode_t
+ * @memberof xkb_keymap
+ */
+void
+xkb_keymap_key_for_each(struct xkb_keymap *keymap, xkb_keymap_key_iter_t iter,
+                        void *data);
+
+/**
  * Get the number of modifiers in the keymap.
  *
  * @sa xkb_mod_index_t
@@ -1001,9 +1056,9 @@ xkb_keymap_key_repeats(struct xkb_keymap *keymap, xkb_keycode_t key);
  */
 
 /**
- * Create a new keyboard state object for a keymap.
+ * Create a new keyboard state object.
  *
- * @param keymap The keymap for which to create the state.
+ * @param keymap The keymap which the state will use.
  *
  * @returns A new keyboard state object, or NULL on failure.
  *
@@ -1033,10 +1088,10 @@ void
 xkb_state_unref(struct xkb_state *state);
 
 /**
- * Get the keymap from which a keyboard state object was created.
+ * Get the keymap which a keyboard state object is using.
  *
- * @returns The keymap which was used in xkb_state_new() to create this
- * state object.
+ * @returns The keymap which was passed to xkb_state_new() when creating
+ * this state object.
  *
  * This function does not take a new reference on the keymap; you must
  * explicitly reference it yourself if you plan to use it beyond the
@@ -1070,7 +1125,8 @@ enum xkb_state_component {
      *  lock has been pressed again. */
     XKB_STATE_MODS_LOCKED = (1 << 2),
     /** Effective modifiers, i.e. currently active and affect key
-     *  processing (derived from the other state components). */
+     *  processing (derived from the other state components).
+     *  Use this unless you explictly care how the state came about. */
     XKB_STATE_MODS_EFFECTIVE = (1 << 3),
     /** Depressed layout, i.e. a key is physically holding it. */
     XKB_STATE_LAYOUT_DEPRESSED = (1 << 4),
@@ -1081,7 +1137,8 @@ enum xkb_state_component {
      *  has been pressed again. */
     XKB_STATE_LAYOUT_LOCKED = (1 << 6),
     /** Effective layout, i.e. currently active and affects key processing
-     *  (derived from the other state components). */
+     *  (derived from the other state components).
+     *  Use this unless you explictly care how the state came about. */
     XKB_STATE_LAYOUT_EFFECTIVE = (1 << 7),
     /** LEDs (derived from the other state components). */
     XKB_STATE_LEDS = (1 << 8)
@@ -1091,16 +1148,65 @@ enum xkb_state_component {
  * Update the keyboard state to reflect a given key being pressed or
  * released.
  *
+ * This entry point is intended for programs which track the keyboard state
+ * explictly (like an evdev client).  If the state is serialized to you by
+ * a master process (like a Wayland compositor) using functions like
+ * xkb_state_serialize_mods(), you should use xkb_state_update_mask() instead.
+ * The two functins should not generally be used together.
+ *
+ * A series of calls to this function should be consistent; that is, a call
+ * with XKB_KEY_DOWN for a key should be matched by an XKB_KEY_UP; if a key
+ * is pressed twice, it should be released twice; etc. Otherwise (e.g. due
+ * to missed input events), situations like "stuck modifiers" may occur.
+ *
  * @returns A mask of state components that have changed as a result of
  * the update.  If nothing in the state has changed, returns 0.
  *
  * @memberof xkb_state
+ *
+ * @sa xkb_state_update_mask()
  */
 enum xkb_state_component
 xkb_state_update_key(struct xkb_state *state, xkb_keycode_t key,
                      enum xkb_key_direction direction);
 
 /**
+ * Update a keyboard state from a set of explicit masks.
+ *
+ * This entry point is intended for window systems and the like, where a
+ * master process holds an xkb_state, then serializes it over a wire
+ * protocol, and clients then use the serialization to feed in to their own
+ * xkb_state.
+ *
+ * All parameters must always be passed, or the resulting state may be
+ * incoherent.
+ *
+ * The serialization is lossy and will not survive round trips; it must only
+ * be used to feed slave state objects, and must not be used to update the
+ * master state.
+ *
+ * If you do not fit the description above, you should use
+ * xkb_state_update_key() instead.  The two functions should not generally be
+ * used together.
+ *
+ * @returns A mask of state components that have changed as a result of
+ * the update.  If nothing in the state has changed, returns 0.
+ *
+ * @memberof xkb_state
+ *
+ * @sa xkb_state_component
+ * @sa xkb_state_update_key
+ */
+enum xkb_state_component
+xkb_state_update_mask(struct xkb_state *state,
+                      xkb_mod_mask_t depressed_mods,
+                      xkb_mod_mask_t latched_mods,
+                      xkb_mod_mask_t locked_mods,
+                      xkb_layout_index_t depressed_layout,
+                      xkb_layout_index_t latched_layout,
+                      xkb_layout_index_t locked_layout);
+
+/**
  * Get the keysyms obtained from pressing a particular key in a given
  * keyboard state.
  *
@@ -1114,8 +1220,9 @@ xkb_state_update_key(struct xkb_state *state, xkb_keycode_t key,
  * key in the given keyboard state.
  *
  * As an extension to XKB, this function can return more than one keysym.
- * If you do not want to handle this case, you can use
- * xkb_state_key_get_one_sym().
+ * If you do not want to handle this case, you should use
+ * xkb_state_key_get_one_sym(), which additionally performs transformations
+ * which are specific to the one-keysym case.
  *
  * @returns The number of keysyms in the syms_out array.  If no keysyms
  * are produced by the key in the given keyboard state, returns 0 and sets
@@ -1131,9 +1238,10 @@ xkb_state_key_get_syms(struct xkb_state *state, xkb_keycode_t key,
  * Get the single keysym obtained from pressing a particular key in a
  * given keyboard state.
  *
- * This function is similar to xkb_state_key_get_syms(), but with a
- * simplified interface for users which cannot or do not want to handle
- * the case where multiple keysyms are returned.
+ * This function is similar to xkb_state_key_get_syms(), but intended
+ * for users which cannot or do not want to handle the case where
+ * multiple keysyms are returned (in which case this function is
+ * preferred).
  *
  * @returns The keysym.  If the key does not have exactly one keysym,
  * returns XKB_KEY_NoSymbol
@@ -1204,39 +1312,6 @@ enum xkb_state_match {
 };
 
 /**
- * Update a keyboard state from a set of explicit masks.
- *
- * This entry point is really only for window systems and the like, where a
- * master process holds an xkb_state, then serializes it over a wire
- * protocol, and clients then use the serialization to feed in to their own
- * xkb_state.
- *
- * All parameters must always be passed, or the resulting state may be
- * incoherent.
- *
- * The serialization is lossy and will not survive round trips; it must only
- * be used to feed slave state objects, and must not be used to update the
- * master state.
- *
- * Please do not use this unless you fit the description above.
- *
- * @returns A mask of state components that have changed as a result of
- * the update.  If nothing in the state has changed, returns 0.
- *
- * @memberof xkb_state
- *
- * @sa xkb_state_component
- */
-enum xkb_state_component
-xkb_state_update_mask(struct xkb_state *state,
-                      xkb_mod_mask_t depressed_mods,
-                      xkb_mod_mask_t latched_mods,
-                      xkb_mod_mask_t locked_mods,
-                      xkb_layout_index_t depressed_layout,
-                      xkb_layout_index_t latched_layout,
-                      xkb_layout_index_t locked_layout);
-
-/**
  * The counterpart to xkb_state_update_mask for modifiers, to be used on
  * the server side of serialization.
  *
@@ -1336,11 +1411,11 @@ xkb_state_mod_index_is_active(struct xkb_state *state, xkb_mod_index_t idx,
  * given modifiers.
  * @param match The manner by which to match the state against the
  * given modifiers.
- * @param ...   The set of of modifier indexes to test, terminated by a
+ * @param ...   The set of of modifier indices to test, terminated by a
  * XKB_MOD_INVALID argument (sentinel).
  *
  * @returns 1 if the modifiers are active, 0 if they are not.  If any of
- * the modifier indexes are invalid in the keymap, returns -1.
+ * the modifier indices are invalid in the keymap, returns -1.
  *
  * @memberof xkb_state
  */
diff --git a/src/3rdparty/xkbcommon/xkbcommon/xkbcommon_workaround.h b/src/3rdparty/xkbcommon/xkbcommon/xkbcommon_workaround.h
deleted file mode 100644
index 58ce143978..0000000000
--- a/src/3rdparty/xkbcommon/xkbcommon/xkbcommon_workaround.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
-** Contact: http://www.qt-project.org/legal
-**
-** This file is part of the plugins of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and Digia.  For licensing terms and
-** conditions see http://qt.digia.com/licensing.  For further information
-** use the contact form at http://qt.digia.com/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Digia gives you certain additional
-** rights.  These rights are described in the Digia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef XKBCOMMON_WORKAROUND_H
-#define XKBCOMMON_WORKAROUND_H
-
-// Function utf32_to_utf8() is borrowed from the libxkbcommon library,
-// file keysym-utf.c. The workaround should be removed once the fix from
-// https://bugs.freedesktop.org/show_bug.cgi?id=56780 gets released.
-static int utf32_to_utf8(uint32_t unichar, char *buffer)
-{
-    int count, shift, length;
-    uint8_t head;
-
-    if (unichar <= 0x007f) {
-        buffer[0] = unichar;
-        buffer[1] = '\0';
-        return 2;
-    }
-    else if (unichar <= 0x07FF) {
-        length = 2;
-        head = 0xc0;
-    }
-    else if (unichar <= 0xffff) {
-        length = 3;
-        head = 0xe0;
-    }
-    else if (unichar <= 0x1fffff) {
-        length = 4;
-        head = 0xf0;
-    }
-    else if (unichar <= 0x3ffffff) {
-        length = 5;
-        head = 0xf8;
-    }
-    else {
-        length = 6;
-        head = 0xfc;
-    }
-
-    for (count = length - 1, shift = 0; count > 0; count--, shift += 6)
-        buffer[count] = 0x80 | ((unichar >> shift) & 0x3f);
-
-    buffer[0] = head | ((unichar >> shift) & 0x3f);
-    buffer[length] = '\0';
-
-    return length + 1;
-}
-
-static bool needWorkaround(uint32_t sym)
-{
-    /* patch encoding botch */
-    if (sym == XKB_KEY_KP_Space)
-        return true;
-
-    /* special keysyms */
-    if ((sym >= XKB_KEY_BackSpace && sym <= XKB_KEY_Clear) ||
-        (sym >= XKB_KEY_KP_Multiply && sym <= XKB_KEY_KP_9) ||
-        sym == XKB_KEY_Return || sym == XKB_KEY_Escape ||
-        sym == XKB_KEY_Delete || sym == XKB_KEY_KP_Tab ||
-        sym == XKB_KEY_KP_Enter || sym == XKB_KEY_KP_Equal)
-        return true;
-
-    return false;
-}
-
-#endif // XKBCOMMON_WORKAROUND_H
diff --git a/src/plugins/platforminputcontexts/compose/compose.pro b/src/plugins/platforminputcontexts/compose/compose.pro
index 546a0a2af7..7182c458fc 100644
--- a/src/plugins/platforminputcontexts/compose/compose.pro
+++ b/src/plugins/platforminputcontexts/compose/compose.pro
@@ -6,8 +6,6 @@ load(qt_plugin)
 
 QT += gui-private
 
-LIBS += $$QMAKE_LIBS_XKBCOMMON
-QMAKE_CXXFLAGS += $$QMAKE_CFLAGS_XKBCOMMON
 DEFINES += X11_PREFIX='\\"$$QMAKE_X11_PREFIX\\"'
 
 SOURCES += $$PWD/main.cpp \
@@ -19,14 +17,12 @@ HEADERS += $$PWD/qcomposeplatforminputcontext.h \
 
 # libxkbcommon
 contains(QT_CONFIG, xkbcommon-qt): {
+    # dont't need x11 dependency for compose key plugin
+    QT_CONFIG -= use-xkbcommon-x11support
     include(../../../3rdparty/xkbcommon.pri)
 } else {
     LIBS += $$QMAKE_LIBS_XKBCOMMON
     QMAKE_CXXFLAGS += $$QMAKE_CFLAGS_XKBCOMMON
-    equals(QMAKE_VERSION_XKBCOMMON, "0.2.0") {
-        DEFINES += XKBCOMMON_0_2_0
-        INCLUDEPATH += ../../../3rdparty/xkbcommon/xkbcommon/
-    }
 }
 
 OTHER_FILES += $$PWD/compose.json
diff --git a/src/plugins/platforminputcontexts/compose/generator/qtablegenerator.cpp b/src/plugins/platforminputcontexts/compose/generator/qtablegenerator.cpp
index ca61b0e495..8bbb490022 100644
--- a/src/plugins/platforminputcontexts/compose/generator/qtablegenerator.cpp
+++ b/src/plugins/platforminputcontexts/compose/generator/qtablegenerator.cpp
@@ -51,10 +51,6 @@
 
 #include <xkbcommon/xkbcommon.h>
 
-#ifdef XKBCOMMON_0_2_0
-#include <xkbcommon_workaround.h>
-#endif
-
 #include <locale.h> // LC_CTYPE
 #include <string.h> // strchr, strncmp, etc.
 #include <strings.h> // strncasecmp
@@ -326,23 +322,7 @@ ushort TableGenerator::keysymToUtf8(quint32 sym)
     QByteArray chars;
     int bytes;
     chars.resize(8);
-
-#ifdef XKBCOMMON_0_2_0
-    if (needWorkaround(sym)) {
-        quint32 codepoint;
-        if (sym == XKB_KEY_KP_Space)
-            codepoint = XKB_KEY_space & 0x7f;
-        else
-            codepoint = sym & 0x7f;
-
-        bytes = utf32_to_utf8(codepoint, chars.data());
-    } else {
-        bytes = xkb_keysym_to_utf8(sym, chars.data(), chars.size());
-    }
-#else
     bytes = xkb_keysym_to_utf8(sym, chars.data(), chars.size());
-#endif
-
     if (bytes == -1)
         qWarning("TableGenerator::keysymToUtf8 - buffer too small");
 
diff --git a/src/plugins/platforminputcontexts/platforminputcontexts.pro b/src/plugins/platforminputcontexts/platforminputcontexts.pro
index 60b66bfb35..faea54b874 100644
--- a/src/plugins/platforminputcontexts/platforminputcontexts.pro
+++ b/src/plugins/platforminputcontexts/platforminputcontexts.pro
@@ -4,7 +4,6 @@ qtHaveModule(dbus) {
 !mac:!win32:SUBDIRS += ibus
 }
 
-unix:!macx:!contains(DEFINES, QT_NO_XKBCOMMON): {
-    SUBDIRS += compose
-}
+contains(QT_CONFIG, xcb-plugin): SUBDIRS += compose
+
 
diff --git a/src/plugins/platforms/xcb/qxcbkeyboard.cpp b/src/plugins/platforms/xcb/qxcbkeyboard.cpp
index 966090dbd5..0a52640c9a 100644
--- a/src/plugins/platforms/xcb/qxcbkeyboard.cpp
+++ b/src/plugins/platforms/xcb/qxcbkeyboard.cpp
@@ -53,10 +53,6 @@
 #include <qpa/qplatformintegration.h>
 #include <qpa/qplatformcursor.h>
 
-#ifdef XKBCOMMON_0_2_0
-#include <xkbcommon_workaround.h>
-#endif
-
 #ifndef XK_ISO_Left_Tab
 #define XK_ISO_Left_Tab         0xFE20
 #endif
@@ -1398,23 +1394,7 @@ QString QXcbKeyboard::keysymToUnicode(xcb_keysym_t sym) const
     QByteArray chars;
     int bytes;
     chars.resize(7);
-
-#ifdef XKBCOMMON_0_2_0
-    if (needWorkaround(sym)) {
-        quint32 codepoint;
-        if (sym == XKB_KEY_KP_Space)
-            codepoint = XKB_KEY_space & 0x7f;
-        else
-            codepoint = sym & 0x7f;
-
-        bytes = utf32_to_utf8(codepoint, chars.data());
-    } else {
-        bytes = xkb_keysym_to_utf8(sym, chars.data(), chars.size());
-    }
-#else
     bytes = xkb_keysym_to_utf8(sym, chars.data(), chars.size());
-#endif
-
     if (bytes == -1)
         qWarning("QXcbKeyboard::handleKeyEvent - buffer too small");
     chars.resize(bytes-1);
diff --git a/src/plugins/platforms/xcb/xcb-plugin.pro b/src/plugins/platforms/xcb/xcb-plugin.pro
index bfbec91e3c..e19bb921e1 100644
--- a/src/plugins/platforms/xcb/xcb-plugin.pro
+++ b/src/plugins/platforms/xcb/xcb-plugin.pro
@@ -131,12 +131,9 @@ contains(QT_CONFIG, xcb-qt) {
 
 # libxkbcommon
 contains(QT_CONFIG, xkbcommon-qt): {
+    QT_CONFIG += use-xkbcommon-x11support
     include(../../../3rdparty/xkbcommon.pri)
 } else {
     LIBS += $$QMAKE_LIBS_XKBCOMMON
     QMAKE_CXXFLAGS += $$QMAKE_CFLAGS_XKBCOMMON
-    equals(QMAKE_VERSION_XKBCOMMON, "0.2.0") {
-        DEFINES += XKBCOMMON_0_2_0
-        INCLUDEPATH += ../../../3rdparty/xkbcommon/xkbcommon/
-    }
 }