diff --git a/.gitignore b/.gitignore index 7131695..5737ece 100644 --- a/.gitignore +++ b/.gitignore @@ -14,3 +14,4 @@ ibus-1.3.6.tar.gz /ibus_master_da.po /ibus-gjs-3.0.2.20110823.tar.gz /ibus-gjs-3.1.4.20110823.tar.gz +/ibus-1.3.99.20110817.tar.gz diff --git a/ibus-530711-preload-sys.patch b/ibus-530711-preload-sys.patch index 7dec5ba..cd41566 100644 --- a/ibus-530711-preload-sys.patch +++ b/ibus-530711-preload-sys.patch @@ -1,6 +1,6 @@ -From 7f81445b3e6613d14f64253506a309095a37c8d7 Mon Sep 17 00:00:00 2001 +From fd80539e980f464192aed22c71e83ff3a6ec61b3 Mon Sep 17 00:00:00 2001 From: fujiwarat -Date: Mon, 20 Jun 2011 19:04:42 +0900 +Date: Thu, 1 Sep 2011 14:38:13 +0900 Subject: [PATCH] Reload preload engines until users customize the list. The idea is, if users don't customize the preload_engines with ibus-setup, @@ -17,19 +17,19 @@ on ibus-setup, ibus-setup sets 'preload_engine_mode' as IBUS_PRELOAD_ENGINE_MODE_USER and users can customize the value 'preload_engines'. --- - bus/ibusimpl.c | 402 +++++++++++++++++++++++++++++++++++++++----------- - data/ibus.schemas.in | 13 ++ + bus/ibusimpl.c | 412 +++++++++++++++++++++++++++++++++++++++----------- + data/ibus.schemas.in | 15 ++- ibus/common.py | 6 + setup/main.py | 70 ++++++++- setup/setup.ui | 21 +++- src/ibustypes.h | 10 ++ - 6 files changed, 427 insertions(+), 95 deletions(-) + 6 files changed, 438 insertions(+), 96 deletions(-) diff --git a/bus/ibusimpl.c b/bus/ibusimpl.c -index a7ae52b..bb4b8ae 100644 +index 1942504..3fce912 100644 --- a/bus/ibusimpl.c +++ b/bus/ibusimpl.c -@@ -144,6 +144,9 @@ static void bus_ibus_impl_set_previous_engine +@@ -142,6 +142,9 @@ static void bus_ibus_impl_set_previous_engine static void bus_ibus_impl_set_preload_engines (BusIBusImpl *ibus, GVariant *value); @@ -39,7 +39,7 @@ index a7ae52b..bb4b8ae 100644 static void bus_ibus_impl_set_use_sys_layout (BusIBusImpl *ibus, GVariant *value); -@@ -285,6 +288,259 @@ _panel_destroy_cb (BusPanelProxy *panel, +@@ -283,6 +286,269 @@ _panel_destroy_cb (BusPanelProxy *panel, } static void @@ -86,6 +86,16 @@ index a7ae52b..bb4b8ae 100644 + + variant = ibus_config_get_value (ibus->config, "general", + "preload_engines"); ++ if (variant != NULL && g_variant_classify (variant) == G_VARIANT_CLASS_ARRAY) { ++ GVariantIter iter; ++ const gchar *engine_name = NULL; ++ g_variant_iter_init (&iter, variant); ++ g_variant_iter_loop (&iter, "&s", &engine_name); ++ if (g_strcmp0 (engine_name, "ibus_null_engine") == 0) { ++ g_variant_unref (variant); ++ variant = NULL; ++ } ++ } + if (variant == NULL) { + /* Set LANG_RELATIVE mode for the initial login */ + preload_engine_mode = IBUS_PRELOAD_ENGINE_MODE_LANG_RELATIVE; @@ -299,7 +309,7 @@ index a7ae52b..bb4b8ae 100644 bus_ibus_impl_set_hotkey (BusIBusImpl *ibus, GQuark hotkey, GVariant *value) -@@ -394,35 +650,50 @@ static void +@@ -392,35 +658,50 @@ static void bus_ibus_impl_set_preload_engines (BusIBusImpl *ibus, GVariant *value) { @@ -372,7 +382,7 @@ index a7ae52b..bb4b8ae 100644 } /** -@@ -503,89 +774,47 @@ bus_ibus_impl_set_use_global_engine (BusIBusImpl *ibus, +@@ -501,89 +782,47 @@ bus_ibus_impl_set_use_global_engine (BusIBusImpl *ibus, } } @@ -484,7 +494,7 @@ index a7ae52b..bb4b8ae 100644 #endif } -@@ -601,6 +830,7 @@ const static struct { +@@ -599,6 +838,7 @@ const static struct { { "general/hotkey", "next_engine_in_menu", bus_ibus_impl_set_next_engine_in_menu }, { "general/hotkey", "previous_engine", bus_ibus_impl_set_previous_engine }, { "general", "preload_engines", bus_ibus_impl_set_preload_engines }, @@ -493,10 +503,19 @@ index a7ae52b..bb4b8ae 100644 { "general", "use_global_engine", bus_ibus_impl_set_use_global_engine }, { "general", "embed_preedit_text", bus_ibus_impl_set_embed_preedit_text }, diff --git a/data/ibus.schemas.in b/data/ibus.schemas.in -index 7ca4899..d4334e1 100644 +index 8979515..fef1810 100644 --- a/data/ibus.schemas.in +++ b/data/ibus.schemas.in -@@ -13,6 +13,19 @@ +@@ -6,7 +6,7 @@ + /desktop/ibus/general/preload_engines + ibus + list +- [] ++ [ibus_null_engine] + string + + Preload engines +@@ -14,6 +14,19 @@ @@ -700,7 +719,7 @@ index f1e6d0b..562c091 100644 diff --git a/src/ibustypes.h b/src/ibustypes.h -index 6a31847..14b44fc 100644 +index 8146719..6151cd0 100644 --- a/src/ibustypes.h +++ b/src/ibustypes.h @@ -186,6 +186,16 @@ typedef enum { @@ -721,5 +740,5 @@ index 6a31847..14b44fc 100644 * @x: x coordinate. * @y: y coordinate. -- -1.7.4.4 +1.7.5.4 diff --git a/ibus-541492-xkb.patch b/ibus-541492-xkb.patch index 003baf4..9c381b5 100644 --- a/ibus-541492-xkb.patch +++ b/ibus-541492-xkb.patch @@ -1,48 +1,56 @@ -From 2d0081ff5f19101a0348461b914274fc8bd63a19 Mon Sep 17 00:00:00 2001 +From c7c1106dd675a86b7f7b59e3a05741e8048c53f3 Mon Sep 17 00:00:00 2001 From: fujiwarat -Date: Thu, 11 Aug 2011 19:07:38 +0900 +Date: Thu, 1 Sep 2011 14:51:37 +0900 Subject: [PATCH] Add XKB layouts --- - Makefile.am | 7 + - configure.ac | 56 ++++ - data/ibus.schemas.in | 36 +++ - ibus-1.0.pc.in | 2 + - ibus/Makefile.am | 26 ++ - ibus/__init__.py | 2 + - ibus/bus.py | 3 + - ibus/interface/iibus.py | 3 + - ibus/xkblayout.py.in | 230 +++++++++++++++++ - ibus/xkbxml.py.in | 419 ++++++++++++++++++++++++++++++ - setup/Makefile.am | 1 + - setup/enginecombobox.py | 7 +- - setup/main.py | 3 + - setup/setup.ui | 609 +++++++++++++++++++++++++++++++++++++++++++- - setup/xkbsetup.py | 454 +++++++++++++++++++++++++++++++++ - src/Makefile.am | 5 + - src/ibus.h | 1 + - src/ibusxkbxml.c | 440 ++++++++++++++++++++++++++++++++ - src/ibusxkbxml.h | 172 +++++++++++++ - ui/gtk/panel.py | 41 +++ - xkb/Makefile.am | 104 ++++++++ - xkb/ibus-engine-xkb-main.c | 413 ++++++++++++++++++++++++++++++ - xkb/ibus-engine-xkb-main.h | 46 ++++ - xkb/ibus-xkb-main.c | 112 ++++++++ - xkb/xkblayout.xml.in | 16 ++ - xkb/xkblayoutconfig.xml.in | 6 + - xkb/xkblib.c | 327 ++++++++++++++++++++++++ - xkb/xkblib.h | 41 +++ - xkb/xkbxml.c | 345 +++++++++++++++++++++++++ - xkb/xkbxml.h | 113 ++++++++ - 30 files changed, 4036 insertions(+), 4 deletions(-) + Makefile.am | 7 + + configure.ac | 56 + + data/ibus.schemas.in | 36 + + ibus-1.0.pc.in | 2 + + ibus/Makefile.am | 26 + + ibus/__init__.py | 2 + + ibus/bus.py | 3 + + ibus/interface/iibus.py | 3 + + ibus/xkblayout.py.in | 230 +++ + ibus/xkbxml.py.in | 419 ++++ + setup/Makefile.am | 1 + + setup/enginecombobox.py | 7 +- + setup/main.py | 3 + + setup/setup.ui | 609 ++++++- + setup/xkbsetup.py | 457 +++++ + src/Makefile.am | 5 + + src/ibus.h | 1 + + src/ibusxkbxml.c | 441 +++++ + src/ibusxkbxml.h | 172 ++ + ui/gtk/panel.py | 41 + + xkb/Makefile.am | 107 + + xkb/Makefile.am.orig | 104 + + xkb/gtkimcontextsimpleseqs.h | 4484 ++++++++++++++++++++++++++++++++++++++++++ + xkb/ibus-engine-xkb-main.c | 303 +++ + xkb/ibus-engine-xkb-main.h | 32 + + xkb/ibus-simple-engine.c | 1049 ++++++++++ + xkb/ibus-simple-engine.h | 11 + + xkb/ibus-xkb-main.c | 112 ++ + xkb/xkblayout.xml.in | 16 + + xkb/xkblayoutconfig.xml.in | 6 + + xkb/xkblib.c | 327 +++ + xkb/xkblib.h | 41 + + xkb/xkbxml.c | 345 ++++ + xkb/xkbxml.h | 113 ++ + 34 files changed, 9567 insertions(+), 4 deletions(-) create mode 100644 ibus/xkblayout.py.in create mode 100644 ibus/xkbxml.py.in create mode 100644 setup/xkbsetup.py create mode 100644 src/ibusxkbxml.c create mode 100644 src/ibusxkbxml.h create mode 100644 xkb/Makefile.am + create mode 100644 xkb/Makefile.am.orig + create mode 100644 xkb/gtkimcontextsimpleseqs.h create mode 100644 xkb/ibus-engine-xkb-main.c create mode 100644 xkb/ibus-engine-xkb-main.h + create mode 100644 xkb/ibus-simple-engine.c + create mode 100644 xkb/ibus-simple-engine.h create mode 100644 xkb/ibus-xkb-main.c create mode 100644 xkb/xkblayout.xml.in create mode 100644 xkb/xkblayoutconfig.xml.in @@ -68,19 +76,19 @@ index ff0fabc..056ddfc 100644 if ENABLE_MEMCONF MEMCONF_DIRS = \ memconf \ -@@ -60,6 +66,7 @@ SUBDIRS = \ +@@ -66,6 +72,7 @@ SUBDIRS = \ $(DAEMON_DIRS) \ $(PYTHON_DIRS) \ $(GCONF_DIRS) \ + $(XKB_DIRS) \ $(MEMCONF_DIRS) \ + $(DCONF_DIRS) \ $(NULL) - diff --git a/configure.ac b/configure.ac -index c3bd423..4c20ae7 100644 +index 367b069..e90f20e 100644 --- a/configure.ac +++ b/configure.ac -@@ -185,6 +185,60 @@ else +@@ -191,6 +191,60 @@ else enable_xim="no (disabled, use --enable-xim to enable)" fi @@ -141,15 +149,15 @@ index c3bd423..4c20ae7 100644 # GObject introspection GOBJECT_INTROSPECTION_CHECK([0.6.8]) -@@ -451,6 +505,7 @@ bindings/Makefile - gconf/gconf.xml.in - bindings/Makefile +@@ -457,6 +511,7 @@ bindings/Makefile bindings/vala/Makefile + dconf/Makefile + dconf/dconf.xml.in +xkb/Makefile ]) AC_OUTPUT -@@ -466,6 +521,7 @@ Build options: +@@ -472,6 +527,7 @@ Build options: Build gtk2 immodule $enable_gtk2 Build gtk3 immodule $enable_gtk3 Build XIM agent server $enable_xim @@ -1679,10 +1687,10 @@ index 0a69df8..f1e6d0b 100644 diff --git a/setup/xkbsetup.py b/setup/xkbsetup.py new file mode 100644 -index 0000000..1685bff +index 0000000..af9ec53 --- /dev/null +++ b/setup/xkbsetup.py -@@ -0,0 +1,454 @@ +@@ -0,0 +1,457 @@ +# vim:set et sts=4 sw=4: +# +# ibus - The Input Bus @@ -1732,8 +1740,7 @@ index 0000000..1685bff + self.__button_system_keyboard_layout.connect("clicked", self.__button_system_keyboard_layout_cb) + + # use system keyboard layout setting -+ button = self.__builder.get_object("checkbutton_use_sys_layout") -+ button.connect("toggled", lambda button: self.__button_system_keyboard_layout.set_sensitive(button.get_active())) ++ self.__config.connect("value-changed", self.__config_value_changed_cb) + + self.__xkblayoutconfig = None + self.__preload_xkb_engines = [] @@ -1748,6 +1755,10 @@ index 0000000..1685bff + # default system keyboard dialog + self.__init_system_keyboard() + ++ def __config_value_changed_cb(self, bus, section, name, value): ++ if section == "general" and name == "use_system_keyboard_layout": ++ self.__button_system_keyboard_layout.set_sensitive(value) ++ + def __get_xkb_engines(self): + xkb_engines = [] + xkbconfig = ibus.XKBConfigRegistry() @@ -2138,10 +2149,10 @@ index 0000000..1685bff + expander.set_data("checked", checked) + diff --git a/src/Makefile.am b/src/Makefile.am -index a53bd23..6454522 100644 +index 90e412f..fc7008e 100644 --- a/src/Makefile.am +++ b/src/Makefile.am -@@ -184,6 +184,11 @@ typelibs_DATA = $(INTROSPECTION_GIRS:.gir=.typelib) +@@ -186,6 +186,11 @@ typelibs_DATA = $(INTROSPECTION_GIRS:.gir=.typelib) CLEANFILES += $(dist_gir_DATA) $(typelibs_DATA) endif @@ -2154,11 +2165,11 @@ index a53bd23..6454522 100644 ibusenumtypes.h: $(ibus_headers) ibusenumtypes.h.template $(AM_V_GEN) ( top_builddir=`cd $(top_builddir) && pwd`; \ diff --git a/src/ibus.h b/src/ibus.h -index c408f3d..6bb9ff5 100644 +index 0765799..5843b7f 100644 --- a/src/ibus.h +++ b/src/ibus.h -@@ -44,6 +44,7 @@ - #include +@@ -45,6 +45,7 @@ + #include #include #include +#include @@ -2167,10 +2178,10 @@ index c408f3d..6bb9ff5 100644 #include diff --git a/src/ibusxkbxml.c b/src/ibusxkbxml.c new file mode 100644 -index 0000000..c630eb9 +index 0000000..5386fdb --- /dev/null +++ b/src/ibusxkbxml.c -@@ -0,0 +1,440 @@ +@@ -0,0 +1,441 @@ +/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */ +/* vim:set et sts=4: */ +/* bus - The Input Bus @@ -2200,6 +2211,7 @@ index 0000000..c630eb9 +#include + +#include "ibus.h" ++#include "ibusxkbxml.h" + +#ifndef XKB_RULES_XML_FILE +#define XKB_RULES_XML_FILE "/usr/share/X11/xkb/rules/evdev.xml" @@ -2884,9 +2896,122 @@ index 90be1d5..8804634 100644 + return "default" diff --git a/xkb/Makefile.am b/xkb/Makefile.am new file mode 100644 -index 0000000..ad9cdd9 +index 0000000..b4d8ba2 --- /dev/null +++ b/xkb/Makefile.am +@@ -0,0 +1,107 @@ ++# vim:set noet ts=4: ++# ++# ibus - The Input Bus ++# ++# Copyright (C) 2011 Takao Fujiwara ++# Copyright (c) 2011 Peng Huang ++# Copyright (c) 2011 Red Hat, Inc. ++# ++# This library is free software; you can redistribute it and/or ++# modify it under the terms of the GNU Lesser General Public ++# License as published by the Free Software Foundation; either ++# version 2 of the License, or (at your option) any later version. ++# ++# This library is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU Lesser General Public License for more details. ++# ++# You should have received a copy of the GNU Lesser General Public ++# License along with this program; if not, write to the ++# Free Software Foundation, Inc., 59 Temple Place, Suite 330, ++# Boston, MA 02111-1307 USA ++ ++libibus = $(top_builddir)/src/libibus-@IBUS_API_VERSION@.la ++ ++INCLUDES = \ ++ -I$(top_srcdir) \ ++ -I$(top_srcdir)/src \ ++ -DIBUS_LOCALEDIR=\"$(datadir)/locale\" \ ++ -DLIBEXECDIR=\""$(libexecdir)"\" \ ++ $(NULL) ++ ++noinst_PROGRAMS = $(TESTS) ++libexec_PROGRAMS = ++EXTRA_DIST = ++DISTCLEANFILES = ++ ++if ENABLE_XKB ++libexec_PROGRAMS += ibus-xkb ++ibus_xkb_SOURCES = \ ++ ibus-xkb-main.c \ ++ xkblib.h \ ++ xkblib.c \ ++ $(NULL) ++ibus_xkb_CFLAGS = \ ++ @XKB_CFLAGS@ \ ++ @X11_CFLAGS@ \ ++ @GLIB2_CFLAGS@ \ ++ $(NULL) ++ibus_xkb_LDADD = \ ++ @XKB_LIBS@ \ ++ @X11_LIBS@ \ ++ @GLIB2_LIBS@ \ ++ $(libibus) \ ++ $(NULL) ++ ++libexec_PROGRAMS += ibus-engine-xkb ++ibus_engine_xkb_SOURCES = \ ++ ibus-engine-xkb-main.c \ ++ ibus-engine-xkb-main.h \ ++ ibus-simple-engine.c \ ++ ibus-simple-engine.h \ ++ gtkimcontextsimpleseqs.h \ ++ xkbxml.c \ ++ xkbxml.h \ ++ $(NULL) ++ibus_engine_xkb_CFLAGS = \ ++ @GLIB2_CFLAGS@ \ ++ @GOBJECT2_CFLAGS@ \ ++ @GCONF_CFLAGS@ \ ++ $(NULL) ++ibus_engine_xkb_LDADD = \ ++ @GLIB2_LIBS@ \ ++ @GOBJECT2_LIBS@ \ ++ @GCONF_LIBS@ \ ++ $(libibus) \ ++ $(NULL) ++ ++xkblayoutdir = $(datadir)/ibus/component ++xkblayout_in_files = xkblayout.xml.in ++xkblayout_DATA = $(xkblayout_in_files:.xml.in=.xml) ++ ++xkblayoutconfigdir = $(datadir)/ibus/xkb ++xkblayoutconfig_in_files = xkblayoutconfig.xml.in ++xkblayoutconfig_DATA = $(xkblayoutconfig_in_files:.xml.in=.xml) ++ ++%.xml : %.xml.in ++ @sed -e "s|\@libexecdir\@|$(libexecdir)|g" \ ++ -e "s|\@datadir\@|$(datadir)|g" \ ++ -e "s|\@XKB_PRELOAD_LAYOUTS\@|$(XKB_PRELOAD_LAYOUTS)|g" \ ++ $< > $@ ++ ++INCLUDES += \ ++ -DXKBLAYOUTCONFIG_FILE=\""$(xkblayoutconfigdir)/$(xkblayoutconfig_DATA)"\" \ ++ $(NULL) ++ ++EXTRA_DIST += \ ++ $(xkblayout_in_files) \ ++ $(xkblayoutconfig_in_files) \ ++ $(NULL) ++ ++DISTCLEANFILES += \ ++ $(xkblayout_DATA) \ ++ $(xkblayoutconfig_DATA) \ ++ $(NULL) ++ ++endif +diff --git a/xkb/Makefile.am.orig b/xkb/Makefile.am.orig +new file mode 100644 +index 0000000..ad9cdd9 +--- /dev/null ++++ b/xkb/Makefile.am.orig @@ -0,0 +1,104 @@ +# vim:set noet ts=4: +# @@ -2992,12 +3117,4502 @@ index 0000000..ad9cdd9 + $(NULL) + +endif +diff --git a/xkb/gtkimcontextsimpleseqs.h b/xkb/gtkimcontextsimpleseqs.h +new file mode 100644 +index 0000000..00dc83c +--- /dev/null ++++ b/xkb/gtkimcontextsimpleseqs.h +@@ -0,0 +1,4484 @@ ++/* GTK - The GIMP Tool Kit ++ * Copyright (C) 2007, 2008 GNOME Foundation ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, write to the ++ * Free Software Foundation, Inc., 59 Temple Place - Suite 330, ++ * Boston, MA 02111-1307, USA. ++ */ ++ ++/* ++ * File auto-generated from script found at http://bugzilla.gnome.org/show_bug.cgi?id=321896 ++ * using the input files ++ * Input : http://gitweb.freedesktop.org/?p=xorg/lib/libX11.git;a=blob_plain;f=nls/en_US.UTF-8/Compose.pre ++ * Input : http://www.cl.cam.ac.uk/~mgk25/ucs/keysyms.txt ++ * Input : http://www.unicode.org/Public/UNIDATA/UnicodeData.txt ++ * ++ * This table is optimised for space and requires special handling to access the content. ++ * This table is used solely by http://svn.gnome.org/viewcvs/gtk%2B/trunk/gtk/gtkimcontextsimple.c ++ * ++ * The resulting file is placed at http://svn.gnome.org/viewcvs/gtk%2B/trunk/gtk/gtkimcontextsimpleseqs.h ++ * This file is described in bug report http://bugzilla.gnome.org/show_bug.cgi?id=321896 ++ */ ++ ++/* ++ * Modified by the GTK+ Team and others 2007, 2008. See the AUTHORS ++ * file for a list of people on the GTK+ Team. See the ChangeLog ++ * files for a list of changes. These files are distributed with ++ * GTK+ at ftp://ftp.gtk.org/pub/gtk/. ++ */ ++ ++#ifndef __GTK_IM_CONTEXT_SIMPLE_SEQS_H__ ++#define __GTK_IM_CONTEXT_SIMPLE_SEQS_H__ ++ ++/* === These are the original comments of the file; we keep for historical purposes === ++ * ++ * The following table was generated from the X compose tables include with ++ * XFree86 4.0 using a set of Perl scripts. Contact Owen Taylor ++ * to obtain the relevant perl scripts. ++ * ++ * The following compose letter letter sequences confliced ++ * Dstroke/dstroke and ETH/eth; resolved to Dstroke (Croation, Vietnamese, Lappish), over ++ * ETH (Icelandic, Faroese, old English, IPA) [ D- -D d- -d ] ++ * Amacron/amacron and ordfeminine; resolved to ordfeminine [ _A A_ a_ _a ] ++ * Amacron/amacron and Atilde/atilde; resolved to atilde [ -A A- a- -a ] ++ * Omacron/Omacron and masculine; resolved to masculine [ _O O_ o_ _o ] ++ * Omacron/omacron and Otilde/atilde; resolved to otilde [ -O O- o- -o ] ++ * ++ * [ Amacron and Omacron are in Latin-4 (Baltic). ordfeminine and masculine are used for ++ * spanish. atilde and otilde are used at least for Portuguese ] ++ * ++ * at and Aring; resolved to Aring [ AA ] ++ * guillemotleft and caron; resolved to guillemotleft [ << ] ++ * ogonek and cedilla; resolved to cedilla [ ,, ] ++ * ++ * This probably should be resolved by first checking an additional set of compose tables ++ * that depend on the locale or selected input method. ++ */ ++ ++static const guint16 gtk_compose_seqs_compact[] = { ++IBUS_dead_stroke, 144, 232, 241, 241, 241, ++IBUS_Greek_accentdieresis, 241, 245, 245, 245, 245, ++IBUS_dead_grave, 245, 307, 394, 606, 606, ++IBUS_dead_acute, 606, 670, 766, 1042, 1042, ++IBUS_dead_circumflex, 1042, 1166, 1166, 1366, 1366, ++IBUS_dead_tilde, 1366, 1450, 1513, 1653, 1653, ++IBUS_dead_macron, 1653, 1699, 1699, 1771, 1771, ++IBUS_dead_breve, 1771, 1821, 1821, 1845, 1845, ++IBUS_dead_abovedot, 1845, 1875, 1878, 1910, 1910, ++IBUS_dead_diaeresis, 1910, 1998, 2007, 2031, 2031, ++IBUS_dead_abovering, 2031, 2041, 2041, 2041, 2041, ++IBUS_dead_doubleacute, 2041, 2051, 2051, 2051, 2051, ++IBUS_dead_caron, 2051, 2093, 2093, 2101, 2101, ++IBUS_dead_cedilla, 2101, 2113, 2113, 2113, 2113, ++IBUS_dead_ogonek, 2113, 2123, 2123, 2123, 2123, ++IBUS_dead_iota, 2123, 2145, 2244, 2676, 3336, ++IBUS_dead_voiced_sound, 3336, 3382, 3382, 3382, 3382, ++IBUS_dead_semivoiced_sound, 3382, 3392, 3392, 3392, 3392, ++IBUS_dead_belowdot, 3392, 3408, 3408, 3424, 3424, ++IBUS_dead_hook, 3424, 3500, 3500, 3556, 3556, ++IBUS_dead_horn, 3556, 3566, 3566, 3566, 3566, ++IBUS_dead_psili, 3566, 3594, 3594, 3594, 3594, ++IBUS_dead_dasia, 3594, 3626, 3626, 3626, 3626, ++IBUS_Multi_key, 3626, 3626, 9560, 13268, 15133, ++IBUS_space, 0x002F, ++IBUS_2, 0x01BB, ++IBUS_A, 0x023A, ++IBUS_B, 0x0243, ++IBUS_C, 0x023B, ++IBUS_D, 0x0110, ++IBUS_E, 0x0246, ++IBUS_G, 0x01E4, ++IBUS_H, 0x0126, ++IBUS_I, 0x0197, ++IBUS_J, 0x0248, ++IBUS_L, 0x0141, ++IBUS_O, 0x00D8, ++IBUS_P, 0x2C63, ++IBUS_R, 0x024C, ++IBUS_T, 0x0166, ++IBUS_U, 0x0244, ++IBUS_Y, 0x024E, ++IBUS_Z, 0x01B5, ++IBUS_a, 0x2C65, ++IBUS_b, 0x0180, ++IBUS_c, 0x023C, ++IBUS_d, 0x0111, ++IBUS_e, 0x0247, ++IBUS_g, 0x01E5, ++IBUS_h, 0x0127, ++IBUS_i, 0x0268, ++IBUS_j, 0x0249, ++IBUS_l, 0x0142, ++IBUS_o, 0x00F8, ++IBUS_p, 0x1D7D, ++IBUS_r, 0x024D, ++IBUS_t, 0x0167, ++IBUS_u, 0x0289, ++IBUS_y, 0x024F, ++IBUS_z, 0x01B6, ++IBUS_nobreakspace, 0x0338, ++IBUS_Oacute, 0x01FE, ++IBUS_oacute, 0x01FF, ++0x0237, 0x025F, ++0x0269, 0x1D7C, ++IBUS_dead_stroke, 0x002F, ++IBUS_lessthanequal, 0x2270, ++IBUS_greaterthanequal, 0x2271, ++IBUS_dead_acute, IBUS_O, 0x01FE, ++IBUS_dead_acute, IBUS_o, 0x01FF, ++IBUS_dead_abovedot, IBUS_j, 0x025F, ++IBUS_Greek_iota, 0x0390, ++IBUS_Greek_upsilon, 0x03B0, ++IBUS_space, 0x0060, ++IBUS_V, 0x01DB, ++IBUS_v, 0x01DC, ++IBUS_nobreakspace, 0x0300, ++IBUS_Abreve, 0x1EB0, ++IBUS_abreve, 0x1EB1, ++IBUS_Emacron, 0x1E14, ++IBUS_emacron, 0x1E15, ++IBUS_Omacron, 0x1E50, ++IBUS_omacron, 0x1E51, ++IBUS_Cyrillic_ie, 0x0450, ++IBUS_Cyrillic_i, 0x045D, ++IBUS_Cyrillic_IE, 0x0400, ++IBUS_Cyrillic_I, 0x040D, ++IBUS_Greek_iotadieresis, 0x1FD2, ++IBUS_Greek_upsilondieresis, 0x1FE2, ++IBUS_Greek_ALPHA, 0x1FBA, ++IBUS_Greek_EPSILON, 0x1FC8, ++IBUS_Greek_ETA, 0x1FCA, ++IBUS_Greek_IOTA, 0x1FDA, ++IBUS_Greek_OMICRON, 0x1FF8, ++IBUS_Greek_UPSILON, 0x1FEA, ++IBUS_Greek_OMEGA, 0x1FFA, ++IBUS_Greek_alpha, 0x1F70, ++IBUS_Greek_epsilon, 0x1F72, ++IBUS_Greek_eta, 0x1F74, ++IBUS_Greek_iota, 0x1F76, ++IBUS_Greek_omicron, 0x1F78, ++IBUS_Greek_upsilon, 0x1F7A, ++IBUS_Greek_omega, 0x1F7C, ++IBUS_dead_grave, 0x0060, ++IBUS_dead_diaeresis, IBUS_Greek_iota, 0x1FD2, ++IBUS_dead_diaeresis, IBUS_Greek_upsilon, 0x1FE2, ++IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F0A, ++IBUS_dead_psili, IBUS_Greek_EPSILON, 0x1F1A, ++IBUS_dead_psili, IBUS_Greek_ETA, 0x1F2A, ++IBUS_dead_psili, IBUS_Greek_IOTA, 0x1F3A, ++IBUS_dead_psili, IBUS_Greek_OMICRON, 0x1F4A, ++IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1F6A, ++IBUS_dead_psili, IBUS_Greek_alpha, 0x1F02, ++IBUS_dead_psili, IBUS_Greek_epsilon, 0x1F12, ++IBUS_dead_psili, IBUS_Greek_eta, 0x1F22, ++IBUS_dead_psili, IBUS_Greek_iota, 0x1F32, ++IBUS_dead_psili, IBUS_Greek_omicron, 0x1F42, ++IBUS_dead_psili, IBUS_Greek_upsilon, 0x1F52, ++IBUS_dead_psili, IBUS_Greek_omega, 0x1F62, ++IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F0B, ++IBUS_dead_dasia, IBUS_Greek_EPSILON, 0x1F1B, ++IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F2B, ++IBUS_dead_dasia, IBUS_Greek_IOTA, 0x1F3B, ++IBUS_dead_dasia, IBUS_Greek_OMICRON, 0x1F4B, ++IBUS_dead_dasia, IBUS_Greek_UPSILON, 0x1F5B, ++IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1F6B, ++IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F03, ++IBUS_dead_dasia, IBUS_Greek_epsilon, 0x1F13, ++IBUS_dead_dasia, IBUS_Greek_eta, 0x1F23, ++IBUS_dead_dasia, IBUS_Greek_iota, 0x1F33, ++IBUS_dead_dasia, IBUS_Greek_omicron, 0x1F43, ++IBUS_dead_dasia, IBUS_Greek_upsilon, 0x1F53, ++IBUS_dead_dasia, IBUS_Greek_omega, 0x1F63, ++IBUS_Multi_key, IBUS_quotedbl, IBUS_U, 0x01DB, ++IBUS_Multi_key, IBUS_quotedbl, IBUS_u, 0x01DC, ++IBUS_Multi_key, IBUS_quotedbl, IBUS_Greek_iota, 0x1FD2, ++IBUS_Multi_key, IBUS_quotedbl, IBUS_Greek_upsilon, 0x1FE2, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F0B, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_EPSILON, 0x1F1B, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ETA, 0x1F2B, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_IOTA, 0x1F3B, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_OMICRON, 0x1F4B, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_UPSILON, 0x1F5B, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1F6B, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_alpha, 0x1F03, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_epsilon, 0x1F13, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_eta, 0x1F23, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_iota, 0x1F33, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_omicron, 0x1F43, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_upsilon, 0x1F53, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_omega, 0x1F63, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F0A, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_EPSILON, 0x1F1A, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ETA, 0x1F2A, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_IOTA, 0x1F3A, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_OMICRON, 0x1F4A, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_OMEGA, 0x1F6A, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_alpha, 0x1F02, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_epsilon, 0x1F12, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_eta, 0x1F22, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_iota, 0x1F32, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_omicron, 0x1F42, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_upsilon, 0x1F52, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_omega, 0x1F62, ++IBUS_Multi_key, IBUS_plus, IBUS_O, 0x1EDC, ++IBUS_Multi_key, IBUS_plus, IBUS_U, 0x1EEA, ++IBUS_Multi_key, IBUS_plus, IBUS_o, 0x1EDD, ++IBUS_Multi_key, IBUS_plus, IBUS_u, 0x1EEB, ++IBUS_Multi_key, IBUS_U, IBUS_A, 0x1EB0, ++IBUS_Multi_key, IBUS_U, IBUS_a, 0x1EB1, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_A, 0x1EA6, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_E, 0x1EC0, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_O, 0x1ED2, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_a, 0x1EA7, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_e, 0x1EC1, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_o, 0x1ED3, ++IBUS_Multi_key, IBUS_underscore, IBUS_E, 0x1E14, ++IBUS_Multi_key, IBUS_underscore, IBUS_O, 0x1E50, ++IBUS_Multi_key, IBUS_underscore, IBUS_e, 0x1E15, ++IBUS_Multi_key, IBUS_underscore, IBUS_o, 0x1E51, ++IBUS_Multi_key, IBUS_b, IBUS_A, 0x1EB0, ++IBUS_Multi_key, IBUS_b, IBUS_a, 0x1EB1, ++IBUS_Multi_key, IBUS_macron, IBUS_E, 0x1E14, ++IBUS_Multi_key, IBUS_macron, IBUS_O, 0x1E50, ++IBUS_Multi_key, IBUS_macron, IBUS_e, 0x1E15, ++IBUS_Multi_key, IBUS_macron, IBUS_o, 0x1E51, ++IBUS_space, 0x0027, ++IBUS_V, 0x01D7, ++IBUS_v, 0x01D8, ++IBUS_nobreakspace, 0x0301, ++IBUS_Abreve, 0x1EAE, ++IBUS_abreve, 0x1EAF, ++IBUS_Emacron, 0x1E16, ++IBUS_emacron, 0x1E17, ++IBUS_Utilde, 0x1E78, ++IBUS_omacron, 0x1E53, ++IBUS_utilde, 0x1E79, ++IBUS_Cyrillic_ghe, 0x0453, ++IBUS_Cyrillic_ka, 0x045C, ++IBUS_Cyrillic_GHE, 0x0403, ++IBUS_Cyrillic_KA, 0x040C, ++IBUS_Greek_iotadieresis, 0x0390, ++IBUS_Greek_upsilondieresis, 0x03B0, ++IBUS_Greek_ALPHA, 0x0386, ++IBUS_Greek_EPSILON, 0x0388, ++IBUS_Greek_ETA, 0x0389, ++IBUS_Greek_IOTA, 0x038A, ++IBUS_Greek_OMICRON, 0x038C, ++IBUS_Greek_UPSILON, 0x038E, ++IBUS_Greek_OMEGA, 0x038F, ++IBUS_Greek_alpha, 0x03AC, ++IBUS_Greek_epsilon, 0x03AD, ++IBUS_Greek_eta, 0x03AE, ++IBUS_Greek_iota, 0x03AF, ++IBUS_Greek_omicron, 0x03CC, ++IBUS_Greek_upsilon, 0x03CD, ++IBUS_Greek_omega, 0x03CE, ++IBUS_dead_acute, 0x00B4, ++IBUS_dead_stroke, IBUS_O, 0x01FE, ++IBUS_dead_stroke, IBUS_o, 0x01FF, ++IBUS_dead_diaeresis, IBUS_space, 0x0385, ++IBUS_dead_diaeresis, IBUS_Greek_iota, 0x0390, ++IBUS_dead_diaeresis, IBUS_Greek_upsilon, 0x03B0, ++IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F0C, ++IBUS_dead_psili, IBUS_Greek_EPSILON, 0x1F1C, ++IBUS_dead_psili, IBUS_Greek_ETA, 0x1F2C, ++IBUS_dead_psili, IBUS_Greek_IOTA, 0x1F3C, ++IBUS_dead_psili, IBUS_Greek_OMICRON, 0x1F4C, ++IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1F6C, ++IBUS_dead_psili, IBUS_Greek_alpha, 0x1F04, ++IBUS_dead_psili, IBUS_Greek_epsilon, 0x1F14, ++IBUS_dead_psili, IBUS_Greek_eta, 0x1F24, ++IBUS_dead_psili, IBUS_Greek_iota, 0x1F34, ++IBUS_dead_psili, IBUS_Greek_omicron, 0x1F44, ++IBUS_dead_psili, IBUS_Greek_upsilon, 0x1F54, ++IBUS_dead_psili, IBUS_Greek_omega, 0x1F64, ++IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F0D, ++IBUS_dead_dasia, IBUS_Greek_EPSILON, 0x1F1D, ++IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F2D, ++IBUS_dead_dasia, IBUS_Greek_IOTA, 0x1F3D, ++IBUS_dead_dasia, IBUS_Greek_OMICRON, 0x1F4D, ++IBUS_dead_dasia, IBUS_Greek_UPSILON, 0x1F5D, ++IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1F6D, ++IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F05, ++IBUS_dead_dasia, IBUS_Greek_epsilon, 0x1F15, ++IBUS_dead_dasia, IBUS_Greek_eta, 0x1F25, ++IBUS_dead_dasia, IBUS_Greek_iota, 0x1F35, ++IBUS_dead_dasia, IBUS_Greek_omicron, 0x1F45, ++IBUS_dead_dasia, IBUS_Greek_upsilon, 0x1F55, ++IBUS_dead_dasia, IBUS_Greek_omega, 0x1F65, ++IBUS_Multi_key, IBUS_quotedbl, IBUS_I, 0x1E2E, ++IBUS_Multi_key, IBUS_quotedbl, IBUS_U, 0x01D7, ++IBUS_Multi_key, IBUS_quotedbl, IBUS_i, 0x1E2F, ++IBUS_Multi_key, IBUS_quotedbl, IBUS_u, 0x01D8, ++IBUS_Multi_key, IBUS_quotedbl, IBUS_Greek_iota, 0x0390, ++IBUS_Multi_key, IBUS_quotedbl, IBUS_Greek_upsilon, 0x03B0, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F0D, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_EPSILON, 0x1F1D, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ETA, 0x1F2D, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_IOTA, 0x1F3D, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_OMICRON, 0x1F4D, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_UPSILON, 0x1F5D, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1F6D, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_alpha, 0x1F05, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_epsilon, 0x1F15, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_eta, 0x1F25, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_iota, 0x1F35, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_omicron, 0x1F45, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_upsilon, 0x1F55, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_omega, 0x1F65, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F0C, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_EPSILON, 0x1F1C, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ETA, 0x1F2C, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_IOTA, 0x1F3C, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_OMICRON, 0x1F4C, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_OMEGA, 0x1F6C, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_alpha, 0x1F04, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_epsilon, 0x1F14, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_eta, 0x1F24, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_iota, 0x1F34, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_omicron, 0x1F44, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_upsilon, 0x1F54, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_omega, 0x1F64, ++IBUS_Multi_key, IBUS_plus, IBUS_O, 0x1EDA, ++IBUS_Multi_key, IBUS_plus, IBUS_U, 0x1EE8, ++IBUS_Multi_key, IBUS_plus, IBUS_o, 0x1EDB, ++IBUS_Multi_key, IBUS_plus, IBUS_u, 0x1EE9, ++IBUS_Multi_key, IBUS_comma, IBUS_C, 0x1E08, ++IBUS_Multi_key, IBUS_comma, IBUS_c, 0x1E09, ++IBUS_Multi_key, IBUS_slash, IBUS_O, 0x01FE, ++IBUS_Multi_key, IBUS_slash, IBUS_o, 0x01FF, ++IBUS_Multi_key, IBUS_U, IBUS_A, 0x1EAE, ++IBUS_Multi_key, IBUS_U, IBUS_a, 0x1EAF, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_A, 0x1EA4, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_E, 0x1EBE, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_O, 0x1ED0, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_a, 0x1EA5, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_e, 0x1EBF, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_o, 0x1ED1, ++IBUS_Multi_key, IBUS_underscore, IBUS_E, 0x1E16, ++IBUS_Multi_key, IBUS_underscore, IBUS_O, 0x1E52, ++IBUS_Multi_key, IBUS_underscore, IBUS_e, 0x1E17, ++IBUS_Multi_key, IBUS_underscore, IBUS_o, 0x1E53, ++IBUS_Multi_key, IBUS_b, IBUS_A, 0x1EAE, ++IBUS_Multi_key, IBUS_b, IBUS_a, 0x1EAF, ++IBUS_Multi_key, IBUS_o, IBUS_A, 0x01FA, ++IBUS_Multi_key, IBUS_o, IBUS_a, 0x01FB, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_O, 0x1E4C, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_U, 0x1E78, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_o, 0x1E4D, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_u, 0x1E79, ++IBUS_Multi_key, IBUS_macron, IBUS_E, 0x1E16, ++IBUS_Multi_key, IBUS_macron, IBUS_O, 0x1E52, ++IBUS_Multi_key, IBUS_macron, IBUS_e, 0x1E17, ++IBUS_Multi_key, IBUS_macron, IBUS_o, 0x1E53, ++IBUS_Multi_key, IBUS_cedilla, IBUS_C, 0x1E08, ++IBUS_Multi_key, IBUS_cedilla, IBUS_c, 0x1E09, ++IBUS_Multi_key, IBUS_KP_Divide, IBUS_O, 0x01FE, ++IBUS_Multi_key, IBUS_KP_Divide, IBUS_o, 0x01FF, ++IBUS_space, 0x005E, ++IBUS_parenleft, 0x207D, ++IBUS_parenright, 0x207E, ++IBUS_plus, 0x207A, ++IBUS_minus, 0x207B, ++IBUS_0, 0x2070, ++IBUS_1, 0x00B9, ++IBUS_2, 0x00B2, ++IBUS_3, 0x00B3, ++IBUS_4, 0x2074, ++IBUS_5, 0x2075, ++IBUS_6, 0x2076, ++IBUS_7, 0x2077, ++IBUS_8, 0x2078, ++IBUS_9, 0x2079, ++IBUS_equal, 0x207C, ++IBUS_nobreakspace, 0x0302, ++IBUS_Agrave, 0x1EA6, ++IBUS_Aacute, 0x1EA4, ++IBUS_Atilde, 0x1EAA, ++IBUS_Egrave, 0x1EC0, ++IBUS_Eacute, 0x1EBE, ++IBUS_Ograve, 0x1ED2, ++IBUS_Oacute, 0x1ED0, ++IBUS_Otilde, 0x1ED6, ++IBUS_agrave, 0x1EA7, ++IBUS_aacute, 0x1EA5, ++IBUS_atilde, 0x1EAB, ++IBUS_egrave, 0x1EC1, ++IBUS_eacute, 0x1EBF, ++IBUS_ograve, 0x1ED3, ++IBUS_oacute, 0x1ED1, ++IBUS_otilde, 0x1ED7, ++0x2212, 0x207B, ++0x4E00, 0x3192, ++0x4E01, 0x319C, ++0x4E09, 0x3194, ++0x4E0A, 0x3196, ++0x4E0B, 0x3198, ++0x4E19, 0x319B, ++0x4E2D, 0x3197, ++0x4E59, 0x319A, ++0x4E8C, 0x3193, ++0x4EBA, 0x319F, ++0x56DB, 0x3195, ++0x5730, 0x319E, ++0x5929, 0x319D, ++0x7532, 0x3199, ++IBUS_dead_circumflex, 0x005E, ++IBUS_KP_Space, 0x00B2, ++IBUS_KP_Add, 0x207A, ++IBUS_KP_0, 0x2070, ++IBUS_KP_1, 0x00B9, ++IBUS_KP_2, 0x00B2, ++IBUS_KP_3, 0x00B3, ++IBUS_KP_4, 0x2074, ++IBUS_KP_5, 0x2075, ++IBUS_KP_6, 0x2076, ++IBUS_KP_7, 0x2077, ++IBUS_KP_8, 0x2078, ++IBUS_KP_9, 0x2079, ++IBUS_KP_Equal, 0x207C, ++IBUS_Multi_key, IBUS_exclam, IBUS_A, 0x1EAC, ++IBUS_Multi_key, IBUS_exclam, IBUS_E, 0x1EC6, ++IBUS_Multi_key, IBUS_exclam, IBUS_O, 0x1ED8, ++IBUS_Multi_key, IBUS_exclam, IBUS_a, 0x1EAD, ++IBUS_Multi_key, IBUS_exclam, IBUS_e, 0x1EC7, ++IBUS_Multi_key, IBUS_exclam, IBUS_o, 0x1ED9, ++IBUS_Multi_key, IBUS_S, IBUS_M, 0x2120, ++IBUS_Multi_key, IBUS_S, IBUS_m, 0x2120, ++IBUS_Multi_key, IBUS_T, IBUS_M, 0x2122, ++IBUS_Multi_key, IBUS_T, IBUS_m, 0x2122, ++IBUS_Multi_key, IBUS_underscore, IBUS_a, 0x00AA, ++IBUS_Multi_key, IBUS_underscore, IBUS_h, 0x02B0, ++IBUS_Multi_key, IBUS_underscore, IBUS_i, 0x2071, ++IBUS_Multi_key, IBUS_underscore, IBUS_j, 0x02B2, ++IBUS_Multi_key, IBUS_underscore, IBUS_l, 0x02E1, ++IBUS_Multi_key, IBUS_underscore, IBUS_n, 0x207F, ++IBUS_Multi_key, IBUS_underscore, IBUS_o, 0x00BA, ++IBUS_Multi_key, IBUS_underscore, IBUS_r, 0x02B3, ++IBUS_Multi_key, IBUS_underscore, IBUS_s, 0x02E2, ++IBUS_Multi_key, IBUS_underscore, IBUS_w, 0x02B7, ++IBUS_Multi_key, IBUS_underscore, IBUS_x, 0x02E3, ++IBUS_Multi_key, IBUS_underscore, IBUS_y, 0x02B8, ++IBUS_Multi_key, IBUS_underscore, 0x0263, 0x02E0, ++IBUS_Multi_key, IBUS_underscore, 0x0266, 0x02B1, ++IBUS_Multi_key, IBUS_underscore, 0x0279, 0x02B4, ++IBUS_Multi_key, IBUS_underscore, 0x027B, 0x02B5, ++IBUS_Multi_key, IBUS_underscore, 0x0281, 0x02B6, ++IBUS_Multi_key, IBUS_underscore, 0x0295, 0x02E4, ++IBUS_Multi_key, IBUS_s, IBUS_M, 0x2120, ++IBUS_Multi_key, IBUS_s, IBUS_m, 0x2120, ++IBUS_Multi_key, IBUS_t, IBUS_M, 0x2122, ++IBUS_Multi_key, IBUS_t, IBUS_m, 0x2122, ++IBUS_Multi_key, IBUS_underbar, IBUS_a, 0x00AA, ++IBUS_Multi_key, IBUS_underbar, IBUS_h, 0x02B0, ++IBUS_Multi_key, IBUS_underbar, IBUS_i, 0x2071, ++IBUS_Multi_key, IBUS_underbar, IBUS_j, 0x02B2, ++IBUS_Multi_key, IBUS_underbar, IBUS_l, 0x02E1, ++IBUS_Multi_key, IBUS_underbar, IBUS_n, 0x207F, ++IBUS_Multi_key, IBUS_underbar, IBUS_o, 0x00BA, ++IBUS_Multi_key, IBUS_underbar, IBUS_r, 0x02B3, ++IBUS_Multi_key, IBUS_underbar, IBUS_s, 0x02E2, ++IBUS_Multi_key, IBUS_underbar, IBUS_w, 0x02B7, ++IBUS_Multi_key, IBUS_underbar, IBUS_x, 0x02E3, ++IBUS_Multi_key, IBUS_underbar, IBUS_y, 0x02B8, ++IBUS_Multi_key, IBUS_underbar, 0x0263, 0x02E0, ++IBUS_Multi_key, IBUS_underbar, 0x0266, 0x02B1, ++IBUS_Multi_key, IBUS_underbar, 0x0279, 0x02B4, ++IBUS_Multi_key, IBUS_underbar, 0x027B, 0x02B5, ++IBUS_Multi_key, IBUS_underbar, 0x0281, 0x02B6, ++IBUS_Multi_key, IBUS_underbar, 0x0295, 0x02E4, ++IBUS_space, 0x007E, ++IBUS_less, 0x2272, ++IBUS_equal, 0x2243, ++IBUS_greater, 0x2273, ++IBUS_nobreakspace, 0x0303, ++IBUS_Oacute, 0x1E4C, ++IBUS_Odiaeresis, 0x1E4E, ++IBUS_Uacute, 0x1E78, ++IBUS_oacute, 0x1E4D, ++IBUS_odiaeresis, 0x1E4F, ++IBUS_uacute, 0x1E79, ++IBUS_Abreve, 0x1EB4, ++IBUS_abreve, 0x1EB5, ++IBUS_Omacron, 0x022C, ++IBUS_omacron, 0x022D, ++IBUS_Greek_iotadieresis, 0x1FD7, ++IBUS_Greek_upsilondieresis, 0x1FE7, ++IBUS_Greek_alpha, 0x1FB6, ++IBUS_Greek_eta, 0x1FC6, ++IBUS_Greek_iota, 0x1FD6, ++IBUS_Greek_upsilon, 0x1FE6, ++IBUS_Greek_omega, 0x1FF6, ++0x1F00, 0x1F06, ++0x1F01, 0x1F07, ++0x1F08, 0x1F0E, ++0x1F09, 0x1F0F, ++0x1F20, 0x1F26, ++0x1F21, 0x1F27, ++0x1F28, 0x1F2E, ++0x1F29, 0x1F2F, ++0x1F30, 0x1F36, ++0x1F31, 0x1F37, ++0x1F38, 0x1F3E, ++0x1F39, 0x1F3F, ++0x1F50, 0x1F56, ++0x1F51, 0x1F57, ++0x1F59, 0x1F5F, ++0x1F60, 0x1F66, ++0x1F61, 0x1F67, ++0x1F68, 0x1F6E, ++0x1F69, 0x1F6F, ++IBUS_dead_tilde, 0x007E, ++IBUS_dead_diaeresis, IBUS_Greek_iota, 0x1FD7, ++IBUS_dead_diaeresis, IBUS_Greek_upsilon, 0x1FE7, ++IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F0E, ++IBUS_dead_psili, IBUS_Greek_ETA, 0x1F2E, ++IBUS_dead_psili, IBUS_Greek_IOTA, 0x1F3E, ++IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1F6E, ++IBUS_dead_psili, IBUS_Greek_alpha, 0x1F06, ++IBUS_dead_psili, IBUS_Greek_eta, 0x1F26, ++IBUS_dead_psili, IBUS_Greek_iota, 0x1F36, ++IBUS_dead_psili, IBUS_Greek_upsilon, 0x1F56, ++IBUS_dead_psili, IBUS_Greek_omega, 0x1F66, ++IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F0F, ++IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F2F, ++IBUS_dead_dasia, IBUS_Greek_IOTA, 0x1F3F, ++IBUS_dead_dasia, IBUS_Greek_UPSILON, 0x1F5F, ++IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1F6F, ++IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F07, ++IBUS_dead_dasia, IBUS_Greek_eta, 0x1F27, ++IBUS_dead_dasia, IBUS_Greek_iota, 0x1F37, ++IBUS_dead_dasia, IBUS_Greek_upsilon, 0x1F57, ++IBUS_dead_dasia, IBUS_Greek_omega, 0x1F67, ++IBUS_Multi_key, IBUS_quotedbl, IBUS_Greek_iota, 0x1FD7, ++IBUS_Multi_key, IBUS_quotedbl, IBUS_Greek_upsilon, 0x1FE7, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F0F, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ETA, 0x1F2F, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_IOTA, 0x1F3F, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_UPSILON, 0x1F5F, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1F6F, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_alpha, 0x1F07, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_eta, 0x1F27, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_iota, 0x1F37, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_upsilon, 0x1F57, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_omega, 0x1F67, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F0E, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ETA, 0x1F2E, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_IOTA, 0x1F3E, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_OMEGA, 0x1F6E, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_alpha, 0x1F06, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_eta, 0x1F26, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_iota, 0x1F36, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_upsilon, 0x1F56, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_omega, 0x1F66, ++IBUS_Multi_key, IBUS_plus, IBUS_O, 0x1EE0, ++IBUS_Multi_key, IBUS_plus, IBUS_U, 0x1EEE, ++IBUS_Multi_key, IBUS_plus, IBUS_o, 0x1EE1, ++IBUS_Multi_key, IBUS_plus, IBUS_u, 0x1EEF, ++IBUS_Multi_key, IBUS_U, IBUS_A, 0x1EB4, ++IBUS_Multi_key, IBUS_U, IBUS_a, 0x1EB5, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_A, 0x1EAA, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_E, 0x1EC4, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_O, 0x1ED6, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_a, 0x1EAB, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_e, 0x1EC5, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_o, 0x1ED7, ++IBUS_Multi_key, IBUS_b, IBUS_A, 0x1EB4, ++IBUS_Multi_key, IBUS_b, IBUS_a, 0x1EB5, ++IBUS_space, 0x00AF, ++IBUS_V, 0x01D5, ++IBUS_v, 0x01D6, ++IBUS_nobreakspace, 0x0304, ++IBUS_Egrave, 0x1E14, ++IBUS_Eacute, 0x1E16, ++IBUS_Ograve, 0x1E50, ++IBUS_Oacute, 0x1E52, ++IBUS_egrave, 0x1E15, ++IBUS_eacute, 0x1E17, ++IBUS_ograve, 0x1E51, ++IBUS_oacute, 0x1E53, ++IBUS_Cyrillic_i, 0x04E3, ++IBUS_Cyrillic_u, 0x04EF, ++IBUS_Cyrillic_I, 0x04E2, ++IBUS_Cyrillic_U, 0x04EE, ++IBUS_Greek_ALPHA, 0x1FB9, ++IBUS_Greek_IOTA, 0x1FD9, ++IBUS_Greek_UPSILON, 0x1FE9, ++IBUS_Greek_alpha, 0x1FB1, ++IBUS_Greek_iota, 0x1FD1, ++IBUS_Greek_upsilon, 0x1FE1, ++IBUS_dead_macron, 0x00AF, ++IBUS_Multi_key, IBUS_exclam, IBUS_L, 0x1E38, ++IBUS_Multi_key, IBUS_exclam, IBUS_R, 0x1E5C, ++IBUS_Multi_key, IBUS_exclam, IBUS_l, 0x1E39, ++IBUS_Multi_key, IBUS_exclam, IBUS_r, 0x1E5D, ++IBUS_Multi_key, IBUS_quotedbl, IBUS_A, 0x01DE, ++IBUS_Multi_key, IBUS_quotedbl, IBUS_O, 0x022A, ++IBUS_Multi_key, IBUS_quotedbl, IBUS_U, 0x01D5, ++IBUS_Multi_key, IBUS_quotedbl, IBUS_a, 0x01DF, ++IBUS_Multi_key, IBUS_quotedbl, IBUS_o, 0x022B, ++IBUS_Multi_key, IBUS_quotedbl, IBUS_u, 0x01D6, ++IBUS_Multi_key, IBUS_period, IBUS_A, 0x01E0, ++IBUS_Multi_key, IBUS_period, IBUS_O, 0x0230, ++IBUS_Multi_key, IBUS_period, IBUS_a, 0x01E1, ++IBUS_Multi_key, IBUS_period, IBUS_o, 0x0231, ++IBUS_Multi_key, IBUS_semicolon, IBUS_O, 0x01EC, ++IBUS_Multi_key, IBUS_semicolon, IBUS_o, 0x01ED, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_O, 0x022C, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_o, 0x022D, ++IBUS_space, 0x02D8, ++IBUS_nobreakspace, 0x0306, ++IBUS_Agrave, 0x1EB0, ++IBUS_Aacute, 0x1EAE, ++IBUS_Atilde, 0x1EB4, ++IBUS_agrave, 0x1EB1, ++IBUS_aacute, 0x1EAF, ++IBUS_atilde, 0x1EB5, ++IBUS_Cyrillic_a, 0x04D1, ++IBUS_Cyrillic_ie, 0x04D7, ++IBUS_Cyrillic_i, 0x0439, ++IBUS_Cyrillic_u, 0x045E, ++IBUS_Cyrillic_zhe, 0x04C2, ++IBUS_Cyrillic_A, 0x04D0, ++IBUS_Cyrillic_IE, 0x04D6, ++IBUS_Cyrillic_I, 0x0419, ++IBUS_Cyrillic_U, 0x040E, ++IBUS_Cyrillic_ZHE, 0x04C1, ++IBUS_Greek_ALPHA, 0x1FB8, ++IBUS_Greek_IOTA, 0x1FD8, ++IBUS_Greek_UPSILON, 0x1FE8, ++IBUS_Greek_alpha, 0x1FB0, ++IBUS_Greek_iota, 0x1FD0, ++IBUS_Greek_upsilon, 0x1FE0, ++IBUS_dead_breve, 0x02D8, ++IBUS_Multi_key, IBUS_exclam, IBUS_A, 0x1EB6, ++IBUS_Multi_key, IBUS_exclam, IBUS_a, 0x1EB7, ++IBUS_Multi_key, IBUS_comma, IBUS_E, 0x1E1C, ++IBUS_Multi_key, IBUS_comma, IBUS_e, 0x1E1D, ++IBUS_Multi_key, IBUS_cedilla, IBUS_E, 0x1E1C, ++IBUS_Multi_key, IBUS_cedilla, IBUS_e, 0x1E1D, ++IBUS_space, 0x02D9, ++IBUS_L, 0x013F, ++IBUS_i, 0x0131, ++IBUS_j, 0x0237, ++IBUS_l, 0x0140, ++IBUS_nobreakspace, 0x0307, ++IBUS_Sacute, 0x1E64, ++IBUS_Scaron, 0x1E66, ++IBUS_sacute, 0x1E65, ++IBUS_scaron, 0x1E67, ++IBUS_Amacron, 0x01E0, ++IBUS_Omacron, 0x0230, ++IBUS_amacron, 0x01E1, ++IBUS_omacron, 0x0231, ++IBUS_dead_abovedot, 0x02D9, ++IBUS_dead_stroke, IBUS_j, 0x025F, ++IBUS_Multi_key, IBUS_exclam, IBUS_S, 0x1E68, ++IBUS_Multi_key, IBUS_exclam, IBUS_s, 0x1E69, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_S, 0x1E64, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_s, 0x1E65, ++IBUS_Multi_key, IBUS_c, IBUS_S, 0x1E66, ++IBUS_Multi_key, IBUS_c, IBUS_s, 0x1E67, ++IBUS_Multi_key, IBUS_acute, IBUS_S, 0x1E64, ++IBUS_Multi_key, IBUS_acute, IBUS_s, 0x1E65, ++IBUS_space, 0x0022, ++IBUS_apostrophe, 0x0344, ++IBUS_nobreakspace, 0x0308, ++IBUS_acute, 0x0344, ++IBUS_Iacute, 0x1E2E, ++IBUS_Ugrave, 0x01DB, ++IBUS_Uacute, 0x01D7, ++IBUS_iacute, 0x1E2F, ++IBUS_ugrave, 0x01DC, ++IBUS_uacute, 0x01D8, ++0x01D3, 0x01D9, ++0x01D4, 0x01DA, ++IBUS_Amacron, 0x01DE, ++IBUS_Umacron, 0x1E7A, ++IBUS_amacron, 0x01DF, ++IBUS_omacron, 0x022B, ++IBUS_umacron, 0x1E7B, ++IBUS_Ukrainian_i, 0x0457, ++IBUS_Ukrainian_I, 0x0407, ++IBUS_Cyrillic_a, 0x04D3, ++IBUS_Cyrillic_ie, 0x0451, ++IBUS_Cyrillic_i, 0x04E5, ++IBUS_Cyrillic_o, 0x04E7, ++IBUS_Cyrillic_u, 0x04F1, ++IBUS_Cyrillic_zhe, 0x04DD, ++IBUS_Cyrillic_yeru, 0x04F9, ++IBUS_Cyrillic_ze, 0x04DF, ++IBUS_Cyrillic_e, 0x04ED, ++IBUS_Cyrillic_che, 0x04F5, ++IBUS_Cyrillic_A, 0x04D2, ++IBUS_Cyrillic_IE, 0x0401, ++IBUS_Cyrillic_I, 0x04E4, ++IBUS_Cyrillic_O, 0x04E6, ++IBUS_Cyrillic_U, 0x04F0, ++IBUS_Cyrillic_ZHE, 0x04DC, ++IBUS_Cyrillic_YERU, 0x04F8, ++IBUS_Cyrillic_ZE, 0x04DE, ++IBUS_Cyrillic_E, 0x04EC, ++IBUS_Cyrillic_CHE, 0x04F4, ++IBUS_Greek_IOTA, 0x03AA, ++IBUS_Greek_UPSILON, 0x03AB, ++IBUS_Greek_iota, 0x03CA, ++IBUS_Greek_upsilon, 0x03CB, ++IBUS_dead_diaeresis, 0x00A8, ++IBUS_dead_acute, IBUS_space, 0x0385, ++IBUS_dead_acute, IBUS_Greek_iota, 0x0390, ++IBUS_dead_acute, IBUS_Greek_upsilon, 0x03B0, ++IBUS_Multi_key, IBUS_underscore, IBUS_U, 0x1E7A, ++IBUS_Multi_key, IBUS_underscore, IBUS_u, 0x1E7B, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_O, 0x1E4E, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_o, 0x1E4F, ++IBUS_Multi_key, IBUS_macron, IBUS_U, 0x1E7A, ++IBUS_Multi_key, IBUS_macron, IBUS_u, 0x1E7B, ++IBUS_space, 0x00B0, ++IBUS_nobreakspace, 0x030A, ++IBUS_Aacute, 0x01FA, ++IBUS_aacute, 0x01FB, ++IBUS_dead_abovering, 0x00B0, ++IBUS_space, 0x02DD, ++IBUS_nobreakspace, 0x030B, ++IBUS_Cyrillic_u, 0x04F3, ++IBUS_Cyrillic_U, 0x04F2, ++IBUS_dead_doubleacute, 0x02DD, ++IBUS_space, 0x02C7, ++IBUS_parenleft, 0x208D, ++IBUS_parenright, 0x208E, ++IBUS_plus, 0x208A, ++IBUS_minus, 0x208B, ++IBUS_0, 0x2080, ++IBUS_1, 0x2081, ++IBUS_2, 0x2082, ++IBUS_3, 0x2083, ++IBUS_4, 0x2084, ++IBUS_5, 0x2085, ++IBUS_6, 0x2086, ++IBUS_7, 0x2087, ++IBUS_8, 0x2088, ++IBUS_9, 0x2089, ++IBUS_equal, 0x208C, ++IBUS_V, 0x01D9, ++IBUS_v, 0x01DA, ++IBUS_nobreakspace, 0x030C, ++0x01F2, 0x01C5, ++IBUS_dead_caron, 0x02C7, ++IBUS_Multi_key, IBUS_quotedbl, IBUS_U, 0x01D9, ++IBUS_Multi_key, IBUS_quotedbl, IBUS_u, 0x01DA, ++IBUS_space, 0x00B8, ++IBUS_nobreakspace, 0x0327, ++IBUS_cent, 0x20B5, ++IBUS_Cacute, 0x1E08, ++IBUS_cacute, 0x1E09, ++IBUS_dead_cedilla, 0x00B8, ++IBUS_space, 0x02DB, ++IBUS_nobreakspace, 0x0328, ++IBUS_Omacron, 0x01EC, ++IBUS_omacron, 0x01ED, ++IBUS_dead_ogonek, 0x02DB, ++IBUS_space, 0x037A, ++IBUS_Greek_alphaaccent, 0x1FB4, ++IBUS_Greek_etaaccent, 0x1FC4, ++IBUS_Greek_omegaaccent, 0x1FF4, ++IBUS_Greek_ALPHA, 0x1FBC, ++IBUS_Greek_ETA, 0x1FCC, ++IBUS_Greek_OMEGA, 0x1FFC, ++IBUS_Greek_alpha, 0x1FB3, ++IBUS_Greek_eta, 0x1FC3, ++IBUS_Greek_omega, 0x1FF3, ++IBUS_dead_iota, 0x037A, ++IBUS_dead_grave, IBUS_Greek_alpha, 0x1FB2, ++IBUS_dead_grave, IBUS_Greek_eta, 0x1FC2, ++IBUS_dead_grave, IBUS_Greek_omega, 0x1FF2, ++IBUS_dead_acute, IBUS_Greek_alpha, 0x1FB4, ++IBUS_dead_acute, IBUS_Greek_eta, 0x1FC4, ++IBUS_dead_acute, IBUS_Greek_omega, 0x1FF4, ++IBUS_dead_tilde, IBUS_Greek_alpha, 0x1FB7, ++IBUS_dead_tilde, IBUS_Greek_eta, 0x1FC7, ++IBUS_dead_tilde, IBUS_Greek_omega, 0x1FF7, ++IBUS_dead_tilde, 0x1F00, 0x1F86, ++IBUS_dead_tilde, 0x1F01, 0x1F87, ++IBUS_dead_tilde, 0x1F08, 0x1F8E, ++IBUS_dead_tilde, 0x1F09, 0x1F8F, ++IBUS_dead_tilde, 0x1F20, 0x1F96, ++IBUS_dead_tilde, 0x1F21, 0x1F97, ++IBUS_dead_tilde, 0x1F28, 0x1F9E, ++IBUS_dead_tilde, 0x1F29, 0x1F9F, ++IBUS_dead_tilde, 0x1F60, 0x1FA6, ++IBUS_dead_tilde, 0x1F61, 0x1FA7, ++IBUS_dead_tilde, 0x1F68, 0x1FAE, ++IBUS_dead_tilde, 0x1F69, 0x1FAF, ++IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F88, ++IBUS_dead_psili, IBUS_Greek_ETA, 0x1F98, ++IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FA8, ++IBUS_dead_psili, IBUS_Greek_alpha, 0x1F80, ++IBUS_dead_psili, IBUS_Greek_eta, 0x1F90, ++IBUS_dead_psili, IBUS_Greek_omega, 0x1FA0, ++IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F89, ++IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F99, ++IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FA9, ++IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F81, ++IBUS_dead_dasia, IBUS_Greek_eta, 0x1F91, ++IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA1, ++IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8A, ++IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9A, ++IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAA, ++IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F82, ++IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_eta, 0x1F92, ++IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA2, ++IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8B, ++IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9B, ++IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAB, ++IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F83, ++IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F93, ++IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA3, ++IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8C, ++IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9C, ++IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAC, ++IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F84, ++IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_eta, 0x1F94, ++IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA4, ++IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8D, ++IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9D, ++IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAD, ++IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F85, ++IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F95, ++IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA5, ++IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8E, ++IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9E, ++IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAE, ++IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F86, ++IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_eta, 0x1F96, ++IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA6, ++IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8F, ++IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9F, ++IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAF, ++IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F87, ++IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F97, ++IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA7, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_Greek_alpha, 0x1FB4, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_Greek_eta, 0x1FC4, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_Greek_omega, 0x1FF4, ++IBUS_Multi_key, IBUS_apostrophe, 0x1F00, 0x1F84, ++IBUS_Multi_key, IBUS_apostrophe, 0x1F01, 0x1F85, ++IBUS_Multi_key, IBUS_apostrophe, 0x1F08, 0x1F8C, ++IBUS_Multi_key, IBUS_apostrophe, 0x1F09, 0x1F8D, ++IBUS_Multi_key, IBUS_apostrophe, 0x1F20, 0x1F94, ++IBUS_Multi_key, IBUS_apostrophe, 0x1F21, 0x1F95, ++IBUS_Multi_key, IBUS_apostrophe, 0x1F28, 0x1F9C, ++IBUS_Multi_key, IBUS_apostrophe, 0x1F29, 0x1F9D, ++IBUS_Multi_key, IBUS_apostrophe, 0x1F60, 0x1FA4, ++IBUS_Multi_key, IBUS_apostrophe, 0x1F61, 0x1FA5, ++IBUS_Multi_key, IBUS_apostrophe, 0x1F68, 0x1FAC, ++IBUS_Multi_key, IBUS_apostrophe, 0x1F69, 0x1FAD, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F89, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ETA, 0x1F99, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FA9, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_alpha, 0x1F81, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_eta, 0x1F91, ++IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_omega, 0x1FA1, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F88, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ETA, 0x1F98, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FA8, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_alpha, 0x1F80, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_eta, 0x1F90, ++IBUS_Multi_key, IBUS_parenright, IBUS_Greek_omega, 0x1FA0, ++IBUS_Multi_key, IBUS_grave, IBUS_Greek_alpha, 0x1FB2, ++IBUS_Multi_key, IBUS_grave, IBUS_Greek_eta, 0x1FC2, ++IBUS_Multi_key, IBUS_grave, IBUS_Greek_omega, 0x1FF2, ++IBUS_Multi_key, IBUS_grave, 0x1F00, 0x1F82, ++IBUS_Multi_key, IBUS_grave, 0x1F01, 0x1F83, ++IBUS_Multi_key, IBUS_grave, 0x1F08, 0x1F8A, ++IBUS_Multi_key, IBUS_grave, 0x1F09, 0x1F8B, ++IBUS_Multi_key, IBUS_grave, 0x1F20, 0x1F92, ++IBUS_Multi_key, IBUS_grave, 0x1F21, 0x1F93, ++IBUS_Multi_key, IBUS_grave, 0x1F28, 0x1F9A, ++IBUS_Multi_key, IBUS_grave, 0x1F29, 0x1F9B, ++IBUS_Multi_key, IBUS_grave, 0x1F60, 0x1FA2, ++IBUS_Multi_key, IBUS_grave, 0x1F61, 0x1FA3, ++IBUS_Multi_key, IBUS_grave, 0x1F68, 0x1FAA, ++IBUS_Multi_key, IBUS_grave, 0x1F69, 0x1FAB, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_Greek_alpha, 0x1FB7, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_Greek_eta, 0x1FC7, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_Greek_omega, 0x1FF7, ++IBUS_Multi_key, IBUS_asciitilde, 0x1F00, 0x1F86, ++IBUS_Multi_key, IBUS_asciitilde, 0x1F01, 0x1F87, ++IBUS_Multi_key, IBUS_asciitilde, 0x1F08, 0x1F8E, ++IBUS_Multi_key, IBUS_asciitilde, 0x1F09, 0x1F8F, ++IBUS_Multi_key, IBUS_asciitilde, 0x1F20, 0x1F96, ++IBUS_Multi_key, IBUS_asciitilde, 0x1F21, 0x1F97, ++IBUS_Multi_key, IBUS_asciitilde, 0x1F28, 0x1F9E, ++IBUS_Multi_key, IBUS_asciitilde, 0x1F29, 0x1F9F, ++IBUS_Multi_key, IBUS_asciitilde, 0x1F60, 0x1FA6, ++IBUS_Multi_key, IBUS_asciitilde, 0x1F61, 0x1FA7, ++IBUS_Multi_key, IBUS_asciitilde, 0x1F68, 0x1FAE, ++IBUS_Multi_key, IBUS_asciitilde, 0x1F69, 0x1FAF, ++IBUS_Multi_key, IBUS_acute, IBUS_Greek_alpha, 0x1FB4, ++IBUS_Multi_key, IBUS_acute, IBUS_Greek_eta, 0x1FC4, ++IBUS_Multi_key, IBUS_acute, IBUS_Greek_omega, 0x1FF4, ++IBUS_Multi_key, IBUS_acute, 0x1F00, 0x1F84, ++IBUS_Multi_key, IBUS_acute, 0x1F01, 0x1F85, ++IBUS_Multi_key, IBUS_acute, 0x1F08, 0x1F8C, ++IBUS_Multi_key, IBUS_acute, 0x1F09, 0x1F8D, ++IBUS_Multi_key, IBUS_acute, 0x1F20, 0x1F94, ++IBUS_Multi_key, IBUS_acute, 0x1F21, 0x1F95, ++IBUS_Multi_key, IBUS_acute, 0x1F28, 0x1F9C, ++IBUS_Multi_key, IBUS_acute, 0x1F29, 0x1F9D, ++IBUS_Multi_key, IBUS_acute, 0x1F60, 0x1FA4, ++IBUS_Multi_key, IBUS_acute, 0x1F61, 0x1FA5, ++IBUS_Multi_key, IBUS_acute, 0x1F68, 0x1FAC, ++IBUS_Multi_key, IBUS_acute, 0x1F69, 0x1FAD, ++IBUS_dead_grave, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8B, ++IBUS_dead_grave, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9B, ++IBUS_dead_grave, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAB, ++IBUS_dead_grave, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_alpha, 0x1F83, ++IBUS_dead_grave, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_eta, 0x1F93, ++IBUS_dead_grave, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_omega, 0x1FA3, ++IBUS_dead_grave, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8A, ++IBUS_dead_grave, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ETA, 0x1F9A, ++IBUS_dead_grave, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAA, ++IBUS_dead_grave, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_alpha, 0x1F82, ++IBUS_dead_grave, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_eta, 0x1F92, ++IBUS_dead_grave, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_omega, 0x1FA2, ++IBUS_dead_acute, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8D, ++IBUS_dead_acute, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9D, ++IBUS_dead_acute, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAD, ++IBUS_dead_acute, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_alpha, 0x1F85, ++IBUS_dead_acute, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_eta, 0x1F95, ++IBUS_dead_acute, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_omega, 0x1FA5, ++IBUS_dead_acute, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8C, ++IBUS_dead_acute, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ETA, 0x1F9C, ++IBUS_dead_acute, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAC, ++IBUS_dead_acute, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_alpha, 0x1F84, ++IBUS_dead_acute, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_eta, 0x1F94, ++IBUS_dead_acute, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_omega, 0x1FA4, ++IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8F, ++IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9F, ++IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAF, ++IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_alpha, 0x1F87, ++IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_eta, 0x1F97, ++IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenleft, IBUS_Greek_omega, 0x1FA7, ++IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8E, ++IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_ETA, 0x1F9E, ++IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAE, ++IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_alpha, 0x1F86, ++IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_eta, 0x1F96, ++IBUS_dead_tilde, IBUS_Multi_key, IBUS_parenright, IBUS_Greek_omega, 0x1FA6, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8D, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9D, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAD, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_alpha, 0x1F85, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_eta, 0x1F95, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_omega, 0x1FA5, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8C, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_ETA, 0x1F9C, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAC, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_alpha, 0x1F84, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_eta, 0x1F94, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_omega, 0x1FA4, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8C, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9C, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAC, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F84, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_eta, 0x1F94, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA4, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8D, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9D, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAD, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F85, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F95, ++IBUS_Multi_key, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA5, ++IBUS_Multi_key, IBUS_grave, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8B, ++IBUS_Multi_key, IBUS_grave, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9B, ++IBUS_Multi_key, IBUS_grave, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAB, ++IBUS_Multi_key, IBUS_grave, IBUS_parenleft, IBUS_Greek_alpha, 0x1F83, ++IBUS_Multi_key, IBUS_grave, IBUS_parenleft, IBUS_Greek_eta, 0x1F93, ++IBUS_Multi_key, IBUS_grave, IBUS_parenleft, IBUS_Greek_omega, 0x1FA3, ++IBUS_Multi_key, IBUS_grave, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8A, ++IBUS_Multi_key, IBUS_grave, IBUS_parenright, IBUS_Greek_ETA, 0x1F9A, ++IBUS_Multi_key, IBUS_grave, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAA, ++IBUS_Multi_key, IBUS_grave, IBUS_parenright, IBUS_Greek_alpha, 0x1F82, ++IBUS_Multi_key, IBUS_grave, IBUS_parenright, IBUS_Greek_eta, 0x1F92, ++IBUS_Multi_key, IBUS_grave, IBUS_parenright, IBUS_Greek_omega, 0x1FA2, ++IBUS_Multi_key, IBUS_grave, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8A, ++IBUS_Multi_key, IBUS_grave, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9A, ++IBUS_Multi_key, IBUS_grave, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAA, ++IBUS_Multi_key, IBUS_grave, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F82, ++IBUS_Multi_key, IBUS_grave, IBUS_dead_psili, IBUS_Greek_eta, 0x1F92, ++IBUS_Multi_key, IBUS_grave, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA2, ++IBUS_Multi_key, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8B, ++IBUS_Multi_key, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9B, ++IBUS_Multi_key, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAB, ++IBUS_Multi_key, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F83, ++IBUS_Multi_key, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F93, ++IBUS_Multi_key, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA3, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8F, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9F, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAF, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_alpha, 0x1F87, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_eta, 0x1F97, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_omega, 0x1FA7, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8E, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_ETA, 0x1F9E, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAE, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_alpha, 0x1F86, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_eta, 0x1F96, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_omega, 0x1FA6, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8E, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9E, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAE, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F86, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_eta, 0x1F96, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA6, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8F, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9F, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAF, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F87, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F97, ++IBUS_Multi_key, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA7, ++IBUS_Multi_key, IBUS_acute, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8D, ++IBUS_Multi_key, IBUS_acute, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9D, ++IBUS_Multi_key, IBUS_acute, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAD, ++IBUS_Multi_key, IBUS_acute, IBUS_parenleft, IBUS_Greek_alpha, 0x1F85, ++IBUS_Multi_key, IBUS_acute, IBUS_parenleft, IBUS_Greek_eta, 0x1F95, ++IBUS_Multi_key, IBUS_acute, IBUS_parenleft, IBUS_Greek_omega, 0x1FA5, ++IBUS_Multi_key, IBUS_acute, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8C, ++IBUS_Multi_key, IBUS_acute, IBUS_parenright, IBUS_Greek_ETA, 0x1F9C, ++IBUS_Multi_key, IBUS_acute, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAC, ++IBUS_Multi_key, IBUS_acute, IBUS_parenright, IBUS_Greek_alpha, 0x1F84, ++IBUS_Multi_key, IBUS_acute, IBUS_parenright, IBUS_Greek_eta, 0x1F94, ++IBUS_Multi_key, IBUS_acute, IBUS_parenright, IBUS_Greek_omega, 0x1FA4, ++IBUS_Multi_key, IBUS_acute, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8C, ++IBUS_Multi_key, IBUS_acute, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9C, ++IBUS_Multi_key, IBUS_acute, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAC, ++IBUS_Multi_key, IBUS_acute, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F84, ++IBUS_Multi_key, IBUS_acute, IBUS_dead_psili, IBUS_Greek_eta, 0x1F94, ++IBUS_Multi_key, IBUS_acute, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA4, ++IBUS_Multi_key, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8D, ++IBUS_Multi_key, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9D, ++IBUS_Multi_key, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAD, ++IBUS_Multi_key, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F85, ++IBUS_Multi_key, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F95, ++IBUS_Multi_key, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA5, ++IBUS_kana_WO, 0x30FA, ++IBUS_kana_U, 0x30F4, ++IBUS_kana_KA, 0x30AC, ++IBUS_kana_KI, 0x30AE, ++IBUS_kana_KU, 0x30B0, ++IBUS_kana_KE, 0x30B2, ++IBUS_kana_KO, 0x30B4, ++IBUS_kana_SA, 0x30B6, ++IBUS_kana_SHI, 0x30B8, ++IBUS_kana_SU, 0x30BA, ++IBUS_kana_SE, 0x30BC, ++IBUS_kana_SO, 0x30BE, ++IBUS_kana_TA, 0x30C0, ++IBUS_kana_CHI, 0x30C2, ++IBUS_kana_TSU, 0x30C5, ++IBUS_kana_TE, 0x30C7, ++IBUS_kana_TO, 0x30C9, ++IBUS_kana_HA, 0x30D0, ++IBUS_kana_HI, 0x30D3, ++IBUS_kana_FU, 0x30D6, ++IBUS_kana_HE, 0x30D9, ++IBUS_kana_HO, 0x30DC, ++IBUS_kana_WA, 0x30F7, ++IBUS_kana_HA, 0x30D1, ++IBUS_kana_HI, 0x30D4, ++IBUS_kana_FU, 0x30D7, ++IBUS_kana_HE, 0x30DA, ++IBUS_kana_HO, 0x30DD, ++IBUS_space, 0x0323, ++IBUS_plus, 0x2A25, ++IBUS_minus, 0x2A2A, ++IBUS_equal, 0x2A66, ++IBUS_nobreakspace, 0x0323, ++IBUS_Abreve, 0x1EB6, ++IBUS_abreve, 0x1EB7, ++IBUS_dead_belowdot, 0x0323, ++IBUS_Multi_key, IBUS_plus, IBUS_O, 0x1EE2, ++IBUS_Multi_key, IBUS_plus, IBUS_U, 0x1EF0, ++IBUS_Multi_key, IBUS_plus, IBUS_o, 0x1EE3, ++IBUS_Multi_key, IBUS_plus, IBUS_u, 0x1EF1, ++IBUS_space, 0x0309, ++IBUS_B, 0x0181, ++IBUS_C, 0x0187, ++IBUS_D, 0x018A, ++IBUS_F, 0x0191, ++IBUS_G, 0x0193, ++IBUS_K, 0x0198, ++IBUS_M, 0x2C6E, ++IBUS_N, 0x019D, ++IBUS_P, 0x01A4, ++IBUS_T, 0x01AC, ++IBUS_V, 0x01B2, ++IBUS_W, 0x2C72, ++IBUS_Z, 0x0224, ++IBUS_b, 0x0253, ++IBUS_c, 0x0188, ++IBUS_d, 0x0257, ++IBUS_f, 0x0192, ++IBUS_g, 0x0260, ++IBUS_h, 0x0266, ++IBUS_k, 0x0199, ++IBUS_m, 0x0271, ++IBUS_n, 0x0272, ++IBUS_p, 0x01A5, ++IBUS_q, 0x02A0, ++IBUS_s, 0x0282, ++IBUS_t, 0x01AD, ++IBUS_v, 0x028B, ++IBUS_w, 0x2C73, ++IBUS_z, 0x0225, ++IBUS_nobreakspace, 0x0309, ++IBUS_Abreve, 0x1EB2, ++IBUS_abreve, 0x1EB3, ++0x0256, 0x1D91, ++0x025C, 0x025D, ++0x025F, 0x0284, ++0x0279, 0x027B, ++IBUS_dead_hook, 0x0309, ++IBUS_Multi_key, IBUS_plus, IBUS_O, 0x1EDE, ++IBUS_Multi_key, IBUS_plus, IBUS_U, 0x1EEC, ++IBUS_Multi_key, IBUS_plus, IBUS_o, 0x1EDF, ++IBUS_Multi_key, IBUS_plus, IBUS_u, 0x1EED, ++IBUS_Multi_key, IBUS_U, IBUS_A, 0x1EB2, ++IBUS_Multi_key, IBUS_U, IBUS_a, 0x1EB3, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_A, 0x1EA8, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_E, 0x1EC2, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_O, 0x1ED4, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_a, 0x1EA9, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_e, 0x1EC3, ++IBUS_Multi_key, IBUS_asciicircum, IBUS_o, 0x1ED5, ++IBUS_Multi_key, IBUS_b, IBUS_A, 0x1EB2, ++IBUS_Multi_key, IBUS_b, IBUS_a, 0x1EB3, ++IBUS_space, 0x031B, ++IBUS_nobreakspace, 0x031B, ++IBUS_Utilde, 0x1EEE, ++IBUS_utilde, 0x1EEF, ++IBUS_dead_horn, 0x031B, ++IBUS_Greek_ALPHA, 0x1F08, ++IBUS_Greek_EPSILON, 0x1F18, ++IBUS_Greek_ETA, 0x1F28, ++IBUS_Greek_IOTA, 0x1F38, ++IBUS_Greek_OMICRON, 0x1F48, ++IBUS_Greek_OMEGA, 0x1F68, ++IBUS_Greek_alpha, 0x1F00, ++IBUS_Greek_epsilon, 0x1F10, ++IBUS_Greek_eta, 0x1F20, ++IBUS_Greek_iota, 0x1F30, ++IBUS_Greek_omicron, 0x1F40, ++IBUS_Greek_rho, 0x1FE4, ++IBUS_Greek_upsilon, 0x1F50, ++IBUS_Greek_omega, 0x1F60, ++IBUS_Greek_ALPHA, 0x1F09, ++IBUS_Greek_EPSILON, 0x1F19, ++IBUS_Greek_ETA, 0x1F29, ++IBUS_Greek_IOTA, 0x1F39, ++IBUS_Greek_OMICRON, 0x1F49, ++IBUS_Greek_RHO, 0x1FEC, ++IBUS_Greek_UPSILON, 0x1F59, ++IBUS_Greek_OMEGA, 0x1F69, ++IBUS_Greek_alpha, 0x1F01, ++IBUS_Greek_epsilon, 0x1F11, ++IBUS_Greek_eta, 0x1F21, ++IBUS_Greek_iota, 0x1F31, ++IBUS_Greek_omicron, 0x1F41, ++IBUS_Greek_rho, 0x1FE5, ++IBUS_Greek_upsilon, 0x1F51, ++IBUS_Greek_omega, 0x1F61, ++IBUS_space, IBUS_space, 0x00A0, ++IBUS_space, IBUS_apostrophe, 0x0027, ++IBUS_space, IBUS_parenleft, 0x02D8, ++IBUS_space, IBUS_comma, 0x00B8, ++IBUS_space, IBUS_minus, 0x007E, ++IBUS_space, IBUS_period, 0x2008, ++IBUS_space, IBUS_less, 0x02C7, ++IBUS_space, IBUS_greater, 0x005E, ++IBUS_space, IBUS_asciicircum, 0x005E, ++IBUS_space, IBUS_grave, 0x0060, ++IBUS_space, IBUS_asciitilde, 0x007E, ++IBUS_exclam, IBUS_exclam, 0x00A1, ++IBUS_exclam, IBUS_question, 0x203D, ++IBUS_exclam, IBUS_A, 0x1EA0, ++IBUS_exclam, IBUS_B, 0x1E04, ++IBUS_exclam, IBUS_D, 0x1E0C, ++IBUS_exclam, IBUS_E, 0x1EB8, ++IBUS_exclam, IBUS_H, 0x1E24, ++IBUS_exclam, IBUS_I, 0x1ECA, ++IBUS_exclam, IBUS_K, 0x1E32, ++IBUS_exclam, IBUS_L, 0x1E36, ++IBUS_exclam, IBUS_M, 0x1E42, ++IBUS_exclam, IBUS_N, 0x1E46, ++IBUS_exclam, IBUS_O, 0x1ECC, ++IBUS_exclam, IBUS_P, 0x00B6, ++IBUS_exclam, IBUS_R, 0x1E5A, ++IBUS_exclam, IBUS_S, 0x1E62, ++IBUS_exclam, IBUS_T, 0x1E6C, ++IBUS_exclam, IBUS_U, 0x1EE4, ++IBUS_exclam, IBUS_V, 0x1E7E, ++IBUS_exclam, IBUS_W, 0x1E88, ++IBUS_exclam, IBUS_Y, 0x1EF4, ++IBUS_exclam, IBUS_Z, 0x1E92, ++IBUS_exclam, IBUS_asciicircum, 0x00A6, ++IBUS_exclam, IBUS_a, 0x1EA1, ++IBUS_exclam, IBUS_b, 0x1E05, ++IBUS_exclam, IBUS_d, 0x1E0D, ++IBUS_exclam, IBUS_e, 0x1EB9, ++IBUS_exclam, IBUS_h, 0x1E25, ++IBUS_exclam, IBUS_i, 0x1ECB, ++IBUS_exclam, IBUS_k, 0x1E33, ++IBUS_exclam, IBUS_l, 0x1E37, ++IBUS_exclam, IBUS_m, 0x1E43, ++IBUS_exclam, IBUS_n, 0x1E47, ++IBUS_exclam, IBUS_o, 0x1ECD, ++IBUS_exclam, IBUS_p, 0x00B6, ++IBUS_exclam, IBUS_r, 0x1E5B, ++IBUS_exclam, IBUS_s, 0x1E63, ++IBUS_exclam, IBUS_t, 0x1E6D, ++IBUS_exclam, IBUS_u, 0x1EE5, ++IBUS_exclam, IBUS_v, 0x1E7F, ++IBUS_exclam, IBUS_w, 0x1E89, ++IBUS_exclam, IBUS_y, 0x1EF5, ++IBUS_exclam, IBUS_z, 0x1E93, ++IBUS_quotedbl, IBUS_quotedbl, 0x00A8, ++IBUS_quotedbl, IBUS_apostrophe, 0x0344, ++IBUS_quotedbl, IBUS_comma, 0x201E, ++IBUS_quotedbl, IBUS_slash, 0x301E, ++IBUS_quotedbl, IBUS_less, 0x201C, ++IBUS_quotedbl, IBUS_greater, 0x201D, ++IBUS_quotedbl, IBUS_A, 0x00C4, ++IBUS_quotedbl, IBUS_E, 0x00CB, ++IBUS_quotedbl, IBUS_H, 0x1E26, ++IBUS_quotedbl, IBUS_I, 0x00CF, ++IBUS_quotedbl, IBUS_O, 0x00D6, ++IBUS_quotedbl, IBUS_U, 0x00DC, ++IBUS_quotedbl, IBUS_W, 0x1E84, ++IBUS_quotedbl, IBUS_X, 0x1E8C, ++IBUS_quotedbl, IBUS_Y, 0x0178, ++IBUS_quotedbl, IBUS_backslash, 0x301D, ++IBUS_quotedbl, IBUS_a, 0x00E4, ++IBUS_quotedbl, IBUS_e, 0x00EB, ++IBUS_quotedbl, IBUS_h, 0x1E27, ++IBUS_quotedbl, IBUS_i, 0x00EF, ++IBUS_quotedbl, IBUS_o, 0x00F6, ++IBUS_quotedbl, IBUS_t, 0x1E97, ++IBUS_quotedbl, IBUS_u, 0x00FC, ++IBUS_quotedbl, IBUS_w, 0x1E85, ++IBUS_quotedbl, IBUS_x, 0x1E8D, ++IBUS_quotedbl, IBUS_y, 0x00FF, ++IBUS_quotedbl, IBUS_acute, 0x0344, ++IBUS_quotedbl, IBUS_Otilde, 0x1E4E, ++IBUS_quotedbl, IBUS_otilde, 0x1E4F, ++IBUS_quotedbl, 0x03D2, 0x03D4, ++IBUS_quotedbl, IBUS_Umacron, 0x1E7A, ++IBUS_quotedbl, IBUS_umacron, 0x1E7B, ++IBUS_quotedbl, 0x04D8, 0x04DA, ++IBUS_quotedbl, 0x04D9, 0x04DB, ++IBUS_quotedbl, 0x04E8, 0x04EA, ++IBUS_quotedbl, 0x04E9, 0x04EB, ++IBUS_quotedbl, IBUS_Ukrainian_i, 0x0457, ++IBUS_quotedbl, IBUS_Ukrainian_I, 0x0407, ++IBUS_quotedbl, IBUS_Cyrillic_a, 0x04D3, ++IBUS_quotedbl, IBUS_Cyrillic_ie, 0x0451, ++IBUS_quotedbl, IBUS_Cyrillic_i, 0x04E5, ++IBUS_quotedbl, IBUS_Cyrillic_o, 0x04E7, ++IBUS_quotedbl, IBUS_Cyrillic_u, 0x04F1, ++IBUS_quotedbl, IBUS_Cyrillic_zhe, 0x04DD, ++IBUS_quotedbl, IBUS_Cyrillic_yeru, 0x04F9, ++IBUS_quotedbl, IBUS_Cyrillic_ze, 0x04DF, ++IBUS_quotedbl, IBUS_Cyrillic_e, 0x04ED, ++IBUS_quotedbl, IBUS_Cyrillic_che, 0x04F5, ++IBUS_quotedbl, IBUS_Cyrillic_A, 0x04D2, ++IBUS_quotedbl, IBUS_Cyrillic_IE, 0x0401, ++IBUS_quotedbl, IBUS_Cyrillic_I, 0x04E4, ++IBUS_quotedbl, IBUS_Cyrillic_O, 0x04E6, ++IBUS_quotedbl, IBUS_Cyrillic_U, 0x04F0, ++IBUS_quotedbl, IBUS_Cyrillic_ZHE, 0x04DC, ++IBUS_quotedbl, IBUS_Cyrillic_YERU, 0x04F8, ++IBUS_quotedbl, IBUS_Cyrillic_ZE, 0x04DE, ++IBUS_quotedbl, IBUS_Cyrillic_E, 0x04EC, ++IBUS_quotedbl, IBUS_Cyrillic_CHE, 0x04F4, ++IBUS_quotedbl, IBUS_Greek_IOTA, 0x03AA, ++IBUS_quotedbl, IBUS_Greek_UPSILON, 0x03AB, ++IBUS_quotedbl, IBUS_Greek_iota, 0x03CA, ++IBUS_quotedbl, IBUS_Greek_upsilon, 0x03CB, ++IBUS_quotedbl, IBUS_dead_acute, 0x0344, ++IBUS_numbersign, IBUS_numbersign, 0x266F, ++IBUS_numbersign, IBUS_b, 0x266D, ++IBUS_numbersign, IBUS_f, 0x266E, ++IBUS_percent, IBUS_o, 0x2030, ++IBUS_apostrophe, IBUS_space, 0x0027, ++IBUS_apostrophe, IBUS_apostrophe, 0x00B4, ++IBUS_apostrophe, IBUS_comma, 0x201A, ++IBUS_apostrophe, IBUS_less, 0x2018, ++IBUS_apostrophe, IBUS_greater, 0x2019, ++IBUS_apostrophe, IBUS_A, 0x00C1, ++IBUS_apostrophe, IBUS_C, 0x0106, ++IBUS_apostrophe, IBUS_E, 0x00C9, ++IBUS_apostrophe, IBUS_G, 0x01F4, ++IBUS_apostrophe, IBUS_I, 0x00CD, ++IBUS_apostrophe, IBUS_K, 0x1E30, ++IBUS_apostrophe, IBUS_L, 0x0139, ++IBUS_apostrophe, IBUS_M, 0x1E3E, ++IBUS_apostrophe, IBUS_N, 0x0143, ++IBUS_apostrophe, IBUS_O, 0x00D3, ++IBUS_apostrophe, IBUS_P, 0x1E54, ++IBUS_apostrophe, IBUS_R, 0x0154, ++IBUS_apostrophe, IBUS_S, 0x015A, ++IBUS_apostrophe, IBUS_U, 0x00DA, ++IBUS_apostrophe, IBUS_W, 0x1E82, ++IBUS_apostrophe, IBUS_Y, 0x00DD, ++IBUS_apostrophe, IBUS_Z, 0x0179, ++IBUS_apostrophe, IBUS_a, 0x00E1, ++IBUS_apostrophe, IBUS_c, 0x0107, ++IBUS_apostrophe, IBUS_e, 0x00E9, ++IBUS_apostrophe, IBUS_g, 0x01F5, ++IBUS_apostrophe, IBUS_i, 0x00ED, ++IBUS_apostrophe, IBUS_k, 0x1E31, ++IBUS_apostrophe, IBUS_l, 0x013A, ++IBUS_apostrophe, IBUS_m, 0x1E3F, ++IBUS_apostrophe, IBUS_n, 0x0144, ++IBUS_apostrophe, IBUS_o, 0x00F3, ++IBUS_apostrophe, IBUS_p, 0x1E55, ++IBUS_apostrophe, IBUS_r, 0x0155, ++IBUS_apostrophe, IBUS_s, 0x015B, ++IBUS_apostrophe, IBUS_u, 0x00FA, ++IBUS_apostrophe, IBUS_w, 0x1E83, ++IBUS_apostrophe, IBUS_y, 0x00FD, ++IBUS_apostrophe, IBUS_z, 0x017A, ++IBUS_apostrophe, IBUS_Acircumflex, 0x1EA4, ++IBUS_apostrophe, IBUS_Aring, 0x01FA, ++IBUS_apostrophe, IBUS_AE, 0x01FC, ++IBUS_apostrophe, IBUS_Ccedilla, 0x1E08, ++IBUS_apostrophe, IBUS_Ecircumflex, 0x1EBE, ++IBUS_apostrophe, IBUS_Idiaeresis, 0x1E2E, ++IBUS_apostrophe, IBUS_Ocircumflex, 0x1ED0, ++IBUS_apostrophe, IBUS_Otilde, 0x1E4C, ++IBUS_apostrophe, IBUS_Ooblique, 0x01FE, ++IBUS_apostrophe, IBUS_Udiaeresis, 0x01D7, ++IBUS_apostrophe, IBUS_acircumflex, 0x1EA5, ++IBUS_apostrophe, IBUS_aring, 0x01FB, ++IBUS_apostrophe, IBUS_ae, 0x01FD, ++IBUS_apostrophe, IBUS_ccedilla, 0x1E09, ++IBUS_apostrophe, IBUS_ecircumflex, 0x1EBF, ++IBUS_apostrophe, IBUS_idiaeresis, 0x1E2F, ++IBUS_apostrophe, IBUS_ocircumflex, 0x1ED1, ++IBUS_apostrophe, IBUS_otilde, 0x1E4D, ++IBUS_apostrophe, IBUS_oslash, 0x01FF, ++IBUS_apostrophe, IBUS_udiaeresis, 0x01D8, ++IBUS_apostrophe, IBUS_Abreve, 0x1EAE, ++IBUS_apostrophe, IBUS_abreve, 0x1EAF, ++IBUS_apostrophe, IBUS_Emacron, 0x1E16, ++IBUS_apostrophe, IBUS_emacron, 0x1E17, ++IBUS_apostrophe, IBUS_Omacron, 0x1E52, ++IBUS_apostrophe, IBUS_Utilde, 0x1E78, ++IBUS_apostrophe, IBUS_omacron, 0x1E53, ++IBUS_apostrophe, IBUS_utilde, 0x1E79, ++IBUS_apostrophe, IBUS_Cyrillic_ghe, 0x0453, ++IBUS_apostrophe, IBUS_Cyrillic_ka, 0x045C, ++IBUS_apostrophe, IBUS_Cyrillic_GHE, 0x0403, ++IBUS_apostrophe, IBUS_Cyrillic_KA, 0x040C, ++IBUS_apostrophe, IBUS_Greek_iotadieresis, 0x0390, ++IBUS_apostrophe, IBUS_Greek_upsilondieresis, 0x03B0, ++IBUS_apostrophe, IBUS_Greek_ALPHA, 0x0386, ++IBUS_apostrophe, IBUS_Greek_EPSILON, 0x0388, ++IBUS_apostrophe, IBUS_Greek_ETA, 0x0389, ++IBUS_apostrophe, IBUS_Greek_IOTA, 0x038A, ++IBUS_apostrophe, IBUS_Greek_OMICRON, 0x038C, ++IBUS_apostrophe, IBUS_Greek_UPSILON, 0x038E, ++IBUS_apostrophe, IBUS_Greek_OMEGA, 0x038F, ++IBUS_apostrophe, IBUS_Greek_alpha, 0x03AC, ++IBUS_apostrophe, IBUS_Greek_epsilon, 0x03AD, ++IBUS_apostrophe, IBUS_Greek_eta, 0x03AE, ++IBUS_apostrophe, IBUS_Greek_iota, 0x03AF, ++IBUS_apostrophe, IBUS_Greek_omicron, 0x03CC, ++IBUS_apostrophe, IBUS_Greek_upsilon, 0x03CD, ++IBUS_apostrophe, IBUS_Greek_omega, 0x03CE, ++IBUS_apostrophe, 0x1F00, 0x1F04, ++IBUS_apostrophe, 0x1F01, 0x1F05, ++IBUS_apostrophe, 0x1F08, 0x1F0C, ++IBUS_apostrophe, 0x1F09, 0x1F0D, ++IBUS_apostrophe, 0x1F10, 0x1F14, ++IBUS_apostrophe, 0x1F11, 0x1F15, ++IBUS_apostrophe, 0x1F18, 0x1F1C, ++IBUS_apostrophe, 0x1F19, 0x1F1D, ++IBUS_apostrophe, 0x1F20, 0x1F24, ++IBUS_apostrophe, 0x1F21, 0x1F25, ++IBUS_apostrophe, 0x1F28, 0x1F2C, ++IBUS_apostrophe, 0x1F29, 0x1F2D, ++IBUS_apostrophe, 0x1F30, 0x1F34, ++IBUS_apostrophe, 0x1F31, 0x1F35, ++IBUS_apostrophe, 0x1F38, 0x1F3C, ++IBUS_apostrophe, 0x1F39, 0x1F3D, ++IBUS_apostrophe, 0x1F40, 0x1F44, ++IBUS_apostrophe, 0x1F41, 0x1F45, ++IBUS_apostrophe, 0x1F48, 0x1F4C, ++IBUS_apostrophe, 0x1F49, 0x1F4D, ++IBUS_apostrophe, 0x1F50, 0x1F54, ++IBUS_apostrophe, 0x1F51, 0x1F55, ++IBUS_apostrophe, 0x1F59, 0x1F5D, ++IBUS_apostrophe, 0x1F60, 0x1F64, ++IBUS_apostrophe, 0x1F61, 0x1F65, ++IBUS_apostrophe, 0x1F68, 0x1F6C, ++IBUS_apostrophe, 0x1F69, 0x1F6D, ++IBUS_parenleft, IBUS_space, 0x02D8, ++IBUS_parenleft, IBUS_parenleft, 0x005B, ++IBUS_parenleft, IBUS_minus, 0x007B, ++IBUS_parenleft, IBUS_A, 0x0102, ++IBUS_parenleft, IBUS_G, 0x011E, ++IBUS_parenleft, IBUS_a, 0x0103, ++IBUS_parenleft, IBUS_c, 0x00A9, ++IBUS_parenleft, IBUS_g, 0x011F, ++IBUS_parenleft, IBUS_r, 0x00AE, ++IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F09, ++IBUS_parenleft, IBUS_Greek_EPSILON, 0x1F19, ++IBUS_parenleft, IBUS_Greek_ETA, 0x1F29, ++IBUS_parenleft, IBUS_Greek_IOTA, 0x1F39, ++IBUS_parenleft, IBUS_Greek_OMICRON, 0x1F49, ++IBUS_parenleft, IBUS_Greek_RHO, 0x1FEC, ++IBUS_parenleft, IBUS_Greek_UPSILON, 0x1F59, ++IBUS_parenleft, IBUS_Greek_OMEGA, 0x1F69, ++IBUS_parenleft, IBUS_Greek_alpha, 0x1F01, ++IBUS_parenleft, IBUS_Greek_epsilon, 0x1F11, ++IBUS_parenleft, IBUS_Greek_eta, 0x1F21, ++IBUS_parenleft, IBUS_Greek_iota, 0x1F31, ++IBUS_parenleft, IBUS_Greek_omicron, 0x1F41, ++IBUS_parenleft, IBUS_Greek_rho, 0x1FE5, ++IBUS_parenleft, IBUS_Greek_upsilon, 0x1F51, ++IBUS_parenleft, IBUS_Greek_omega, 0x1F61, ++IBUS_parenright, IBUS_parenright, 0x005D, ++IBUS_parenright, IBUS_minus, 0x007D, ++IBUS_parenright, IBUS_Greek_ALPHA, 0x1F08, ++IBUS_parenright, IBUS_Greek_EPSILON, 0x1F18, ++IBUS_parenright, IBUS_Greek_ETA, 0x1F28, ++IBUS_parenright, IBUS_Greek_IOTA, 0x1F38, ++IBUS_parenright, IBUS_Greek_OMICRON, 0x1F48, ++IBUS_parenright, IBUS_Greek_OMEGA, 0x1F68, ++IBUS_parenright, IBUS_Greek_alpha, 0x1F00, ++IBUS_parenright, IBUS_Greek_epsilon, 0x1F10, ++IBUS_parenright, IBUS_Greek_eta, 0x1F20, ++IBUS_parenright, IBUS_Greek_iota, 0x1F30, ++IBUS_parenright, IBUS_Greek_omicron, 0x1F40, ++IBUS_parenright, IBUS_Greek_rho, 0x1FE4, ++IBUS_parenright, IBUS_Greek_upsilon, 0x1F50, ++IBUS_parenright, IBUS_Greek_omega, 0x1F60, ++IBUS_asterisk, IBUS_0, 0x00B0, ++IBUS_asterisk, IBUS_A, 0x00C5, ++IBUS_asterisk, IBUS_U, 0x016E, ++IBUS_asterisk, IBUS_a, 0x00E5, ++IBUS_asterisk, IBUS_u, 0x016F, ++IBUS_plus, IBUS_plus, 0x0023, ++IBUS_plus, IBUS_minus, 0x00B1, ++IBUS_plus, IBUS_O, 0x01A0, ++IBUS_plus, IBUS_U, 0x01AF, ++IBUS_plus, IBUS_o, 0x01A1, ++IBUS_plus, IBUS_u, 0x01B0, ++IBUS_comma, IBUS_space, 0x00B8, ++IBUS_comma, IBUS_quotedbl, 0x201E, ++IBUS_comma, IBUS_apostrophe, 0x201A, ++IBUS_comma, IBUS_comma, 0x00B8, ++IBUS_comma, IBUS_minus, 0x00AC, ++IBUS_comma, IBUS_A, 0x0104, ++IBUS_comma, IBUS_C, 0x00C7, ++IBUS_comma, IBUS_D, 0x1E10, ++IBUS_comma, IBUS_E, 0x0228, ++IBUS_comma, IBUS_G, 0x0122, ++IBUS_comma, IBUS_H, 0x1E28, ++IBUS_comma, IBUS_I, 0x012E, ++IBUS_comma, IBUS_K, 0x0136, ++IBUS_comma, IBUS_L, 0x013B, ++IBUS_comma, IBUS_N, 0x0145, ++IBUS_comma, IBUS_R, 0x0156, ++IBUS_comma, IBUS_S, 0x015E, ++IBUS_comma, IBUS_T, 0x0162, ++IBUS_comma, IBUS_U, 0x0172, ++IBUS_comma, IBUS_a, 0x0105, ++IBUS_comma, IBUS_c, 0x00E7, ++IBUS_comma, IBUS_d, 0x1E11, ++IBUS_comma, IBUS_e, 0x0229, ++IBUS_comma, IBUS_g, 0x0123, ++IBUS_comma, IBUS_h, 0x1E29, ++IBUS_comma, IBUS_i, 0x012F, ++IBUS_comma, IBUS_k, 0x0137, ++IBUS_comma, IBUS_l, 0x013C, ++IBUS_comma, IBUS_n, 0x0146, ++IBUS_comma, IBUS_r, 0x0157, ++IBUS_comma, IBUS_s, 0x015F, ++IBUS_comma, IBUS_t, 0x0163, ++IBUS_comma, IBUS_u, 0x0173, ++IBUS_minus, IBUS_space, 0x007E, ++IBUS_minus, IBUS_parenleft, 0x007B, ++IBUS_minus, IBUS_parenright, 0x007D, ++IBUS_minus, IBUS_plus, 0x00B1, ++IBUS_minus, IBUS_comma, 0x00AC, ++IBUS_minus, IBUS_colon, 0x00F7, ++IBUS_minus, IBUS_greater, 0x2192, ++IBUS_minus, IBUS_A, 0x00C3, ++IBUS_minus, IBUS_D, 0x0110, ++IBUS_minus, IBUS_E, 0x0112, ++IBUS_minus, IBUS_I, 0x012A, ++IBUS_minus, IBUS_L, 0x00A3, ++IBUS_minus, IBUS_N, 0x00D1, ++IBUS_minus, IBUS_O, 0x00D5, ++IBUS_minus, IBUS_U, 0x016A, ++IBUS_minus, IBUS_Y, 0x00A5, ++IBUS_minus, IBUS_asciicircum, 0x00AF, ++IBUS_minus, IBUS_a, 0x0101, ++IBUS_minus, IBUS_d, 0x0111, ++IBUS_minus, IBUS_e, 0x0113, ++IBUS_minus, IBUS_i, 0x012B, ++IBUS_minus, IBUS_l, 0x00A3, ++IBUS_minus, IBUS_n, 0x00F1, ++IBUS_minus, IBUS_o, 0x014D, ++IBUS_minus, IBUS_u, 0x016B, ++IBUS_minus, IBUS_y, 0x00A5, ++IBUS_period, IBUS_minus, 0x00B7, ++IBUS_period, IBUS_period, 0x2026, ++IBUS_period, IBUS_less, 0x2039, ++IBUS_period, IBUS_equal, 0x2022, ++IBUS_period, IBUS_greater, 0x203A, ++IBUS_period, IBUS_A, 0x0226, ++IBUS_period, IBUS_B, 0x1E02, ++IBUS_period, IBUS_C, 0x010A, ++IBUS_period, IBUS_D, 0x1E0A, ++IBUS_period, IBUS_E, 0x0116, ++IBUS_period, IBUS_F, 0x1E1E, ++IBUS_period, IBUS_G, 0x0120, ++IBUS_period, IBUS_H, 0x1E22, ++IBUS_period, IBUS_I, 0x0130, ++IBUS_period, IBUS_M, 0x1E40, ++IBUS_period, IBUS_N, 0x1E44, ++IBUS_period, IBUS_O, 0x022E, ++IBUS_period, IBUS_P, 0x1E56, ++IBUS_period, IBUS_R, 0x1E58, ++IBUS_period, IBUS_S, 0x1E60, ++IBUS_period, IBUS_T, 0x1E6A, ++IBUS_period, IBUS_W, 0x1E86, ++IBUS_period, IBUS_X, 0x1E8A, ++IBUS_period, IBUS_Y, 0x1E8E, ++IBUS_period, IBUS_Z, 0x017B, ++IBUS_period, IBUS_asciicircum, 0x00B7, ++IBUS_period, IBUS_a, 0x0227, ++IBUS_period, IBUS_b, 0x1E03, ++IBUS_period, IBUS_c, 0x010B, ++IBUS_period, IBUS_d, 0x1E0B, ++IBUS_period, IBUS_e, 0x0117, ++IBUS_period, IBUS_f, 0x1E1F, ++IBUS_period, IBUS_g, 0x0121, ++IBUS_period, IBUS_h, 0x1E23, ++IBUS_period, IBUS_i, 0x0131, ++IBUS_period, IBUS_m, 0x1E41, ++IBUS_period, IBUS_n, 0x1E45, ++IBUS_period, IBUS_o, 0x022F, ++IBUS_period, IBUS_p, 0x1E57, ++IBUS_period, IBUS_r, 0x1E59, ++IBUS_period, IBUS_s, 0x1E61, ++IBUS_period, IBUS_t, 0x1E6B, ++IBUS_period, IBUS_w, 0x1E87, ++IBUS_period, IBUS_x, 0x1E8B, ++IBUS_period, IBUS_y, 0x1E8F, ++IBUS_period, IBUS_z, 0x017C, ++IBUS_period, 0x017F, 0x1E9B, ++IBUS_period, IBUS_Sacute, 0x1E64, ++IBUS_period, IBUS_Scaron, 0x1E66, ++IBUS_period, IBUS_sacute, 0x1E65, ++IBUS_period, IBUS_scaron, 0x1E67, ++IBUS_period, 0x1E62, 0x1E68, ++IBUS_period, 0x1E63, 0x1E69, ++IBUS_slash, IBUS_slash, 0x005C, ++IBUS_slash, IBUS_less, 0x005C, ++IBUS_slash, IBUS_equal, 0x2260, ++IBUS_slash, IBUS_C, 0x20A1, ++IBUS_slash, IBUS_D, 0x0110, ++IBUS_slash, IBUS_G, 0x01E4, ++IBUS_slash, IBUS_H, 0x0126, ++IBUS_slash, IBUS_I, 0x0197, ++IBUS_slash, IBUS_L, 0x0141, ++IBUS_slash, IBUS_O, 0x00D8, ++IBUS_slash, IBUS_T, 0x0166, ++IBUS_slash, IBUS_U, 0x00B5, ++IBUS_slash, IBUS_Z, 0x01B5, ++IBUS_slash, IBUS_asciicircum, 0x007C, ++IBUS_slash, IBUS_b, 0x0180, ++IBUS_slash, IBUS_c, 0x00A2, ++IBUS_slash, IBUS_d, 0x0111, ++IBUS_slash, IBUS_g, 0x01E5, ++IBUS_slash, IBUS_h, 0x0127, ++IBUS_slash, IBUS_i, 0x0268, ++IBUS_slash, IBUS_l, 0x0142, ++IBUS_slash, IBUS_m, 0x20A5, ++IBUS_slash, IBUS_o, 0x00F8, ++IBUS_slash, IBUS_t, 0x0167, ++IBUS_slash, IBUS_u, 0x00B5, ++IBUS_slash, IBUS_z, 0x01B6, ++IBUS_slash, 0x0294, 0x02A1, ++IBUS_slash, 0x04AE, 0x04B0, ++IBUS_slash, 0x04AF, 0x04B1, ++IBUS_slash, IBUS_Cyrillic_ghe, 0x0493, ++IBUS_slash, IBUS_Cyrillic_ka, 0x049F, ++IBUS_slash, IBUS_Cyrillic_GHE, 0x0492, ++IBUS_slash, IBUS_Cyrillic_KA, 0x049E, ++IBUS_slash, IBUS_leftarrow, 0x219A, ++IBUS_slash, IBUS_rightarrow, 0x219B, ++IBUS_slash, 0x2194, 0x21AE, ++IBUS_0, IBUS_asterisk, 0x00B0, ++IBUS_0, IBUS_C, 0x00A9, ++IBUS_0, IBUS_S, 0x00A7, ++IBUS_0, IBUS_X, 0x00A4, ++IBUS_0, IBUS_asciicircum, 0x00B0, ++IBUS_0, IBUS_c, 0x00A9, ++IBUS_0, IBUS_s, 0x00A7, ++IBUS_0, IBUS_x, 0x00A4, ++IBUS_1, IBUS_2, 0x00BD, ++IBUS_1, IBUS_3, 0x2153, ++IBUS_1, IBUS_4, 0x00BC, ++IBUS_1, IBUS_5, 0x2155, ++IBUS_1, IBUS_6, 0x2159, ++IBUS_1, IBUS_8, 0x215B, ++IBUS_1, IBUS_S, 0x00B9, ++IBUS_1, IBUS_asciicircum, 0x00B9, ++IBUS_1, IBUS_s, 0x00B9, ++IBUS_2, IBUS_3, 0x2154, ++IBUS_2, IBUS_5, 0x2156, ++IBUS_2, IBUS_S, 0x00B2, ++IBUS_2, IBUS_asciicircum, 0x00B2, ++IBUS_2, IBUS_s, 0x00B2, ++IBUS_3, IBUS_4, 0x00BE, ++IBUS_3, IBUS_5, 0x2157, ++IBUS_3, IBUS_8, 0x215C, ++IBUS_3, IBUS_S, 0x00B3, ++IBUS_3, IBUS_asciicircum, 0x00B3, ++IBUS_3, IBUS_s, 0x00B3, ++IBUS_4, IBUS_5, 0x2158, ++IBUS_5, IBUS_6, 0x215A, ++IBUS_5, IBUS_8, 0x215D, ++IBUS_7, IBUS_8, 0x215E, ++IBUS_colon, IBUS_parenleft, 0x2639, ++IBUS_colon, IBUS_parenright, 0x263A, ++IBUS_colon, IBUS_minus, 0x00F7, ++IBUS_semicolon, IBUS_A, 0x0104, ++IBUS_semicolon, IBUS_E, 0x0118, ++IBUS_semicolon, IBUS_I, 0x012E, ++IBUS_semicolon, IBUS_O, 0x01EA, ++IBUS_semicolon, IBUS_U, 0x0172, ++IBUS_semicolon, IBUS_a, 0x0105, ++IBUS_semicolon, IBUS_e, 0x0119, ++IBUS_semicolon, IBUS_i, 0x012F, ++IBUS_semicolon, IBUS_o, 0x01EB, ++IBUS_semicolon, IBUS_u, 0x0173, ++IBUS_less, IBUS_space, 0x02C7, ++IBUS_less, IBUS_quotedbl, 0x201C, ++IBUS_less, IBUS_apostrophe, 0x2018, ++IBUS_less, IBUS_minus, 0x2190, ++IBUS_less, IBUS_slash, 0x005C, ++IBUS_less, IBUS_3, 0x2665, ++IBUS_less, IBUS_less, 0x00AB, ++IBUS_less, IBUS_equal, 0x2264, ++IBUS_less, IBUS_C, 0x010C, ++IBUS_less, IBUS_D, 0x010E, ++IBUS_less, IBUS_E, 0x011A, ++IBUS_less, IBUS_L, 0x013D, ++IBUS_less, IBUS_N, 0x0147, ++IBUS_less, IBUS_R, 0x0158, ++IBUS_less, IBUS_S, 0x0160, ++IBUS_less, IBUS_T, 0x0164, ++IBUS_less, IBUS_Z, 0x017D, ++IBUS_less, IBUS_c, 0x010D, ++IBUS_less, IBUS_d, 0x010F, ++IBUS_less, IBUS_e, 0x011B, ++IBUS_less, IBUS_l, 0x013E, ++IBUS_less, IBUS_n, 0x0148, ++IBUS_less, IBUS_r, 0x0159, ++IBUS_less, IBUS_s, 0x0161, ++IBUS_less, IBUS_t, 0x0165, ++IBUS_less, IBUS_z, 0x017E, ++IBUS_less, 0x0338, 0x226E, ++IBUS_equal, IBUS_slash, 0x2260, ++IBUS_equal, IBUS_C, 0x20AC, ++IBUS_equal, IBUS_E, 0x20AC, ++IBUS_equal, IBUS_L, 0x20A4, ++IBUS_equal, IBUS_N, 0x20A6, ++IBUS_equal, IBUS_O, 0x0150, ++IBUS_equal, IBUS_U, 0x0170, ++IBUS_equal, IBUS_W, 0x20A9, ++IBUS_equal, IBUS_Y, 0x00A5, ++IBUS_equal, IBUS_c, 0x20AC, ++IBUS_equal, IBUS_e, 0x20AC, ++IBUS_equal, IBUS_l, 0x00A3, ++IBUS_equal, IBUS_o, 0x0151, ++IBUS_equal, IBUS_u, 0x0171, ++IBUS_equal, IBUS_y, 0x00A5, ++IBUS_equal, 0x0338, 0x2260, ++IBUS_equal, IBUS_Cyrillic_u, 0x04F3, ++IBUS_equal, IBUS_Cyrillic_IE, 0x20AC, ++IBUS_equal, IBUS_Cyrillic_ES, 0x20AC, ++IBUS_equal, IBUS_Cyrillic_U, 0x04F2, ++IBUS_greater, IBUS_space, 0x005E, ++IBUS_greater, IBUS_quotedbl, 0x201D, ++IBUS_greater, IBUS_apostrophe, 0x2019, ++IBUS_greater, IBUS_equal, 0x2265, ++IBUS_greater, IBUS_greater, 0x00BB, ++IBUS_greater, IBUS_A, 0x00C2, ++IBUS_greater, IBUS_E, 0x00CA, ++IBUS_greater, IBUS_I, 0x00CE, ++IBUS_greater, IBUS_O, 0x00D4, ++IBUS_greater, IBUS_U, 0x00DB, ++IBUS_greater, IBUS_a, 0x00E2, ++IBUS_greater, IBUS_e, 0x00EA, ++IBUS_greater, IBUS_i, 0x00EE, ++IBUS_greater, IBUS_o, 0x00F4, ++IBUS_greater, IBUS_u, 0x00FB, ++IBUS_greater, 0x0338, 0x226F, ++IBUS_question, IBUS_exclam, 0x203D, ++IBUS_question, IBUS_question, 0x00BF, ++IBUS_question, IBUS_A, 0x1EA2, ++IBUS_question, IBUS_E, 0x1EBA, ++IBUS_question, IBUS_I, 0x1EC8, ++IBUS_question, IBUS_O, 0x1ECE, ++IBUS_question, IBUS_U, 0x1EE6, ++IBUS_question, IBUS_Y, 0x1EF6, ++IBUS_question, IBUS_a, 0x1EA3, ++IBUS_question, IBUS_e, 0x1EBB, ++IBUS_question, IBUS_i, 0x1EC9, ++IBUS_question, IBUS_o, 0x1ECF, ++IBUS_question, IBUS_u, 0x1EE7, ++IBUS_question, IBUS_y, 0x1EF7, ++IBUS_question, IBUS_Acircumflex, 0x1EA8, ++IBUS_question, IBUS_Ecircumflex, 0x1EC2, ++IBUS_question, IBUS_Ocircumflex, 0x1ED4, ++IBUS_question, IBUS_acircumflex, 0x1EA9, ++IBUS_question, IBUS_ecircumflex, 0x1EC3, ++IBUS_question, IBUS_ocircumflex, 0x1ED5, ++IBUS_question, IBUS_Abreve, 0x1EB2, ++IBUS_question, IBUS_abreve, 0x1EB3, ++IBUS_A, IBUS_quotedbl, 0x00C4, ++IBUS_A, IBUS_apostrophe, 0x00C1, ++IBUS_A, IBUS_parenleft, 0x0102, ++IBUS_A, IBUS_asterisk, 0x00C5, ++IBUS_A, IBUS_comma, 0x0104, ++IBUS_A, IBUS_minus, 0x00C3, ++IBUS_A, IBUS_greater, 0x00C2, ++IBUS_A, IBUS_A, 0x00C5, ++IBUS_A, IBUS_E, 0x00C6, ++IBUS_A, IBUS_T, 0x0040, ++IBUS_A, IBUS_asciicircum, 0x00C2, ++IBUS_A, IBUS_underscore, 0x00AA, ++IBUS_A, IBUS_grave, 0x00C0, ++IBUS_A, IBUS_asciitilde, 0x00C3, ++IBUS_A, IBUS_diaeresis, 0x00C4, ++IBUS_A, IBUS_acute, 0x00C1, ++IBUS_B, IBUS_period, 0x1E02, ++IBUS_C, IBUS_apostrophe, 0x0106, ++IBUS_C, IBUS_comma, 0x00C7, ++IBUS_C, IBUS_period, 0x010A, ++IBUS_C, IBUS_slash, 0x20A1, ++IBUS_C, IBUS_0, 0x00A9, ++IBUS_C, IBUS_less, 0x010C, ++IBUS_C, IBUS_equal, 0x20AC, ++IBUS_C, IBUS_E, 0x20A0, ++IBUS_C, IBUS_O, 0x00A9, ++IBUS_C, IBUS_o, 0x00A9, ++IBUS_C, IBUS_r, 0x20A2, ++IBUS_C, IBUS_bar, 0x00A2, ++IBUS_D, IBUS_minus, 0x0110, ++IBUS_D, IBUS_period, 0x1E0A, ++IBUS_D, IBUS_less, 0x010E, ++IBUS_D, IBUS_H, 0x00D0, ++IBUS_E, IBUS_quotedbl, 0x00CB, ++IBUS_E, IBUS_apostrophe, 0x00C9, ++IBUS_E, IBUS_comma, 0x0118, ++IBUS_E, IBUS_minus, 0x0112, ++IBUS_E, IBUS_period, 0x0116, ++IBUS_E, IBUS_less, 0x011A, ++IBUS_E, IBUS_equal, 0x20AC, ++IBUS_E, IBUS_greater, 0x00CA, ++IBUS_E, IBUS_asciicircum, 0x00CA, ++IBUS_E, IBUS_underscore, 0x0112, ++IBUS_E, IBUS_grave, 0x00C8, ++IBUS_E, IBUS_diaeresis, 0x00CB, ++IBUS_E, IBUS_acute, 0x00C9, ++IBUS_F, IBUS_period, 0x1E1E, ++IBUS_F, IBUS_r, 0x20A3, ++IBUS_G, IBUS_parenleft, 0x011E, ++IBUS_G, IBUS_comma, 0x0122, ++IBUS_G, IBUS_period, 0x0120, ++IBUS_G, IBUS_U, 0x011E, ++IBUS_G, IBUS_breve, 0x011E, ++IBUS_I, IBUS_quotedbl, 0x00CF, ++IBUS_I, IBUS_apostrophe, 0x00CD, ++IBUS_I, IBUS_comma, 0x012E, ++IBUS_I, IBUS_minus, 0x012A, ++IBUS_I, IBUS_period, 0x0130, ++IBUS_I, IBUS_greater, 0x00CE, ++IBUS_I, IBUS_asciicircum, 0x00CE, ++IBUS_I, IBUS_underscore, 0x012A, ++IBUS_I, IBUS_grave, 0x00CC, ++IBUS_I, IBUS_asciitilde, 0x0128, ++IBUS_I, IBUS_diaeresis, 0x00CF, ++IBUS_I, IBUS_acute, 0x00CD, ++IBUS_K, IBUS_comma, 0x0136, ++IBUS_L, IBUS_apostrophe, 0x0139, ++IBUS_L, IBUS_comma, 0x013B, ++IBUS_L, IBUS_minus, 0x00A3, ++IBUS_L, IBUS_slash, 0x0141, ++IBUS_L, IBUS_less, 0x013D, ++IBUS_L, IBUS_equal, 0x00A3, ++IBUS_L, IBUS_V, 0x007C, ++IBUS_M, IBUS_period, 0x1E40, ++IBUS_N, IBUS_apostrophe, 0x0143, ++IBUS_N, IBUS_comma, 0x0145, ++IBUS_N, IBUS_minus, 0x00D1, ++IBUS_N, IBUS_less, 0x0147, ++IBUS_N, IBUS_equal, 0x20A6, ++IBUS_N, IBUS_G, 0x014A, ++IBUS_N, IBUS_O, 0x2116, ++IBUS_N, IBUS_o, 0x2116, ++IBUS_N, IBUS_asciitilde, 0x00D1, ++IBUS_O, IBUS_quotedbl, 0x00D6, ++IBUS_O, IBUS_apostrophe, 0x00D3, ++IBUS_O, IBUS_minus, 0x00D5, ++IBUS_O, IBUS_slash, 0x00D8, ++IBUS_O, IBUS_greater, 0x00D4, ++IBUS_O, IBUS_C, 0x00A9, ++IBUS_O, IBUS_E, 0x0152, ++IBUS_O, IBUS_R, 0x00AE, ++IBUS_O, IBUS_S, 0x00A7, ++IBUS_O, IBUS_X, 0x00A4, ++IBUS_O, IBUS_asciicircum, 0x00D4, ++IBUS_O, IBUS_underscore, 0x00BA, ++IBUS_O, IBUS_grave, 0x00D2, ++IBUS_O, IBUS_c, 0x00A9, ++IBUS_O, IBUS_r, 0x00AE, ++IBUS_O, IBUS_x, 0x00A4, ++IBUS_O, IBUS_asciitilde, 0x00D5, ++IBUS_O, IBUS_diaeresis, 0x00D6, ++IBUS_O, IBUS_acute, 0x00D3, ++IBUS_P, IBUS_exclam, 0x00B6, ++IBUS_P, IBUS_period, 0x1E56, ++IBUS_P, IBUS_P, 0x00B6, ++IBUS_P, IBUS_t, 0x20A7, ++IBUS_R, IBUS_apostrophe, 0x0154, ++IBUS_R, IBUS_comma, 0x0156, ++IBUS_R, IBUS_less, 0x0158, ++IBUS_R, IBUS_O, 0x00AE, ++IBUS_R, IBUS_s, 0x20A8, ++IBUS_S, IBUS_exclam, 0x00A7, ++IBUS_S, IBUS_apostrophe, 0x015A, ++IBUS_S, IBUS_comma, 0x015E, ++IBUS_S, IBUS_period, 0x1E60, ++IBUS_S, IBUS_0, 0x00A7, ++IBUS_S, IBUS_1, 0x00B9, ++IBUS_S, IBUS_2, 0x00B2, ++IBUS_S, IBUS_3, 0x00B3, ++IBUS_S, IBUS_less, 0x0160, ++IBUS_S, IBUS_M, 0x2120, ++IBUS_S, IBUS_O, 0x00A7, ++IBUS_S, IBUS_m, 0x2120, ++IBUS_S, IBUS_cedilla, 0x015E, ++IBUS_T, IBUS_minus, 0x0166, ++IBUS_T, IBUS_period, 0x1E6A, ++IBUS_T, IBUS_slash, 0x0166, ++IBUS_T, IBUS_less, 0x0164, ++IBUS_T, IBUS_H, 0x00DE, ++IBUS_T, IBUS_M, 0x2122, ++IBUS_T, IBUS_m, 0x2122, ++IBUS_U, IBUS_quotedbl, 0x00DC, ++IBUS_U, IBUS_apostrophe, 0x00DA, ++IBUS_U, IBUS_asterisk, 0x016E, ++IBUS_U, IBUS_comma, 0x0172, ++IBUS_U, IBUS_minus, 0x016A, ++IBUS_U, IBUS_slash, 0x00B5, ++IBUS_U, IBUS_greater, 0x00DB, ++IBUS_U, IBUS_A, 0x0102, ++IBUS_U, IBUS_E, 0x0114, ++IBUS_U, IBUS_G, 0x011E, ++IBUS_U, IBUS_I, 0x012C, ++IBUS_U, IBUS_O, 0x014E, ++IBUS_U, IBUS_U, 0x016C, ++IBUS_U, IBUS_asciicircum, 0x00DB, ++IBUS_U, IBUS_underscore, 0x016A, ++IBUS_U, IBUS_grave, 0x00D9, ++IBUS_U, IBUS_a, 0x0103, ++IBUS_U, IBUS_e, 0x0115, ++IBUS_U, IBUS_g, 0x011F, ++IBUS_U, IBUS_i, 0x012D, ++IBUS_U, IBUS_o, 0x014F, ++IBUS_U, IBUS_u, 0x016D, ++IBUS_U, IBUS_asciitilde, 0x0168, ++IBUS_U, IBUS_diaeresis, 0x00DC, ++IBUS_U, IBUS_acute, 0x00DA, ++IBUS_U, 0x0228, 0x1E1C, ++IBUS_U, 0x0229, 0x1E1D, ++IBUS_U, IBUS_Cyrillic_a, 0x04D1, ++IBUS_U, IBUS_Cyrillic_ie, 0x04D7, ++IBUS_U, IBUS_Cyrillic_i, 0x0439, ++IBUS_U, IBUS_Cyrillic_u, 0x045E, ++IBUS_U, IBUS_Cyrillic_zhe, 0x04C2, ++IBUS_U, IBUS_Cyrillic_A, 0x04D0, ++IBUS_U, IBUS_Cyrillic_IE, 0x04D6, ++IBUS_U, IBUS_Cyrillic_I, 0x0419, ++IBUS_U, IBUS_Cyrillic_U, 0x040E, ++IBUS_U, IBUS_Cyrillic_ZHE, 0x04C1, ++IBUS_U, IBUS_Greek_ALPHA, 0x1FB8, ++IBUS_U, IBUS_Greek_IOTA, 0x1FD8, ++IBUS_U, IBUS_Greek_UPSILON, 0x1FE8, ++IBUS_U, IBUS_Greek_alpha, 0x1FB0, ++IBUS_U, IBUS_Greek_iota, 0x1FD0, ++IBUS_U, IBUS_Greek_upsilon, 0x1FE0, ++IBUS_U, 0x1EA0, 0x1EB6, ++IBUS_U, 0x1EA1, 0x1EB7, ++IBUS_V, IBUS_L, 0x007C, ++IBUS_W, IBUS_equal, 0x20A9, ++IBUS_W, IBUS_asciicircum, 0x0174, ++IBUS_X, IBUS_0, 0x00A4, ++IBUS_X, IBUS_O, 0x00A4, ++IBUS_X, IBUS_o, 0x00A4, ++IBUS_Y, IBUS_quotedbl, 0x0178, ++IBUS_Y, IBUS_apostrophe, 0x00DD, ++IBUS_Y, IBUS_minus, 0x00A5, ++IBUS_Y, IBUS_equal, 0x00A5, ++IBUS_Y, IBUS_asciicircum, 0x0176, ++IBUS_Y, IBUS_diaeresis, 0x0178, ++IBUS_Y, IBUS_acute, 0x00DD, ++IBUS_Z, IBUS_apostrophe, 0x0179, ++IBUS_Z, IBUS_period, 0x017B, ++IBUS_Z, IBUS_less, 0x017D, ++IBUS_asciicircum, IBUS_space, 0x005E, ++IBUS_asciicircum, IBUS_parenleft, 0x207D, ++IBUS_asciicircum, IBUS_parenright, 0x207E, ++IBUS_asciicircum, IBUS_plus, 0x207A, ++IBUS_asciicircum, IBUS_minus, 0x00AF, ++IBUS_asciicircum, IBUS_period, 0x00B7, ++IBUS_asciicircum, IBUS_slash, 0x007C, ++IBUS_asciicircum, IBUS_0, 0x2070, ++IBUS_asciicircum, IBUS_1, 0x00B9, ++IBUS_asciicircum, IBUS_2, 0x00B2, ++IBUS_asciicircum, IBUS_3, 0x00B3, ++IBUS_asciicircum, IBUS_4, 0x2074, ++IBUS_asciicircum, IBUS_5, 0x2075, ++IBUS_asciicircum, IBUS_6, 0x2076, ++IBUS_asciicircum, IBUS_7, 0x2077, ++IBUS_asciicircum, IBUS_8, 0x2078, ++IBUS_asciicircum, IBUS_9, 0x2079, ++IBUS_asciicircum, IBUS_equal, 0x207C, ++IBUS_asciicircum, IBUS_A, 0x00C2, ++IBUS_asciicircum, IBUS_C, 0x0108, ++IBUS_asciicircum, IBUS_E, 0x00CA, ++IBUS_asciicircum, IBUS_G, 0x011C, ++IBUS_asciicircum, IBUS_H, 0x0124, ++IBUS_asciicircum, IBUS_I, 0x00CE, ++IBUS_asciicircum, IBUS_J, 0x0134, ++IBUS_asciicircum, IBUS_O, 0x00D4, ++IBUS_asciicircum, IBUS_S, 0x015C, ++IBUS_asciicircum, IBUS_U, 0x00DB, ++IBUS_asciicircum, IBUS_W, 0x0174, ++IBUS_asciicircum, IBUS_Y, 0x0176, ++IBUS_asciicircum, IBUS_Z, 0x1E90, ++IBUS_asciicircum, IBUS_underscore, 0x00AF, ++IBUS_asciicircum, IBUS_a, 0x00E2, ++IBUS_asciicircum, IBUS_c, 0x0109, ++IBUS_asciicircum, IBUS_e, 0x00EA, ++IBUS_asciicircum, IBUS_g, 0x011D, ++IBUS_asciicircum, IBUS_h, 0x0125, ++IBUS_asciicircum, IBUS_i, 0x00EE, ++IBUS_asciicircum, IBUS_j, 0x0135, ++IBUS_asciicircum, IBUS_o, 0x00F4, ++IBUS_asciicircum, IBUS_s, 0x015D, ++IBUS_asciicircum, IBUS_u, 0x00FB, ++IBUS_asciicircum, IBUS_w, 0x0175, ++IBUS_asciicircum, IBUS_y, 0x0177, ++IBUS_asciicircum, IBUS_z, 0x1E91, ++IBUS_asciicircum, 0x1EA0, 0x1EAC, ++IBUS_asciicircum, 0x1EA1, 0x1EAD, ++IBUS_asciicircum, 0x1EB8, 0x1EC6, ++IBUS_asciicircum, 0x1EB9, 0x1EC7, ++IBUS_asciicircum, 0x1ECC, 0x1ED8, ++IBUS_asciicircum, 0x1ECD, 0x1ED9, ++IBUS_asciicircum, 0x2212, 0x207B, ++IBUS_asciicircum, 0x4E00, 0x3192, ++IBUS_asciicircum, 0x4E01, 0x319C, ++IBUS_asciicircum, 0x4E09, 0x3194, ++IBUS_asciicircum, 0x4E0A, 0x3196, ++IBUS_asciicircum, 0x4E0B, 0x3198, ++IBUS_asciicircum, 0x4E19, 0x319B, ++IBUS_asciicircum, 0x4E2D, 0x3197, ++IBUS_asciicircum, 0x4E59, 0x319A, ++IBUS_asciicircum, 0x4E8C, 0x3193, ++IBUS_asciicircum, 0x4EBA, 0x319F, ++IBUS_asciicircum, 0x56DB, 0x3195, ++IBUS_asciicircum, 0x5730, 0x319E, ++IBUS_asciicircum, 0x5929, 0x319D, ++IBUS_asciicircum, 0x7532, 0x3199, ++IBUS_asciicircum, IBUS_KP_Space, 0x00B2, ++IBUS_asciicircum, IBUS_KP_Add, 0x207A, ++IBUS_asciicircum, IBUS_KP_0, 0x2070, ++IBUS_asciicircum, IBUS_KP_1, 0x00B9, ++IBUS_asciicircum, IBUS_KP_2, 0x00B2, ++IBUS_asciicircum, IBUS_KP_3, 0x00B3, ++IBUS_asciicircum, IBUS_KP_4, 0x2074, ++IBUS_asciicircum, IBUS_KP_5, 0x2075, ++IBUS_asciicircum, IBUS_KP_6, 0x2076, ++IBUS_asciicircum, IBUS_KP_7, 0x2077, ++IBUS_asciicircum, IBUS_KP_8, 0x2078, ++IBUS_asciicircum, IBUS_KP_9, 0x2079, ++IBUS_asciicircum, IBUS_KP_Equal, 0x207C, ++IBUS_underscore, IBUS_parenleft, 0x208D, ++IBUS_underscore, IBUS_parenright, 0x208E, ++IBUS_underscore, IBUS_plus, 0x208A, ++IBUS_underscore, IBUS_0, 0x2080, ++IBUS_underscore, IBUS_1, 0x2081, ++IBUS_underscore, IBUS_2, 0x2082, ++IBUS_underscore, IBUS_3, 0x2083, ++IBUS_underscore, IBUS_4, 0x2084, ++IBUS_underscore, IBUS_5, 0x2085, ++IBUS_underscore, IBUS_6, 0x2086, ++IBUS_underscore, IBUS_7, 0x2087, ++IBUS_underscore, IBUS_8, 0x2088, ++IBUS_underscore, IBUS_9, 0x2089, ++IBUS_underscore, IBUS_equal, 0x208C, ++IBUS_underscore, IBUS_A, 0x0100, ++IBUS_underscore, IBUS_E, 0x0112, ++IBUS_underscore, IBUS_G, 0x1E20, ++IBUS_underscore, IBUS_I, 0x012A, ++IBUS_underscore, IBUS_O, 0x014C, ++IBUS_underscore, IBUS_U, 0x016A, ++IBUS_underscore, IBUS_Y, 0x0232, ++IBUS_underscore, IBUS_asciicircum, 0x00AF, ++IBUS_underscore, IBUS_underscore, 0x00AF, ++IBUS_underscore, IBUS_a, 0x0101, ++IBUS_underscore, IBUS_e, 0x0113, ++IBUS_underscore, IBUS_g, 0x1E21, ++IBUS_underscore, IBUS_i, 0x012B, ++IBUS_underscore, IBUS_o, 0x014D, ++IBUS_underscore, IBUS_u, 0x016B, ++IBUS_underscore, IBUS_y, 0x0233, ++IBUS_underscore, IBUS_Adiaeresis, 0x01DE, ++IBUS_underscore, IBUS_AE, 0x01E2, ++IBUS_underscore, IBUS_Otilde, 0x022C, ++IBUS_underscore, IBUS_Odiaeresis, 0x022A, ++IBUS_underscore, IBUS_Udiaeresis, 0x01D5, ++IBUS_underscore, IBUS_adiaeresis, 0x01DF, ++IBUS_underscore, IBUS_ae, 0x01E3, ++IBUS_underscore, IBUS_otilde, 0x022D, ++IBUS_underscore, IBUS_odiaeresis, 0x022B, ++IBUS_underscore, IBUS_udiaeresis, 0x01D6, ++IBUS_underscore, 0x01EA, 0x01EC, ++IBUS_underscore, 0x01EB, 0x01ED, ++IBUS_underscore, 0x0226, 0x01E0, ++IBUS_underscore, 0x0227, 0x01E1, ++IBUS_underscore, 0x022E, 0x0230, ++IBUS_underscore, 0x022F, 0x0231, ++IBUS_underscore, IBUS_Cyrillic_i, 0x04E3, ++IBUS_underscore, IBUS_Cyrillic_u, 0x04EF, ++IBUS_underscore, IBUS_Cyrillic_I, 0x04E2, ++IBUS_underscore, IBUS_Cyrillic_U, 0x04EE, ++IBUS_underscore, IBUS_Greek_ALPHA, 0x1FB9, ++IBUS_underscore, IBUS_Greek_IOTA, 0x1FD9, ++IBUS_underscore, IBUS_Greek_UPSILON, 0x1FE9, ++IBUS_underscore, IBUS_Greek_alpha, 0x1FB1, ++IBUS_underscore, IBUS_Greek_iota, 0x1FD1, ++IBUS_underscore, IBUS_Greek_upsilon, 0x1FE1, ++IBUS_underscore, 0x1E36, 0x1E38, ++IBUS_underscore, 0x1E37, 0x1E39, ++IBUS_underscore, 0x1E5A, 0x1E5C, ++IBUS_underscore, 0x1E5B, 0x1E5D, ++IBUS_underscore, 0x2212, 0x208B, ++IBUS_underscore, IBUS_KP_Space, 0x2082, ++IBUS_underscore, IBUS_KP_Add, 0x208A, ++IBUS_underscore, IBUS_KP_0, 0x2080, ++IBUS_underscore, IBUS_KP_1, 0x2081, ++IBUS_underscore, IBUS_KP_2, 0x2082, ++IBUS_underscore, IBUS_KP_3, 0x2083, ++IBUS_underscore, IBUS_KP_4, 0x2084, ++IBUS_underscore, IBUS_KP_5, 0x2085, ++IBUS_underscore, IBUS_KP_6, 0x2086, ++IBUS_underscore, IBUS_KP_7, 0x2087, ++IBUS_underscore, IBUS_KP_8, 0x2088, ++IBUS_underscore, IBUS_KP_9, 0x2089, ++IBUS_underscore, IBUS_KP_Equal, 0x208C, ++IBUS_grave, IBUS_space, 0x0060, ++IBUS_grave, IBUS_A, 0x00C0, ++IBUS_grave, IBUS_E, 0x00C8, ++IBUS_grave, IBUS_I, 0x00CC, ++IBUS_grave, IBUS_N, 0x01F8, ++IBUS_grave, IBUS_O, 0x00D2, ++IBUS_grave, IBUS_U, 0x00D9, ++IBUS_grave, IBUS_W, 0x1E80, ++IBUS_grave, IBUS_Y, 0x1EF2, ++IBUS_grave, IBUS_a, 0x00E0, ++IBUS_grave, IBUS_e, 0x00E8, ++IBUS_grave, IBUS_i, 0x00EC, ++IBUS_grave, IBUS_n, 0x01F9, ++IBUS_grave, IBUS_o, 0x00F2, ++IBUS_grave, IBUS_u, 0x00F9, ++IBUS_grave, IBUS_w, 0x1E81, ++IBUS_grave, IBUS_y, 0x1EF3, ++IBUS_grave, IBUS_Acircumflex, 0x1EA6, ++IBUS_grave, IBUS_Ecircumflex, 0x1EC0, ++IBUS_grave, IBUS_Ocircumflex, 0x1ED2, ++IBUS_grave, IBUS_Udiaeresis, 0x01DB, ++IBUS_grave, IBUS_acircumflex, 0x1EA7, ++IBUS_grave, IBUS_ecircumflex, 0x1EC1, ++IBUS_grave, IBUS_ocircumflex, 0x1ED3, ++IBUS_grave, IBUS_udiaeresis, 0x01DC, ++IBUS_grave, IBUS_Abreve, 0x1EB0, ++IBUS_grave, IBUS_abreve, 0x1EB1, ++IBUS_grave, IBUS_Emacron, 0x1E14, ++IBUS_grave, IBUS_emacron, 0x1E15, ++IBUS_grave, IBUS_Omacron, 0x1E50, ++IBUS_grave, IBUS_omacron, 0x1E51, ++IBUS_grave, IBUS_Cyrillic_ie, 0x0450, ++IBUS_grave, IBUS_Cyrillic_i, 0x045D, ++IBUS_grave, IBUS_Cyrillic_IE, 0x0400, ++IBUS_grave, IBUS_Cyrillic_I, 0x040D, ++IBUS_grave, IBUS_Greek_iotadieresis, 0x1FD2, ++IBUS_grave, IBUS_Greek_upsilondieresis, 0x1FE2, ++IBUS_grave, IBUS_Greek_ALPHA, 0x1FBA, ++IBUS_grave, IBUS_Greek_EPSILON, 0x1FC8, ++IBUS_grave, IBUS_Greek_ETA, 0x1FCA, ++IBUS_grave, IBUS_Greek_IOTA, 0x1FDA, ++IBUS_grave, IBUS_Greek_OMICRON, 0x1FF8, ++IBUS_grave, IBUS_Greek_UPSILON, 0x1FEA, ++IBUS_grave, IBUS_Greek_OMEGA, 0x1FFA, ++IBUS_grave, IBUS_Greek_alpha, 0x1F70, ++IBUS_grave, IBUS_Greek_epsilon, 0x1F72, ++IBUS_grave, IBUS_Greek_eta, 0x1F74, ++IBUS_grave, IBUS_Greek_iota, 0x1F76, ++IBUS_grave, IBUS_Greek_omicron, 0x1F78, ++IBUS_grave, IBUS_Greek_upsilon, 0x1F7A, ++IBUS_grave, IBUS_Greek_omega, 0x1F7C, ++IBUS_grave, 0x1F00, 0x1F02, ++IBUS_grave, 0x1F01, 0x1F03, ++IBUS_grave, 0x1F08, 0x1F0A, ++IBUS_grave, 0x1F09, 0x1F0B, ++IBUS_grave, 0x1F10, 0x1F12, ++IBUS_grave, 0x1F11, 0x1F13, ++IBUS_grave, 0x1F18, 0x1F1A, ++IBUS_grave, 0x1F19, 0x1F1B, ++IBUS_grave, 0x1F20, 0x1F22, ++IBUS_grave, 0x1F21, 0x1F23, ++IBUS_grave, 0x1F28, 0x1F2A, ++IBUS_grave, 0x1F29, 0x1F2B, ++IBUS_grave, 0x1F30, 0x1F32, ++IBUS_grave, 0x1F31, 0x1F33, ++IBUS_grave, 0x1F38, 0x1F3A, ++IBUS_grave, 0x1F39, 0x1F3B, ++IBUS_grave, 0x1F40, 0x1F42, ++IBUS_grave, 0x1F41, 0x1F43, ++IBUS_grave, 0x1F48, 0x1F4A, ++IBUS_grave, 0x1F49, 0x1F4B, ++IBUS_grave, 0x1F50, 0x1F52, ++IBUS_grave, 0x1F51, 0x1F53, ++IBUS_grave, 0x1F59, 0x1F5B, ++IBUS_grave, 0x1F60, 0x1F62, ++IBUS_grave, 0x1F61, 0x1F63, ++IBUS_grave, 0x1F68, 0x1F6A, ++IBUS_grave, 0x1F69, 0x1F6B, ++IBUS_a, IBUS_quotedbl, 0x00E4, ++IBUS_a, IBUS_apostrophe, 0x00E1, ++IBUS_a, IBUS_parenleft, 0x0103, ++IBUS_a, IBUS_asterisk, 0x00E5, ++IBUS_a, IBUS_comma, 0x0105, ++IBUS_a, IBUS_minus, 0x0101, ++IBUS_a, IBUS_greater, 0x00E2, ++IBUS_a, IBUS_asciicircum, 0x00E2, ++IBUS_a, IBUS_underscore, 0x00AA, ++IBUS_a, IBUS_grave, 0x00E0, ++IBUS_a, IBUS_a, 0x00E5, ++IBUS_a, IBUS_e, 0x00E6, ++IBUS_a, IBUS_asciitilde, 0x00E3, ++IBUS_a, IBUS_diaeresis, 0x00E4, ++IBUS_a, IBUS_acute, 0x00E1, ++IBUS_b, IBUS_period, 0x1E03, ++IBUS_b, IBUS_A, 0x0102, ++IBUS_b, IBUS_E, 0x0114, ++IBUS_b, IBUS_G, 0x011E, ++IBUS_b, IBUS_I, 0x012C, ++IBUS_b, IBUS_O, 0x014E, ++IBUS_b, IBUS_U, 0x016C, ++IBUS_b, IBUS_a, 0x0103, ++IBUS_b, IBUS_e, 0x0115, ++IBUS_b, IBUS_g, 0x011F, ++IBUS_b, IBUS_i, 0x012D, ++IBUS_b, IBUS_o, 0x014F, ++IBUS_b, IBUS_u, 0x016D, ++IBUS_b, 0x0228, 0x1E1C, ++IBUS_b, 0x0229, 0x1E1D, ++IBUS_b, IBUS_Cyrillic_a, 0x04D1, ++IBUS_b, IBUS_Cyrillic_ie, 0x04D7, ++IBUS_b, IBUS_Cyrillic_i, 0x0439, ++IBUS_b, IBUS_Cyrillic_u, 0x045E, ++IBUS_b, IBUS_Cyrillic_zhe, 0x04C2, ++IBUS_b, IBUS_Cyrillic_A, 0x04D0, ++IBUS_b, IBUS_Cyrillic_IE, 0x04D6, ++IBUS_b, IBUS_Cyrillic_I, 0x0419, ++IBUS_b, IBUS_Cyrillic_U, 0x040E, ++IBUS_b, IBUS_Cyrillic_ZHE, 0x04C1, ++IBUS_b, IBUS_Greek_ALPHA, 0x1FB8, ++IBUS_b, IBUS_Greek_IOTA, 0x1FD8, ++IBUS_b, IBUS_Greek_UPSILON, 0x1FE8, ++IBUS_b, IBUS_Greek_alpha, 0x1FB0, ++IBUS_b, IBUS_Greek_iota, 0x1FD0, ++IBUS_b, IBUS_Greek_upsilon, 0x1FE0, ++IBUS_b, 0x1EA0, 0x1EB6, ++IBUS_b, 0x1EA1, 0x1EB7, ++IBUS_c, IBUS_apostrophe, 0x0107, ++IBUS_c, IBUS_comma, 0x00E7, ++IBUS_c, IBUS_period, 0x010B, ++IBUS_c, IBUS_slash, 0x00A2, ++IBUS_c, IBUS_0, 0x00A9, ++IBUS_c, IBUS_less, 0x010D, ++IBUS_c, IBUS_equal, 0x20AC, ++IBUS_c, IBUS_A, 0x01CD, ++IBUS_c, IBUS_C, 0x010C, ++IBUS_c, IBUS_D, 0x010E, ++IBUS_c, IBUS_E, 0x011A, ++IBUS_c, IBUS_G, 0x01E6, ++IBUS_c, IBUS_H, 0x021E, ++IBUS_c, IBUS_I, 0x01CF, ++IBUS_c, IBUS_K, 0x01E8, ++IBUS_c, IBUS_L, 0x013D, ++IBUS_c, IBUS_N, 0x0147, ++IBUS_c, IBUS_O, 0x01D1, ++IBUS_c, IBUS_R, 0x0158, ++IBUS_c, IBUS_S, 0x0160, ++IBUS_c, IBUS_T, 0x0164, ++IBUS_c, IBUS_U, 0x01D3, ++IBUS_c, IBUS_Z, 0x017D, ++IBUS_c, IBUS_a, 0x01CE, ++IBUS_c, IBUS_c, 0x010D, ++IBUS_c, IBUS_d, 0x010F, ++IBUS_c, IBUS_e, 0x011B, ++IBUS_c, IBUS_g, 0x01E7, ++IBUS_c, IBUS_h, 0x021F, ++IBUS_c, IBUS_i, 0x01D0, ++IBUS_c, IBUS_j, 0x01F0, ++IBUS_c, IBUS_k, 0x01E9, ++IBUS_c, IBUS_l, 0x013E, ++IBUS_c, IBUS_n, 0x0148, ++IBUS_c, IBUS_o, 0x01D2, ++IBUS_c, IBUS_r, 0x0159, ++IBUS_c, IBUS_s, 0x0161, ++IBUS_c, IBUS_t, 0x0165, ++IBUS_c, IBUS_u, 0x01D4, ++IBUS_c, IBUS_z, 0x017E, ++IBUS_c, IBUS_bar, 0x00A2, ++IBUS_c, IBUS_Udiaeresis, 0x01D9, ++IBUS_c, IBUS_udiaeresis, 0x01DA, ++IBUS_c, 0x01B7, 0x01EE, ++IBUS_c, 0x0292, 0x01EF, ++IBUS_d, IBUS_minus, 0x20AB, ++IBUS_d, IBUS_period, 0x1E0B, ++IBUS_d, IBUS_less, 0x010F, ++IBUS_d, IBUS_h, 0x00F0, ++IBUS_e, IBUS_quotedbl, 0x00EB, ++IBUS_e, IBUS_apostrophe, 0x00E9, ++IBUS_e, IBUS_comma, 0x0119, ++IBUS_e, IBUS_minus, 0x0113, ++IBUS_e, IBUS_period, 0x0117, ++IBUS_e, IBUS_less, 0x011B, ++IBUS_e, IBUS_equal, 0x20AC, ++IBUS_e, IBUS_greater, 0x00EA, ++IBUS_e, IBUS_asciicircum, 0x00EA, ++IBUS_e, IBUS_underscore, 0x0113, ++IBUS_e, IBUS_grave, 0x00E8, ++IBUS_e, IBUS_e, 0x0259, ++IBUS_e, IBUS_diaeresis, 0x00EB, ++IBUS_e, IBUS_acute, 0x00E9, ++IBUS_f, IBUS_period, 0x1E1F, ++IBUS_f, IBUS_S, 0x017F, ++IBUS_f, IBUS_s, 0x017F, ++IBUS_g, IBUS_parenleft, 0x011F, ++IBUS_g, IBUS_comma, 0x0123, ++IBUS_g, IBUS_period, 0x0121, ++IBUS_g, IBUS_U, 0x011F, ++IBUS_g, IBUS_breve, 0x011F, ++IBUS_i, IBUS_quotedbl, 0x00EF, ++IBUS_i, IBUS_apostrophe, 0x00ED, ++IBUS_i, IBUS_comma, 0x012F, ++IBUS_i, IBUS_minus, 0x012B, ++IBUS_i, IBUS_period, 0x0131, ++IBUS_i, IBUS_greater, 0x00EE, ++IBUS_i, IBUS_asciicircum, 0x00EE, ++IBUS_i, IBUS_underscore, 0x012B, ++IBUS_i, IBUS_grave, 0x00EC, ++IBUS_i, IBUS_asciitilde, 0x0129, ++IBUS_i, IBUS_diaeresis, 0x00EF, ++IBUS_i, IBUS_acute, 0x00ED, ++IBUS_k, IBUS_comma, 0x0137, ++IBUS_k, IBUS_k, 0x0138, ++IBUS_l, IBUS_apostrophe, 0x013A, ++IBUS_l, IBUS_comma, 0x013C, ++IBUS_l, IBUS_minus, 0x00A3, ++IBUS_l, IBUS_slash, 0x0142, ++IBUS_l, IBUS_less, 0x013E, ++IBUS_l, IBUS_equal, 0x00A3, ++IBUS_l, IBUS_v, 0x007C, ++IBUS_m, IBUS_period, 0x1E41, ++IBUS_m, IBUS_slash, 0x20A5, ++IBUS_m, IBUS_u, 0x00B5, ++IBUS_n, IBUS_apostrophe, 0x0144, ++IBUS_n, IBUS_comma, 0x0146, ++IBUS_n, IBUS_minus, 0x00F1, ++IBUS_n, IBUS_less, 0x0148, ++IBUS_n, IBUS_g, 0x014B, ++IBUS_n, IBUS_asciitilde, 0x00F1, ++IBUS_o, IBUS_quotedbl, 0x00F6, ++IBUS_o, IBUS_apostrophe, 0x00F3, ++IBUS_o, IBUS_minus, 0x014D, ++IBUS_o, IBUS_slash, 0x00F8, ++IBUS_o, IBUS_greater, 0x00F4, ++IBUS_o, IBUS_A, 0x00C5, ++IBUS_o, IBUS_C, 0x00A9, ++IBUS_o, IBUS_R, 0x00AE, ++IBUS_o, IBUS_U, 0x016E, ++IBUS_o, IBUS_X, 0x00A4, ++IBUS_o, IBUS_asciicircum, 0x00F4, ++IBUS_o, IBUS_underscore, 0x00BA, ++IBUS_o, IBUS_grave, 0x00F2, ++IBUS_o, IBUS_a, 0x00E5, ++IBUS_o, IBUS_c, 0x00A9, ++IBUS_o, IBUS_e, 0x0153, ++IBUS_o, IBUS_o, 0x00B0, ++IBUS_o, IBUS_r, 0x00AE, ++IBUS_o, IBUS_s, 0x00A7, ++IBUS_o, IBUS_u, 0x016F, ++IBUS_o, IBUS_w, 0x1E98, ++IBUS_o, IBUS_x, 0x00A4, ++IBUS_o, IBUS_y, 0x1E99, ++IBUS_o, IBUS_asciitilde, 0x00F5, ++IBUS_o, IBUS_diaeresis, 0x00F6, ++IBUS_o, IBUS_acute, 0x00F3, ++IBUS_p, IBUS_exclam, 0x00B6, ++IBUS_p, IBUS_period, 0x1E57, ++IBUS_r, IBUS_apostrophe, 0x0155, ++IBUS_r, IBUS_comma, 0x0157, ++IBUS_r, IBUS_less, 0x0159, ++IBUS_s, IBUS_exclam, 0x00A7, ++IBUS_s, IBUS_apostrophe, 0x015B, ++IBUS_s, IBUS_comma, 0x015F, ++IBUS_s, IBUS_period, 0x1E61, ++IBUS_s, IBUS_0, 0x00A7, ++IBUS_s, IBUS_1, 0x00B9, ++IBUS_s, IBUS_2, 0x00B2, ++IBUS_s, IBUS_3, 0x00B3, ++IBUS_s, IBUS_less, 0x0161, ++IBUS_s, IBUS_M, 0x2120, ++IBUS_s, IBUS_m, 0x2120, ++IBUS_s, IBUS_o, 0x00A7, ++IBUS_s, IBUS_s, 0x00DF, ++IBUS_s, IBUS_cedilla, 0x015F, ++IBUS_t, IBUS_minus, 0x0167, ++IBUS_t, IBUS_period, 0x1E6B, ++IBUS_t, IBUS_slash, 0x0167, ++IBUS_t, IBUS_less, 0x0165, ++IBUS_t, IBUS_M, 0x2122, ++IBUS_t, IBUS_h, 0x00FE, ++IBUS_t, IBUS_m, 0x2122, ++IBUS_u, IBUS_quotedbl, 0x00FC, ++IBUS_u, IBUS_apostrophe, 0x00FA, ++IBUS_u, IBUS_asterisk, 0x016F, ++IBUS_u, IBUS_comma, 0x0173, ++IBUS_u, IBUS_minus, 0x016B, ++IBUS_u, IBUS_slash, 0x00B5, ++IBUS_u, IBUS_greater, 0x00FB, ++IBUS_u, IBUS_asciicircum, 0x00FB, ++IBUS_u, IBUS_underscore, 0x016B, ++IBUS_u, IBUS_grave, 0x00F9, ++IBUS_u, IBUS_u, 0x016D, ++IBUS_u, IBUS_asciitilde, 0x0169, ++IBUS_u, IBUS_diaeresis, 0x00FC, ++IBUS_u, IBUS_acute, 0x00FA, ++IBUS_v, IBUS_Z, 0x017D, ++IBUS_v, IBUS_l, 0x007C, ++IBUS_v, IBUS_z, 0x017E, ++IBUS_w, IBUS_asciicircum, 0x0175, ++IBUS_x, IBUS_0, 0x00A4, ++IBUS_x, IBUS_O, 0x00A4, ++IBUS_x, IBUS_o, 0x00A4, ++IBUS_x, IBUS_x, 0x00D7, ++IBUS_y, IBUS_quotedbl, 0x00FF, ++IBUS_y, IBUS_apostrophe, 0x00FD, ++IBUS_y, IBUS_minus, 0x00A5, ++IBUS_y, IBUS_equal, 0x00A5, ++IBUS_y, IBUS_asciicircum, 0x0177, ++IBUS_y, IBUS_diaeresis, 0x00FF, ++IBUS_y, IBUS_acute, 0x00FD, ++IBUS_z, IBUS_apostrophe, 0x017A, ++IBUS_z, IBUS_period, 0x017C, ++IBUS_z, IBUS_less, 0x017E, ++IBUS_bar, IBUS_C, 0x00A2, ++IBUS_bar, IBUS_c, 0x00A2, ++IBUS_asciitilde, IBUS_space, 0x007E, ++IBUS_asciitilde, IBUS_A, 0x00C3, ++IBUS_asciitilde, IBUS_E, 0x1EBC, ++IBUS_asciitilde, IBUS_I, 0x0128, ++IBUS_asciitilde, IBUS_N, 0x00D1, ++IBUS_asciitilde, IBUS_O, 0x00D5, ++IBUS_asciitilde, IBUS_U, 0x0168, ++IBUS_asciitilde, IBUS_V, 0x1E7C, ++IBUS_asciitilde, IBUS_Y, 0x1EF8, ++IBUS_asciitilde, IBUS_a, 0x00E3, ++IBUS_asciitilde, IBUS_e, 0x1EBD, ++IBUS_asciitilde, IBUS_i, 0x0129, ++IBUS_asciitilde, IBUS_n, 0x00F1, ++IBUS_asciitilde, IBUS_o, 0x00F5, ++IBUS_asciitilde, IBUS_u, 0x0169, ++IBUS_asciitilde, IBUS_v, 0x1E7D, ++IBUS_asciitilde, IBUS_y, 0x1EF9, ++IBUS_asciitilde, IBUS_Acircumflex, 0x1EAA, ++IBUS_asciitilde, IBUS_Ecircumflex, 0x1EC4, ++IBUS_asciitilde, IBUS_Ocircumflex, 0x1ED6, ++IBUS_asciitilde, IBUS_acircumflex, 0x1EAB, ++IBUS_asciitilde, IBUS_ecircumflex, 0x1EC5, ++IBUS_asciitilde, IBUS_ocircumflex, 0x1ED7, ++IBUS_asciitilde, IBUS_Abreve, 0x1EB4, ++IBUS_asciitilde, IBUS_abreve, 0x1EB5, ++IBUS_asciitilde, IBUS_Greek_iotadieresis, 0x1FD7, ++IBUS_asciitilde, IBUS_Greek_upsilondieresis, 0x1FE7, ++IBUS_asciitilde, IBUS_Greek_alpha, 0x1FB6, ++IBUS_asciitilde, IBUS_Greek_eta, 0x1FC6, ++IBUS_asciitilde, IBUS_Greek_iota, 0x1FD6, ++IBUS_asciitilde, IBUS_Greek_upsilon, 0x1FE6, ++IBUS_asciitilde, IBUS_Greek_omega, 0x1FF6, ++IBUS_asciitilde, 0x1F00, 0x1F06, ++IBUS_asciitilde, 0x1F01, 0x1F07, ++IBUS_asciitilde, 0x1F08, 0x1F0E, ++IBUS_asciitilde, 0x1F09, 0x1F0F, ++IBUS_asciitilde, 0x1F20, 0x1F26, ++IBUS_asciitilde, 0x1F21, 0x1F27, ++IBUS_asciitilde, 0x1F28, 0x1F2E, ++IBUS_asciitilde, 0x1F29, 0x1F2F, ++IBUS_asciitilde, 0x1F30, 0x1F36, ++IBUS_asciitilde, 0x1F31, 0x1F37, ++IBUS_asciitilde, 0x1F38, 0x1F3E, ++IBUS_asciitilde, 0x1F39, 0x1F3F, ++IBUS_asciitilde, 0x1F50, 0x1F56, ++IBUS_asciitilde, 0x1F51, 0x1F57, ++IBUS_asciitilde, 0x1F59, 0x1F5F, ++IBUS_asciitilde, 0x1F60, 0x1F66, ++IBUS_asciitilde, 0x1F61, 0x1F67, ++IBUS_asciitilde, 0x1F68, 0x1F6E, ++IBUS_asciitilde, 0x1F69, 0x1F6F, ++IBUS_diaeresis, IBUS_apostrophe, 0x0385, ++IBUS_diaeresis, IBUS_A, 0x00C4, ++IBUS_diaeresis, IBUS_E, 0x00CB, ++IBUS_diaeresis, IBUS_I, 0x00CF, ++IBUS_diaeresis, IBUS_O, 0x00D6, ++IBUS_diaeresis, IBUS_U, 0x00DC, ++IBUS_diaeresis, IBUS_Y, 0x0178, ++IBUS_diaeresis, IBUS_grave, 0x1FED, ++IBUS_diaeresis, IBUS_a, 0x00E4, ++IBUS_diaeresis, IBUS_e, 0x00EB, ++IBUS_diaeresis, IBUS_i, 0x00EF, ++IBUS_diaeresis, IBUS_o, 0x00F6, ++IBUS_diaeresis, IBUS_u, 0x00FC, ++IBUS_diaeresis, IBUS_y, 0x00FF, ++IBUS_diaeresis, IBUS_asciitilde, 0x1FC1, ++IBUS_diaeresis, IBUS_acute, 0x0385, ++IBUS_diaeresis, IBUS_dead_grave, 0x1FED, ++IBUS_diaeresis, IBUS_dead_acute, 0x0385, ++IBUS_diaeresis, IBUS_dead_tilde, 0x1FC1, ++IBUS_macron, IBUS_A, 0x0100, ++IBUS_macron, IBUS_E, 0x0112, ++IBUS_macron, IBUS_G, 0x1E20, ++IBUS_macron, IBUS_I, 0x012A, ++IBUS_macron, IBUS_O, 0x014C, ++IBUS_macron, IBUS_U, 0x016A, ++IBUS_macron, IBUS_Y, 0x0232, ++IBUS_macron, IBUS_a, 0x0101, ++IBUS_macron, IBUS_e, 0x0113, ++IBUS_macron, IBUS_g, 0x1E21, ++IBUS_macron, IBUS_i, 0x012B, ++IBUS_macron, IBUS_o, 0x014D, ++IBUS_macron, IBUS_u, 0x016B, ++IBUS_macron, IBUS_y, 0x0233, ++IBUS_macron, IBUS_Adiaeresis, 0x01DE, ++IBUS_macron, IBUS_AE, 0x01E2, ++IBUS_macron, IBUS_Otilde, 0x022C, ++IBUS_macron, IBUS_Odiaeresis, 0x022A, ++IBUS_macron, IBUS_Udiaeresis, 0x01D5, ++IBUS_macron, IBUS_adiaeresis, 0x01DF, ++IBUS_macron, IBUS_ae, 0x01E3, ++IBUS_macron, IBUS_otilde, 0x022D, ++IBUS_macron, IBUS_odiaeresis, 0x022B, ++IBUS_macron, IBUS_udiaeresis, 0x01D6, ++IBUS_macron, 0x01EA, 0x01EC, ++IBUS_macron, 0x01EB, 0x01ED, ++IBUS_macron, 0x0226, 0x01E0, ++IBUS_macron, 0x0227, 0x01E1, ++IBUS_macron, 0x022E, 0x0230, ++IBUS_macron, 0x022F, 0x0231, ++IBUS_macron, IBUS_Cyrillic_i, 0x04E3, ++IBUS_macron, IBUS_Cyrillic_u, 0x04EF, ++IBUS_macron, IBUS_Cyrillic_I, 0x04E2, ++IBUS_macron, IBUS_Cyrillic_U, 0x04EE, ++IBUS_macron, IBUS_Greek_ALPHA, 0x1FB9, ++IBUS_macron, IBUS_Greek_IOTA, 0x1FD9, ++IBUS_macron, IBUS_Greek_UPSILON, 0x1FE9, ++IBUS_macron, IBUS_Greek_alpha, 0x1FB1, ++IBUS_macron, IBUS_Greek_iota, 0x1FD1, ++IBUS_macron, IBUS_Greek_upsilon, 0x1FE1, ++IBUS_macron, 0x1E36, 0x1E38, ++IBUS_macron, 0x1E37, 0x1E39, ++IBUS_macron, 0x1E5A, 0x1E5C, ++IBUS_macron, 0x1E5B, 0x1E5D, ++IBUS_acute, IBUS_A, 0x00C1, ++IBUS_acute, IBUS_C, 0x0106, ++IBUS_acute, IBUS_E, 0x00C9, ++IBUS_acute, IBUS_G, 0x01F4, ++IBUS_acute, IBUS_I, 0x00CD, ++IBUS_acute, IBUS_K, 0x1E30, ++IBUS_acute, IBUS_L, 0x0139, ++IBUS_acute, IBUS_M, 0x1E3E, ++IBUS_acute, IBUS_N, 0x0143, ++IBUS_acute, IBUS_O, 0x00D3, ++IBUS_acute, IBUS_P, 0x1E54, ++IBUS_acute, IBUS_R, 0x0154, ++IBUS_acute, IBUS_S, 0x015A, ++IBUS_acute, IBUS_U, 0x00DA, ++IBUS_acute, IBUS_W, 0x1E82, ++IBUS_acute, IBUS_Y, 0x00DD, ++IBUS_acute, IBUS_Z, 0x0179, ++IBUS_acute, IBUS_a, 0x00E1, ++IBUS_acute, IBUS_c, 0x0107, ++IBUS_acute, IBUS_e, 0x00E9, ++IBUS_acute, IBUS_g, 0x01F5, ++IBUS_acute, IBUS_i, 0x00ED, ++IBUS_acute, IBUS_k, 0x1E31, ++IBUS_acute, IBUS_l, 0x013A, ++IBUS_acute, IBUS_m, 0x1E3F, ++IBUS_acute, IBUS_n, 0x0144, ++IBUS_acute, IBUS_o, 0x00F3, ++IBUS_acute, IBUS_p, 0x1E55, ++IBUS_acute, IBUS_r, 0x0155, ++IBUS_acute, IBUS_s, 0x015B, ++IBUS_acute, IBUS_u, 0x00FA, ++IBUS_acute, IBUS_w, 0x1E83, ++IBUS_acute, IBUS_y, 0x00FD, ++IBUS_acute, IBUS_z, 0x017A, ++IBUS_acute, IBUS_Acircumflex, 0x1EA4, ++IBUS_acute, IBUS_Aring, 0x01FA, ++IBUS_acute, IBUS_AE, 0x01FC, ++IBUS_acute, IBUS_Ccedilla, 0x1E08, ++IBUS_acute, IBUS_Ecircumflex, 0x1EBE, ++IBUS_acute, IBUS_Idiaeresis, 0x1E2E, ++IBUS_acute, IBUS_Ocircumflex, 0x1ED0, ++IBUS_acute, IBUS_Otilde, 0x1E4C, ++IBUS_acute, IBUS_Ooblique, 0x01FE, ++IBUS_acute, IBUS_Udiaeresis, 0x01D7, ++IBUS_acute, IBUS_acircumflex, 0x1EA5, ++IBUS_acute, IBUS_aring, 0x01FB, ++IBUS_acute, IBUS_ae, 0x01FD, ++IBUS_acute, IBUS_ccedilla, 0x1E09, ++IBUS_acute, IBUS_ecircumflex, 0x1EBF, ++IBUS_acute, IBUS_idiaeresis, 0x1E2F, ++IBUS_acute, IBUS_ocircumflex, 0x1ED1, ++IBUS_acute, IBUS_otilde, 0x1E4D, ++IBUS_acute, IBUS_oslash, 0x01FF, ++IBUS_acute, IBUS_udiaeresis, 0x01D8, ++IBUS_acute, IBUS_Abreve, 0x1EAE, ++IBUS_acute, IBUS_abreve, 0x1EAF, ++IBUS_acute, IBUS_Emacron, 0x1E16, ++IBUS_acute, IBUS_emacron, 0x1E17, ++IBUS_acute, IBUS_Omacron, 0x1E52, ++IBUS_acute, IBUS_Utilde, 0x1E78, ++IBUS_acute, IBUS_omacron, 0x1E53, ++IBUS_acute, IBUS_utilde, 0x1E79, ++IBUS_acute, IBUS_Cyrillic_ghe, 0x0453, ++IBUS_acute, IBUS_Cyrillic_ka, 0x045C, ++IBUS_acute, IBUS_Cyrillic_GHE, 0x0403, ++IBUS_acute, IBUS_Cyrillic_KA, 0x040C, ++IBUS_acute, IBUS_Greek_iotadieresis, 0x0390, ++IBUS_acute, IBUS_Greek_upsilondieresis, 0x03B0, ++IBUS_acute, IBUS_Greek_ALPHA, 0x0386, ++IBUS_acute, IBUS_Greek_EPSILON, 0x0388, ++IBUS_acute, IBUS_Greek_ETA, 0x0389, ++IBUS_acute, IBUS_Greek_IOTA, 0x038A, ++IBUS_acute, IBUS_Greek_OMICRON, 0x038C, ++IBUS_acute, IBUS_Greek_UPSILON, 0x038E, ++IBUS_acute, IBUS_Greek_OMEGA, 0x038F, ++IBUS_acute, IBUS_Greek_alpha, 0x03AC, ++IBUS_acute, IBUS_Greek_epsilon, 0x03AD, ++IBUS_acute, IBUS_Greek_eta, 0x03AE, ++IBUS_acute, IBUS_Greek_iota, 0x03AF, ++IBUS_acute, IBUS_Greek_omicron, 0x03CC, ++IBUS_acute, IBUS_Greek_upsilon, 0x03CD, ++IBUS_acute, IBUS_Greek_omega, 0x03CE, ++IBUS_acute, 0x1F00, 0x1F04, ++IBUS_acute, 0x1F01, 0x1F05, ++IBUS_acute, 0x1F08, 0x1F0C, ++IBUS_acute, 0x1F09, 0x1F0D, ++IBUS_acute, 0x1F10, 0x1F14, ++IBUS_acute, 0x1F11, 0x1F15, ++IBUS_acute, 0x1F18, 0x1F1C, ++IBUS_acute, 0x1F19, 0x1F1D, ++IBUS_acute, 0x1F20, 0x1F24, ++IBUS_acute, 0x1F21, 0x1F25, ++IBUS_acute, 0x1F28, 0x1F2C, ++IBUS_acute, 0x1F29, 0x1F2D, ++IBUS_acute, 0x1F30, 0x1F34, ++IBUS_acute, 0x1F31, 0x1F35, ++IBUS_acute, 0x1F38, 0x1F3C, ++IBUS_acute, 0x1F39, 0x1F3D, ++IBUS_acute, 0x1F40, 0x1F44, ++IBUS_acute, 0x1F41, 0x1F45, ++IBUS_acute, 0x1F48, 0x1F4C, ++IBUS_acute, 0x1F49, 0x1F4D, ++IBUS_acute, 0x1F50, 0x1F54, ++IBUS_acute, 0x1F51, 0x1F55, ++IBUS_acute, 0x1F59, 0x1F5D, ++IBUS_acute, 0x1F60, 0x1F64, ++IBUS_acute, 0x1F61, 0x1F65, ++IBUS_acute, 0x1F68, 0x1F6C, ++IBUS_acute, 0x1F69, 0x1F6D, ++IBUS_cedilla, IBUS_C, 0x00C7, ++IBUS_cedilla, IBUS_D, 0x1E10, ++IBUS_cedilla, IBUS_E, 0x0228, ++IBUS_cedilla, IBUS_G, 0x0122, ++IBUS_cedilla, IBUS_H, 0x1E28, ++IBUS_cedilla, IBUS_K, 0x0136, ++IBUS_cedilla, IBUS_L, 0x013B, ++IBUS_cedilla, IBUS_N, 0x0145, ++IBUS_cedilla, IBUS_R, 0x0156, ++IBUS_cedilla, IBUS_S, 0x015E, ++IBUS_cedilla, IBUS_T, 0x0162, ++IBUS_cedilla, IBUS_c, 0x00E7, ++IBUS_cedilla, IBUS_d, 0x1E11, ++IBUS_cedilla, IBUS_e, 0x0229, ++IBUS_cedilla, IBUS_g, 0x0123, ++IBUS_cedilla, IBUS_h, 0x1E29, ++IBUS_cedilla, IBUS_k, 0x0137, ++IBUS_cedilla, IBUS_l, 0x013C, ++IBUS_cedilla, IBUS_n, 0x0146, ++IBUS_cedilla, IBUS_r, 0x0157, ++IBUS_cedilla, IBUS_s, 0x015F, ++IBUS_cedilla, IBUS_t, 0x0163, ++IBUS_breve, IBUS_G, 0x011E, ++IBUS_breve, IBUS_g, 0x011F, ++0x05B4, IBUS_hebrew_yod, 0xFB1D, ++0x05B7, 0x05F2, 0xFB1F, ++0x05B7, IBUS_hebrew_aleph, 0xFB2E, ++0x05B8, IBUS_hebrew_aleph, 0xFB2F, ++0x05B9, IBUS_hebrew_waw, 0xFB4B, ++0x05BC, IBUS_hebrew_aleph, 0xFB30, ++0x05BC, IBUS_hebrew_beth, 0xFB31, ++0x05BC, IBUS_hebrew_gimmel, 0xFB32, ++0x05BC, IBUS_hebrew_daleth, 0xFB33, ++0x05BC, IBUS_hebrew_he, 0xFB34, ++0x05BC, IBUS_hebrew_waw, 0xFB35, ++0x05BC, IBUS_hebrew_zayin, 0xFB36, ++0x05BC, IBUS_hebrew_teth, 0xFB38, ++0x05BC, IBUS_hebrew_yod, 0xFB39, ++0x05BC, IBUS_hebrew_finalkaph, 0xFB3A, ++0x05BC, IBUS_hebrew_kaph, 0xFB3B, ++0x05BC, IBUS_hebrew_lamed, 0xFB3C, ++0x05BC, IBUS_hebrew_mem, 0xFB3E, ++0x05BC, IBUS_hebrew_nun, 0xFB40, ++0x05BC, IBUS_hebrew_samekh, 0xFB41, ++0x05BC, IBUS_hebrew_finalpe, 0xFB43, ++0x05BC, IBUS_hebrew_pe, 0xFB44, ++0x05BC, IBUS_hebrew_zadi, 0xFB46, ++0x05BC, IBUS_hebrew_qoph, 0xFB47, ++0x05BC, IBUS_hebrew_resh, 0xFB48, ++0x05BC, IBUS_hebrew_shin, 0xFB49, ++0x05BC, IBUS_hebrew_taw, 0xFB4A, ++0x05BF, IBUS_hebrew_beth, 0xFB4C, ++0x05BF, IBUS_hebrew_kaph, 0xFB4D, ++0x05BF, IBUS_hebrew_pe, 0xFB4E, ++0x05C1, IBUS_hebrew_shin, 0xFB2A, ++0x05C1, 0xFB49, 0xFB2C, ++0x05C2, IBUS_hebrew_shin, 0xFB2B, ++0x05C2, 0xFB49, 0xFB2D, ++0x0653, IBUS_Arabic_alef, 0x0622, ++0x0654, IBUS_Arabic_alef, 0x0623, ++0x0654, IBUS_Arabic_waw, 0x0624, ++0x0654, IBUS_Arabic_yeh, 0x0626, ++0x0654, 0x06C1, 0x06C2, ++0x0654, 0x06D2, 0x06D3, ++0x0654, 0x06D5, 0x06C0, ++0x0655, IBUS_Arabic_alef, 0x0625, ++IBUS_Cyrillic_pe, IBUS_Cyrillic_a, 0x00A7, ++IBUS_Cyrillic_IE, IBUS_equal, 0x20AC, ++IBUS_Cyrillic_EN, IBUS_Cyrillic_o, 0x2116, ++IBUS_Cyrillic_EN, IBUS_Cyrillic_O, 0x2116, ++IBUS_Cyrillic_ES, IBUS_equal, 0x20AC, ++IBUS_Greek_ALPHA, IBUS_apostrophe, 0x0386, ++IBUS_Greek_EPSILON, IBUS_apostrophe, 0x0388, ++IBUS_Greek_ETA, IBUS_apostrophe, 0x0389, ++IBUS_Greek_IOTA, IBUS_quotedbl, 0x03AA, ++IBUS_Greek_IOTA, IBUS_apostrophe, 0x038A, ++IBUS_Greek_OMICRON, IBUS_apostrophe, 0x038C, ++IBUS_Greek_UPSILON, IBUS_quotedbl, 0x03AB, ++IBUS_Greek_UPSILON, IBUS_apostrophe, 0x038E, ++IBUS_Greek_OMEGA, IBUS_apostrophe, 0x038F, ++IBUS_Greek_alpha, IBUS_apostrophe, 0x03AC, ++IBUS_Greek_epsilon, IBUS_apostrophe, 0x03AD, ++IBUS_Greek_eta, IBUS_apostrophe, 0x03AE, ++IBUS_Greek_iota, IBUS_quotedbl, 0x03CA, ++IBUS_Greek_iota, IBUS_apostrophe, 0x03AF, ++IBUS_Greek_iota, IBUS_Greek_alphaaccent, 0x1FB4, ++IBUS_Greek_iota, IBUS_Greek_etaaccent, 0x1FC4, ++IBUS_Greek_iota, IBUS_Greek_omegaaccent, 0x1FF4, ++IBUS_Greek_iota, IBUS_Greek_ALPHA, 0x1FBC, ++IBUS_Greek_iota, IBUS_Greek_ETA, 0x1FCC, ++IBUS_Greek_iota, IBUS_Greek_OMEGA, 0x1FFC, ++IBUS_Greek_iota, IBUS_Greek_alpha, 0x1FB3, ++IBUS_Greek_iota, IBUS_Greek_eta, 0x1FC3, ++IBUS_Greek_iota, IBUS_Greek_omega, 0x1FF3, ++IBUS_Greek_iota, 0x1F00, 0x1F80, ++IBUS_Greek_iota, 0x1F01, 0x1F81, ++IBUS_Greek_iota, 0x1F02, 0x1F82, ++IBUS_Greek_iota, 0x1F03, 0x1F83, ++IBUS_Greek_iota, 0x1F04, 0x1F84, ++IBUS_Greek_iota, 0x1F05, 0x1F85, ++IBUS_Greek_iota, 0x1F06, 0x1F86, ++IBUS_Greek_iota, 0x1F07, 0x1F87, ++IBUS_Greek_iota, 0x1F08, 0x1F88, ++IBUS_Greek_iota, 0x1F09, 0x1F89, ++IBUS_Greek_iota, 0x1F0A, 0x1F8A, ++IBUS_Greek_iota, 0x1F0B, 0x1F8B, ++IBUS_Greek_iota, 0x1F0C, 0x1F8C, ++IBUS_Greek_iota, 0x1F0D, 0x1F8D, ++IBUS_Greek_iota, 0x1F0E, 0x1F8E, ++IBUS_Greek_iota, 0x1F0F, 0x1F8F, ++IBUS_Greek_iota, 0x1F20, 0x1F90, ++IBUS_Greek_iota, 0x1F21, 0x1F91, ++IBUS_Greek_iota, 0x1F22, 0x1F92, ++IBUS_Greek_iota, 0x1F23, 0x1F93, ++IBUS_Greek_iota, 0x1F24, 0x1F94, ++IBUS_Greek_iota, 0x1F25, 0x1F95, ++IBUS_Greek_iota, 0x1F26, 0x1F96, ++IBUS_Greek_iota, 0x1F27, 0x1F97, ++IBUS_Greek_iota, 0x1F28, 0x1F98, ++IBUS_Greek_iota, 0x1F29, 0x1F99, ++IBUS_Greek_iota, 0x1F2A, 0x1F9A, ++IBUS_Greek_iota, 0x1F2B, 0x1F9B, ++IBUS_Greek_iota, 0x1F2C, 0x1F9C, ++IBUS_Greek_iota, 0x1F2D, 0x1F9D, ++IBUS_Greek_iota, 0x1F2E, 0x1F9E, ++IBUS_Greek_iota, 0x1F2F, 0x1F9F, ++IBUS_Greek_iota, 0x1F60, 0x1FA0, ++IBUS_Greek_iota, 0x1F61, 0x1FA1, ++IBUS_Greek_iota, 0x1F62, 0x1FA2, ++IBUS_Greek_iota, 0x1F63, 0x1FA3, ++IBUS_Greek_iota, 0x1F64, 0x1FA4, ++IBUS_Greek_iota, 0x1F65, 0x1FA5, ++IBUS_Greek_iota, 0x1F66, 0x1FA6, ++IBUS_Greek_iota, 0x1F67, 0x1FA7, ++IBUS_Greek_iota, 0x1F68, 0x1FA8, ++IBUS_Greek_iota, 0x1F69, 0x1FA9, ++IBUS_Greek_iota, 0x1F6A, 0x1FAA, ++IBUS_Greek_iota, 0x1F6B, 0x1FAB, ++IBUS_Greek_iota, 0x1F6C, 0x1FAC, ++IBUS_Greek_iota, 0x1F6D, 0x1FAD, ++IBUS_Greek_iota, 0x1F6E, 0x1FAE, ++IBUS_Greek_iota, 0x1F6F, 0x1FAF, ++IBUS_Greek_iota, 0x1F70, 0x1FB2, ++IBUS_Greek_iota, 0x1F74, 0x1FC2, ++IBUS_Greek_iota, 0x1F7C, 0x1FF2, ++IBUS_Greek_iota, 0x1FB6, 0x1FB7, ++IBUS_Greek_iota, 0x1FC6, 0x1FC7, ++IBUS_Greek_iota, 0x1FF6, 0x1FF7, ++IBUS_Greek_omicron, IBUS_apostrophe, 0x03CC, ++IBUS_Greek_upsilon, IBUS_quotedbl, 0x03CB, ++IBUS_Greek_upsilon, IBUS_apostrophe, 0x03CD, ++IBUS_Greek_omega, IBUS_apostrophe, 0x03CE, ++IBUS_lessthanequal, 0x0338, 0x2270, ++IBUS_greaterthanequal, 0x0338, 0x2271, ++IBUS_approximate, 0x0338, 0x2247, ++IBUS_identical, 0x0338, 0x2262, ++IBUS_includedin, 0x0338, 0x2284, ++IBUS_includes, 0x0338, 0x2285, ++0x093C, 0x0915, 0x0958, ++0x093C, 0x0916, 0x0959, ++0x093C, 0x0917, 0x095A, ++0x093C, 0x091C, 0x095B, ++0x093C, 0x0921, 0x095C, ++0x093C, 0x0922, 0x095D, ++0x093C, 0x0928, 0x0929, ++0x093C, 0x092B, 0x095E, ++0x093C, 0x092F, 0x095F, ++0x093C, 0x0930, 0x0931, ++0x093C, 0x0933, 0x0934, ++0x09BC, 0x09A1, 0x09DC, ++0x09BC, 0x09A2, 0x09DD, ++0x09BC, 0x09AF, 0x09DF, ++0x09C7, 0x09BE, 0x09CB, ++0x09C7, 0x09D7, 0x09CC, ++0x0A3C, 0x0A16, 0x0A59, ++0x0A3C, 0x0A17, 0x0A5A, ++0x0A3C, 0x0A1C, 0x0A5B, ++0x0A3C, 0x0A2B, 0x0A5E, ++0x0A3C, 0x0A32, 0x0A33, ++0x0A3C, 0x0A38, 0x0A36, ++0x0B3C, 0x0B21, 0x0B5C, ++0x0B3C, 0x0B22, 0x0B5D, ++0x0B47, 0x0B3E, 0x0B4B, ++0x0B47, 0x0B56, 0x0B48, ++0x0B47, 0x0B57, 0x0B4C, ++IBUS_leftcaret, 0x0338, 0x226E, ++IBUS_rightcaret, 0x0338, 0x226F, ++IBUS_underbar, IBUS_parenleft, 0x208D, ++IBUS_underbar, IBUS_parenright, 0x208E, ++IBUS_underbar, IBUS_plus, 0x208A, ++IBUS_underbar, IBUS_0, 0x2080, ++IBUS_underbar, IBUS_1, 0x2081, ++IBUS_underbar, IBUS_2, 0x2082, ++IBUS_underbar, IBUS_3, 0x2083, ++IBUS_underbar, IBUS_4, 0x2084, ++IBUS_underbar, IBUS_5, 0x2085, ++IBUS_underbar, IBUS_6, 0x2086, ++IBUS_underbar, IBUS_7, 0x2087, ++IBUS_underbar, IBUS_8, 0x2088, ++IBUS_underbar, IBUS_9, 0x2089, ++IBUS_underbar, IBUS_equal, 0x208C, ++0x0BC6, 0x0BBE, 0x0BCA, ++0x0BC6, 0x0BD7, 0x0BCC, ++IBUS_underbar, 0x2212, 0x208B, ++IBUS_underbar, IBUS_KP_Space, 0x2082, ++IBUS_underbar, IBUS_KP_Add, 0x208A, ++IBUS_underbar, IBUS_KP_0, 0x2080, ++IBUS_underbar, IBUS_KP_1, 0x2081, ++IBUS_underbar, IBUS_KP_2, 0x2082, ++IBUS_underbar, IBUS_KP_3, 0x2083, ++IBUS_underbar, IBUS_KP_4, 0x2084, ++IBUS_underbar, IBUS_KP_5, 0x2085, ++IBUS_underbar, IBUS_KP_6, 0x2086, ++IBUS_underbar, IBUS_KP_7, 0x2087, ++IBUS_underbar, IBUS_KP_8, 0x2088, ++IBUS_underbar, IBUS_KP_9, 0x2089, ++IBUS_underbar, IBUS_KP_Equal, 0x208C, ++0x0BC7, 0x0BBE, 0x0BCB, ++0x0BD7, 0x0B92, 0x0B94, ++IBUS_rightshoe, 0x0338, 0x2285, ++IBUS_leftshoe, 0x0338, 0x2284, ++IBUS_righttack, 0x0338, 0x22AC, ++0x0C46, 0x0C56, 0x0C48, ++0x0CBF, 0x0CD5, 0x0CC0, ++0x0CC6, 0x0CC2, 0x0CCA, ++0x0CC6, 0x0CD5, 0x0CC7, ++0x0CC6, 0x0CD6, 0x0CC8, ++0x0CCA, 0x0CD5, 0x0CCB, ++0x0D46, 0x0D3E, 0x0D4A, ++0x0D46, 0x0D57, 0x0D4C, ++0x0D47, 0x0D3E, 0x0D4B, ++0x0DD9, 0x0DCA, 0x0DDA, ++0x0DD9, 0x0DCF, 0x0DDC, ++0x0DD9, 0x0DDF, 0x0DDE, ++0x0DDC, 0x0DCA, 0x0DDD, ++0x0F71, 0x0F72, 0x0F73, ++0x0F71, 0x0F74, 0x0F75, ++0x0F71, 0x0F80, 0x0F81, ++0x0F90, 0x0FB5, 0x0FB9, ++0x0F92, 0x0FB7, 0x0F93, ++0x0F9C, 0x0FB7, 0x0F9D, ++0x0FA1, 0x0FB7, 0x0FA2, ++0x0FA6, 0x0FB7, 0x0FA7, ++0x0FAB, 0x0FB7, 0x0FAC, ++0x0FB2, 0x0F80, 0x0F76, ++0x0FB3, 0x0F80, 0x0F78, ++0x0FB5, 0x0F40, 0x0F69, ++0x0FB7, 0x0F42, 0x0F43, ++0x0FB7, 0x0F4C, 0x0F4D, ++0x0FB7, 0x0F51, 0x0F52, ++0x0FB7, 0x0F56, 0x0F57, ++0x0FB7, 0x0F5B, 0x0F5C, ++0x102E, 0x1025, 0x1026, ++0x1100, 0x1100, 0x1101, ++0x1102, 0x1100, 0x1113, ++0x1102, 0x1102, 0x1114, ++0x1102, 0x1103, 0x1115, ++0x1102, 0x1107, 0x1116, ++0x1103, 0x1100, 0x1117, ++0x1103, 0x1103, 0x1104, ++0x1105, 0x1102, 0x1118, ++0x1105, 0x1105, 0x1119, ++0x1105, 0x110B, 0x111B, ++0x1105, 0x1112, 0x111A, ++0x1106, 0x1107, 0x111C, ++0x1106, 0x110B, 0x111D, ++0x1107, 0x1100, 0x111E, ++0x1107, 0x1102, 0x111F, ++0x1107, 0x1103, 0x1120, ++0x1107, 0x1107, 0x1108, ++0x1107, 0x1109, 0x1121, ++0x1107, 0x110A, 0x1125, ++0x1107, 0x110B, 0x112B, ++0x1107, 0x110C, 0x1127, ++0x1107, 0x110E, 0x1128, ++0x1107, 0x1110, 0x1129, ++0x1107, 0x1111, 0x112A, ++0x1107, 0x112B, 0x112C, ++0x1107, 0x112D, 0x1122, ++0x1107, 0x112F, 0x1123, ++0x1107, 0x1132, 0x1124, ++0x1107, 0x1136, 0x1126, ++0x1108, 0x110B, 0x112C, ++0x1109, 0x1100, 0x112D, ++0x1109, 0x1102, 0x112E, ++0x1109, 0x1103, 0x112F, ++0x1109, 0x1105, 0x1130, ++0x1109, 0x1106, 0x1131, ++0x1109, 0x1107, 0x1132, ++0x1109, 0x1109, 0x110A, ++0x1109, 0x110A, 0x1134, ++0x1109, 0x110B, 0x1135, ++0x1109, 0x110C, 0x1136, ++0x1109, 0x110E, 0x1137, ++0x1109, 0x110F, 0x1138, ++0x1109, 0x1110, 0x1139, ++0x1109, 0x1111, 0x113A, ++0x1109, 0x1112, 0x113B, ++0x1109, 0x111E, 0x1133, ++0x110A, 0x1109, 0x1134, ++0x110B, 0x1100, 0x1141, ++0x110B, 0x1103, 0x1142, ++0x110B, 0x1106, 0x1143, ++0x110B, 0x1107, 0x1144, ++0x110B, 0x1109, 0x1145, ++0x110B, 0x110B, 0x1147, ++0x110B, 0x110C, 0x1148, ++0x110B, 0x110E, 0x1149, ++0x110B, 0x1110, 0x114A, ++0x110B, 0x1111, 0x114B, ++0x110B, 0x1140, 0x1146, ++0x110C, 0x110B, 0x114D, ++0x110C, 0x110C, 0x110D, ++0x110E, 0x110F, 0x1152, ++0x110E, 0x1112, 0x1153, ++0x1111, 0x1107, 0x1156, ++0x1111, 0x110B, 0x1157, ++0x1112, 0x1112, 0x1158, ++0x1121, 0x1100, 0x1122, ++0x1121, 0x1103, 0x1123, ++0x1121, 0x1107, 0x1124, ++0x1121, 0x1109, 0x1125, ++0x1121, 0x110C, 0x1126, ++0x1132, 0x1100, 0x1133, ++0x113C, 0x113C, 0x113D, ++0x113E, 0x113E, 0x113F, ++0x114E, 0x114E, 0x114F, ++0x1150, 0x1150, 0x1151, ++0x1161, 0x1169, 0x1176, ++0x1161, 0x116E, 0x1177, ++0x1161, 0x1175, 0x1162, ++0x1163, 0x1169, 0x1178, ++0x1163, 0x116D, 0x1179, ++0x1163, 0x1175, 0x1164, ++0x1165, 0x1169, 0x117A, ++0x1165, 0x116E, 0x117B, ++0x1165, 0x1173, 0x117C, ++0x1165, 0x1175, 0x1166, ++0x1167, 0x1169, 0x117D, ++0x1167, 0x116E, 0x117E, ++0x1167, 0x1175, 0x1168, ++0x1169, 0x1161, 0x116A, ++0x1169, 0x1162, 0x116B, ++0x1169, 0x1165, 0x117F, ++0x1169, 0x1166, 0x1180, ++0x1169, 0x1168, 0x1181, ++0x1169, 0x1169, 0x1182, ++0x1169, 0x116E, 0x1183, ++0x1169, 0x1175, 0x116C, ++0x116A, 0x1175, 0x116B, ++0x116D, 0x1163, 0x1184, ++0x116D, 0x1164, 0x1185, ++0x116D, 0x1167, 0x1186, ++0x116D, 0x1169, 0x1187, ++0x116D, 0x1175, 0x1188, ++0x116E, 0x1161, 0x1189, ++0x116E, 0x1162, 0x118A, ++0x116E, 0x1165, 0x116F, ++0x116E, 0x1166, 0x1170, ++0x116E, 0x1168, 0x118C, ++0x116E, 0x116E, 0x118D, ++0x116E, 0x1175, 0x1171, ++0x116E, 0x117C, 0x118B, ++0x116F, 0x1173, 0x118B, ++0x116F, 0x1175, 0x1170, ++0x1172, 0x1161, 0x118E, ++0x1172, 0x1165, 0x118F, ++0x1172, 0x1166, 0x1190, ++0x1172, 0x1167, 0x1191, ++0x1172, 0x1168, 0x1192, ++0x1172, 0x116E, 0x1193, ++0x1172, 0x1175, 0x1194, ++0x1173, 0x116E, 0x1195, ++0x1173, 0x1173, 0x1196, ++0x1173, 0x1175, 0x1174, ++0x1174, 0x116E, 0x1197, ++0x1175, 0x1161, 0x1198, ++0x1175, 0x1163, 0x1199, ++0x1175, 0x1169, 0x119A, ++0x1175, 0x116E, 0x119B, ++0x1175, 0x1173, 0x119C, ++0x1175, 0x119E, 0x119D, ++0x119E, 0x1165, 0x119F, ++0x119E, 0x116E, 0x11A0, ++0x119E, 0x1175, 0x11A1, ++0x119E, 0x119E, 0x11A2, ++0x11A8, 0x11A8, 0x11A9, ++0x11A8, 0x11AF, 0x11C3, ++0x11A8, 0x11BA, 0x11AA, ++0x11A8, 0x11E7, 0x11C4, ++0x11AA, 0x11A8, 0x11C4, ++0x11AB, 0x11A8, 0x11C5, ++0x11AB, 0x11AE, 0x11C6, ++0x11AB, 0x11BA, 0x11C7, ++0x11AB, 0x11BD, 0x11AC, ++0x11AB, 0x11C0, 0x11C9, ++0x11AB, 0x11C2, 0x11AD, ++0x11AB, 0x11EB, 0x11C8, ++0x11AE, 0x11A8, 0x11CA, ++0x11AE, 0x11AF, 0x11CB, ++0x11AF, 0x11A8, 0x11B0, ++0x11AF, 0x11AA, 0x11CC, ++0x11AF, 0x11AB, 0x11CD, ++0x11AF, 0x11AE, 0x11CE, ++0x11AF, 0x11AF, 0x11D0, ++0x11AF, 0x11B7, 0x11B1, ++0x11AF, 0x11B8, 0x11B2, ++0x11AF, 0x11B9, 0x11D3, ++0x11AF, 0x11BA, 0x11B3, ++0x11AF, 0x11BB, 0x11D6, ++0x11AF, 0x11BF, 0x11D8, ++0x11AF, 0x11C0, 0x11B4, ++0x11AF, 0x11C1, 0x11B5, ++0x11AF, 0x11C2, 0x11B6, ++0x11AF, 0x11DA, 0x11D1, ++0x11AF, 0x11DD, 0x11D2, ++0x11AF, 0x11E5, 0x11D4, ++0x11AF, 0x11E6, 0x11D5, ++0x11AF, 0x11EB, 0x11D7, ++0x11AF, 0x11F9, 0x11D9, ++0x11B0, 0x11BA, 0x11CC, ++0x11B1, 0x11A8, 0x11D1, ++0x11B1, 0x11BA, 0x11D2, ++0x11B2, 0x11BA, 0x11D3, ++0x11B2, 0x11BC, 0x11D5, ++0x11B2, 0x11C2, 0x11D4, ++0x11B3, 0x11BA, 0x11D6, ++0x11B7, 0x11A8, 0x11DA, ++0x11B7, 0x11AF, 0x11DB, ++0x11B7, 0x11B8, 0x11DC, ++0x11B7, 0x11BA, 0x11DD, ++0x11B7, 0x11BB, 0x11DE, ++0x11B7, 0x11BC, 0x11E2, ++0x11B7, 0x11BE, 0x11E0, ++0x11B7, 0x11C2, 0x11E1, ++0x11B7, 0x11EB, 0x11DF, ++0x11B8, 0x11AF, 0x11E3, ++0x11B8, 0x11BA, 0x11B9, ++0x11B8, 0x11BC, 0x11E6, ++0x11B8, 0x11C1, 0x11E4, ++0x11B8, 0x11C2, 0x11E5, ++0x11BA, 0x11A8, 0x11E7, ++0x11BA, 0x11AE, 0x11E8, ++0x11BA, 0x11AF, 0x11E9, ++0x11BA, 0x11B8, 0x11EA, ++0x11BA, 0x11BA, 0x11BB, ++0x11BC, 0x11A8, 0x11EC, ++0x11BC, 0x11A9, 0x11ED, ++0x11BC, 0x11BC, 0x11EE, ++0x11BC, 0x11BF, 0x11EF, ++0x11C1, 0x11B8, 0x11F3, ++0x11C1, 0x11BC, 0x11F4, ++0x11C2, 0x11AB, 0x11F5, ++0x11C2, 0x11AF, 0x11F6, ++0x11C2, 0x11B7, 0x11F7, ++0x11C2, 0x11B8, 0x11F8, ++0x11CE, 0x11C2, 0x11CF, ++0x11DD, 0x11BA, 0x11DE, ++0x11EC, 0x11A8, 0x11ED, ++0x11F0, 0x11BA, 0x11F1, ++0x11F0, 0x11EB, 0x11F2, ++0x1FBF, IBUS_apostrophe, 0x1FCE, ++0x1FBF, IBUS_grave, 0x1FCD, ++0x1FBF, IBUS_asciitilde, 0x1FCF, ++0x1FBF, IBUS_acute, 0x1FCE, ++0x1FBF, IBUS_dead_grave, 0x1FCD, ++0x1FBF, IBUS_dead_acute, 0x1FCE, ++0x1FBF, IBUS_dead_tilde, 0x1FCF, ++0x1FFE, IBUS_apostrophe, 0x1FDE, ++0x1FFE, IBUS_grave, 0x1FDD, ++0x1FFE, IBUS_asciitilde, 0x1FDF, ++0x1FFE, IBUS_acute, 0x1FDE, ++0x1FFE, IBUS_dead_grave, 0x1FDD, ++0x1FFE, IBUS_dead_acute, 0x1FDE, ++0x1FFE, IBUS_dead_tilde, 0x1FDF, ++0x2203, 0x0338, 0x2204, ++0x2208, 0x0338, 0x2209, ++0x220B, 0x0338, 0x220C, ++0x2223, 0x0338, 0x2224, ++0x2225, 0x0338, 0x2226, ++0x223C, 0x0338, 0x2241, ++0x2243, 0x0338, 0x2244, ++0x2248, 0x0338, 0x2249, ++0x224D, 0x0338, 0x226D, ++0x2272, 0x0338, 0x2274, ++0x2273, 0x0338, 0x2275, ++0x2276, 0x0338, 0x2278, ++0x2277, 0x0338, 0x2279, ++0x227A, 0x0338, 0x2280, ++0x227B, 0x0338, 0x2281, ++0x227C, 0x0338, 0x22E0, ++0x227D, 0x0338, 0x22E1, ++0x2286, 0x0338, 0x2288, ++0x2287, 0x0338, 0x2289, ++0x2291, 0x0338, 0x22E2, ++0x2292, 0x0338, 0x22E3, ++0x22A8, 0x0338, 0x22AD, ++0x22A9, 0x0338, 0x22AE, ++0x22AB, 0x0338, 0x22AF, ++0x22B2, 0x0338, 0x22EA, ++0x22B3, 0x0338, 0x22EB, ++0x22B4, 0x0338, 0x22EC, ++0x22B5, 0x0338, 0x22ED, ++0x2ADD, 0x0338, 0x2ADC, ++IBUS_KP_Divide, IBUS_D, 0x0110, ++IBUS_KP_Divide, IBUS_G, 0x01E4, ++IBUS_KP_Divide, IBUS_H, 0x0126, ++IBUS_KP_Divide, IBUS_I, 0x0197, ++IBUS_KP_Divide, IBUS_L, 0x0141, ++IBUS_KP_Divide, IBUS_O, 0x00D8, ++IBUS_KP_Divide, IBUS_T, 0x0166, ++IBUS_KP_Divide, IBUS_Z, 0x01B5, ++IBUS_KP_Divide, IBUS_b, 0x0180, ++IBUS_KP_Divide, IBUS_d, 0x0111, ++IBUS_KP_Divide, IBUS_g, 0x01E5, ++IBUS_KP_Divide, IBUS_h, 0x0127, ++IBUS_KP_Divide, IBUS_i, 0x0268, ++IBUS_KP_Divide, IBUS_l, 0x0142, ++IBUS_KP_Divide, IBUS_o, 0x00F8, ++IBUS_KP_Divide, IBUS_t, 0x0167, ++IBUS_KP_Divide, IBUS_z, 0x01B6, ++IBUS_KP_Divide, 0x0294, 0x02A1, ++IBUS_KP_Divide, 0x04AE, 0x04B0, ++IBUS_KP_Divide, 0x04AF, 0x04B1, ++IBUS_KP_Divide, IBUS_Cyrillic_ghe, 0x0493, ++IBUS_KP_Divide, IBUS_Cyrillic_ka, 0x049F, ++IBUS_KP_Divide, IBUS_Cyrillic_GHE, 0x0492, ++IBUS_KP_Divide, IBUS_Cyrillic_KA, 0x049E, ++IBUS_KP_Divide, IBUS_leftarrow, 0x219A, ++IBUS_KP_Divide, IBUS_rightarrow, 0x219B, ++IBUS_KP_Divide, 0x2194, 0x21AE, ++IBUS_KP_Equal, 0x0338, 0x2260, ++IBUS_exclam, IBUS_plus, IBUS_O, 0x1EE2, ++IBUS_exclam, IBUS_plus, IBUS_U, 0x1EF0, ++IBUS_exclam, IBUS_plus, IBUS_o, 0x1EE3, ++IBUS_exclam, IBUS_plus, IBUS_u, 0x1EF1, ++IBUS_exclam, IBUS_dead_horn, IBUS_O, 0x1EE2, ++IBUS_exclam, IBUS_dead_horn, IBUS_U, 0x1EF0, ++IBUS_exclam, IBUS_dead_horn, IBUS_o, 0x1EE3, ++IBUS_exclam, IBUS_dead_horn, IBUS_u, 0x1EF1, ++IBUS_quotedbl, IBUS_apostrophe, IBUS_space, 0x0385, ++IBUS_quotedbl, IBUS_apostrophe, IBUS_Greek_iota, 0x0390, ++IBUS_quotedbl, IBUS_apostrophe, IBUS_Greek_upsilon, 0x03B0, ++IBUS_quotedbl, IBUS_underscore, IBUS_U, 0x1E7A, ++IBUS_quotedbl, IBUS_underscore, IBUS_u, 0x1E7B, ++IBUS_quotedbl, IBUS_asciitilde, IBUS_O, 0x1E4E, ++IBUS_quotedbl, IBUS_asciitilde, IBUS_o, 0x1E4F, ++IBUS_quotedbl, IBUS_macron, IBUS_U, 0x1E7A, ++IBUS_quotedbl, IBUS_macron, IBUS_u, 0x1E7B, ++IBUS_quotedbl, IBUS_dead_tilde, IBUS_O, 0x1E4E, ++IBUS_quotedbl, IBUS_dead_tilde, IBUS_o, 0x1E4F, ++IBUS_quotedbl, IBUS_dead_macron, IBUS_U, 0x1E7A, ++IBUS_quotedbl, IBUS_dead_macron, IBUS_u, 0x1E7B, ++IBUS_apostrophe, IBUS_quotedbl, IBUS_space, 0x0385, ++IBUS_apostrophe, IBUS_quotedbl, IBUS_I, 0x1E2E, ++IBUS_apostrophe, IBUS_quotedbl, IBUS_U, 0x01D7, ++IBUS_apostrophe, IBUS_quotedbl, IBUS_i, 0x1E2F, ++IBUS_apostrophe, IBUS_quotedbl, IBUS_u, 0x01D8, ++IBUS_apostrophe, IBUS_quotedbl, IBUS_Greek_iota, 0x0390, ++IBUS_apostrophe, IBUS_quotedbl, IBUS_Greek_upsilon, 0x03B0, ++IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F0D, ++IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_EPSILON, 0x1F1D, ++IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_ETA, 0x1F2D, ++IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_IOTA, 0x1F3D, ++IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_OMICRON, 0x1F4D, ++IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_UPSILON, 0x1F5D, ++IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1F6D, ++IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_alpha, 0x1F05, ++IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_epsilon, 0x1F15, ++IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_eta, 0x1F25, ++IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_iota, 0x1F35, ++IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_omicron, 0x1F45, ++IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_upsilon, 0x1F55, ++IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_omega, 0x1F65, ++IBUS_apostrophe, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F0C, ++IBUS_apostrophe, IBUS_parenright, IBUS_Greek_EPSILON, 0x1F1C, ++IBUS_apostrophe, IBUS_parenright, IBUS_Greek_ETA, 0x1F2C, ++IBUS_apostrophe, IBUS_parenright, IBUS_Greek_IOTA, 0x1F3C, ++IBUS_apostrophe, IBUS_parenright, IBUS_Greek_OMICRON, 0x1F4C, ++IBUS_apostrophe, IBUS_parenright, IBUS_Greek_OMEGA, 0x1F6C, ++IBUS_apostrophe, IBUS_parenright, IBUS_Greek_alpha, 0x1F04, ++IBUS_apostrophe, IBUS_parenright, IBUS_Greek_epsilon, 0x1F14, ++IBUS_apostrophe, IBUS_parenright, IBUS_Greek_eta, 0x1F24, ++IBUS_apostrophe, IBUS_parenright, IBUS_Greek_iota, 0x1F34, ++IBUS_apostrophe, IBUS_parenright, IBUS_Greek_omicron, 0x1F44, ++IBUS_apostrophe, IBUS_parenright, IBUS_Greek_upsilon, 0x1F54, ++IBUS_apostrophe, IBUS_parenright, IBUS_Greek_omega, 0x1F64, ++IBUS_apostrophe, IBUS_plus, IBUS_O, 0x1EDA, ++IBUS_apostrophe, IBUS_plus, IBUS_U, 0x1EE8, ++IBUS_apostrophe, IBUS_plus, IBUS_o, 0x1EDB, ++IBUS_apostrophe, IBUS_plus, IBUS_u, 0x1EE9, ++IBUS_apostrophe, IBUS_slash, IBUS_O, 0x01FE, ++IBUS_apostrophe, IBUS_slash, IBUS_o, 0x01FF, ++IBUS_apostrophe, IBUS_asciicircum, IBUS_A, 0x1EA4, ++IBUS_apostrophe, IBUS_asciicircum, IBUS_E, 0x1EBE, ++IBUS_apostrophe, IBUS_asciicircum, IBUS_O, 0x1ED0, ++IBUS_apostrophe, IBUS_asciicircum, IBUS_a, 0x1EA5, ++IBUS_apostrophe, IBUS_asciicircum, IBUS_e, 0x1EBF, ++IBUS_apostrophe, IBUS_asciicircum, IBUS_o, 0x1ED1, ++IBUS_apostrophe, IBUS_underscore, IBUS_E, 0x1E16, ++IBUS_apostrophe, IBUS_underscore, IBUS_O, 0x1E52, ++IBUS_apostrophe, IBUS_underscore, IBUS_e, 0x1E17, ++IBUS_apostrophe, IBUS_underscore, IBUS_o, 0x1E53, ++IBUS_apostrophe, IBUS_b, IBUS_A, 0x1EAE, ++IBUS_apostrophe, IBUS_b, IBUS_a, 0x1EAF, ++IBUS_apostrophe, IBUS_asciitilde, IBUS_O, 0x1E4C, ++IBUS_apostrophe, IBUS_asciitilde, IBUS_U, 0x1E78, ++IBUS_apostrophe, IBUS_asciitilde, IBUS_o, 0x1E4D, ++IBUS_apostrophe, IBUS_asciitilde, IBUS_u, 0x1E79, ++IBUS_apostrophe, IBUS_macron, IBUS_E, 0x1E16, ++IBUS_apostrophe, IBUS_macron, IBUS_O, 0x1E52, ++IBUS_apostrophe, IBUS_macron, IBUS_e, 0x1E17, ++IBUS_apostrophe, IBUS_macron, IBUS_o, 0x1E53, ++IBUS_apostrophe, IBUS_cedilla, IBUS_C, 0x1E08, ++IBUS_apostrophe, IBUS_cedilla, IBUS_c, 0x1E09, ++IBUS_apostrophe, IBUS_dead_circumflex, IBUS_A, 0x1EA4, ++IBUS_apostrophe, IBUS_dead_circumflex, IBUS_E, 0x1EBE, ++IBUS_apostrophe, IBUS_dead_circumflex, IBUS_O, 0x1ED0, ++IBUS_apostrophe, IBUS_dead_circumflex, IBUS_a, 0x1EA5, ++IBUS_apostrophe, IBUS_dead_circumflex, IBUS_e, 0x1EBF, ++IBUS_apostrophe, IBUS_dead_circumflex, IBUS_o, 0x1ED1, ++IBUS_apostrophe, IBUS_dead_tilde, IBUS_O, 0x1E4C, ++IBUS_apostrophe, IBUS_dead_tilde, IBUS_U, 0x1E78, ++IBUS_apostrophe, IBUS_dead_tilde, IBUS_o, 0x1E4D, ++IBUS_apostrophe, IBUS_dead_tilde, IBUS_u, 0x1E79, ++IBUS_apostrophe, IBUS_dead_macron, IBUS_E, 0x1E16, ++IBUS_apostrophe, IBUS_dead_macron, IBUS_O, 0x1E52, ++IBUS_apostrophe, IBUS_dead_macron, IBUS_e, 0x1E17, ++IBUS_apostrophe, IBUS_dead_macron, IBUS_o, 0x1E53, ++IBUS_apostrophe, IBUS_dead_breve, IBUS_A, 0x1EAE, ++IBUS_apostrophe, IBUS_dead_breve, IBUS_a, 0x1EAF, ++IBUS_apostrophe, IBUS_dead_diaeresis, IBUS_I, 0x1E2E, ++IBUS_apostrophe, IBUS_dead_diaeresis, IBUS_U, 0x01D7, ++IBUS_apostrophe, IBUS_dead_diaeresis, IBUS_i, 0x1E2F, ++IBUS_apostrophe, IBUS_dead_diaeresis, IBUS_u, 0x01D8, ++IBUS_apostrophe, IBUS_dead_diaeresis, IBUS_Greek_iota, 0x0390, ++IBUS_apostrophe, IBUS_dead_diaeresis, IBUS_Greek_upsilon, 0x03B0, ++IBUS_apostrophe, IBUS_dead_abovering, IBUS_A, 0x01FA, ++IBUS_apostrophe, IBUS_dead_abovering, IBUS_a, 0x01FB, ++IBUS_apostrophe, IBUS_dead_cedilla, IBUS_C, 0x1E08, ++IBUS_apostrophe, IBUS_dead_cedilla, IBUS_c, 0x1E09, ++IBUS_apostrophe, IBUS_dead_horn, IBUS_O, 0x1EDA, ++IBUS_apostrophe, IBUS_dead_horn, IBUS_U, 0x1EE8, ++IBUS_apostrophe, IBUS_dead_horn, IBUS_o, 0x1EDB, ++IBUS_apostrophe, IBUS_dead_horn, IBUS_u, 0x1EE9, ++IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F0C, ++IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_EPSILON, 0x1F1C, ++IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F2C, ++IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_IOTA, 0x1F3C, ++IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_OMICRON, 0x1F4C, ++IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1F6C, ++IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F04, ++IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_epsilon, 0x1F14, ++IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_eta, 0x1F24, ++IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_iota, 0x1F34, ++IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_omicron, 0x1F44, ++IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_upsilon, 0x1F54, ++IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_omega, 0x1F64, ++IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F0D, ++IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_EPSILON, 0x1F1D, ++IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F2D, ++IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_IOTA, 0x1F3D, ++IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_OMICRON, 0x1F4D, ++IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_UPSILON, 0x1F5D, ++IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1F6D, ++IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F05, ++IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_epsilon, 0x1F15, ++IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F25, ++IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_iota, 0x1F35, ++IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_omicron, 0x1F45, ++IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_upsilon, 0x1F55, ++IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_omega, 0x1F65, ++IBUS_apostrophe, IBUS_KP_Divide, IBUS_O, 0x01FE, ++IBUS_apostrophe, IBUS_KP_Divide, IBUS_o, 0x01FF, ++IBUS_parenleft, IBUS_0, IBUS_parenright, 0x24EA, ++IBUS_parenleft, IBUS_1, IBUS_parenright, 0x2460, ++IBUS_parenleft, IBUS_2, IBUS_parenright, 0x2461, ++IBUS_parenleft, IBUS_3, IBUS_parenright, 0x2462, ++IBUS_parenleft, IBUS_4, IBUS_parenright, 0x2463, ++IBUS_parenleft, IBUS_5, IBUS_parenright, 0x2464, ++IBUS_parenleft, IBUS_6, IBUS_parenright, 0x2465, ++IBUS_parenleft, IBUS_7, IBUS_parenright, 0x2466, ++IBUS_parenleft, IBUS_8, IBUS_parenright, 0x2467, ++IBUS_parenleft, IBUS_9, IBUS_parenright, 0x2468, ++IBUS_parenleft, IBUS_A, IBUS_parenright, 0x24B6, ++IBUS_parenleft, IBUS_B, IBUS_parenright, 0x24B7, ++IBUS_parenleft, IBUS_C, IBUS_parenright, 0x24B8, ++IBUS_parenleft, IBUS_D, IBUS_parenright, 0x24B9, ++IBUS_parenleft, IBUS_E, IBUS_parenright, 0x24BA, ++IBUS_parenleft, IBUS_F, IBUS_parenright, 0x24BB, ++IBUS_parenleft, IBUS_G, IBUS_parenright, 0x24BC, ++IBUS_parenleft, IBUS_H, IBUS_parenright, 0x24BD, ++IBUS_parenleft, IBUS_I, IBUS_parenright, 0x24BE, ++IBUS_parenleft, IBUS_J, IBUS_parenright, 0x24BF, ++IBUS_parenleft, IBUS_K, IBUS_parenright, 0x24C0, ++IBUS_parenleft, IBUS_L, IBUS_parenright, 0x24C1, ++IBUS_parenleft, IBUS_M, IBUS_parenright, 0x24C2, ++IBUS_parenleft, IBUS_N, IBUS_parenright, 0x24C3, ++IBUS_parenleft, IBUS_O, IBUS_parenright, 0x24C4, ++IBUS_parenleft, IBUS_P, IBUS_parenright, 0x24C5, ++IBUS_parenleft, IBUS_Q, IBUS_parenright, 0x24C6, ++IBUS_parenleft, IBUS_R, IBUS_parenright, 0x24C7, ++IBUS_parenleft, IBUS_S, IBUS_parenright, 0x24C8, ++IBUS_parenleft, IBUS_T, IBUS_parenright, 0x24C9, ++IBUS_parenleft, IBUS_U, IBUS_parenright, 0x24CA, ++IBUS_parenleft, IBUS_V, IBUS_parenright, 0x24CB, ++IBUS_parenleft, IBUS_W, IBUS_parenright, 0x24CC, ++IBUS_parenleft, IBUS_X, IBUS_parenright, 0x24CD, ++IBUS_parenleft, IBUS_Y, IBUS_parenright, 0x24CE, ++IBUS_parenleft, IBUS_Z, IBUS_parenright, 0x24CF, ++IBUS_parenleft, IBUS_a, IBUS_parenright, 0x24D0, ++IBUS_parenleft, IBUS_b, IBUS_parenright, 0x24D1, ++IBUS_parenleft, IBUS_c, IBUS_parenright, 0x24D2, ++IBUS_parenleft, IBUS_d, IBUS_parenright, 0x24D3, ++IBUS_parenleft, IBUS_e, IBUS_parenright, 0x24D4, ++IBUS_parenleft, IBUS_f, IBUS_parenright, 0x24D5, ++IBUS_parenleft, IBUS_g, IBUS_parenright, 0x24D6, ++IBUS_parenleft, IBUS_h, IBUS_parenright, 0x24D7, ++IBUS_parenleft, IBUS_i, IBUS_parenright, 0x24D8, ++IBUS_parenleft, IBUS_j, IBUS_parenright, 0x24D9, ++IBUS_parenleft, IBUS_k, IBUS_parenright, 0x24DA, ++IBUS_parenleft, IBUS_l, IBUS_parenright, 0x24DB, ++IBUS_parenleft, IBUS_m, IBUS_parenright, 0x24DC, ++IBUS_parenleft, IBUS_n, IBUS_parenright, 0x24DD, ++IBUS_parenleft, IBUS_o, IBUS_parenright, 0x24DE, ++IBUS_parenleft, IBUS_p, IBUS_parenright, 0x24DF, ++IBUS_parenleft, IBUS_q, IBUS_parenright, 0x24E0, ++IBUS_parenleft, IBUS_r, IBUS_parenright, 0x24E1, ++IBUS_parenleft, IBUS_s, IBUS_parenright, 0x24E2, ++IBUS_parenleft, IBUS_t, IBUS_parenright, 0x24E3, ++IBUS_parenleft, IBUS_u, IBUS_parenright, 0x24E4, ++IBUS_parenleft, IBUS_v, IBUS_parenright, 0x24E5, ++IBUS_parenleft, IBUS_w, IBUS_parenright, 0x24E6, ++IBUS_parenleft, IBUS_x, IBUS_parenright, 0x24E7, ++IBUS_parenleft, IBUS_y, IBUS_parenright, 0x24E8, ++IBUS_parenleft, IBUS_z, IBUS_parenright, 0x24E9, ++IBUS_parenleft, IBUS_kana_WO, IBUS_parenright, 0x32FE, ++IBUS_parenleft, IBUS_kana_A, IBUS_parenright, 0x32D0, ++IBUS_parenleft, IBUS_kana_I, IBUS_parenright, 0x32D1, ++IBUS_parenleft, IBUS_kana_U, IBUS_parenright, 0x32D2, ++IBUS_parenleft, IBUS_kana_E, IBUS_parenright, 0x32D3, ++IBUS_parenleft, IBUS_kana_O, IBUS_parenright, 0x32D4, ++IBUS_parenleft, IBUS_kana_KA, IBUS_parenright, 0x32D5, ++IBUS_parenleft, IBUS_kana_KI, IBUS_parenright, 0x32D6, ++IBUS_parenleft, IBUS_kana_KU, IBUS_parenright, 0x32D7, ++IBUS_parenleft, IBUS_kana_KE, IBUS_parenright, 0x32D8, ++IBUS_parenleft, IBUS_kana_KO, IBUS_parenright, 0x32D9, ++IBUS_parenleft, IBUS_kana_SA, IBUS_parenright, 0x32DA, ++IBUS_parenleft, IBUS_kana_SHI, IBUS_parenright, 0x32DB, ++IBUS_parenleft, IBUS_kana_SU, IBUS_parenright, 0x32DC, ++IBUS_parenleft, IBUS_kana_SE, IBUS_parenright, 0x32DD, ++IBUS_parenleft, IBUS_kana_SO, IBUS_parenright, 0x32DE, ++IBUS_parenleft, IBUS_kana_TA, IBUS_parenright, 0x32DF, ++IBUS_parenleft, IBUS_kana_CHI, IBUS_parenright, 0x32E0, ++IBUS_parenleft, IBUS_kana_TSU, IBUS_parenright, 0x32E1, ++IBUS_parenleft, IBUS_kana_TE, IBUS_parenright, 0x32E2, ++IBUS_parenleft, IBUS_kana_TO, IBUS_parenright, 0x32E3, ++IBUS_parenleft, IBUS_kana_NA, IBUS_parenright, 0x32E4, ++IBUS_parenleft, IBUS_kana_NI, IBUS_parenright, 0x32E5, ++IBUS_parenleft, IBUS_kana_NU, IBUS_parenright, 0x32E6, ++IBUS_parenleft, IBUS_kana_NE, IBUS_parenright, 0x32E7, ++IBUS_parenleft, IBUS_kana_NO, IBUS_parenright, 0x32E8, ++IBUS_parenleft, IBUS_kana_HA, IBUS_parenright, 0x32E9, ++IBUS_parenleft, IBUS_kana_HI, IBUS_parenright, 0x32EA, ++IBUS_parenleft, IBUS_kana_FU, IBUS_parenright, 0x32EB, ++IBUS_parenleft, IBUS_kana_HE, IBUS_parenright, 0x32EC, ++IBUS_parenleft, IBUS_kana_HO, IBUS_parenright, 0x32ED, ++IBUS_parenleft, IBUS_kana_MA, IBUS_parenright, 0x32EE, ++IBUS_parenleft, IBUS_kana_MI, IBUS_parenright, 0x32EF, ++IBUS_parenleft, IBUS_kana_MU, IBUS_parenright, 0x32F0, ++IBUS_parenleft, IBUS_kana_ME, IBUS_parenright, 0x32F1, ++IBUS_parenleft, IBUS_kana_MO, IBUS_parenright, 0x32F2, ++IBUS_parenleft, IBUS_kana_YA, IBUS_parenright, 0x32F3, ++IBUS_parenleft, IBUS_kana_YU, IBUS_parenright, 0x32F4, ++IBUS_parenleft, IBUS_kana_YO, IBUS_parenright, 0x32F5, ++IBUS_parenleft, IBUS_kana_RA, IBUS_parenright, 0x32F6, ++IBUS_parenleft, IBUS_kana_RI, IBUS_parenright, 0x32F7, ++IBUS_parenleft, IBUS_kana_RU, IBUS_parenright, 0x32F8, ++IBUS_parenleft, IBUS_kana_RE, IBUS_parenright, 0x32F9, ++IBUS_parenleft, IBUS_kana_RO, IBUS_parenright, 0x32FA, ++IBUS_parenleft, IBUS_kana_WA, IBUS_parenright, 0x32FB, ++IBUS_parenleft, 0x1100, IBUS_parenright, 0x3260, ++IBUS_parenleft, 0x1102, IBUS_parenright, 0x3261, ++IBUS_parenleft, 0x1103, IBUS_parenright, 0x3262, ++IBUS_parenleft, 0x1105, IBUS_parenright, 0x3263, ++IBUS_parenleft, 0x1106, IBUS_parenright, 0x3264, ++IBUS_parenleft, 0x1107, IBUS_parenright, 0x3265, ++IBUS_parenleft, 0x1109, IBUS_parenright, 0x3266, ++IBUS_parenleft, 0x110B, IBUS_parenright, 0x3267, ++IBUS_parenleft, 0x110C, IBUS_parenright, 0x3268, ++IBUS_parenleft, 0x110E, IBUS_parenright, 0x3269, ++IBUS_parenleft, 0x110F, IBUS_parenright, 0x326A, ++IBUS_parenleft, 0x1110, IBUS_parenright, 0x326B, ++IBUS_parenleft, 0x1111, IBUS_parenright, 0x326C, ++IBUS_parenleft, 0x1112, IBUS_parenright, 0x326D, ++IBUS_parenleft, 0x30F0, IBUS_parenright, 0x32FC, ++IBUS_parenleft, 0x30F1, IBUS_parenright, 0x32FD, ++IBUS_parenleft, 0x4E00, IBUS_parenright, 0x3280, ++IBUS_parenleft, 0x4E03, IBUS_parenright, 0x3286, ++IBUS_parenleft, 0x4E09, IBUS_parenright, 0x3282, ++IBUS_parenleft, 0x4E0A, IBUS_parenright, 0x32A4, ++IBUS_parenleft, 0x4E0B, IBUS_parenright, 0x32A6, ++IBUS_parenleft, 0x4E2D, IBUS_parenright, 0x32A5, ++IBUS_parenleft, 0x4E5D, IBUS_parenright, 0x3288, ++IBUS_parenleft, 0x4E8C, IBUS_parenright, 0x3281, ++IBUS_parenleft, 0x4E94, IBUS_parenright, 0x3284, ++IBUS_parenleft, 0x4F01, IBUS_parenright, 0x32AD, ++IBUS_parenleft, 0x4F11, IBUS_parenright, 0x32A1, ++IBUS_parenleft, 0x512A, IBUS_parenright, 0x329D, ++IBUS_parenleft, 0x516B, IBUS_parenright, 0x3287, ++IBUS_parenleft, 0x516D, IBUS_parenright, 0x3285, ++IBUS_parenleft, 0x5199, IBUS_parenright, 0x32A2, ++IBUS_parenleft, 0x52B4, IBUS_parenright, 0x3298, ++IBUS_parenleft, 0x533B, IBUS_parenright, 0x32A9, ++IBUS_parenleft, 0x5341, IBUS_parenright, 0x3289, ++IBUS_parenleft, 0x5354, IBUS_parenright, 0x32AF, ++IBUS_parenleft, 0x5370, IBUS_parenright, 0x329E, ++IBUS_parenleft, 0x53F3, IBUS_parenright, 0x32A8, ++IBUS_parenleft, 0x540D, IBUS_parenright, 0x3294, ++IBUS_parenleft, 0x56DB, IBUS_parenright, 0x3283, ++IBUS_parenleft, 0x571F, IBUS_parenright, 0x328F, ++IBUS_parenleft, 0x591C, IBUS_parenright, 0x32B0, ++IBUS_parenleft, 0x5973, IBUS_parenright, 0x329B, ++IBUS_parenleft, 0x5B66, IBUS_parenright, 0x32AB, ++IBUS_parenleft, 0x5B97, IBUS_parenright, 0x32AA, ++IBUS_parenleft, 0x5DE6, IBUS_parenright, 0x32A7, ++IBUS_parenleft, 0x65E5, IBUS_parenright, 0x3290, ++IBUS_parenleft, 0x6708, IBUS_parenright, 0x328A, ++IBUS_parenleft, 0x6709, IBUS_parenright, 0x3292, ++IBUS_parenleft, 0x6728, IBUS_parenright, 0x328D, ++IBUS_parenleft, 0x682A, IBUS_parenright, 0x3291, ++IBUS_parenleft, 0x6B63, IBUS_parenright, 0x32A3, ++IBUS_parenleft, 0x6C34, IBUS_parenright, 0x328C, ++IBUS_parenleft, 0x6CE8, IBUS_parenright, 0x329F, ++IBUS_parenleft, 0x706B, IBUS_parenright, 0x328B, ++IBUS_parenleft, 0x7279, IBUS_parenright, 0x3295, ++IBUS_parenleft, 0x7537, IBUS_parenright, 0x329A, ++IBUS_parenleft, 0x76E3, IBUS_parenright, 0x32AC, ++IBUS_parenleft, 0x793E, IBUS_parenright, 0x3293, ++IBUS_parenleft, 0x795D, IBUS_parenright, 0x3297, ++IBUS_parenleft, 0x79D8, IBUS_parenright, 0x3299, ++IBUS_parenleft, 0x8CA1, IBUS_parenright, 0x3296, ++IBUS_parenleft, 0x8CC7, IBUS_parenright, 0x32AE, ++IBUS_parenleft, 0x9069, IBUS_parenright, 0x329C, ++IBUS_parenleft, 0x91D1, IBUS_parenright, 0x328E, ++IBUS_parenleft, 0x9805, IBUS_parenright, 0x32A0, ++IBUS_parenleft, IBUS_KP_Space, IBUS_parenright, 0x2461, ++IBUS_parenleft, IBUS_KP_0, IBUS_parenright, 0x24EA, ++IBUS_parenleft, IBUS_KP_1, IBUS_parenright, 0x2460, ++IBUS_parenleft, IBUS_KP_2, IBUS_parenright, 0x2461, ++IBUS_parenleft, IBUS_KP_3, IBUS_parenright, 0x2462, ++IBUS_parenleft, IBUS_KP_4, IBUS_parenright, 0x2463, ++IBUS_parenleft, IBUS_KP_5, IBUS_parenright, 0x2464, ++IBUS_parenleft, IBUS_KP_6, IBUS_parenright, 0x2465, ++IBUS_parenleft, IBUS_KP_7, IBUS_parenright, 0x2466, ++IBUS_parenleft, IBUS_KP_8, IBUS_parenright, 0x2467, ++IBUS_parenleft, IBUS_KP_9, IBUS_parenright, 0x2468, ++IBUS_minus, IBUS_minus, IBUS_space, 0x00AD, ++IBUS_minus, IBUS_minus, IBUS_minus, 0x2014, ++IBUS_minus, IBUS_minus, IBUS_period, 0x2013, ++IBUS_period, IBUS_exclam, IBUS_S, 0x1E68, ++IBUS_period, IBUS_exclam, IBUS_s, 0x1E69, ++IBUS_period, IBUS_apostrophe, IBUS_S, 0x1E64, ++IBUS_period, IBUS_apostrophe, IBUS_s, 0x1E65, ++IBUS_period, IBUS_acute, IBUS_S, 0x1E64, ++IBUS_period, IBUS_acute, IBUS_s, 0x1E65, ++IBUS_period, IBUS_dead_acute, IBUS_S, 0x1E64, ++IBUS_period, IBUS_dead_acute, IBUS_s, 0x1E65, ++IBUS_period, IBUS_dead_caron, IBUS_S, 0x1E66, ++IBUS_period, IBUS_dead_caron, IBUS_s, 0x1E67, ++IBUS_period, IBUS_dead_belowdot, IBUS_S, 0x1E68, ++IBUS_period, IBUS_dead_belowdot, IBUS_s, 0x1E69, ++IBUS_question, IBUS_plus, IBUS_O, 0x1EDE, ++IBUS_question, IBUS_plus, IBUS_U, 0x1EEC, ++IBUS_question, IBUS_plus, IBUS_o, 0x1EDF, ++IBUS_question, IBUS_plus, IBUS_u, 0x1EED, ++IBUS_question, IBUS_asciicircum, IBUS_A, 0x1EA8, ++IBUS_question, IBUS_asciicircum, IBUS_E, 0x1EC2, ++IBUS_question, IBUS_asciicircum, IBUS_O, 0x1ED4, ++IBUS_question, IBUS_asciicircum, IBUS_a, 0x1EA9, ++IBUS_question, IBUS_asciicircum, IBUS_e, 0x1EC3, ++IBUS_question, IBUS_asciicircum, IBUS_o, 0x1ED5, ++IBUS_question, IBUS_b, IBUS_A, 0x1EB2, ++IBUS_question, IBUS_b, IBUS_a, 0x1EB3, ++IBUS_question, IBUS_dead_circumflex, IBUS_A, 0x1EA8, ++IBUS_question, IBUS_dead_circumflex, IBUS_E, 0x1EC2, ++IBUS_question, IBUS_dead_circumflex, IBUS_O, 0x1ED4, ++IBUS_question, IBUS_dead_circumflex, IBUS_a, 0x1EA9, ++IBUS_question, IBUS_dead_circumflex, IBUS_e, 0x1EC3, ++IBUS_question, IBUS_dead_circumflex, IBUS_o, 0x1ED5, ++IBUS_question, IBUS_dead_breve, IBUS_A, 0x1EB2, ++IBUS_question, IBUS_dead_breve, IBUS_a, 0x1EB3, ++IBUS_question, IBUS_dead_horn, IBUS_O, 0x1EDE, ++IBUS_question, IBUS_dead_horn, IBUS_U, 0x1EEC, ++IBUS_question, IBUS_dead_horn, IBUS_o, 0x1EDF, ++IBUS_question, IBUS_dead_horn, IBUS_u, 0x1EED, ++IBUS_U, IBUS_exclam, IBUS_A, 0x1EB6, ++IBUS_U, IBUS_exclam, IBUS_a, 0x1EB7, ++IBUS_U, IBUS_comma, IBUS_E, 0x1E1C, ++IBUS_U, IBUS_comma, IBUS_e, 0x1E1D, ++IBUS_U, IBUS_cedilla, IBUS_E, 0x1E1C, ++IBUS_U, IBUS_cedilla, IBUS_e, 0x1E1D, ++IBUS_U, IBUS_dead_cedilla, IBUS_E, 0x1E1C, ++IBUS_U, IBUS_dead_cedilla, IBUS_e, 0x1E1D, ++IBUS_U, IBUS_dead_belowdot, IBUS_A, 0x1EB6, ++IBUS_U, IBUS_dead_belowdot, IBUS_a, 0x1EB7, ++IBUS_asciicircum, IBUS_exclam, IBUS_A, 0x1EAC, ++IBUS_asciicircum, IBUS_exclam, IBUS_E, 0x1EC6, ++IBUS_asciicircum, IBUS_exclam, IBUS_O, 0x1ED8, ++IBUS_asciicircum, IBUS_exclam, IBUS_a, 0x1EAD, ++IBUS_asciicircum, IBUS_exclam, IBUS_e, 0x1EC7, ++IBUS_asciicircum, IBUS_exclam, IBUS_o, 0x1ED9, ++IBUS_asciicircum, IBUS_underscore, IBUS_a, 0x00AA, ++IBUS_asciicircum, IBUS_underscore, IBUS_h, 0x02B0, ++IBUS_asciicircum, IBUS_underscore, IBUS_i, 0x2071, ++IBUS_asciicircum, IBUS_underscore, IBUS_j, 0x02B2, ++IBUS_asciicircum, IBUS_underscore, IBUS_l, 0x02E1, ++IBUS_asciicircum, IBUS_underscore, IBUS_n, 0x207F, ++IBUS_asciicircum, IBUS_underscore, IBUS_o, 0x00BA, ++IBUS_asciicircum, IBUS_underscore, IBUS_r, 0x02B3, ++IBUS_asciicircum, IBUS_underscore, IBUS_s, 0x02E2, ++IBUS_asciicircum, IBUS_underscore, IBUS_w, 0x02B7, ++IBUS_asciicircum, IBUS_underscore, IBUS_x, 0x02E3, ++IBUS_asciicircum, IBUS_underscore, IBUS_y, 0x02B8, ++IBUS_asciicircum, IBUS_underscore, 0x0263, 0x02E0, ++IBUS_asciicircum, IBUS_underscore, 0x0266, 0x02B1, ++IBUS_asciicircum, IBUS_underscore, 0x0279, 0x02B4, ++IBUS_asciicircum, IBUS_underscore, 0x027B, 0x02B5, ++IBUS_asciicircum, IBUS_underscore, 0x0281, 0x02B6, ++IBUS_asciicircum, IBUS_underscore, 0x0295, 0x02E4, ++IBUS_asciicircum, IBUS_underbar, IBUS_a, 0x00AA, ++IBUS_asciicircum, IBUS_underbar, IBUS_h, 0x02B0, ++IBUS_asciicircum, IBUS_underbar, IBUS_i, 0x2071, ++IBUS_asciicircum, IBUS_underbar, IBUS_j, 0x02B2, ++IBUS_asciicircum, IBUS_underbar, IBUS_l, 0x02E1, ++IBUS_asciicircum, IBUS_underbar, IBUS_n, 0x207F, ++IBUS_asciicircum, IBUS_underbar, IBUS_o, 0x00BA, ++IBUS_asciicircum, IBUS_underbar, IBUS_r, 0x02B3, ++IBUS_asciicircum, IBUS_underbar, IBUS_s, 0x02E2, ++IBUS_asciicircum, IBUS_underbar, IBUS_w, 0x02B7, ++IBUS_asciicircum, IBUS_underbar, IBUS_x, 0x02E3, ++IBUS_asciicircum, IBUS_underbar, IBUS_y, 0x02B8, ++IBUS_asciicircum, IBUS_underbar, 0x0263, 0x02E0, ++IBUS_asciicircum, IBUS_underbar, 0x0266, 0x02B1, ++IBUS_asciicircum, IBUS_underbar, 0x0279, 0x02B4, ++IBUS_asciicircum, IBUS_underbar, 0x027B, 0x02B5, ++IBUS_asciicircum, IBUS_underbar, 0x0281, 0x02B6, ++IBUS_asciicircum, IBUS_underbar, 0x0295, 0x02E4, ++IBUS_asciicircum, IBUS_dead_belowdot, IBUS_A, 0x1EAC, ++IBUS_asciicircum, IBUS_dead_belowdot, IBUS_E, 0x1EC6, ++IBUS_asciicircum, IBUS_dead_belowdot, IBUS_O, 0x1ED8, ++IBUS_asciicircum, IBUS_dead_belowdot, IBUS_a, 0x1EAD, ++IBUS_asciicircum, IBUS_dead_belowdot, IBUS_e, 0x1EC7, ++IBUS_asciicircum, IBUS_dead_belowdot, IBUS_o, 0x1ED9, ++IBUS_underscore, IBUS_exclam, IBUS_L, 0x1E38, ++IBUS_underscore, IBUS_exclam, IBUS_R, 0x1E5C, ++IBUS_underscore, IBUS_exclam, IBUS_l, 0x1E39, ++IBUS_underscore, IBUS_exclam, IBUS_r, 0x1E5D, ++IBUS_underscore, IBUS_quotedbl, IBUS_A, 0x01DE, ++IBUS_underscore, IBUS_quotedbl, IBUS_O, 0x022A, ++IBUS_underscore, IBUS_quotedbl, IBUS_U, 0x01D5, ++IBUS_underscore, IBUS_quotedbl, IBUS_a, 0x01DF, ++IBUS_underscore, IBUS_quotedbl, IBUS_o, 0x022B, ++IBUS_underscore, IBUS_quotedbl, IBUS_u, 0x01D6, ++IBUS_underscore, IBUS_period, IBUS_A, 0x01E0, ++IBUS_underscore, IBUS_period, IBUS_O, 0x0230, ++IBUS_underscore, IBUS_period, IBUS_a, 0x01E1, ++IBUS_underscore, IBUS_period, IBUS_o, 0x0231, ++IBUS_underscore, IBUS_semicolon, IBUS_O, 0x01EC, ++IBUS_underscore, IBUS_semicolon, IBUS_o, 0x01ED, ++IBUS_underscore, IBUS_asciitilde, IBUS_O, 0x022C, ++IBUS_underscore, IBUS_asciitilde, IBUS_o, 0x022D, ++IBUS_underscore, IBUS_dead_tilde, IBUS_O, 0x022C, ++IBUS_underscore, IBUS_dead_tilde, IBUS_o, 0x022D, ++IBUS_underscore, IBUS_dead_abovedot, IBUS_A, 0x01E0, ++IBUS_underscore, IBUS_dead_abovedot, IBUS_O, 0x0230, ++IBUS_underscore, IBUS_dead_abovedot, IBUS_a, 0x01E1, ++IBUS_underscore, IBUS_dead_abovedot, IBUS_o, 0x0231, ++IBUS_underscore, IBUS_dead_diaeresis, IBUS_A, 0x01DE, ++IBUS_underscore, IBUS_dead_diaeresis, IBUS_O, 0x022A, ++IBUS_underscore, IBUS_dead_diaeresis, IBUS_U, 0x01D5, ++IBUS_underscore, IBUS_dead_diaeresis, IBUS_a, 0x01DF, ++IBUS_underscore, IBUS_dead_diaeresis, IBUS_o, 0x022B, ++IBUS_underscore, IBUS_dead_diaeresis, IBUS_u, 0x01D6, ++IBUS_underscore, IBUS_dead_ogonek, IBUS_O, 0x01EC, ++IBUS_underscore, IBUS_dead_ogonek, IBUS_o, 0x01ED, ++IBUS_underscore, IBUS_dead_belowdot, IBUS_L, 0x1E38, ++IBUS_underscore, IBUS_dead_belowdot, IBUS_R, 0x1E5C, ++IBUS_underscore, IBUS_dead_belowdot, IBUS_l, 0x1E39, ++IBUS_underscore, IBUS_dead_belowdot, IBUS_r, 0x1E5D, ++IBUS_grave, IBUS_quotedbl, IBUS_U, 0x01DB, ++IBUS_grave, IBUS_quotedbl, IBUS_u, 0x01DC, ++IBUS_grave, IBUS_quotedbl, IBUS_Greek_iota, 0x1FD2, ++IBUS_grave, IBUS_quotedbl, IBUS_Greek_upsilon, 0x1FE2, ++IBUS_grave, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F0B, ++IBUS_grave, IBUS_parenleft, IBUS_Greek_EPSILON, 0x1F1B, ++IBUS_grave, IBUS_parenleft, IBUS_Greek_ETA, 0x1F2B, ++IBUS_grave, IBUS_parenleft, IBUS_Greek_IOTA, 0x1F3B, ++IBUS_grave, IBUS_parenleft, IBUS_Greek_OMICRON, 0x1F4B, ++IBUS_grave, IBUS_parenleft, IBUS_Greek_UPSILON, 0x1F5B, ++IBUS_grave, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1F6B, ++IBUS_grave, IBUS_parenleft, IBUS_Greek_alpha, 0x1F03, ++IBUS_grave, IBUS_parenleft, IBUS_Greek_epsilon, 0x1F13, ++IBUS_grave, IBUS_parenleft, IBUS_Greek_eta, 0x1F23, ++IBUS_grave, IBUS_parenleft, IBUS_Greek_iota, 0x1F33, ++IBUS_grave, IBUS_parenleft, IBUS_Greek_omicron, 0x1F43, ++IBUS_grave, IBUS_parenleft, IBUS_Greek_upsilon, 0x1F53, ++IBUS_grave, IBUS_parenleft, IBUS_Greek_omega, 0x1F63, ++IBUS_grave, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F0A, ++IBUS_grave, IBUS_parenright, IBUS_Greek_EPSILON, 0x1F1A, ++IBUS_grave, IBUS_parenright, IBUS_Greek_ETA, 0x1F2A, ++IBUS_grave, IBUS_parenright, IBUS_Greek_IOTA, 0x1F3A, ++IBUS_grave, IBUS_parenright, IBUS_Greek_OMICRON, 0x1F4A, ++IBUS_grave, IBUS_parenright, IBUS_Greek_OMEGA, 0x1F6A, ++IBUS_grave, IBUS_parenright, IBUS_Greek_alpha, 0x1F02, ++IBUS_grave, IBUS_parenright, IBUS_Greek_epsilon, 0x1F12, ++IBUS_grave, IBUS_parenright, IBUS_Greek_eta, 0x1F22, ++IBUS_grave, IBUS_parenright, IBUS_Greek_iota, 0x1F32, ++IBUS_grave, IBUS_parenright, IBUS_Greek_omicron, 0x1F42, ++IBUS_grave, IBUS_parenright, IBUS_Greek_upsilon, 0x1F52, ++IBUS_grave, IBUS_parenright, IBUS_Greek_omega, 0x1F62, ++IBUS_grave, IBUS_plus, IBUS_O, 0x1EDC, ++IBUS_grave, IBUS_plus, IBUS_U, 0x1EEA, ++IBUS_grave, IBUS_plus, IBUS_o, 0x1EDD, ++IBUS_grave, IBUS_plus, IBUS_u, 0x1EEB, ++IBUS_grave, IBUS_asciicircum, IBUS_A, 0x1EA6, ++IBUS_grave, IBUS_asciicircum, IBUS_E, 0x1EC0, ++IBUS_grave, IBUS_asciicircum, IBUS_O, 0x1ED2, ++IBUS_grave, IBUS_asciicircum, IBUS_a, 0x1EA7, ++IBUS_grave, IBUS_asciicircum, IBUS_e, 0x1EC1, ++IBUS_grave, IBUS_asciicircum, IBUS_o, 0x1ED3, ++IBUS_grave, IBUS_underscore, IBUS_E, 0x1E14, ++IBUS_grave, IBUS_underscore, IBUS_O, 0x1E50, ++IBUS_grave, IBUS_underscore, IBUS_e, 0x1E15, ++IBUS_grave, IBUS_underscore, IBUS_o, 0x1E51, ++IBUS_grave, IBUS_b, IBUS_A, 0x1EB0, ++IBUS_grave, IBUS_b, IBUS_a, 0x1EB1, ++IBUS_grave, IBUS_macron, IBUS_E, 0x1E14, ++IBUS_grave, IBUS_macron, IBUS_O, 0x1E50, ++IBUS_grave, IBUS_macron, IBUS_e, 0x1E15, ++IBUS_grave, IBUS_macron, IBUS_o, 0x1E51, ++IBUS_grave, IBUS_dead_circumflex, IBUS_A, 0x1EA6, ++IBUS_grave, IBUS_dead_circumflex, IBUS_E, 0x1EC0, ++IBUS_grave, IBUS_dead_circumflex, IBUS_O, 0x1ED2, ++IBUS_grave, IBUS_dead_circumflex, IBUS_a, 0x1EA7, ++IBUS_grave, IBUS_dead_circumflex, IBUS_e, 0x1EC1, ++IBUS_grave, IBUS_dead_circumflex, IBUS_o, 0x1ED3, ++IBUS_grave, IBUS_dead_macron, IBUS_E, 0x1E14, ++IBUS_grave, IBUS_dead_macron, IBUS_O, 0x1E50, ++IBUS_grave, IBUS_dead_macron, IBUS_e, 0x1E15, ++IBUS_grave, IBUS_dead_macron, IBUS_o, 0x1E51, ++IBUS_grave, IBUS_dead_breve, IBUS_A, 0x1EB0, ++IBUS_grave, IBUS_dead_breve, IBUS_a, 0x1EB1, ++IBUS_grave, IBUS_dead_diaeresis, IBUS_U, 0x01DB, ++IBUS_grave, IBUS_dead_diaeresis, IBUS_u, 0x01DC, ++IBUS_grave, IBUS_dead_diaeresis, IBUS_Greek_iota, 0x1FD2, ++IBUS_grave, IBUS_dead_diaeresis, IBUS_Greek_upsilon, 0x1FE2, ++IBUS_grave, IBUS_dead_horn, IBUS_O, 0x1EDC, ++IBUS_grave, IBUS_dead_horn, IBUS_U, 0x1EEA, ++IBUS_grave, IBUS_dead_horn, IBUS_o, 0x1EDD, ++IBUS_grave, IBUS_dead_horn, IBUS_u, 0x1EEB, ++IBUS_grave, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F0A, ++IBUS_grave, IBUS_dead_psili, IBUS_Greek_EPSILON, 0x1F1A, ++IBUS_grave, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F2A, ++IBUS_grave, IBUS_dead_psili, IBUS_Greek_IOTA, 0x1F3A, ++IBUS_grave, IBUS_dead_psili, IBUS_Greek_OMICRON, 0x1F4A, ++IBUS_grave, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1F6A, ++IBUS_grave, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F02, ++IBUS_grave, IBUS_dead_psili, IBUS_Greek_epsilon, 0x1F12, ++IBUS_grave, IBUS_dead_psili, IBUS_Greek_eta, 0x1F22, ++IBUS_grave, IBUS_dead_psili, IBUS_Greek_iota, 0x1F32, ++IBUS_grave, IBUS_dead_psili, IBUS_Greek_omicron, 0x1F42, ++IBUS_grave, IBUS_dead_psili, IBUS_Greek_upsilon, 0x1F52, ++IBUS_grave, IBUS_dead_psili, IBUS_Greek_omega, 0x1F62, ++IBUS_grave, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F0B, ++IBUS_grave, IBUS_dead_dasia, IBUS_Greek_EPSILON, 0x1F1B, ++IBUS_grave, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F2B, ++IBUS_grave, IBUS_dead_dasia, IBUS_Greek_IOTA, 0x1F3B, ++IBUS_grave, IBUS_dead_dasia, IBUS_Greek_OMICRON, 0x1F4B, ++IBUS_grave, IBUS_dead_dasia, IBUS_Greek_UPSILON, 0x1F5B, ++IBUS_grave, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1F6B, ++IBUS_grave, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F03, ++IBUS_grave, IBUS_dead_dasia, IBUS_Greek_epsilon, 0x1F13, ++IBUS_grave, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F23, ++IBUS_grave, IBUS_dead_dasia, IBUS_Greek_iota, 0x1F33, ++IBUS_grave, IBUS_dead_dasia, IBUS_Greek_omicron, 0x1F43, ++IBUS_grave, IBUS_dead_dasia, IBUS_Greek_upsilon, 0x1F53, ++IBUS_grave, IBUS_dead_dasia, IBUS_Greek_omega, 0x1F63, ++IBUS_b, IBUS_exclam, IBUS_A, 0x1EB6, ++IBUS_b, IBUS_exclam, IBUS_a, 0x1EB7, ++IBUS_b, IBUS_comma, IBUS_E, 0x1E1C, ++IBUS_b, IBUS_comma, IBUS_e, 0x1E1D, ++IBUS_b, IBUS_cedilla, IBUS_E, 0x1E1C, ++IBUS_b, IBUS_cedilla, IBUS_e, 0x1E1D, ++IBUS_b, IBUS_dead_cedilla, IBUS_E, 0x1E1C, ++IBUS_b, IBUS_dead_cedilla, IBUS_e, 0x1E1D, ++IBUS_b, IBUS_dead_belowdot, IBUS_A, 0x1EB6, ++IBUS_b, IBUS_dead_belowdot, IBUS_a, 0x1EB7, ++IBUS_c, IBUS_quotedbl, IBUS_U, 0x01D9, ++IBUS_c, IBUS_quotedbl, IBUS_u, 0x01DA, ++IBUS_c, IBUS_dead_diaeresis, IBUS_U, 0x01D9, ++IBUS_c, IBUS_dead_diaeresis, IBUS_u, 0x01DA, ++IBUS_o, IBUS_apostrophe, IBUS_A, 0x01FA, ++IBUS_o, IBUS_apostrophe, IBUS_a, 0x01FB, ++IBUS_asciitilde, IBUS_quotedbl, IBUS_Greek_iota, 0x1FD7, ++IBUS_asciitilde, IBUS_quotedbl, IBUS_Greek_upsilon, 0x1FE7, ++IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F0F, ++IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_ETA, 0x1F2F, ++IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_IOTA, 0x1F3F, ++IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_UPSILON, 0x1F5F, ++IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1F6F, ++IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_alpha, 0x1F07, ++IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_eta, 0x1F27, ++IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_iota, 0x1F37, ++IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_upsilon, 0x1F57, ++IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_omega, 0x1F67, ++IBUS_asciitilde, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F0E, ++IBUS_asciitilde, IBUS_parenright, IBUS_Greek_ETA, 0x1F2E, ++IBUS_asciitilde, IBUS_parenright, IBUS_Greek_IOTA, 0x1F3E, ++IBUS_asciitilde, IBUS_parenright, IBUS_Greek_OMEGA, 0x1F6E, ++IBUS_asciitilde, IBUS_parenright, IBUS_Greek_alpha, 0x1F06, ++IBUS_asciitilde, IBUS_parenright, IBUS_Greek_eta, 0x1F26, ++IBUS_asciitilde, IBUS_parenright, IBUS_Greek_iota, 0x1F36, ++IBUS_asciitilde, IBUS_parenright, IBUS_Greek_upsilon, 0x1F56, ++IBUS_asciitilde, IBUS_parenright, IBUS_Greek_omega, 0x1F66, ++IBUS_asciitilde, IBUS_plus, IBUS_O, 0x1EE0, ++IBUS_asciitilde, IBUS_plus, IBUS_U, 0x1EEE, ++IBUS_asciitilde, IBUS_plus, IBUS_o, 0x1EE1, ++IBUS_asciitilde, IBUS_plus, IBUS_u, 0x1EEF, ++IBUS_asciitilde, IBUS_asciicircum, IBUS_A, 0x1EAA, ++IBUS_asciitilde, IBUS_asciicircum, IBUS_E, 0x1EC4, ++IBUS_asciitilde, IBUS_asciicircum, IBUS_O, 0x1ED6, ++IBUS_asciitilde, IBUS_asciicircum, IBUS_a, 0x1EAB, ++IBUS_asciitilde, IBUS_asciicircum, IBUS_e, 0x1EC5, ++IBUS_asciitilde, IBUS_asciicircum, IBUS_o, 0x1ED7, ++IBUS_asciitilde, IBUS_b, IBUS_A, 0x1EB4, ++IBUS_asciitilde, IBUS_b, IBUS_a, 0x1EB5, ++IBUS_asciitilde, IBUS_dead_circumflex, IBUS_A, 0x1EAA, ++IBUS_asciitilde, IBUS_dead_circumflex, IBUS_E, 0x1EC4, ++IBUS_asciitilde, IBUS_dead_circumflex, IBUS_O, 0x1ED6, ++IBUS_asciitilde, IBUS_dead_circumflex, IBUS_a, 0x1EAB, ++IBUS_asciitilde, IBUS_dead_circumflex, IBUS_e, 0x1EC5, ++IBUS_asciitilde, IBUS_dead_circumflex, IBUS_o, 0x1ED7, ++IBUS_asciitilde, IBUS_dead_breve, IBUS_A, 0x1EB4, ++IBUS_asciitilde, IBUS_dead_breve, IBUS_a, 0x1EB5, ++IBUS_asciitilde, IBUS_dead_diaeresis, IBUS_Greek_iota, 0x1FD7, ++IBUS_asciitilde, IBUS_dead_diaeresis, IBUS_Greek_upsilon, 0x1FE7, ++IBUS_asciitilde, IBUS_dead_horn, IBUS_O, 0x1EE0, ++IBUS_asciitilde, IBUS_dead_horn, IBUS_U, 0x1EEE, ++IBUS_asciitilde, IBUS_dead_horn, IBUS_o, 0x1EE1, ++IBUS_asciitilde, IBUS_dead_horn, IBUS_u, 0x1EEF, ++IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F0E, ++IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F2E, ++IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_IOTA, 0x1F3E, ++IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1F6E, ++IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F06, ++IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_eta, 0x1F26, ++IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_iota, 0x1F36, ++IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_upsilon, 0x1F56, ++IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_omega, 0x1F66, ++IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F0F, ++IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F2F, ++IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_IOTA, 0x1F3F, ++IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_UPSILON, 0x1F5F, ++IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1F6F, ++IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F07, ++IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F27, ++IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_iota, 0x1F37, ++IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_upsilon, 0x1F57, ++IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_omega, 0x1F67, ++IBUS_macron, IBUS_exclam, IBUS_L, 0x1E38, ++IBUS_macron, IBUS_exclam, IBUS_R, 0x1E5C, ++IBUS_macron, IBUS_exclam, IBUS_l, 0x1E39, ++IBUS_macron, IBUS_exclam, IBUS_r, 0x1E5D, ++IBUS_macron, IBUS_quotedbl, IBUS_A, 0x01DE, ++IBUS_macron, IBUS_quotedbl, IBUS_O, 0x022A, ++IBUS_macron, IBUS_quotedbl, IBUS_U, 0x01D5, ++IBUS_macron, IBUS_quotedbl, IBUS_a, 0x01DF, ++IBUS_macron, IBUS_quotedbl, IBUS_o, 0x022B, ++IBUS_macron, IBUS_quotedbl, IBUS_u, 0x01D6, ++IBUS_macron, IBUS_period, IBUS_A, 0x01E0, ++IBUS_macron, IBUS_period, IBUS_O, 0x0230, ++IBUS_macron, IBUS_period, IBUS_a, 0x01E1, ++IBUS_macron, IBUS_period, IBUS_o, 0x0231, ++IBUS_macron, IBUS_semicolon, IBUS_O, 0x01EC, ++IBUS_macron, IBUS_semicolon, IBUS_o, 0x01ED, ++IBUS_macron, IBUS_asciitilde, IBUS_O, 0x022C, ++IBUS_macron, IBUS_asciitilde, IBUS_o, 0x022D, ++IBUS_macron, IBUS_dead_tilde, IBUS_O, 0x022C, ++IBUS_macron, IBUS_dead_tilde, IBUS_o, 0x022D, ++IBUS_macron, IBUS_dead_abovedot, IBUS_A, 0x01E0, ++IBUS_macron, IBUS_dead_abovedot, IBUS_O, 0x0230, ++IBUS_macron, IBUS_dead_abovedot, IBUS_a, 0x01E1, ++IBUS_macron, IBUS_dead_abovedot, IBUS_o, 0x0231, ++IBUS_macron, IBUS_dead_diaeresis, IBUS_A, 0x01DE, ++IBUS_macron, IBUS_dead_diaeresis, IBUS_O, 0x022A, ++IBUS_macron, IBUS_dead_diaeresis, IBUS_U, 0x01D5, ++IBUS_macron, IBUS_dead_diaeresis, IBUS_a, 0x01DF, ++IBUS_macron, IBUS_dead_diaeresis, IBUS_o, 0x022B, ++IBUS_macron, IBUS_dead_diaeresis, IBUS_u, 0x01D6, ++IBUS_macron, IBUS_dead_ogonek, IBUS_O, 0x01EC, ++IBUS_macron, IBUS_dead_ogonek, IBUS_o, 0x01ED, ++IBUS_macron, IBUS_dead_belowdot, IBUS_L, 0x1E38, ++IBUS_macron, IBUS_dead_belowdot, IBUS_R, 0x1E5C, ++IBUS_macron, IBUS_dead_belowdot, IBUS_l, 0x1E39, ++IBUS_macron, IBUS_dead_belowdot, IBUS_r, 0x1E5D, ++IBUS_acute, IBUS_quotedbl, IBUS_I, 0x1E2E, ++IBUS_acute, IBUS_quotedbl, IBUS_U, 0x01D7, ++IBUS_acute, IBUS_quotedbl, IBUS_i, 0x1E2F, ++IBUS_acute, IBUS_quotedbl, IBUS_u, 0x01D8, ++IBUS_acute, IBUS_quotedbl, IBUS_Greek_iota, 0x0390, ++IBUS_acute, IBUS_quotedbl, IBUS_Greek_upsilon, 0x03B0, ++IBUS_acute, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F0D, ++IBUS_acute, IBUS_parenleft, IBUS_Greek_EPSILON, 0x1F1D, ++IBUS_acute, IBUS_parenleft, IBUS_Greek_ETA, 0x1F2D, ++IBUS_acute, IBUS_parenleft, IBUS_Greek_IOTA, 0x1F3D, ++IBUS_acute, IBUS_parenleft, IBUS_Greek_OMICRON, 0x1F4D, ++IBUS_acute, IBUS_parenleft, IBUS_Greek_UPSILON, 0x1F5D, ++IBUS_acute, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1F6D, ++IBUS_acute, IBUS_parenleft, IBUS_Greek_alpha, 0x1F05, ++IBUS_acute, IBUS_parenleft, IBUS_Greek_epsilon, 0x1F15, ++IBUS_acute, IBUS_parenleft, IBUS_Greek_eta, 0x1F25, ++IBUS_acute, IBUS_parenleft, IBUS_Greek_iota, 0x1F35, ++IBUS_acute, IBUS_parenleft, IBUS_Greek_omicron, 0x1F45, ++IBUS_acute, IBUS_parenleft, IBUS_Greek_upsilon, 0x1F55, ++IBUS_acute, IBUS_parenleft, IBUS_Greek_omega, 0x1F65, ++IBUS_acute, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F0C, ++IBUS_acute, IBUS_parenright, IBUS_Greek_EPSILON, 0x1F1C, ++IBUS_acute, IBUS_parenright, IBUS_Greek_ETA, 0x1F2C, ++IBUS_acute, IBUS_parenright, IBUS_Greek_IOTA, 0x1F3C, ++IBUS_acute, IBUS_parenright, IBUS_Greek_OMICRON, 0x1F4C, ++IBUS_acute, IBUS_parenright, IBUS_Greek_OMEGA, 0x1F6C, ++IBUS_acute, IBUS_parenright, IBUS_Greek_alpha, 0x1F04, ++IBUS_acute, IBUS_parenright, IBUS_Greek_epsilon, 0x1F14, ++IBUS_acute, IBUS_parenright, IBUS_Greek_eta, 0x1F24, ++IBUS_acute, IBUS_parenright, IBUS_Greek_iota, 0x1F34, ++IBUS_acute, IBUS_parenright, IBUS_Greek_omicron, 0x1F44, ++IBUS_acute, IBUS_parenright, IBUS_Greek_upsilon, 0x1F54, ++IBUS_acute, IBUS_parenright, IBUS_Greek_omega, 0x1F64, ++IBUS_acute, IBUS_plus, IBUS_O, 0x1EDA, ++IBUS_acute, IBUS_plus, IBUS_U, 0x1EE8, ++IBUS_acute, IBUS_plus, IBUS_o, 0x1EDB, ++IBUS_acute, IBUS_plus, IBUS_u, 0x1EE9, ++IBUS_acute, IBUS_comma, IBUS_C, 0x1E08, ++IBUS_acute, IBUS_comma, IBUS_c, 0x1E09, ++IBUS_acute, IBUS_slash, IBUS_O, 0x01FE, ++IBUS_acute, IBUS_slash, IBUS_o, 0x01FF, ++IBUS_acute, IBUS_asciicircum, IBUS_A, 0x1EA4, ++IBUS_acute, IBUS_asciicircum, IBUS_E, 0x1EBE, ++IBUS_acute, IBUS_asciicircum, IBUS_O, 0x1ED0, ++IBUS_acute, IBUS_asciicircum, IBUS_a, 0x1EA5, ++IBUS_acute, IBUS_asciicircum, IBUS_e, 0x1EBF, ++IBUS_acute, IBUS_asciicircum, IBUS_o, 0x1ED1, ++IBUS_acute, IBUS_underscore, IBUS_E, 0x1E16, ++IBUS_acute, IBUS_underscore, IBUS_O, 0x1E52, ++IBUS_acute, IBUS_underscore, IBUS_e, 0x1E17, ++IBUS_acute, IBUS_underscore, IBUS_o, 0x1E53, ++IBUS_acute, IBUS_b, IBUS_A, 0x1EAE, ++IBUS_acute, IBUS_b, IBUS_a, 0x1EAF, ++IBUS_acute, IBUS_asciitilde, IBUS_O, 0x1E4C, ++IBUS_acute, IBUS_asciitilde, IBUS_U, 0x1E78, ++IBUS_acute, IBUS_asciitilde, IBUS_o, 0x1E4D, ++IBUS_acute, IBUS_asciitilde, IBUS_u, 0x1E79, ++IBUS_acute, IBUS_macron, IBUS_E, 0x1E16, ++IBUS_acute, IBUS_macron, IBUS_O, 0x1E52, ++IBUS_acute, IBUS_macron, IBUS_e, 0x1E17, ++IBUS_acute, IBUS_macron, IBUS_o, 0x1E53, ++IBUS_acute, IBUS_cedilla, IBUS_C, 0x1E08, ++IBUS_acute, IBUS_cedilla, IBUS_c, 0x1E09, ++IBUS_acute, IBUS_dead_circumflex, IBUS_A, 0x1EA4, ++IBUS_acute, IBUS_dead_circumflex, IBUS_E, 0x1EBE, ++IBUS_acute, IBUS_dead_circumflex, IBUS_O, 0x1ED0, ++IBUS_acute, IBUS_dead_circumflex, IBUS_a, 0x1EA5, ++IBUS_acute, IBUS_dead_circumflex, IBUS_e, 0x1EBF, ++IBUS_acute, IBUS_dead_circumflex, IBUS_o, 0x1ED1, ++IBUS_acute, IBUS_dead_tilde, IBUS_O, 0x1E4C, ++IBUS_acute, IBUS_dead_tilde, IBUS_U, 0x1E78, ++IBUS_acute, IBUS_dead_tilde, IBUS_o, 0x1E4D, ++IBUS_acute, IBUS_dead_tilde, IBUS_u, 0x1E79, ++IBUS_acute, IBUS_dead_macron, IBUS_E, 0x1E16, ++IBUS_acute, IBUS_dead_macron, IBUS_O, 0x1E52, ++IBUS_acute, IBUS_dead_macron, IBUS_e, 0x1E17, ++IBUS_acute, IBUS_dead_macron, IBUS_o, 0x1E53, ++IBUS_acute, IBUS_dead_breve, IBUS_A, 0x1EAE, ++IBUS_acute, IBUS_dead_breve, IBUS_a, 0x1EAF, ++IBUS_acute, IBUS_dead_diaeresis, IBUS_I, 0x1E2E, ++IBUS_acute, IBUS_dead_diaeresis, IBUS_U, 0x01D7, ++IBUS_acute, IBUS_dead_diaeresis, IBUS_i, 0x1E2F, ++IBUS_acute, IBUS_dead_diaeresis, IBUS_u, 0x01D8, ++IBUS_acute, IBUS_dead_diaeresis, IBUS_Greek_iota, 0x0390, ++IBUS_acute, IBUS_dead_diaeresis, IBUS_Greek_upsilon, 0x03B0, ++IBUS_acute, IBUS_dead_abovering, IBUS_A, 0x01FA, ++IBUS_acute, IBUS_dead_abovering, IBUS_a, 0x01FB, ++IBUS_acute, IBUS_dead_cedilla, IBUS_C, 0x1E08, ++IBUS_acute, IBUS_dead_cedilla, IBUS_c, 0x1E09, ++IBUS_acute, IBUS_dead_horn, IBUS_O, 0x1EDA, ++IBUS_acute, IBUS_dead_horn, IBUS_U, 0x1EE8, ++IBUS_acute, IBUS_dead_horn, IBUS_o, 0x1EDB, ++IBUS_acute, IBUS_dead_horn, IBUS_u, 0x1EE9, ++IBUS_acute, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F0C, ++IBUS_acute, IBUS_dead_psili, IBUS_Greek_EPSILON, 0x1F1C, ++IBUS_acute, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F2C, ++IBUS_acute, IBUS_dead_psili, IBUS_Greek_IOTA, 0x1F3C, ++IBUS_acute, IBUS_dead_psili, IBUS_Greek_OMICRON, 0x1F4C, ++IBUS_acute, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1F6C, ++IBUS_acute, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F04, ++IBUS_acute, IBUS_dead_psili, IBUS_Greek_epsilon, 0x1F14, ++IBUS_acute, IBUS_dead_psili, IBUS_Greek_eta, 0x1F24, ++IBUS_acute, IBUS_dead_psili, IBUS_Greek_iota, 0x1F34, ++IBUS_acute, IBUS_dead_psili, IBUS_Greek_omicron, 0x1F44, ++IBUS_acute, IBUS_dead_psili, IBUS_Greek_upsilon, 0x1F54, ++IBUS_acute, IBUS_dead_psili, IBUS_Greek_omega, 0x1F64, ++IBUS_acute, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F0D, ++IBUS_acute, IBUS_dead_dasia, IBUS_Greek_EPSILON, 0x1F1D, ++IBUS_acute, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F2D, ++IBUS_acute, IBUS_dead_dasia, IBUS_Greek_IOTA, 0x1F3D, ++IBUS_acute, IBUS_dead_dasia, IBUS_Greek_OMICRON, 0x1F4D, ++IBUS_acute, IBUS_dead_dasia, IBUS_Greek_UPSILON, 0x1F5D, ++IBUS_acute, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1F6D, ++IBUS_acute, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F05, ++IBUS_acute, IBUS_dead_dasia, IBUS_Greek_epsilon, 0x1F15, ++IBUS_acute, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F25, ++IBUS_acute, IBUS_dead_dasia, IBUS_Greek_iota, 0x1F35, ++IBUS_acute, IBUS_dead_dasia, IBUS_Greek_omicron, 0x1F45, ++IBUS_acute, IBUS_dead_dasia, IBUS_Greek_upsilon, 0x1F55, ++IBUS_acute, IBUS_dead_dasia, IBUS_Greek_omega, 0x1F65, ++IBUS_acute, IBUS_KP_Divide, IBUS_O, 0x01FE, ++IBUS_acute, IBUS_KP_Divide, IBUS_o, 0x01FF, ++0x05C1, 0x05BC, IBUS_hebrew_shin, 0xFB2C, ++0x05C2, 0x05BC, IBUS_hebrew_shin, 0xFB2D, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_Greek_alpha, 0x1FB4, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_Greek_eta, 0x1FC4, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_Greek_omega, 0x1FF4, ++IBUS_Greek_iota, IBUS_apostrophe, 0x1F00, 0x1F84, ++IBUS_Greek_iota, IBUS_apostrophe, 0x1F01, 0x1F85, ++IBUS_Greek_iota, IBUS_apostrophe, 0x1F08, 0x1F8C, ++IBUS_Greek_iota, IBUS_apostrophe, 0x1F09, 0x1F8D, ++IBUS_Greek_iota, IBUS_apostrophe, 0x1F20, 0x1F94, ++IBUS_Greek_iota, IBUS_apostrophe, 0x1F21, 0x1F95, ++IBUS_Greek_iota, IBUS_apostrophe, 0x1F28, 0x1F9C, ++IBUS_Greek_iota, IBUS_apostrophe, 0x1F29, 0x1F9D, ++IBUS_Greek_iota, IBUS_apostrophe, 0x1F60, 0x1FA4, ++IBUS_Greek_iota, IBUS_apostrophe, 0x1F61, 0x1FA5, ++IBUS_Greek_iota, IBUS_apostrophe, 0x1F68, 0x1FAC, ++IBUS_Greek_iota, IBUS_apostrophe, 0x1F69, 0x1FAD, ++IBUS_Greek_iota, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F89, ++IBUS_Greek_iota, IBUS_parenleft, IBUS_Greek_ETA, 0x1F99, ++IBUS_Greek_iota, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FA9, ++IBUS_Greek_iota, IBUS_parenleft, IBUS_Greek_alpha, 0x1F81, ++IBUS_Greek_iota, IBUS_parenleft, IBUS_Greek_eta, 0x1F91, ++IBUS_Greek_iota, IBUS_parenleft, IBUS_Greek_omega, 0x1FA1, ++IBUS_Greek_iota, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F88, ++IBUS_Greek_iota, IBUS_parenright, IBUS_Greek_ETA, 0x1F98, ++IBUS_Greek_iota, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FA8, ++IBUS_Greek_iota, IBUS_parenright, IBUS_Greek_alpha, 0x1F80, ++IBUS_Greek_iota, IBUS_parenright, IBUS_Greek_eta, 0x1F90, ++IBUS_Greek_iota, IBUS_parenright, IBUS_Greek_omega, 0x1FA0, ++IBUS_Greek_iota, IBUS_grave, IBUS_Greek_alpha, 0x1FB2, ++IBUS_Greek_iota, IBUS_grave, IBUS_Greek_eta, 0x1FC2, ++IBUS_Greek_iota, IBUS_grave, IBUS_Greek_omega, 0x1FF2, ++IBUS_Greek_iota, IBUS_grave, 0x1F00, 0x1F82, ++IBUS_Greek_iota, IBUS_grave, 0x1F01, 0x1F83, ++IBUS_Greek_iota, IBUS_grave, 0x1F08, 0x1F8A, ++IBUS_Greek_iota, IBUS_grave, 0x1F09, 0x1F8B, ++IBUS_Greek_iota, IBUS_grave, 0x1F20, 0x1F92, ++IBUS_Greek_iota, IBUS_grave, 0x1F21, 0x1F93, ++IBUS_Greek_iota, IBUS_grave, 0x1F28, 0x1F9A, ++IBUS_Greek_iota, IBUS_grave, 0x1F29, 0x1F9B, ++IBUS_Greek_iota, IBUS_grave, 0x1F60, 0x1FA2, ++IBUS_Greek_iota, IBUS_grave, 0x1F61, 0x1FA3, ++IBUS_Greek_iota, IBUS_grave, 0x1F68, 0x1FAA, ++IBUS_Greek_iota, IBUS_grave, 0x1F69, 0x1FAB, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_Greek_alpha, 0x1FB7, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_Greek_eta, 0x1FC7, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_Greek_omega, 0x1FF7, ++IBUS_Greek_iota, IBUS_asciitilde, 0x1F00, 0x1F86, ++IBUS_Greek_iota, IBUS_asciitilde, 0x1F01, 0x1F87, ++IBUS_Greek_iota, IBUS_asciitilde, 0x1F08, 0x1F8E, ++IBUS_Greek_iota, IBUS_asciitilde, 0x1F09, 0x1F8F, ++IBUS_Greek_iota, IBUS_asciitilde, 0x1F20, 0x1F96, ++IBUS_Greek_iota, IBUS_asciitilde, 0x1F21, 0x1F97, ++IBUS_Greek_iota, IBUS_asciitilde, 0x1F28, 0x1F9E, ++IBUS_Greek_iota, IBUS_asciitilde, 0x1F29, 0x1F9F, ++IBUS_Greek_iota, IBUS_asciitilde, 0x1F60, 0x1FA6, ++IBUS_Greek_iota, IBUS_asciitilde, 0x1F61, 0x1FA7, ++IBUS_Greek_iota, IBUS_asciitilde, 0x1F68, 0x1FAE, ++IBUS_Greek_iota, IBUS_asciitilde, 0x1F69, 0x1FAF, ++IBUS_Greek_iota, IBUS_acute, IBUS_Greek_alpha, 0x1FB4, ++IBUS_Greek_iota, IBUS_acute, IBUS_Greek_eta, 0x1FC4, ++IBUS_Greek_iota, IBUS_acute, IBUS_Greek_omega, 0x1FF4, ++IBUS_Greek_iota, IBUS_acute, 0x1F00, 0x1F84, ++IBUS_Greek_iota, IBUS_acute, 0x1F01, 0x1F85, ++IBUS_Greek_iota, IBUS_acute, 0x1F08, 0x1F8C, ++IBUS_Greek_iota, IBUS_acute, 0x1F09, 0x1F8D, ++IBUS_Greek_iota, IBUS_acute, 0x1F20, 0x1F94, ++IBUS_Greek_iota, IBUS_acute, 0x1F21, 0x1F95, ++IBUS_Greek_iota, IBUS_acute, 0x1F28, 0x1F9C, ++IBUS_Greek_iota, IBUS_acute, 0x1F29, 0x1F9D, ++IBUS_Greek_iota, IBUS_acute, 0x1F60, 0x1FA4, ++IBUS_Greek_iota, IBUS_acute, 0x1F61, 0x1FA5, ++IBUS_Greek_iota, IBUS_acute, 0x1F68, 0x1FAC, ++IBUS_Greek_iota, IBUS_acute, 0x1F69, 0x1FAD, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_Greek_alpha, 0x1FB2, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_Greek_eta, 0x1FC2, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_Greek_omega, 0x1FF2, ++IBUS_Greek_iota, IBUS_dead_grave, 0x1F00, 0x1F82, ++IBUS_Greek_iota, IBUS_dead_grave, 0x1F01, 0x1F83, ++IBUS_Greek_iota, IBUS_dead_grave, 0x1F08, 0x1F8A, ++IBUS_Greek_iota, IBUS_dead_grave, 0x1F09, 0x1F8B, ++IBUS_Greek_iota, IBUS_dead_grave, 0x1F20, 0x1F92, ++IBUS_Greek_iota, IBUS_dead_grave, 0x1F21, 0x1F93, ++IBUS_Greek_iota, IBUS_dead_grave, 0x1F28, 0x1F9A, ++IBUS_Greek_iota, IBUS_dead_grave, 0x1F29, 0x1F9B, ++IBUS_Greek_iota, IBUS_dead_grave, 0x1F60, 0x1FA2, ++IBUS_Greek_iota, IBUS_dead_grave, 0x1F61, 0x1FA3, ++IBUS_Greek_iota, IBUS_dead_grave, 0x1F68, 0x1FAA, ++IBUS_Greek_iota, IBUS_dead_grave, 0x1F69, 0x1FAB, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_Greek_alpha, 0x1FB4, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_Greek_eta, 0x1FC4, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_Greek_omega, 0x1FF4, ++IBUS_Greek_iota, IBUS_dead_acute, 0x1F00, 0x1F84, ++IBUS_Greek_iota, IBUS_dead_acute, 0x1F01, 0x1F85, ++IBUS_Greek_iota, IBUS_dead_acute, 0x1F08, 0x1F8C, ++IBUS_Greek_iota, IBUS_dead_acute, 0x1F09, 0x1F8D, ++IBUS_Greek_iota, IBUS_dead_acute, 0x1F20, 0x1F94, ++IBUS_Greek_iota, IBUS_dead_acute, 0x1F21, 0x1F95, ++IBUS_Greek_iota, IBUS_dead_acute, 0x1F28, 0x1F9C, ++IBUS_Greek_iota, IBUS_dead_acute, 0x1F29, 0x1F9D, ++IBUS_Greek_iota, IBUS_dead_acute, 0x1F60, 0x1FA4, ++IBUS_Greek_iota, IBUS_dead_acute, 0x1F61, 0x1FA5, ++IBUS_Greek_iota, IBUS_dead_acute, 0x1F68, 0x1FAC, ++IBUS_Greek_iota, IBUS_dead_acute, 0x1F69, 0x1FAD, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_Greek_alpha, 0x1FB7, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_Greek_eta, 0x1FC7, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_Greek_omega, 0x1FF7, ++IBUS_Greek_iota, IBUS_dead_tilde, 0x1F00, 0x1F86, ++IBUS_Greek_iota, IBUS_dead_tilde, 0x1F01, 0x1F87, ++IBUS_Greek_iota, IBUS_dead_tilde, 0x1F08, 0x1F8E, ++IBUS_Greek_iota, IBUS_dead_tilde, 0x1F09, 0x1F8F, ++IBUS_Greek_iota, IBUS_dead_tilde, 0x1F20, 0x1F96, ++IBUS_Greek_iota, IBUS_dead_tilde, 0x1F21, 0x1F97, ++IBUS_Greek_iota, IBUS_dead_tilde, 0x1F28, 0x1F9E, ++IBUS_Greek_iota, IBUS_dead_tilde, 0x1F29, 0x1F9F, ++IBUS_Greek_iota, IBUS_dead_tilde, 0x1F60, 0x1FA6, ++IBUS_Greek_iota, IBUS_dead_tilde, 0x1F61, 0x1FA7, ++IBUS_Greek_iota, IBUS_dead_tilde, 0x1F68, 0x1FAE, ++IBUS_Greek_iota, IBUS_dead_tilde, 0x1F69, 0x1FAF, ++IBUS_Greek_iota, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F88, ++IBUS_Greek_iota, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F98, ++IBUS_Greek_iota, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FA8, ++IBUS_Greek_iota, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F80, ++IBUS_Greek_iota, IBUS_dead_psili, IBUS_Greek_eta, 0x1F90, ++IBUS_Greek_iota, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA0, ++IBUS_Greek_iota, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F89, ++IBUS_Greek_iota, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F99, ++IBUS_Greek_iota, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FA9, ++IBUS_Greek_iota, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F81, ++IBUS_Greek_iota, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F91, ++IBUS_Greek_iota, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA1, ++IBUS_parenleft, IBUS_1, IBUS_0, IBUS_parenright, 0x2469, ++IBUS_parenleft, IBUS_1, IBUS_1, IBUS_parenright, 0x246A, ++IBUS_parenleft, IBUS_1, IBUS_2, IBUS_parenright, 0x246B, ++IBUS_parenleft, IBUS_1, IBUS_3, IBUS_parenright, 0x246C, ++IBUS_parenleft, IBUS_1, IBUS_4, IBUS_parenright, 0x246D, ++IBUS_parenleft, IBUS_1, IBUS_5, IBUS_parenright, 0x246E, ++IBUS_parenleft, IBUS_1, IBUS_6, IBUS_parenright, 0x246F, ++IBUS_parenleft, IBUS_1, IBUS_7, IBUS_parenright, 0x2470, ++IBUS_parenleft, IBUS_1, IBUS_8, IBUS_parenright, 0x2471, ++IBUS_parenleft, IBUS_1, IBUS_9, IBUS_parenright, 0x2472, ++IBUS_parenleft, IBUS_1, IBUS_KP_Space, IBUS_parenright, 0x246B, ++IBUS_parenleft, IBUS_1, IBUS_KP_0, IBUS_parenright, 0x2469, ++IBUS_parenleft, IBUS_1, IBUS_KP_1, IBUS_parenright, 0x246A, ++IBUS_parenleft, IBUS_1, IBUS_KP_2, IBUS_parenright, 0x246B, ++IBUS_parenleft, IBUS_1, IBUS_KP_3, IBUS_parenright, 0x246C, ++IBUS_parenleft, IBUS_1, IBUS_KP_4, IBUS_parenright, 0x246D, ++IBUS_parenleft, IBUS_1, IBUS_KP_5, IBUS_parenright, 0x246E, ++IBUS_parenleft, IBUS_1, IBUS_KP_6, IBUS_parenright, 0x246F, ++IBUS_parenleft, IBUS_1, IBUS_KP_7, IBUS_parenright, 0x2470, ++IBUS_parenleft, IBUS_1, IBUS_KP_8, IBUS_parenright, 0x2471, ++IBUS_parenleft, IBUS_1, IBUS_KP_9, IBUS_parenright, 0x2472, ++IBUS_parenleft, IBUS_2, IBUS_0, IBUS_parenright, 0x2473, ++IBUS_parenleft, IBUS_2, IBUS_1, IBUS_parenright, 0x3251, ++IBUS_parenleft, IBUS_2, IBUS_2, IBUS_parenright, 0x3252, ++IBUS_parenleft, IBUS_2, IBUS_3, IBUS_parenright, 0x3253, ++IBUS_parenleft, IBUS_2, IBUS_4, IBUS_parenright, 0x3254, ++IBUS_parenleft, IBUS_2, IBUS_5, IBUS_parenright, 0x3255, ++IBUS_parenleft, IBUS_2, IBUS_6, IBUS_parenright, 0x3256, ++IBUS_parenleft, IBUS_2, IBUS_7, IBUS_parenright, 0x3257, ++IBUS_parenleft, IBUS_2, IBUS_8, IBUS_parenright, 0x3258, ++IBUS_parenleft, IBUS_2, IBUS_9, IBUS_parenright, 0x3259, ++IBUS_parenleft, IBUS_2, IBUS_KP_Space, IBUS_parenright, 0x3252, ++IBUS_parenleft, IBUS_2, IBUS_KP_0, IBUS_parenright, 0x2473, ++IBUS_parenleft, IBUS_2, IBUS_KP_1, IBUS_parenright, 0x3251, ++IBUS_parenleft, IBUS_2, IBUS_KP_2, IBUS_parenright, 0x3252, ++IBUS_parenleft, IBUS_2, IBUS_KP_3, IBUS_parenright, 0x3253, ++IBUS_parenleft, IBUS_2, IBUS_KP_4, IBUS_parenright, 0x3254, ++IBUS_parenleft, IBUS_2, IBUS_KP_5, IBUS_parenright, 0x3255, ++IBUS_parenleft, IBUS_2, IBUS_KP_6, IBUS_parenright, 0x3256, ++IBUS_parenleft, IBUS_2, IBUS_KP_7, IBUS_parenright, 0x3257, ++IBUS_parenleft, IBUS_2, IBUS_KP_8, IBUS_parenright, 0x3258, ++IBUS_parenleft, IBUS_2, IBUS_KP_9, IBUS_parenright, 0x3259, ++IBUS_parenleft, IBUS_3, IBUS_0, IBUS_parenright, 0x325A, ++IBUS_parenleft, IBUS_3, IBUS_1, IBUS_parenright, 0x325B, ++IBUS_parenleft, IBUS_3, IBUS_2, IBUS_parenright, 0x325C, ++IBUS_parenleft, IBUS_3, IBUS_3, IBUS_parenright, 0x325D, ++IBUS_parenleft, IBUS_3, IBUS_4, IBUS_parenright, 0x325E, ++IBUS_parenleft, IBUS_3, IBUS_5, IBUS_parenright, 0x325F, ++IBUS_parenleft, IBUS_3, IBUS_6, IBUS_parenright, 0x32B1, ++IBUS_parenleft, IBUS_3, IBUS_7, IBUS_parenright, 0x32B2, ++IBUS_parenleft, IBUS_3, IBUS_8, IBUS_parenright, 0x32B3, ++IBUS_parenleft, IBUS_3, IBUS_9, IBUS_parenright, 0x32B4, ++IBUS_parenleft, IBUS_3, IBUS_KP_Space, IBUS_parenright, 0x325C, ++IBUS_parenleft, IBUS_3, IBUS_KP_0, IBUS_parenright, 0x325A, ++IBUS_parenleft, IBUS_3, IBUS_KP_1, IBUS_parenright, 0x325B, ++IBUS_parenleft, IBUS_3, IBUS_KP_2, IBUS_parenright, 0x325C, ++IBUS_parenleft, IBUS_3, IBUS_KP_3, IBUS_parenright, 0x325D, ++IBUS_parenleft, IBUS_3, IBUS_KP_4, IBUS_parenright, 0x325E, ++IBUS_parenleft, IBUS_3, IBUS_KP_5, IBUS_parenright, 0x325F, ++IBUS_parenleft, IBUS_3, IBUS_KP_6, IBUS_parenright, 0x32B1, ++IBUS_parenleft, IBUS_3, IBUS_KP_7, IBUS_parenright, 0x32B2, ++IBUS_parenleft, IBUS_3, IBUS_KP_8, IBUS_parenright, 0x32B3, ++IBUS_parenleft, IBUS_3, IBUS_KP_9, IBUS_parenright, 0x32B4, ++IBUS_parenleft, IBUS_4, IBUS_0, IBUS_parenright, 0x32B5, ++IBUS_parenleft, IBUS_4, IBUS_1, IBUS_parenright, 0x32B6, ++IBUS_parenleft, IBUS_4, IBUS_2, IBUS_parenright, 0x32B7, ++IBUS_parenleft, IBUS_4, IBUS_3, IBUS_parenright, 0x32B8, ++IBUS_parenleft, IBUS_4, IBUS_4, IBUS_parenright, 0x32B9, ++IBUS_parenleft, IBUS_4, IBUS_5, IBUS_parenright, 0x32BA, ++IBUS_parenleft, IBUS_4, IBUS_6, IBUS_parenright, 0x32BB, ++IBUS_parenleft, IBUS_4, IBUS_7, IBUS_parenright, 0x32BC, ++IBUS_parenleft, IBUS_4, IBUS_8, IBUS_parenright, 0x32BD, ++IBUS_parenleft, IBUS_4, IBUS_9, IBUS_parenright, 0x32BE, ++IBUS_parenleft, IBUS_4, IBUS_KP_Space, IBUS_parenright, 0x32B7, ++IBUS_parenleft, IBUS_4, IBUS_KP_0, IBUS_parenright, 0x32B5, ++IBUS_parenleft, IBUS_4, IBUS_KP_1, IBUS_parenright, 0x32B6, ++IBUS_parenleft, IBUS_4, IBUS_KP_2, IBUS_parenright, 0x32B7, ++IBUS_parenleft, IBUS_4, IBUS_KP_3, IBUS_parenright, 0x32B8, ++IBUS_parenleft, IBUS_4, IBUS_KP_4, IBUS_parenright, 0x32B9, ++IBUS_parenleft, IBUS_4, IBUS_KP_5, IBUS_parenright, 0x32BA, ++IBUS_parenleft, IBUS_4, IBUS_KP_6, IBUS_parenright, 0x32BB, ++IBUS_parenleft, IBUS_4, IBUS_KP_7, IBUS_parenright, 0x32BC, ++IBUS_parenleft, IBUS_4, IBUS_KP_8, IBUS_parenright, 0x32BD, ++IBUS_parenleft, IBUS_4, IBUS_KP_9, IBUS_parenright, 0x32BE, ++IBUS_parenleft, IBUS_5, IBUS_KP_0, IBUS_parenright, 0x32BF, ++IBUS_parenleft, 0x1100, 0x1161, IBUS_parenright, 0x326E, ++IBUS_parenleft, 0x1102, 0x1161, IBUS_parenright, 0x326F, ++IBUS_parenleft, 0x1103, 0x1161, IBUS_parenright, 0x3270, ++IBUS_parenleft, 0x1105, 0x1161, IBUS_parenright, 0x3271, ++IBUS_parenleft, 0x1106, 0x1161, IBUS_parenright, 0x3272, ++IBUS_parenleft, 0x1107, 0x1161, IBUS_parenright, 0x3273, ++IBUS_parenleft, 0x1109, 0x1161, IBUS_parenright, 0x3274, ++IBUS_parenleft, 0x110B, 0x1161, IBUS_parenright, 0x3275, ++IBUS_parenleft, 0x110C, 0x1161, IBUS_parenright, 0x3276, ++IBUS_parenleft, 0x110E, 0x1161, IBUS_parenright, 0x3277, ++IBUS_parenleft, 0x110F, 0x1161, IBUS_parenright, 0x3278, ++IBUS_parenleft, 0x1110, 0x1161, IBUS_parenright, 0x3279, ++IBUS_parenleft, 0x1111, 0x1161, IBUS_parenright, 0x327A, ++IBUS_parenleft, 0x1112, 0x1161, IBUS_parenright, 0x327B, ++IBUS_parenleft, IBUS_KP_Space, IBUS_0, IBUS_parenright, 0x2473, ++IBUS_parenleft, IBUS_KP_Space, IBUS_1, IBUS_parenright, 0x3251, ++IBUS_parenleft, IBUS_KP_Space, IBUS_2, IBUS_parenright, 0x3252, ++IBUS_parenleft, IBUS_KP_Space, IBUS_3, IBUS_parenright, 0x3253, ++IBUS_parenleft, IBUS_KP_Space, IBUS_4, IBUS_parenright, 0x3254, ++IBUS_parenleft, IBUS_KP_Space, IBUS_5, IBUS_parenright, 0x3255, ++IBUS_parenleft, IBUS_KP_Space, IBUS_6, IBUS_parenright, 0x3256, ++IBUS_parenleft, IBUS_KP_Space, IBUS_7, IBUS_parenright, 0x3257, ++IBUS_parenleft, IBUS_KP_Space, IBUS_8, IBUS_parenright, 0x3258, ++IBUS_parenleft, IBUS_KP_Space, IBUS_9, IBUS_parenright, 0x3259, ++IBUS_parenleft, IBUS_KP_Space, IBUS_KP_Space, IBUS_parenright, 0x3252, ++IBUS_parenleft, IBUS_KP_Space, IBUS_KP_0, IBUS_parenright, 0x2473, ++IBUS_parenleft, IBUS_KP_Space, IBUS_KP_1, IBUS_parenright, 0x3251, ++IBUS_parenleft, IBUS_KP_Space, IBUS_KP_2, IBUS_parenright, 0x3252, ++IBUS_parenleft, IBUS_KP_Space, IBUS_KP_3, IBUS_parenright, 0x3253, ++IBUS_parenleft, IBUS_KP_Space, IBUS_KP_4, IBUS_parenright, 0x3254, ++IBUS_parenleft, IBUS_KP_Space, IBUS_KP_5, IBUS_parenright, 0x3255, ++IBUS_parenleft, IBUS_KP_Space, IBUS_KP_6, IBUS_parenright, 0x3256, ++IBUS_parenleft, IBUS_KP_Space, IBUS_KP_7, IBUS_parenright, 0x3257, ++IBUS_parenleft, IBUS_KP_Space, IBUS_KP_8, IBUS_parenright, 0x3258, ++IBUS_parenleft, IBUS_KP_Space, IBUS_KP_9, IBUS_parenright, 0x3259, ++IBUS_parenleft, IBUS_KP_1, IBUS_0, IBUS_parenright, 0x2469, ++IBUS_parenleft, IBUS_KP_1, IBUS_1, IBUS_parenright, 0x246A, ++IBUS_parenleft, IBUS_KP_1, IBUS_2, IBUS_parenright, 0x246B, ++IBUS_parenleft, IBUS_KP_1, IBUS_3, IBUS_parenright, 0x246C, ++IBUS_parenleft, IBUS_KP_1, IBUS_4, IBUS_parenright, 0x246D, ++IBUS_parenleft, IBUS_KP_1, IBUS_5, IBUS_parenright, 0x246E, ++IBUS_parenleft, IBUS_KP_1, IBUS_6, IBUS_parenright, 0x246F, ++IBUS_parenleft, IBUS_KP_1, IBUS_7, IBUS_parenright, 0x2470, ++IBUS_parenleft, IBUS_KP_1, IBUS_8, IBUS_parenright, 0x2471, ++IBUS_parenleft, IBUS_KP_1, IBUS_9, IBUS_parenright, 0x2472, ++IBUS_parenleft, IBUS_KP_1, IBUS_KP_Space, IBUS_parenright, 0x246B, ++IBUS_parenleft, IBUS_KP_1, IBUS_KP_0, IBUS_parenright, 0x2469, ++IBUS_parenleft, IBUS_KP_1, IBUS_KP_1, IBUS_parenright, 0x246A, ++IBUS_parenleft, IBUS_KP_1, IBUS_KP_2, IBUS_parenright, 0x246B, ++IBUS_parenleft, IBUS_KP_1, IBUS_KP_3, IBUS_parenright, 0x246C, ++IBUS_parenleft, IBUS_KP_1, IBUS_KP_4, IBUS_parenright, 0x246D, ++IBUS_parenleft, IBUS_KP_1, IBUS_KP_5, IBUS_parenright, 0x246E, ++IBUS_parenleft, IBUS_KP_1, IBUS_KP_6, IBUS_parenright, 0x246F, ++IBUS_parenleft, IBUS_KP_1, IBUS_KP_7, IBUS_parenright, 0x2470, ++IBUS_parenleft, IBUS_KP_1, IBUS_KP_8, IBUS_parenright, 0x2471, ++IBUS_parenleft, IBUS_KP_1, IBUS_KP_9, IBUS_parenright, 0x2472, ++IBUS_parenleft, IBUS_KP_2, IBUS_0, IBUS_parenright, 0x2473, ++IBUS_parenleft, IBUS_KP_2, IBUS_1, IBUS_parenright, 0x3251, ++IBUS_parenleft, IBUS_KP_2, IBUS_2, IBUS_parenright, 0x3252, ++IBUS_parenleft, IBUS_KP_2, IBUS_3, IBUS_parenright, 0x3253, ++IBUS_parenleft, IBUS_KP_2, IBUS_4, IBUS_parenright, 0x3254, ++IBUS_parenleft, IBUS_KP_2, IBUS_5, IBUS_parenright, 0x3255, ++IBUS_parenleft, IBUS_KP_2, IBUS_6, IBUS_parenright, 0x3256, ++IBUS_parenleft, IBUS_KP_2, IBUS_7, IBUS_parenright, 0x3257, ++IBUS_parenleft, IBUS_KP_2, IBUS_8, IBUS_parenright, 0x3258, ++IBUS_parenleft, IBUS_KP_2, IBUS_9, IBUS_parenright, 0x3259, ++IBUS_parenleft, IBUS_KP_2, IBUS_KP_Space, IBUS_parenright, 0x3252, ++IBUS_parenleft, IBUS_KP_2, IBUS_KP_0, IBUS_parenright, 0x2473, ++IBUS_parenleft, IBUS_KP_2, IBUS_KP_1, IBUS_parenright, 0x3251, ++IBUS_parenleft, IBUS_KP_2, IBUS_KP_2, IBUS_parenright, 0x3252, ++IBUS_parenleft, IBUS_KP_2, IBUS_KP_3, IBUS_parenright, 0x3253, ++IBUS_parenleft, IBUS_KP_2, IBUS_KP_4, IBUS_parenright, 0x3254, ++IBUS_parenleft, IBUS_KP_2, IBUS_KP_5, IBUS_parenright, 0x3255, ++IBUS_parenleft, IBUS_KP_2, IBUS_KP_6, IBUS_parenright, 0x3256, ++IBUS_parenleft, IBUS_KP_2, IBUS_KP_7, IBUS_parenright, 0x3257, ++IBUS_parenleft, IBUS_KP_2, IBUS_KP_8, IBUS_parenright, 0x3258, ++IBUS_parenleft, IBUS_KP_2, IBUS_KP_9, IBUS_parenright, 0x3259, ++IBUS_parenleft, IBUS_KP_3, IBUS_0, IBUS_parenright, 0x325A, ++IBUS_parenleft, IBUS_KP_3, IBUS_1, IBUS_parenright, 0x325B, ++IBUS_parenleft, IBUS_KP_3, IBUS_2, IBUS_parenright, 0x325C, ++IBUS_parenleft, IBUS_KP_3, IBUS_3, IBUS_parenright, 0x325D, ++IBUS_parenleft, IBUS_KP_3, IBUS_4, IBUS_parenright, 0x325E, ++IBUS_parenleft, IBUS_KP_3, IBUS_5, IBUS_parenright, 0x325F, ++IBUS_parenleft, IBUS_KP_3, IBUS_6, IBUS_parenright, 0x32B1, ++IBUS_parenleft, IBUS_KP_3, IBUS_7, IBUS_parenright, 0x32B2, ++IBUS_parenleft, IBUS_KP_3, IBUS_8, IBUS_parenright, 0x32B3, ++IBUS_parenleft, IBUS_KP_3, IBUS_9, IBUS_parenright, 0x32B4, ++IBUS_parenleft, IBUS_KP_3, IBUS_KP_Space, IBUS_parenright, 0x325C, ++IBUS_parenleft, IBUS_KP_3, IBUS_KP_0, IBUS_parenright, 0x325A, ++IBUS_parenleft, IBUS_KP_3, IBUS_KP_1, IBUS_parenright, 0x325B, ++IBUS_parenleft, IBUS_KP_3, IBUS_KP_2, IBUS_parenright, 0x325C, ++IBUS_parenleft, IBUS_KP_3, IBUS_KP_3, IBUS_parenright, 0x325D, ++IBUS_parenleft, IBUS_KP_3, IBUS_KP_4, IBUS_parenright, 0x325E, ++IBUS_parenleft, IBUS_KP_3, IBUS_KP_5, IBUS_parenright, 0x325F, ++IBUS_parenleft, IBUS_KP_3, IBUS_KP_6, IBUS_parenright, 0x32B1, ++IBUS_parenleft, IBUS_KP_3, IBUS_KP_7, IBUS_parenright, 0x32B2, ++IBUS_parenleft, IBUS_KP_3, IBUS_KP_8, IBUS_parenright, 0x32B3, ++IBUS_parenleft, IBUS_KP_3, IBUS_KP_9, IBUS_parenright, 0x32B4, ++IBUS_parenleft, IBUS_KP_4, IBUS_0, IBUS_parenright, 0x32B5, ++IBUS_parenleft, IBUS_KP_4, IBUS_1, IBUS_parenright, 0x32B6, ++IBUS_parenleft, IBUS_KP_4, IBUS_2, IBUS_parenright, 0x32B7, ++IBUS_parenleft, IBUS_KP_4, IBUS_3, IBUS_parenright, 0x32B8, ++IBUS_parenleft, IBUS_KP_4, IBUS_4, IBUS_parenright, 0x32B9, ++IBUS_parenleft, IBUS_KP_4, IBUS_5, IBUS_parenright, 0x32BA, ++IBUS_parenleft, IBUS_KP_4, IBUS_6, IBUS_parenright, 0x32BB, ++IBUS_parenleft, IBUS_KP_4, IBUS_7, IBUS_parenright, 0x32BC, ++IBUS_parenleft, IBUS_KP_4, IBUS_8, IBUS_parenright, 0x32BD, ++IBUS_parenleft, IBUS_KP_4, IBUS_9, IBUS_parenright, 0x32BE, ++IBUS_parenleft, IBUS_KP_4, IBUS_KP_Space, IBUS_parenright, 0x32B7, ++IBUS_parenleft, IBUS_KP_4, IBUS_KP_0, IBUS_parenright, 0x32B5, ++IBUS_parenleft, IBUS_KP_4, IBUS_KP_1, IBUS_parenright, 0x32B6, ++IBUS_parenleft, IBUS_KP_4, IBUS_KP_2, IBUS_parenright, 0x32B7, ++IBUS_parenleft, IBUS_KP_4, IBUS_KP_3, IBUS_parenright, 0x32B8, ++IBUS_parenleft, IBUS_KP_4, IBUS_KP_4, IBUS_parenright, 0x32B9, ++IBUS_parenleft, IBUS_KP_4, IBUS_KP_5, IBUS_parenright, 0x32BA, ++IBUS_parenleft, IBUS_KP_4, IBUS_KP_6, IBUS_parenright, 0x32BB, ++IBUS_parenleft, IBUS_KP_4, IBUS_KP_7, IBUS_parenright, 0x32BC, ++IBUS_parenleft, IBUS_KP_4, IBUS_KP_8, IBUS_parenright, 0x32BD, ++IBUS_parenleft, IBUS_KP_4, IBUS_KP_9, IBUS_parenright, 0x32BE, ++IBUS_parenleft, IBUS_KP_5, IBUS_KP_0, IBUS_parenright, 0x32BF, ++IBUS_C, IBUS_C, IBUS_C, IBUS_P, 0x262D, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8D, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9D, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAD, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_alpha, 0x1F85, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_eta, 0x1F95, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenleft, IBUS_Greek_omega, 0x1FA5, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8C, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_ETA, 0x1F9C, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAC, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_alpha, 0x1F84, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_eta, 0x1F94, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_parenright, IBUS_Greek_omega, 0x1FA4, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8C, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9C, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAC, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F84, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_eta, 0x1F94, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA4, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8D, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9D, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAD, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F85, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F95, ++IBUS_Greek_iota, IBUS_apostrophe, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA5, ++IBUS_Greek_iota, IBUS_grave, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8B, ++IBUS_Greek_iota, IBUS_grave, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9B, ++IBUS_Greek_iota, IBUS_grave, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAB, ++IBUS_Greek_iota, IBUS_grave, IBUS_parenleft, IBUS_Greek_alpha, 0x1F83, ++IBUS_Greek_iota, IBUS_grave, IBUS_parenleft, IBUS_Greek_eta, 0x1F93, ++IBUS_Greek_iota, IBUS_grave, IBUS_parenleft, IBUS_Greek_omega, 0x1FA3, ++IBUS_Greek_iota, IBUS_grave, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8A, ++IBUS_Greek_iota, IBUS_grave, IBUS_parenright, IBUS_Greek_ETA, 0x1F9A, ++IBUS_Greek_iota, IBUS_grave, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAA, ++IBUS_Greek_iota, IBUS_grave, IBUS_parenright, IBUS_Greek_alpha, 0x1F82, ++IBUS_Greek_iota, IBUS_grave, IBUS_parenright, IBUS_Greek_eta, 0x1F92, ++IBUS_Greek_iota, IBUS_grave, IBUS_parenright, IBUS_Greek_omega, 0x1FA2, ++IBUS_Greek_iota, IBUS_grave, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8A, ++IBUS_Greek_iota, IBUS_grave, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9A, ++IBUS_Greek_iota, IBUS_grave, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAA, ++IBUS_Greek_iota, IBUS_grave, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F82, ++IBUS_Greek_iota, IBUS_grave, IBUS_dead_psili, IBUS_Greek_eta, 0x1F92, ++IBUS_Greek_iota, IBUS_grave, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA2, ++IBUS_Greek_iota, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8B, ++IBUS_Greek_iota, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9B, ++IBUS_Greek_iota, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAB, ++IBUS_Greek_iota, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F83, ++IBUS_Greek_iota, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F93, ++IBUS_Greek_iota, IBUS_grave, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA3, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8F, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9F, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAF, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_alpha, 0x1F87, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_eta, 0x1F97, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenleft, IBUS_Greek_omega, 0x1FA7, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8E, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_ETA, 0x1F9E, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAE, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_alpha, 0x1F86, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_eta, 0x1F96, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_parenright, IBUS_Greek_omega, 0x1FA6, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8E, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9E, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAE, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F86, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_eta, 0x1F96, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA6, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8F, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9F, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAF, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F87, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F97, ++IBUS_Greek_iota, IBUS_asciitilde, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA7, ++IBUS_Greek_iota, IBUS_acute, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8D, ++IBUS_Greek_iota, IBUS_acute, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9D, ++IBUS_Greek_iota, IBUS_acute, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAD, ++IBUS_Greek_iota, IBUS_acute, IBUS_parenleft, IBUS_Greek_alpha, 0x1F85, ++IBUS_Greek_iota, IBUS_acute, IBUS_parenleft, IBUS_Greek_eta, 0x1F95, ++IBUS_Greek_iota, IBUS_acute, IBUS_parenleft, IBUS_Greek_omega, 0x1FA5, ++IBUS_Greek_iota, IBUS_acute, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8C, ++IBUS_Greek_iota, IBUS_acute, IBUS_parenright, IBUS_Greek_ETA, 0x1F9C, ++IBUS_Greek_iota, IBUS_acute, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAC, ++IBUS_Greek_iota, IBUS_acute, IBUS_parenright, IBUS_Greek_alpha, 0x1F84, ++IBUS_Greek_iota, IBUS_acute, IBUS_parenright, IBUS_Greek_eta, 0x1F94, ++IBUS_Greek_iota, IBUS_acute, IBUS_parenright, IBUS_Greek_omega, 0x1FA4, ++IBUS_Greek_iota, IBUS_acute, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8C, ++IBUS_Greek_iota, IBUS_acute, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9C, ++IBUS_Greek_iota, IBUS_acute, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAC, ++IBUS_Greek_iota, IBUS_acute, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F84, ++IBUS_Greek_iota, IBUS_acute, IBUS_dead_psili, IBUS_Greek_eta, 0x1F94, ++IBUS_Greek_iota, IBUS_acute, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA4, ++IBUS_Greek_iota, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8D, ++IBUS_Greek_iota, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9D, ++IBUS_Greek_iota, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAD, ++IBUS_Greek_iota, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F85, ++IBUS_Greek_iota, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F95, ++IBUS_Greek_iota, IBUS_acute, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA5, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8B, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9B, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAB, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenleft, IBUS_Greek_alpha, 0x1F83, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenleft, IBUS_Greek_eta, 0x1F93, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenleft, IBUS_Greek_omega, 0x1FA3, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8A, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenright, IBUS_Greek_ETA, 0x1F9A, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAA, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenright, IBUS_Greek_alpha, 0x1F82, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenright, IBUS_Greek_eta, 0x1F92, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_parenright, IBUS_Greek_omega, 0x1FA2, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8A, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9A, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAA, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F82, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_eta, 0x1F92, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA2, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8B, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9B, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAB, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F83, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F93, ++IBUS_Greek_iota, IBUS_dead_grave, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA3, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8D, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9D, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAD, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenleft, IBUS_Greek_alpha, 0x1F85, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenleft, IBUS_Greek_eta, 0x1F95, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenleft, IBUS_Greek_omega, 0x1FA5, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8C, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenright, IBUS_Greek_ETA, 0x1F9C, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAC, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenright, IBUS_Greek_alpha, 0x1F84, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenright, IBUS_Greek_eta, 0x1F94, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_parenright, IBUS_Greek_omega, 0x1FA4, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8C, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9C, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAC, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F84, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_eta, 0x1F94, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA4, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8D, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9D, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAD, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F85, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F95, ++IBUS_Greek_iota, IBUS_dead_acute, IBUS_dead_dasia, IBUS_Greek_omega, 0x1FA5, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenleft, IBUS_Greek_ALPHA, 0x1F8F, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenleft, IBUS_Greek_ETA, 0x1F9F, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenleft, IBUS_Greek_OMEGA, 0x1FAF, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenleft, IBUS_Greek_alpha, 0x1F87, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenleft, IBUS_Greek_eta, 0x1F97, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenleft, IBUS_Greek_omega, 0x1FA7, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenright, IBUS_Greek_ALPHA, 0x1F8E, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenright, IBUS_Greek_ETA, 0x1F9E, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenright, IBUS_Greek_OMEGA, 0x1FAE, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenright, IBUS_Greek_alpha, 0x1F86, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenright, IBUS_Greek_eta, 0x1F96, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_parenright, IBUS_Greek_omega, 0x1FA6, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_ALPHA, 0x1F8E, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_ETA, 0x1F9E, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_OMEGA, 0x1FAE, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_alpha, 0x1F86, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_eta, 0x1F96, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_psili, IBUS_Greek_omega, 0x1FA6, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_ALPHA, 0x1F8F, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_ETA, 0x1F9F, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_OMEGA, 0x1FAF, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_alpha, 0x1F87, ++IBUS_Greek_iota, IBUS_dead_tilde, IBUS_dead_dasia, IBUS_Greek_eta, 0x1F97, ++}; ++ ++#endif /* __GTK_IM_CONTEXT_SIMPLE_SEQS_H__ */ ++ diff --git a/xkb/ibus-engine-xkb-main.c b/xkb/ibus-engine-xkb-main.c new file mode 100644 -index 0000000..0fb0f0c +index 0000000..5866b40 --- /dev/null +++ b/xkb/ibus-engine-xkb-main.c -@@ -0,0 +1,413 @@ +@@ -0,0 +1,303 @@ +/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */ +/* vim:set et sts=4: */ +/* bus - The Input Bus @@ -3025,20 +7640,20 @@ index 0000000..0fb0f0c +#endif + +#include ++#include +#include + +#ifdef ENABLE_NLS +#include +#endif + -+#include "ibus-engine-xkb-main.h" +#include "xkbxml.h" ++#include "ibusxkbxml.h" ++#include "ibus-simple-engine.h" + -+#define IBUS_TYPE_XKB_ENGINE (ibus_xkb_engine_get_type ()) + +static IBusBus *bus = NULL; +static IBusFactory *factory = NULL; -+static IBusEngineClass *parent_class = NULL; +static gboolean ibus = FALSE; +static gboolean xml = FALSE; + @@ -3049,99 +7664,6 @@ index 0000000..0fb0f0c + { NULL }, +}; + -+static GObject* -+ibus_xkb_engine_constructor (GType type, -+ guint n_construct_params, -+ GObjectConstructParam *construct_params) -+{ -+ IBusXKBEngine *engine; -+ -+ engine = (IBusXKBEngine *) G_OBJECT_CLASS (parent_class)->constructor (type, -+ n_construct_params, -+ construct_params); -+ -+ return (GObject *) engine; -+} -+ -+static void -+ibus_xkb_engine_destroy (IBusObject *object) -+{ -+ IBUS_OBJECT_CLASS (parent_class)->destroy (object); -+} -+ -+static void -+ibus_xkb_engine_enable (IBusEngine *engine) -+{ -+ parent_class->enable (engine); -+} -+ -+static void -+ibus_xkb_engine_disable (IBusEngine *engine) -+{ -+ parent_class->disable (engine); -+} -+ -+static void -+ibus_xkb_engine_focus_in (IBusEngine *engine) -+{ -+ parent_class->focus_in (engine); -+} -+ -+static void -+ibus_xkb_engine_focus_out (IBusEngine *engine) -+{ -+ parent_class->focus_out (engine); -+} -+ -+static void -+ibus_xkb_engine_class_init (IBusXKBEngineClass *klass) -+{ -+ GObjectClass *object_class = G_OBJECT_CLASS (klass); -+ IBusObjectClass *ibus_object_class = IBUS_OBJECT_CLASS (klass); -+ IBusEngineClass *engine_class = IBUS_ENGINE_CLASS (klass); -+ -+ parent_class = (IBusEngineClass *) g_type_class_peek_parent (klass); -+ object_class->constructor = ibus_xkb_engine_constructor; -+ ibus_object_class->destroy = (IBusObjectDestroyFunc) ibus_xkb_engine_destroy; -+ engine_class->enable = ibus_xkb_engine_enable; -+ engine_class->disable = ibus_xkb_engine_disable; -+ engine_class->focus_in = ibus_xkb_engine_focus_in; -+ engine_class->focus_out = ibus_xkb_engine_focus_out; -+ -+} -+ -+static void -+ibus_xkb_engine_init (IBusXKBEngine *engine) -+{ -+} -+ -+GType -+ibus_xkb_engine_get_type (void) -+{ -+ static GType type = 0; -+ -+ static const GTypeInfo type_info = { -+ sizeof (IBusXKBEngineClass), -+ (GBaseInitFunc) NULL, -+ (GBaseFinalizeFunc) NULL, -+ (GClassInitFunc) ibus_xkb_engine_class_init, -+ NULL, -+ NULL, -+ sizeof (IBusXKBEngine), -+ 0, -+ (GInstanceInitFunc) ibus_xkb_engine_init, -+ }; -+ -+ if (type == 0) { -+ type = g_type_register_static (IBUS_TYPE_ENGINE, -+ "IBusXKBEngine", -+ &type_info, -+ (GTypeFlags) 0); -+ } -+ -+ return type; -+} -+ +static void +ibus_disconnected_cb (IBusBus *bus, + gpointer user_data) @@ -3155,9 +7677,6 @@ index 0000000..0fb0f0c + const gchar *engine_name, + gpointer data) +{ -+#if 0 -+ static GHashTable *engine_table = NULL; -+#endif + IBusEngine *engine = NULL; + gchar *object_path = NULL; + static int id = 0; @@ -3168,29 +7687,13 @@ index 0000000..0fb0f0c + return NULL; + } + -+ /* FIXME: Do we always need a new object path for the same engine name? */ -+#if 0 -+ if (engine_table == NULL) { -+ engine_table = g_hash_table_new_full (g_str_hash, -+ g_str_equal, -+ g_free, -+ NULL); -+ } -+ -+ if ((engine = (IBusEngine *) g_hash_table_lookup (engine_table, -+ engine_name))) { -+ return engine; -+ } -+#endif -+ + object_path = g_strdup_printf ("/org/freedesktop/IBus/XKBEngine/%d", + ++id); -+ engine = ibus_engine_new (engine_name, -+ object_path, -+ ibus_service_get_connection (IBUS_SERVICE (factory))); -+#if 0 -+ g_hash_table_insert (engine_table, g_strdup (engine_name), engine); -+#endif ++ engine = ibus_engine_new_type (IBUS_TYPE_SIMPLE_ENGINE, ++ engine_name, ++ object_path, ++ ibus_service_get_connection (IBUS_SERVICE (factory))); ++ g_free (object_path); + return engine; +} + @@ -3222,7 +7725,7 @@ index 0000000..0fb0f0c + + factory = ibus_factory_new (ibus_bus_get_connection (bus)); + -+ ibus_factory_add_engine (factory, "xkb:layout:us", IBUS_TYPE_XKB_ENGINE); ++ ibus_factory_add_engine (factory, "xkb:layout:us", IBUS_TYPE_SIMPLE_ENGINE); + + g_signal_connect (G_OBJECT (factory), "create-engine", + G_CALLBACK (_factory_create_engine_cb), @@ -3390,6 +7893,8 @@ index 0000000..0fb0f0c + +#ifdef ENABLE_NLS + setlocale (LC_ALL, ""); ++ bindtextdomain (GETTEXT_PACKAGE, IBUS_LOCALEDIR); ++ bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); +#endif + + g_type_init (); @@ -3413,10 +7918,10 @@ index 0000000..0fb0f0c +} diff --git a/xkb/ibus-engine-xkb-main.h b/xkb/ibus-engine-xkb-main.h new file mode 100644 -index 0000000..c17c857 +index 0000000..255e952 --- /dev/null +++ b/xkb/ibus-engine-xkb-main.h -@@ -0,0 +1,46 @@ +@@ -0,0 +1,32 @@ +/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */ +/* vim:set et sts=4: */ +/* bus - The Input Bus @@ -3442,27 +7947,1085 @@ index 0000000..c17c857 +#ifndef __IBUS_ENGINE_XKB_MAIN_H_ +#define __IBUS_ENGINE_XKB_MAIN_H_ + ++G_BEGIN_DECLS ++ ++typedef struct _IBusXKBEngine IBusXKBEngine; ++typedef struct _IBusXKBEngineClass IBusXKBEngineClass; ++ ++G_END_DECLS ++#endif +diff --git a/xkb/ibus-simple-engine.c b/xkb/ibus-simple-engine.c +new file mode 100644 +index 0000000..41702cb +--- /dev/null ++++ b/xkb/ibus-simple-engine.c +@@ -0,0 +1,1049 @@ ++/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */ ++/* vim:set et sts=4: */ +#ifdef HAVE_CONFIG_H -+#include ++# include "config.h" +#endif ++#include "ibus-simple-engine.h" ++#include ++#include ++#include + -+#include ++#ifdef ENABLE_NLS ++#include ++#endif + -+G_BEGIN_DECLS ++#define MAX_COMPOSE_LEN 7 + -+typedef struct _IBusXKBEngine IBusXKBEngine; -+typedef struct _IBusXKBEngineClass IBusXKBEngineClass; ++typedef struct _IBusSimpleEngine IBusSimpleEngine; ++typedef struct _IBusSimpleEngineClass IBusSimpleEngineClass; ++ ++struct _IBusSimpleEngine { ++ IBusEngine parent; ++ ++ IBusPropList *prop_list; + -+struct _IBusXKBEngine { -+ IBusEngine engine; ++ GSList *tables; ++ ++ guint compose_buffer[MAX_COMPOSE_LEN + 1]; ++ gunichar tentative_match; ++ gint tentative_match_len; ++ ++ guint in_hex_sequence : 1; ++ guint modifiers_dropped : 1; +}; + -+struct _IBusXKBEngineClass { ++struct _IBusSimpleEngineClass { + IBusEngineClass parent; +}; + -+G_END_DECLS ++typedef struct _GtkComposeTable GtkComposeTable; ++struct _GtkComposeTable ++{ ++ const guint16 *data; ++ gint max_seq_len; ++ gint n_seqs; ++}; ++ ++typedef struct _GtkComposeTableCompact GtkComposeTableCompact; ++struct _GtkComposeTableCompact ++{ ++ const guint16 *data; ++ gint max_seq_len; ++ gint n_index_size; ++ gint n_index_stride; ++}; ++ ++/* This file contains the table of the compose sequences, ++ * static const guint16 gtk_compose_seqs_compact[] = {} ++ * IT is generated from the compose-parse.py script. ++ */ ++#include "gtkimcontextsimpleseqs.h" ++ ++/* From the values below, the value 23 means the number of different first keysyms ++ * that exist in the Compose file (from Xorg). When running compose-parse.py without ++ * parameters, you get the count that you can put here. Needed when updating the ++ * gtkimcontextsimpleseqs.h header file (contains the compose sequences). ++ */ ++static const GtkComposeTableCompact gtk_compose_table_compact = { ++ gtk_compose_seqs_compact, ++ 5, ++ 24, ++ 6 ++}; ++ ++static const guint16 gtk_compose_ignore[] = { ++ IBUS_Shift_L, ++ IBUS_Shift_R, ++ IBUS_Control_L, ++ IBUS_Control_R, ++ IBUS_Caps_Lock, ++ IBUS_Shift_Lock, ++ IBUS_Meta_L, ++ IBUS_Meta_R, ++ IBUS_Alt_L, ++ IBUS_Alt_R, ++ IBUS_Super_L, ++ IBUS_Super_R, ++ IBUS_Hyper_L, ++ IBUS_Hyper_R, ++ IBUS_Mode_switch, ++ IBUS_ISO_Level3_Shift ++}; ++ ++/* Copied from gtk+2.0-2.20.1/modules/input/imcedilla.c to fix crosbug.com/11421. ++ * Overwrite the original Gtk+'s compose table in gtk+-2.x.y/gtk/gtkimcontextsimple.c. */ ++ ++/* The difference between this and the default input method is the handling ++ * of C+acute - this method produces C WITH CEDILLA rather than C WITH ACUTE. ++ * For languages that use CCedilla and not acute, this is the preferred mapping, ++ * and is particularly important for pt_BR, where the us-intl keyboard is ++ * used extensively. ++ */ ++static guint16 cedilla_compose_seqs[] = { ++ IBUS_dead_acute, IBUS_C, 0, 0, 0, 0x00C7, /* LATIN_CAPITAL_LETTER_C_WITH_CEDILLA */ ++ IBUS_dead_acute, IBUS_c, 0, 0, 0, 0x00E7, /* LATIN_SMALL_LETTER_C_WITH_CEDILLA */ ++ IBUS_Multi_key, IBUS_apostrophe, IBUS_C, 0, 0, 0x00C7, /* LATIN_CAPITAL_LETTER_C_WITH_CEDILLA */ ++ IBUS_Multi_key, IBUS_apostrophe, IBUS_c, 0, 0, 0x00E7, /* LATIN_SMALL_LETTER_C_WITH_CEDILLA */ ++ IBUS_Multi_key, IBUS_C, IBUS_apostrophe, 0, 0, 0x00C7, /* LATIN_CAPITAL_LETTER_C_WITH_CEDILLA */ ++ IBUS_Multi_key, IBUS_c, IBUS_apostrophe, 0, 0, 0x00E7, /* LATIN_SMALL_LETTER_C_WITH_CEDILLA */ ++}; ++ ++/* functions prototype */ ++static void ibus_simple_engine_class_init (IBusSimpleEngineClass *klass); ++static void ibus_simple_engine_init (IBusSimpleEngine *simple); ++static void ibus_simple_engine_destroy (IBusSimpleEngine *simple); ++static void ibus_simple_engine_reset (IBusEngine *engine); ++static void ibus_simple_engine_enable (IBusEngine *engine); ++static void ibus_simple_engine_disable (IBusEngine *engine); ++static void ibus_simple_engine_focus_in (IBusEngine *engine); ++static void ibus_simple_engine_focus_out (IBusEngine *engine); ++static void ibus_simple_engine_reset (IBusEngine *engine); ++static void ibus_simple_engine_property_activate ++ (IBusEngine *engine, ++ const gchar *prop_name, ++ guint prop_state); ++static gboolean ibus_simple_engine_process_key_event ++ (IBusEngine *engine, ++ guint keyval, ++ guint keycode, ++ guint modifiers); ++static void ibus_simple_engine_commit_char (IBusSimpleEngine *simple, ++ gunichar ch); ++static void ibus_simple_engine_update_preedit_text ++ (IBusSimpleEngine *simple); ++static void ibus_simple_engine_add_table (IBusSimpleEngine *simple, ++ guint16 *data, ++ gint max_seq_len, ++ gint n_seqs); ++static void ibus_simple_engine_add_table_with_lang ++ (IBusSimpleEngine *simple, ++ const gchar *lang); ++ ++G_DEFINE_TYPE (IBusSimpleEngine, ibus_simple_engine, IBUS_TYPE_ENGINE) ++ ++static void ++ibus_simple_engine_class_init (IBusSimpleEngineClass *klass) ++{ ++ IBusObjectClass *ibus_object_class = IBUS_OBJECT_CLASS (klass); ++ IBusEngineClass *engine_class = IBUS_ENGINE_CLASS (klass); ++ ++ ibus_object_class->destroy = (IBusObjectDestroyFunc) ibus_simple_engine_destroy; ++ ++ engine_class->reset = ibus_simple_engine_reset; ++ engine_class->enable = ibus_simple_engine_enable; ++ engine_class->disable = ibus_simple_engine_disable; ++ engine_class->focus_in = ibus_simple_engine_focus_in; ++ engine_class->focus_out = ibus_simple_engine_focus_out; ++ engine_class->property_activate ++ = ibus_simple_engine_property_activate; ++ engine_class->process_key_event ++ = ibus_simple_engine_process_key_event; ++} ++ ++static void ++ibus_simple_engine_init (IBusSimpleEngine *simple) ++{ ++ gchar *ling = NULL; ++#ifdef ENABLE_SETUP_GUI ++ IBusText *label; ++ IBusText *tooltip; ++ IBusProperty *prop; ++ ++ simple->prop_list = ibus_prop_list_new (); ++ ++ g_object_ref_sink (simple->prop_list); ++ label = ibus_text_new_from_string (_("Setup")); ++ tooltip = ibus_text_new_from_string (_("Configure XKB engine")); ++ prop = ibus_property_new ("setup", ++ PROP_TYPE_NORMAL, ++ label, ++ "gtk-preferences", ++ tooltip, ++ TRUE, TRUE, ++ PROP_STATE_UNCHECKED, ++ NULL); ++ g_object_ref_sink (prop); ++ ibus_prop_list_append (simple->prop_list, prop); ++#endif ++ ++#ifdef ENABLE_NLS ++ ling = g_strdup (setlocale (LC_CTYPE, NULL)); +#endif ++ if (ling == NULL) { ++ ling = g_strdup (g_getenv ("LANG")); ++ } ++ ibus_simple_engine_add_table_with_lang (simple, ling); ++ g_free (ling); ++} ++ ++static void ++ibus_simple_engine_destroy (IBusSimpleEngine *simple) ++{ ++#ifdef ENABLE_SETUP_GUI ++ if (simple->prop_list) { ++ g_object_unref (simple->prop_list); ++ simple->prop_list = NULL; ++ } ++#endif ++ ++ if (simple->tables) { ++ g_slist_foreach (simple->tables, (GFunc) g_free, NULL); ++ g_slist_free (simple->tables); ++ simple->tables = NULL; ++ } ++ ++ ((IBusObjectClass *) ibus_simple_engine_parent_class)->destroy ((IBusObject *)simple); ++} ++ ++static void ++ibus_simple_engine_reset (IBusEngine *engine) ++{ ++ IBusSimpleEngine *simple = (IBusSimpleEngine *)engine; ++ simple->compose_buffer[0] = 0; ++ ++ if (simple->tentative_match || simple->in_hex_sequence) { ++ simple->in_hex_sequence = FALSE; ++ simple->tentative_match = 0; ++ simple->tentative_match_len = 0; ++ ibus_engine_hide_preedit_text ((IBusEngine *)simple); ++ } ++} ++ ++static void ++ibus_simple_engine_enable (IBusEngine *engine) ++{ ++ IBUS_ENGINE_CLASS (ibus_simple_engine_parent_class)->enable (engine); ++} ++ ++static void ++ibus_simple_engine_disable (IBusEngine *engine) ++{ ++ IBUS_ENGINE_CLASS (ibus_simple_engine_parent_class)->disable (engine); ++} ++ ++static void ++ibus_simple_engine_focus_in (IBusEngine *engine) ++{ ++#ifdef ENABLE_SETUP_GUI ++ IBusSimpleEngine *simple = (IBusSimpleEngine *) engine; ++ ++ ibus_engine_register_properties (engine, simple->prop_list); ++#endif ++ IBUS_ENGINE_CLASS (ibus_simple_engine_parent_class)->focus_in (engine); ++} ++ ++static void ++ibus_simple_engine_focus_out (IBusEngine *engine) ++{ ++ IBUS_ENGINE_CLASS (ibus_simple_engine_parent_class)->focus_out (engine); ++} ++ ++static void ++ibus_simple_engine_property_activate (IBusEngine *engine, ++ const gchar *prop_name, ++ guint prop_state) ++{ ++ if (g_strcmp0 (prop_name, "setup") == 0) { ++ gchar *argv[2] = { NULL, NULL}; ++ gchar *path; ++ const gchar *libexecdir = g_getenv ("LIBEXECDIR"); ++ GError *error = NULL; ++ ++ if (libexecdir == NULL) { ++ libexecdir = LIBEXECDIR; ++ } ++ path = g_build_filename (libexecdir, "ibus-setup-xkb", NULL); ++ argv[0] = path; ++ if (!g_spawn_async (NULL, argv, NULL, 0, NULL, NULL, NULL, &error)) { ++ if (error) { ++ g_warning ("exec failure: %s", error->message); ++ g_error_free (error); ++ } ++ } ++ g_free (path); ++ return; ++ } ++ IBUS_ENGINE_CLASS (ibus_simple_engine_parent_class)->property_activate (engine, prop_name, prop_state); ++} ++ ++static void ++ibus_simple_engine_commit_char (IBusSimpleEngine *simple, ++ gunichar ch) ++{ ++ g_return_if_fail (g_unichar_validate (ch)); ++ ++ if (simple->tentative_match || simple->in_hex_sequence) { ++ simple->in_hex_sequence = FALSE; ++ simple->tentative_match = 0; ++ simple->tentative_match_len = 0; ++ ibus_simple_engine_update_preedit_text (simple); ++ } ++ ++ ibus_engine_commit_text ((IBusEngine *)simple, ++ ibus_text_new_from_unichar (ch)); ++} ++ ++static void ++ibus_simple_engine_update_preedit_text (IBusSimpleEngine *simple) ++{ ++ gunichar outbuf[MAX_COMPOSE_LEN + 2]; ++ int len = 0; ++ ++ if (simple->in_hex_sequence) { ++ int hexchars = 0; ++ ++ outbuf[0] = L'u'; ++ len = 1; ++ ++ while (simple->compose_buffer[hexchars] != 0) { ++ outbuf[len] = ibus_keyval_to_unicode (simple->compose_buffer[hexchars]); ++ ++len; ++ ++hexchars; ++ } ++ g_assert (len <= MAX_COMPOSE_LEN + 1); ++ } ++ else if (simple->tentative_match) ++ outbuf[len++] = simple->tentative_match; ++ ++ outbuf[len] = L'\0'; ++ if (len == 0) { ++ ibus_engine_hide_preedit_text ((IBusEngine *)simple); ++ } ++ else { ++ IBusText *text = ibus_text_new_from_ucs4 (outbuf); ++ ibus_text_append_attribute (text, ++ IBUS_ATTR_TYPE_UNDERLINE, IBUS_ATTR_UNDERLINE_SINGLE, 0, len); ++ g_debug ("UpdatePreedit text=%s", text->text); ++ ibus_engine_update_preedit_text ((IBusEngine *)simple, text, len, TRUE); ++ } ++} ++ ++ ++/* In addition to the table-driven sequences, we allow Unicode hex ++ * codes to be entered. The method chosen here is similar to the ++ * one recommended in ISO 14755, but not exactly the same, since we ++ * don't want to steal 16 valuable key combinations. ++ * ++ * A hex Unicode sequence must be started with Ctrl-Shift-U, followed ++ * by a sequence of hex digits entered with Ctrl-Shift still held. ++ * Releasing one of the modifiers or pressing space while the modifiers ++ * are still held commits the character. It is possible to erase ++ * digits using backspace. ++ * ++ * As an extension to the above, we also allow to start the sequence ++ * with Ctrl-Shift-U, then release the modifiers before typing any ++ * digits, and enter the digits without modifiers. ++ */ ++#define HEX_MOD_MASK (IBUS_CONTROL_MASK | IBUS_SHIFT_MASK) ++ ++static gboolean ++check_hex (IBusSimpleEngine *simple, ++ gint n_compose) ++{ ++ gint i; ++ GString *str; ++ gulong n; ++ gchar *nptr = NULL; ++ gchar buf[7]; ++ ++ simple->tentative_match = 0; ++ simple->tentative_match_len = 0; ++ ++ str = g_string_new (NULL); ++ ++ i = 0; ++ while (i < n_compose) { ++ gunichar ch; ++ ++ ch = ibus_keyval_to_unicode (simple->compose_buffer[i]); ++ ++ if (ch == 0) ++ return FALSE; ++ ++ if (!g_unichar_isxdigit (ch)) ++ return FALSE; ++ ++ buf[g_unichar_to_utf8 (ch, buf)] = '\0'; ++ ++ g_string_append (str, buf); ++ ++ ++i; ++ } ++ ++ n = strtoul (str->str, &nptr, 16); ++ ++ /* if strtoul fails it probably means non-latin digits were used; ++ * we should in principle handle that, but we probably don't. ++ */ ++ if (nptr - str->str < str->len) { ++ g_string_free (str, TRUE); ++ return FALSE; ++ } else ++ g_string_free (str, TRUE); ++ ++ if (g_unichar_validate (n)) { ++ simple->tentative_match = n; ++ simple->tentative_match_len = n_compose; ++ } ++ ++ return TRUE; ++} ++ ++static int ++compare_seq_index (const void *key, const void *value) ++{ ++ const guint *keysyms = key; ++ const guint16 *seq = value; ++ ++ if (keysyms[0] < seq[0]) ++ return -1; ++ else if (keysyms[0] > seq[0]) ++ return 1; ++ return 0; ++} ++ ++static int ++compare_seq (const void *key, const void *value) ++{ ++ int i = 0; ++ const guint *keysyms = key; ++ const guint16 *seq = value; ++ ++ while (keysyms[i]) { ++ if (keysyms[i] < seq[i]) ++ return -1; ++ else if (keysyms[i] > seq[i]) ++ return 1; ++ ++ i++; ++ } ++ ++ return 0; ++} ++ ++ ++static gboolean ++check_table (IBusSimpleEngine *simple, ++ const GtkComposeTable *table, ++ gint n_compose) ++{ ++ gint row_stride = table->max_seq_len + 2; ++ guint16 *seq; ++ ++ /* Will never match, if the sequence in the compose buffer is longer ++ * than the sequences in the table. Further, compare_seq (key, val) ++ * will overrun val if key is longer than val. */ ++ if (n_compose > table->max_seq_len) { ++ return FALSE; ++ } ++ ++ seq = bsearch (simple->compose_buffer, ++ table->data, table->n_seqs, ++ sizeof (guint16) * row_stride, ++ compare_seq); ++ ++ if (seq) { ++ guint16 *prev_seq; ++ ++ /* Back up to the first sequence that matches to make sure ++ * we find the exact match if their is one. ++ */ ++ while (seq > table->data) { ++ prev_seq = seq - row_stride; ++ if (compare_seq (simple->compose_buffer, prev_seq) != 0) { ++ break; ++ } ++ seq = prev_seq; ++ } ++ ++ /* complete sequence */ ++ if (n_compose == table->max_seq_len || seq[n_compose] == 0) { ++ guint16 *next_seq; ++ gunichar value = ++ 0x10000 * seq[table->max_seq_len] + seq[table->max_seq_len + 1]; ++ ++ /* We found a tentative match. See if there are any longer ++ * sequences containing this subsequence ++ */ ++ next_seq = seq + row_stride; ++ if (next_seq < table->data + row_stride * table->n_seqs) { ++ if (compare_seq (simple->compose_buffer, next_seq) == 0) { ++ simple->tentative_match = value; ++ simple->tentative_match_len = n_compose; ++ ++ ibus_simple_engine_update_preedit_text (simple); ++ ++ return TRUE; ++ } ++ } ++ ++ ibus_simple_engine_commit_char (simple, value); ++ g_debug ("U+%04X\n", value); ++ simple->compose_buffer[0] = 0; ++ } ++ return TRUE; ++ } ++ return FALSE; ++} ++ ++static gboolean ++check_compact_table (IBusSimpleEngine *simple, ++ const GtkComposeTableCompact *table, ++ gint n_compose) ++{ ++ gint row_stride; ++ guint16 *seq_index; ++ guint16 *seq; ++ gint i; ++ ++ /* Will never match, if the sequence in the compose buffer is longer ++ * than the sequences in the table. Further, compare_seq (key, val) ++ * will overrun val if key is longer than val. */ ++ if (n_compose > table->max_seq_len) ++ return FALSE; ++ ++ g_debug ("check_compact_table(n_compose=%d) [%04x, %04x, %04x, %04x]", ++ n_compose, ++ simple->compose_buffer[0], ++ simple->compose_buffer[1], ++ simple->compose_buffer[2], ++ simple->compose_buffer[3]); ++ ++ seq_index = bsearch (simple->compose_buffer, ++ table->data, ++ table->n_index_size, ++ sizeof (guint16) * table->n_index_stride, ++ compare_seq_index); ++ ++ if (seq_index == NULL) { ++ g_debug ("compact: no\n"); ++ return FALSE; ++ } ++ ++ if (n_compose == 1) { ++ g_debug ("compact: yes\n"); ++ return TRUE; ++ } ++ ++ g_debug ("compact: %04x ", *seq_index); ++ seq = NULL; ++ ++ for (i = n_compose - 1; i < table->max_seq_len; i++) { ++ row_stride = i + 1; ++ ++ if (seq_index[i + 1] - seq_index[i] > 0) { ++ seq = bsearch (simple->compose_buffer + 1, ++ table->data + seq_index[i], ++ (seq_index[i + 1] - seq_index[i]) / row_stride, ++ sizeof (guint16) * row_stride, ++ compare_seq); ++ g_debug ("seq = %p", seq); ++ ++ if (seq) { ++ if (i == n_compose - 1) ++ break; ++ else { ++ ibus_simple_engine_update_preedit_text (simple); ++ g_debug ("yes\n"); ++ return TRUE; ++ } ++ } ++ } ++ } ++ ++ if (!seq) { ++ g_debug ("no\n"); ++ return FALSE; ++ } ++ else { ++ gunichar value; ++ ++ value = seq[row_stride - 1]; ++ ibus_simple_engine_commit_char (simple, value); ++ simple->compose_buffer[0] = 0; ++ ++ g_debug ("U+%04X\n", value); ++ return TRUE; ++ } ++} ++ ++/* Checks if a keysym is a dead key. Dead key keysym values are defined in ++ * ../gdk/gdkkeysyms.h and the first is GDK_KEY_dead_grave. As X.Org is updated, ++ * more dead keys are added and we need to update the upper limit. ++ * Currently, the upper limit is GDK_KEY_dead_dasia+1. The +1 has to do with ++ * a temporary issue in the X.Org header files. ++ * In future versions it will be just the keysym (no +1). ++ */ ++#define IS_DEAD_KEY(k) \ ++ ((k) >= IBUS_dead_grave && (k) <= (IBUS_dead_dasia+1)) ++ ++/* This function receives a sequence of Unicode characters and tries to ++ * normalize it (NFC). We check for the case the the resulting string ++ * has length 1 (single character). ++ * NFC normalisation normally rearranges diacritic marks, unless these ++ * belong to the same Canonical Combining Class. ++ * If they belong to the same canonical combining class, we produce all ++ * permutations of the diacritic marks, then attempt to normalize. ++ */ ++static gboolean ++check_normalize_nfc (gunichar* combination_buffer, gint n_compose) ++{ ++ gunichar combination_buffer_temp[MAX_COMPOSE_LEN]; ++ gchar *combination_utf8_temp = NULL; ++ gchar *nfc_temp = NULL; ++ gint n_combinations; ++ gunichar temp_swap; ++ gint i; ++ ++ n_combinations = 1; ++ ++ for (i = 1; i < n_compose; i++ ) ++ n_combinations *= i; ++ ++ /* Xorg reuses dead_tilde for the perispomeni diacritic mark. ++ * We check if base character belongs to Greek Unicode block, ++ * and if so, we replace tilde with perispomeni. */ ++ if (combination_buffer[0] >= 0x390 && combination_buffer[0] <= 0x3FF) { ++ for (i = 1; i < n_compose; i++ ) ++ if (combination_buffer[i] == 0x303) ++ combination_buffer[i] = 0x342; ++ } ++ ++ memcpy (combination_buffer_temp, combination_buffer, MAX_COMPOSE_LEN * sizeof (gunichar) ); ++ ++ for (i = 0; i < n_combinations; i++ ) { ++ g_unicode_canonical_ordering (combination_buffer_temp, n_compose); ++ combination_utf8_temp = g_ucs4_to_utf8 (combination_buffer_temp, -1, NULL, NULL, NULL); ++ nfc_temp = g_utf8_normalize (combination_utf8_temp, -1, G_NORMALIZE_NFC); ++ ++ if (g_utf8_strlen (nfc_temp, -1) == 1) { ++ memcpy (combination_buffer, combination_buffer_temp, MAX_COMPOSE_LEN * sizeof (gunichar) ); ++ ++ g_free (combination_utf8_temp); ++ g_free (nfc_temp); ++ ++ return TRUE; ++ } ++ ++ g_free (combination_utf8_temp); ++ g_free (nfc_temp); ++ ++ if (n_compose > 2) { ++ temp_swap = combination_buffer_temp[i % (n_compose - 1) + 1]; ++ combination_buffer_temp[i % (n_compose - 1) + 1] = combination_buffer_temp[(i+1) % (n_compose - 1) + 1]; ++ combination_buffer_temp[(i+1) % (n_compose - 1) + 1] = temp_swap; ++ } ++ else ++ break; ++ } ++ ++ return FALSE; ++} ++ ++static gboolean ++check_algorithmically (IBusSimpleEngine *simple, ++ gint n_compose) ++ ++{ ++ gint i; ++ gunichar combination_buffer[MAX_COMPOSE_LEN]; ++ gchar *combination_utf8, *nfc; ++ ++ if (n_compose >= MAX_COMPOSE_LEN) ++ return FALSE; ++ ++ for (i = 0; i < n_compose && IS_DEAD_KEY (simple->compose_buffer[i]); i++) ++ ; ++ if (i == n_compose) ++ return TRUE; ++ ++ if (i > 0 && i == n_compose - 1) { ++ combination_buffer[0] = ibus_keyval_to_unicode (simple->compose_buffer[i]); ++ combination_buffer[n_compose] = 0; ++ i--; ++ while (i >= 0) { ++ switch (simple->compose_buffer[i]) { ++#define CASE(keysym, unicode) \ ++ case IBUS_dead_##keysym: combination_buffer[i+1] = unicode; break ++ CASE (grave, 0x0300); ++ CASE (acute, 0x0301); ++ CASE (circumflex, 0x0302); ++ CASE (tilde, 0x0303); /* Also used with perispomeni, 0x342. */ ++ CASE (macron, 0x0304); ++ CASE (breve, 0x0306); ++ CASE (abovedot, 0x0307); ++ CASE (diaeresis, 0x0308); ++ CASE (hook, 0x0309); ++ CASE (abovering, 0x030A); ++ CASE (doubleacute, 0x030B); ++ CASE (caron, 0x030C); ++ CASE (abovecomma, 0x0313); /* Equivalent to psili */ ++ CASE (abovereversedcomma, 0x0314); /* Equivalent to dasia */ ++ CASE (horn, 0x031B); /* Legacy use for psili, 0x313 (or 0x343). */ ++ CASE (belowdot, 0x0323); ++ CASE (cedilla, 0x0327); ++ CASE (ogonek, 0x0328); /* Legacy use for dasia, 0x314.*/ ++ CASE (iota, 0x0345); ++ CASE (voiced_sound, 0x3099); /* Per Markus Kuhn keysyms.txt file. */ ++ CASE (semivoiced_sound, 0x309A); /* Per Markus Kuhn keysyms.txt file. */ ++ ++ /* The following cases are to be removed once xkeyboard-config, ++ * xorg are fully updated. ++ */ ++ /* Workaround for typo in 1.4.x xserver-xorg */ ++ case 0xfe66: combination_buffer[i+1] = 0x314; break; ++ /* CASE (dasia, 0x314); */ ++ /* CASE (perispomeni, 0x342); */ ++ /* CASE (psili, 0x343); */ ++#undef CASE ++ default: ++ combination_buffer[i+1] = ibus_keyval_to_unicode (simple->compose_buffer[i]); ++ } ++ i--; ++ } ++ ++ /* If the buffer normalizes to a single character, ++ * then modify the order of combination_buffer accordingly, if necessary, ++ * and return TRUE. ++ */ ++ if (check_normalize_nfc (combination_buffer, n_compose)) { ++ gunichar value; ++ combination_utf8 = g_ucs4_to_utf8 (combination_buffer, -1, NULL, NULL, NULL); ++ nfc = g_utf8_normalize (combination_utf8, -1, G_NORMALIZE_NFC); ++ ++ value = g_utf8_get_char (nfc); ++ ibus_simple_engine_commit_char (simple, value); ++ simple->compose_buffer[0] = 0; ++ ++ g_free (combination_utf8); ++ g_free (nfc); ++ ++ return TRUE; ++ } ++ } ++ ++ return FALSE; ++} ++ ++static gboolean ++no_sequence_matches (IBusSimpleEngine *simple, ++ gint n_compose, ++ guint keyval, ++ guint keycode, ++ guint modifiers) ++{ ++ gunichar ch; ++ ++ /* No compose sequences found, check first if we have a partial ++ * match pending. ++ */ ++ if (simple->tentative_match) { ++ gint len = simple->tentative_match_len; ++ int i; ++ ++ ibus_simple_engine_commit_char (simple, ++ simple->tentative_match); ++ simple->compose_buffer[0] = 0; ++ ++ for (i=0; i < n_compose - len - 1; i++) { ++ ibus_simple_engine_process_key_event ( ++ (IBusEngine *)simple, ++ simple->compose_buffer[len + i], ++ 0, 0); ++ } ++ ++ return ibus_simple_engine_process_key_event ( ++ (IBusEngine *)simple, keyval, keycode, modifiers); ++ } ++ else { ++ simple->compose_buffer[0] = 0; ++ if (n_compose > 1) { ++ /* Invalid sequence */ ++ // FIXME beep_window (event->window); ++ return TRUE; ++ } ++ ++ ch = ibus_keyval_to_unicode (keyval); ++ if (ch != 0 && !g_unichar_iscntrl (ch)) { ++ ibus_simple_engine_commit_char (simple, ch); ++ return TRUE; ++ } ++ else ++ return FALSE; ++ } ++} ++ ++gboolean ++ibus_simple_engine_process_key_event (IBusEngine *engine, ++ guint keyval, ++ guint keycode, ++ guint modifiers) ++{ ++ IBusSimpleEngine *simple = (IBusSimpleEngine *)engine; ++ gint n_compose = 0; ++ gboolean have_hex_mods; ++ gboolean is_hex_start; ++ gboolean is_hex_end; ++ gboolean is_backspace; ++ gboolean is_escape; ++ guint hex_keyval; ++ gint i; ++ ++ while (simple->compose_buffer[n_compose] != 0) ++ n_compose++; ++ ++ if (n_compose >= MAX_COMPOSE_LEN) ++ return TRUE; ++ ++ if (modifiers & IBUS_RELEASE_MASK) { ++ if (simple->in_hex_sequence && ++ (keyval == IBUS_Control_L || keyval == IBUS_Control_R || ++ keyval == IBUS_Shift_L || keyval == IBUS_Shift_R)) { ++ if (simple->tentative_match && ++ g_unichar_validate (simple->tentative_match)) { ++ ibus_simple_engine_commit_char (simple, ++ simple->tentative_match); ++ } ++ else if (n_compose == 0) { ++ simple->modifiers_dropped = TRUE; ++ } ++ else { ++ /* invalid hex sequence */ ++ /* FIXME beep_window (event->window); */ ++ simple->tentative_match = 0; ++ simple->in_hex_sequence = FALSE; ++ simple->compose_buffer[0] = 0; ++ ++ ibus_simple_engine_update_preedit_text (simple); ++ } ++ ++ return TRUE; ++ } ++ else ++ return FALSE; ++ } ++ ++ /* Ignore modifier key presses */ ++ for (i = 0; i < G_N_ELEMENTS (gtk_compose_ignore); i++) ++ if (keyval == gtk_compose_ignore[i]) ++ return FALSE; ++ ++ if (simple->in_hex_sequence && simple->modifiers_dropped) ++ have_hex_mods = TRUE; ++ else ++ have_hex_mods = (modifiers & (HEX_MOD_MASK)) == HEX_MOD_MASK; ++ ++ is_hex_start = keyval == IBUS_U; ++ is_hex_end = (keyval == IBUS_space || ++ keyval == IBUS_KP_Space || ++ keyval == IBUS_Return || ++ keyval == IBUS_ISO_Enter || ++ keyval == IBUS_KP_Enter); ++ is_backspace = keyval == IBUS_BackSpace; ++ is_escape = keyval == IBUS_Escape; ++ hex_keyval = keyval; ++ ++ /* If we are already in a non-hex sequence, or ++ * this keystroke is not hex modifiers + hex digit, don't filter ++ * key events with accelerator modifiers held down. We only treat ++ * Control and Alt as accel modifiers here, since Super, Hyper and ++ * Meta are often co-located with Mode_Switch, Multi_Key or ++ * ISO_Level3_Switch. ++ */ ++ if (!have_hex_mods || ++ (n_compose > 0 && !simple->in_hex_sequence) || ++ (n_compose == 0 && !simple->in_hex_sequence && !is_hex_start) || ++ (simple->in_hex_sequence && !hex_keyval && ++ !is_hex_start && !is_hex_end && !is_escape && !is_backspace)) { ++ if (modifiers & (IBUS_MOD1_MASK | IBUS_CONTROL_MASK) || ++ (simple->in_hex_sequence && simple->modifiers_dropped && ++ (keyval == IBUS_Return || ++ keyval == IBUS_ISO_Enter || ++ keyval == IBUS_KP_Enter))) { ++ return FALSE; ++ } ++ } ++ ++ /* Handle backspace */ ++ if (simple->in_hex_sequence && have_hex_mods && is_backspace) { ++ if (n_compose > 0) { ++ n_compose--; ++ simple->compose_buffer[n_compose] = 0; ++ check_hex (simple, n_compose); ++ } ++ else { ++ simple->in_hex_sequence = FALSE; ++ } ++ ++ ibus_simple_engine_update_preedit_text (simple); ++ ++ return TRUE; ++ } ++ ++ /* Check for hex sequence restart */ ++ if (simple->in_hex_sequence && have_hex_mods && is_hex_start) { ++ if (simple->tentative_match && ++ g_unichar_validate (simple->tentative_match)) { ++ ibus_simple_engine_commit_char (simple, simple->tentative_match); ++ } ++ else { ++ /* invalid hex sequence */ ++ if (n_compose > 0) { ++ // FIXME beep_window (event->window); ++ simple->tentative_match = 0; ++ simple->in_hex_sequence = FALSE; ++ simple->compose_buffer[0] = 0; ++ } ++ } ++ } ++ ++ /* Check for hex sequence start */ ++ if (!simple->in_hex_sequence && have_hex_mods && is_hex_start) { ++ simple->compose_buffer[0] = 0; ++ simple->in_hex_sequence = TRUE; ++ simple->modifiers_dropped = FALSE; ++ simple->tentative_match = 0; ++ ++ g_debug ("Start HEX MODE"); ++ ++ ibus_simple_engine_update_preedit_text (simple); ++ ++ return TRUE; ++ } ++ ++ /* Then, check for compose sequences */ ++ if (simple->in_hex_sequence) { ++ if (hex_keyval) ++ simple->compose_buffer[n_compose++] = hex_keyval; ++ else if (is_escape) { ++ // FIXME ++ ibus_simple_engine_reset (engine); ++ ++ return TRUE; ++ } ++ else if (!is_hex_end) { ++ // FIXME ++ /* non-hex character in hex sequence */ ++ // beep_window (event->window); ++ return TRUE; ++ } ++ } ++ else ++ simple->compose_buffer[n_compose++] = keyval; ++ ++ simple->compose_buffer[n_compose] = 0; ++ ++ if (simple->in_hex_sequence) { ++ /* If the modifiers are still held down, consider the sequence again */ ++ if (have_hex_mods) { ++ /* space or return ends the sequence, and we eat the key */ ++ if (n_compose > 0 && is_hex_end) { ++ if (simple->tentative_match && ++ g_unichar_validate (simple->tentative_match)) { ++ ibus_simple_engine_commit_char (simple, ++ simple->tentative_match); ++ simple->compose_buffer[0] = 0; ++ } ++ else { ++ // FIXME ++ /* invalid hex sequence */ ++ // beep_window (event->window); ++ simple->tentative_match = 0; ++ simple->in_hex_sequence = FALSE; ++ simple->compose_buffer[0] = 0; ++ } ++ } ++ else if (!check_hex (simple, n_compose)) ++ // FIXME ++ // beep_window (event->window); ++ ; ++ ibus_simple_engine_update_preedit_text (simple); ++ ++ return TRUE; ++ } ++ } ++ else { ++ GSList *tmp_list = simple->tables; ++ while (tmp_list) { ++ if (check_table (simple, tmp_list->data, n_compose)) { ++ return TRUE; ++ } ++ tmp_list = tmp_list->next; ++ } ++ // TODO CONT ++ if (check_compact_table (simple, >k_compose_table_compact, n_compose)) ++ return TRUE; ++ ++ if (check_algorithmically (simple, n_compose)) ++ return TRUE; ++ } ++ ++ /* The current compose_buffer doesn't match anything */ ++ return no_sequence_matches (simple, n_compose, keyval, keycode, modifiers); ++} ++ ++static void ++ibus_simple_engine_add_table_with_lang (IBusSimpleEngine *simple, ++ const gchar *lang) ++{ ++ if (lang == NULL) { ++ return; ++ } ++ ++ if (g_strcmp0 (lang, "reset") == 0) { ++ if (simple->tables) { ++ g_slist_foreach (simple->tables, (GFunc) g_free, NULL); ++ g_slist_free (simple->tables); ++ simple->tables = NULL; ++ } ++ return; ++ } ++ ++ if (g_ascii_strncasecmp (lang, "pt_BR", strlen ("pt_BR")) == 0) { ++ ibus_simple_engine_add_table (simple, ++ cedilla_compose_seqs, ++ 4, ++ G_N_ELEMENTS (cedilla_compose_seqs) / (4 + 2)); ++ return; ++ } ++} ++ ++static void ++ibus_simple_engine_add_table (IBusSimpleEngine *simple, ++ guint16 *data, ++ gint max_seq_len, ++ gint n_seqs) ++{ ++ GtkComposeTable *table; ++ ++ g_return_if_fail (IBUS_IS_SIMPLE_ENGINE (simple)); ++ g_return_if_fail (data != NULL); ++ g_return_if_fail (max_seq_len <= MAX_COMPOSE_LEN); ++ ++ table = g_new (GtkComposeTable, 1); ++ table->data = data; ++ table->max_seq_len = max_seq_len; ++ table->n_seqs = n_seqs; ++ ++ simple->tables = g_slist_prepend (simple->tables, table); ++} +diff --git a/xkb/ibus-simple-engine.h b/xkb/ibus-simple-engine.h +new file mode 100644 +index 0000000..17ca57a +--- /dev/null ++++ b/xkb/ibus-simple-engine.h +@@ -0,0 +1,11 @@ ++#ifndef __IBUS_SIMPLE_ENGINE_H__ ++#define __IBUS_SIMPLE_ENGINE_H__ ++ ++#include ++ ++#define IBUS_TYPE_SIMPLE_ENGINE (ibus_simple_engine_get_type ()) ++#define IBUS_IS_SIMPLE_ENGINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), IBUS_TYPE_SIMPLE_ENGINE)) ++ ++GType ibus_simple_engine_get_type (void); ++ ++#endif // __IBUS_SIMPLE_ENGINE_H__ diff --git a/xkb/ibus-xkb-main.c b/xkb/ibus-xkb-main.c new file mode 100644 index 0000000..ef57553 diff --git a/ibus-HEAD.patch b/ibus-HEAD.patch index e54df13..d48afe8 100644 --- a/ibus-HEAD.patch +++ b/ibus-HEAD.patch @@ -1,1346 +1,632 @@ -From 80e5bd0785ca91a70f0b5fe511a3bd8e143d8d05 Mon Sep 17 00:00:00 2001 -From: Takao Fujiwara -Date: Wed, 27 Apr 2011 07:48:50 -0400 -Subject: [PATCH] Fix the zombie process of ibus-gconf when ibus-daemon - restarts. +From 9614076737ee88c092af209485d1d65d2269f4ad Mon Sep 17 00:00:00 2001 +From: Tsuyoshi Horo +Date: Thu, 18 Aug 2011 11:48:30 -0400 +Subject: [PATCH] Fix for ibus_serializable_{get,set}_attachment. -- Fix the typo in bus_dbus_impl_destroy() (dbusimpl.c) -- Modify bus_server_run() and _ibus_exit() (ibusimpl.c, server.c) - bus_ibus_impl_destroy() needs to be called so that waitpid() - prevents processes from becoming zombie. -- Change the declaration of bus_server_quit(). (server.h) - -BUG=redhat#697471 TEST=Linux desktop -Review URL: http://codereview.appspot.com/4440059 -Patch from Takao Fujiwara . +Review URL: http://codereview.appspot.com/4905054 +Patch from Tsuyoshi Horo . --- - bus/dbusimpl.c | 5 ++--- - bus/ibusimpl.c | 40 +--------------------------------------- - bus/server.c | 50 +++++++++++++++++++++++++++++++++++++++++++++++++- - bus/server.h | 3 ++- - src/ibusbus.c | 8 +++++++- - 5 files changed, 61 insertions(+), 45 deletions(-) - -diff --git a/bus/dbusimpl.c b/bus/dbusimpl.c -index d67a3ce..5616222 100644 ---- a/bus/dbusimpl.c -+++ b/bus/dbusimpl.c -@@ -577,11 +577,10 @@ bus_dbus_impl_destroy (BusDBusImpl *dbus) - dbus->rules = NULL; - - for (p = dbus->connections; p != NULL; p = p->next) { -- GDBusConnection *connection = G_DBUS_CONNECTION (p->data); -+ BusConnection *connection = BUS_CONNECTION (p->data); - g_signal_handlers_disconnect_by_func (connection, - bus_dbus_impl_connection_destroy_cb, dbus); -- /* FIXME should handle result? */ -- g_dbus_connection_close (connection, NULL, NULL, NULL); -+ ibus_object_destroy (IBUS_OBJECT (connection)); - g_object_unref (connection); - } - g_list_free (dbus->connections); -diff --git a/bus/ibusimpl.c b/bus/ibusimpl.c -index a7ae52b..b356b2c 100644 ---- a/bus/ibusimpl.c -+++ b/bus/ibusimpl.c -@@ -24,9 +24,7 @@ - #include - #include - #include --#include - #include --#include - #include - #include "types.h" - #include "ibusimpl.h" -@@ -937,7 +935,6 @@ bus_ibus_impl_destroy (BusIBusImpl *ibus) - ibus->fake_context = NULL; + src/ibusserializable.c | 18 +++++++++--------- + src/ibusserializable.h | 3 +-- + src/tests/ibus-serializable.c | 34 ++++++++++++++++++++++++++++++++++ + 3 files changed, 44 insertions(+), 11 deletions(-) + +diff --git a/src/ibusserializable.c b/src/ibusserializable.c +index 2e4b21f..ed89534 100644 +--- a/src/ibusserializable.c ++++ b/src/ibusserializable.c +@@ -164,7 +164,7 @@ _g_value_serialize (GValue *value) + { \ + g##_type v; \ + v = g_value_get_##_type (value); \ +- return g_variant_new ("v", g_variant_new (signature, v)); \ ++ return g_variant_new (signature, v); \ + } + CASE_ENTRY(CHAR, char, "y"); + CASE_ENTRY(BOOLEAN, boolean, "b"); +@@ -198,14 +198,14 @@ _g_value_deserialize (GVariant *variant) } -- bus_server_quit (); - IBUS_OBJECT_CLASS (bus_ibus_impl_parent_class)->destroy (IBUS_OBJECT (ibus)); - } - -@@ -1682,43 +1679,8 @@ _ibus_exit (BusIBusImpl *ibus, - g_dbus_connection_flush_sync (g_dbus_method_invocation_get_connection (invocation), - NULL, - NULL); -- bus_server_quit (); + typedef gchar *gstring; +-#define IF_ENTRY(TYPE, _type, signature) \ +- if (type == G_VARIANT_TYPE_##TYPE) { \ +- g##_type v; \ +- g_variant_get (variant, signature, &v); \ +- value = g_slice_new0 (GValue); \ +- g_value_init (value, G_TYPE_##TYPE); \ +- g_value_set_##_type (value, v); \ +- return value; \ ++#define IF_ENTRY(TYPE, _type, signature) \ ++ if (g_variant_type_equal(type, G_VARIANT_TYPE_##TYPE)) { \ ++ g##_type v; \ ++ g_variant_get (variant, signature, &v); \ ++ value = g_slice_new0 (GValue); \ ++ g_value_init (value, G_TYPE_##TYPE); \ ++ g_value_set_##_type (value, v); \ ++ return value; \ + } + #define G_VARIANT_TYPE_CHAR G_VARIANT_TYPE_BYTE + IF_ENTRY(CHAR, char, "y"); +diff --git a/src/ibusserializable.h b/src/ibusserializable.h +index 358af32..8fd9f8a 100644 +--- a/src/ibusserializable.h ++++ b/src/ibusserializable.h +@@ -87,12 +87,11 @@ + * ibus_serializable_get_attachment: + * @o: An IBusSerializable. + * @k: String formatted key for indexing value. +- * @v: Value to be attached. Should be also serializable. + * + * Get a value from attachment of an IBusSerializable. + * This macro is an convenient wrapper of ibus_serializable_get_qattachment(). + */ +-#define ibus_serializable_get_attachment(o, k, v) \ ++#define ibus_serializable_get_attachment(o, k) \ + ibus_serializable_get_qattachment (o, g_quark_from_string (k)) -- if (!restart) { -- exit (0); -- } -- else { -- extern gchar **g_argv; -- gchar *exe; -- gint fd; -- -- exe = g_strdup_printf ("/proc/%d/exe", getpid ()); -- exe = g_file_read_link (exe, NULL); -- -- if (exe == NULL) -- exe = BINDIR "/ibus-daemon"; -- -- /* close all fds except stdin, stdout, stderr */ -- for (fd = 3; fd <= sysconf (_SC_OPEN_MAX); fd ++) { -- close (fd); -- } -- -- execv (exe, g_argv); -- -- /* If the server binary is replaced while the server is running, -- * "readlink /proc/[pid]/exe" might return a path with " (deleted)" -- * suffix. */ -- const gchar suffix[] = " (deleted)"; -- if (g_str_has_suffix (exe, suffix)) { -- exe [strlen (exe) - sizeof (suffix) + 1] = '\0'; -- execv (exe, g_argv); -- } -- g_warning ("execv %s failed!", g_argv[0]); -- exit (-1); -- } -- -- /* should not reach here */ -- g_assert_not_reached (); -+ bus_server_quit (restart); + /** +diff --git a/src/tests/ibus-serializable.c b/src/tests/ibus-serializable.c +index c2a7529..e2541ec 100644 +--- a/src/tests/ibus-serializable.c ++++ b/src/tests/ibus-serializable.c +@@ -128,6 +128,39 @@ test_property (void) + g_variant_type_info_assert_no_infos (); } - /** -diff --git a/bus/server.c b/bus/server.c -index d180513..c2ab9a4 100644 ---- a/bus/server.c -+++ b/bus/server.c -@@ -21,6 +21,8 @@ - */ - #include "server.h" - #include -+#include -+#include - #include "dbusimpl.h" - #include "ibusimpl.h" - #include "option.h" -@@ -30,6 +32,40 @@ static GMainLoop *mainloop = NULL; - static BusDBusImpl *dbus = NULL; - static BusIBusImpl *ibus = NULL; - static gchar *address = NULL; -+static gboolean _restart = FALSE; -+ +static void -+_restart_server (void) ++test_attachment (void) +{ -+ extern gchar **g_argv; -+ gchar *exe; -+ gint fd; ++ IBusText *text = ibus_text_new_from_string ("main text"); + -+ exe = g_strdup_printf ("/proc/%d/exe", getpid ()); -+ exe = g_file_read_link (exe, NULL); ++ GValue value1 = { 0 }; ++ g_value_init(&value1, G_TYPE_INT); ++ g_value_set_int(&value1, 100); ++ ibus_serializable_set_attachment ((IBusSerializable *)text, "key1", &value1); + -+ if (exe == NULL) -+ exe = BINDIR "/ibus-daemon"; ++ GValue value2 = { 0 }; ++ g_value_init(&value2, G_TYPE_STRING); ++ g_value_set_string(&value2, "value string"); ++ ibus_serializable_set_attachment ((IBusSerializable *)text, "key2", &value2); + -+ /* close all fds except stdin, stdout, stderr */ -+ for (fd = 3; fd <= sysconf (_SC_OPEN_MAX); fd ++) { -+ close (fd); -+ } ++ GVariant *variant = ibus_serializable_serialize ((IBusSerializable *)text); ++ g_object_unref ((IBusSerializable *)text); + -+ _restart = FALSE; -+ execv (exe, g_argv); ++ IBusSerializable *object = (IBusSerializable *) ibus_serializable_deserialize (variant); ++ g_variant_unref (variant); + -+ /* If the server binary is replaced while the server is running, -+ * "readlink /proc/[pid]/exe" might return a path with " (deleted)" -+ * suffix. */ -+ const gchar suffix[] = " (deleted)"; -+ if (g_str_has_suffix (exe, suffix)) { -+ exe [strlen (exe) - sizeof (suffix) + 1] = '\0'; -+ execv (exe, g_argv); -+ } -+ g_warning ("execv %s failed!", g_argv[0]); -+ exit (-1); -+} - - /** - * bus_new_connection_cb: -@@ -112,11 +148,23 @@ bus_server_run (void) - mainloop = NULL; - g_free (address); - address = NULL; ++ g_assert_cmpstr (((IBusText *)object)->text, ==, "main text"); + -+ /* When _ibus_exit() is called, bus_ibus_impl_destroy() needs -+ * to be called so that waitpid() prevents the processes from -+ * becoming the daemons. So we run execv() after -+ * ibus_object_destroy(ibus) is called here. */ -+ if (_restart) { -+ _restart_server (); ++ const GValue *newvalue1 = ibus_serializable_get_attachment (object, "key1"); ++ g_assert (newvalue1 != NULL); ++ g_assert (g_value_get_int (newvalue1) == 100); + -+ /* should not reach here */ -+ g_assert_not_reached (); -+ } - } - - void --bus_server_quit (void) -+bus_server_quit (gboolean restart) - { -+ _restart = restart; - if (mainloop) - g_main_loop_quit (mainloop); - } -diff --git a/bus/server.h b/bus/server.h -index 6dfd79a..e1cb3ec 100644 ---- a/bus/server.h -+++ b/bus/server.h -@@ -43,10 +43,11 @@ void bus_server_run (void); - - /** - * bus_server_quit: -+ * @restart: TRUE if ibus-daemon restarts. - * - * Quit the glib main loop. - */ --void bus_server_quit (void); -+void bus_server_quit (gboolean restart); - - /** - * bus_server_get_address: -diff --git a/src/ibusbus.c b/src/ibusbus.c -index 0e9418e..39ad784 100644 ---- a/src/ibusbus.c -+++ b/src/ibusbus.c -@@ -236,7 +236,13 @@ _connection_closed_cb (GDBusConnection *connection, - IBusBus *bus) - { - if (error) { -- g_warning ("_connection_closed_cb: %s", error->message); -+ /* We replaced g_warning with g_debug here because -+ * currently when ibus-daemon restarts, GTK client calls this and -+ * _g_dbus_worker_do_read_cb() sets the error message: -+ * "Underlying GIOStream returned 0 bytes on an async read" -+ * http://git.gnome.org/browse/glib/tree/gio/gdbusprivate.c#n693 -+ * However we think the error message is almost harmless. */ -+ g_debug ("_connection_closed_cb: %s", error->message); - } - - g_assert (bus->priv->connection == connection); --- -1.7.4.4 - -From d059132885d3c90647f08f3083e39daa9f82b700 Mon Sep 17 00:00:00 2001 -From: Ryo Onodera -Date: Tue, 17 May 2011 20:07:40 +0900 -Subject: [PATCH] fix wrong forward key event signature - ---- - ibus/engine.py | 4 ++-- - ibus/interface/iengine.py | 4 ++-- - 2 files changed, 4 insertions(+), 4 deletions(-) - -diff --git a/ibus/engine.py b/ibus/engine.py -index 8cbcee3..fe5dd98 100644 ---- a/ibus/engine.py -+++ b/ibus/engine.py -@@ -114,8 +114,8 @@ class EngineBase(object.Object): - text = serializable.serialize_object(text) - return self.__proxy.CommitText(text) - -- def forward_key_event(self, keyval, state): -- return self.__proxy.ForwardKeyEvent(keyval, state) -+ def forward_key_event(self, keyval, keycode, state): -+ return self.__proxy.ForwardKeyEvent(keyval, keycode, state) - - def update_preedit_text(self, text, cursor_pos, visible, mode=common.IBUS_ENGINE_PREEDIT_CLEAR): - text = serializable.serialize_object(text) -diff --git a/ibus/interface/iengine.py b/ibus/interface/iengine.py -index 0e0f4ee..9e0d981 100644 ---- a/ibus/interface/iengine.py -+++ b/ibus/interface/iengine.py -@@ -104,8 +104,8 @@ class IEngine(dbus.service.Object): - @signal(signature="v") - def CommitText(self, text): pass - -- @signal(signature="uu") -- def ForwardKeyEvent(self, keyval, state): pass -+ @signal(signature="uuu") -+ def ForwardKeyEvent(self, keyval, keycode, state): pass - - @signal(signature="vubu") - def UpdatePreeditText(self, text, cursor_pos, visible, mode): pass --- -1.7.4.4 - -From d3e750eab6db7035f494fcdb328b87b2923e33a2 Mon Sep 17 00:00:00 2001 -From: Yusuke Sato -Date: Wed, 1 Jun 2011 23:37:14 +0900 -Subject: [PATCH] Send the new capabilities to ibus-daemon in - ibus_im_context_set_use_preedit. - -BUG=none -TEST=none - -Review URL: http://codereview.appspot.com/4529103 ---- - client/gtk2/ibusimcontext.c | 2 ++ - 1 files changed, 2 insertions(+), 0 deletions(-) - -diff --git a/client/gtk2/ibusimcontext.c b/client/gtk2/ibusimcontext.c -index ebae09d..4a894b0 100644 ---- a/client/gtk2/ibusimcontext.c -+++ b/client/gtk2/ibusimcontext.c -@@ -942,6 +942,8 @@ ibus_im_context_set_use_preedit (GtkIMContext *context, gboolean use_preedit) - else { - ibusimcontext->caps &= ~IBUS_CAP_PREEDIT_TEXT; - } -+ ibus_input_context_set_capabilities (ibusimcontext->ibuscontext, -+ ibusimcontext->caps); - } - gtk_im_context_set_use_preedit (ibusimcontext->slave, use_preedit); - } --- -1.7.4.4 - -From 52425daa537a32bed1781958e1ef62dbf199ad8b Mon Sep 17 00:00:00 2001 -From: Peng Huang -Date: Mon, 6 Jun 2011 09:30:27 -0400 -Subject: [PATCH] Fix Python input context binding. - -Export "forward-key-event" and "delete-surrounding-text" signals to Python; clear __needs_surrounding_text property on "enabled" and "disabled" signals. - -BUG=none -TEST=briefly tested, at least I don't see any regression - -Review URL: http://codereview.appspot.com/4437062 ---- - ibus/inputcontext.py | 26 +++++++++++++++++++++++++- - ibus/interface/iinputcontext.py | 3 +++ - 2 files changed, 28 insertions(+), 1 deletions(-) - -diff --git a/ibus/inputcontext.py b/ibus/inputcontext.py -index d143727..ceeb56d 100644 ---- a/ibus/inputcontext.py -+++ b/ibus/inputcontext.py -@@ -116,6 +116,16 @@ class InputContext(object.Object): - gobject.TYPE_NONE, - () - ), -+ "forward-key-event" : ( -+ gobject.SIGNAL_RUN_LAST, -+ gobject.TYPE_NONE, -+ (gobject.TYPE_UINT, gobject.TYPE_UINT, gobject.TYPE_UINT) -+ ), -+ "delete-surrounding-text" : ( -+ gobject.SIGNAL_RUN_LAST, -+ gobject.TYPE_NONE, -+ (gobject.TYPE_INT, gobject.TYPE_UINT) -+ ), - } - - def __init__(self, bus, path, watch_signals=False): -@@ -142,8 +152,14 @@ class InputContext(object.Object): - self.__signal_matches.append(m) - m = self.__context.connect_to_signal("RequireSurroundingText", self.__require_surrounding_text_cb) - self.__signal_matches.append(m) -+ m = self.__context.connect_to_signal("Enabled", self.__enabled_cb) -+ self.__signal_matches.append(m) -+ m = self.__context.connect_to_signal("Disabled", self.__disabled_cb) -+ self.__signal_matches.append(m) - -- m = self.__context.connect_to_signal("Enabled", lambda *args: self.emit("enabled")) -+ m = self.__context.connect_to_signal("ForwardKeyEvent", lambda *args: self.emit("forward-key-event", *args)) -+ self.__signal_matches.append(m) -+ m = self.__context.connect_to_signal("DeleteSurroundingText", lambda *args: self.emit("delete-surrounding-text", *args)) - self.__signal_matches.append(m) - m = self.__context.connect_to_signal("Disabled", lambda *args: self.emit("disabled")) - self.__signal_matches.append(m) -@@ -168,6 +184,14 @@ class InputContext(object.Object): - m = self.__context.connect_to_signal("CursorDownLookupTable", lambda *args: self.emit("cursor-down-lookup-table")) - self.__signal_matches.append(m) - -+ def __enabled_cb(self, *args): -+ self.__needs_surrounding_text = False -+ self.emit("enabled") -+ -+ def __disabled_cb(self, *args): -+ self.__needs_surrounding_text = False -+ self.emit("disabled") ++ const GValue *newvalue2 = ibus_serializable_get_attachment (object, "key2"); ++ g_assert (newvalue2 != NULL); ++ g_assert_cmpstr (g_value_get_string (newvalue2), ==, "value string"); + - def __commit_text_cb(self, *args): - text = serializable.deserialize_object(args[0]) - self.emit("commit-text", text) -diff --git a/ibus/interface/iinputcontext.py b/ibus/interface/iinputcontext.py -index 2db1c9b..1d3cd2a 100644 ---- a/ibus/interface/iinputcontext.py -+++ b/ibus/interface/iinputcontext.py -@@ -95,6 +95,9 @@ class IInputContext(dbus.service.Object): - @signal(signature="uuu") - def ForwardKeyEvent(self, keyval, keycode, state): pass ++ g_variant_type_info_assert_no_infos (); ++} -+ @signal(signature="iu") -+ def DeleteSurroundingText(self, offset_from_cursor, nchars): pass -+ - @signal(signature="vub") - def UpdatePreeditText(self, text, cursor_pos, visible): pass + gint + main (gint argc, +@@ -142,6 +175,7 @@ main (gint argc, + g_test_add_func ("/ibus/enginedesc", test_engine_desc); + g_test_add_func ("/ibus/lookuptable", test_lookup_table); + g_test_add_func ("/ibus/property", test_property); ++ g_test_add_func ("/ibus/attachment", test_attachment); + return g_test_run (); + } -- -1.7.4.4 +1.7.5.4 -From 59ce675e335e599ed18d74ab8849b9a5fe75d4be Mon Sep 17 00:00:00 2001 +From ac9dfac13cef34288440a2ecdf067cd827fb2f8f Mon Sep 17 00:00:00 2001 From: Peng Huang -Date: Mon, 13 Jun 2011 13:18:29 -0400 -Subject: [PATCH] Fix some race condition between idle and timeout - events. Also fix a memory leak. +Date: Fri, 19 Aug 2011 08:23:33 -0400 +Subject: [PATCH] Use GVariant as attachment for IBusSerializable. -BUG=http://crosbug.com/16387 +BUG=None TEST=Linux desktop -Review URL: http://codereview.appspot.com/4568072 +Review URL: http://codereview.appspot.com/4902051 --- - bus/engineproxy.c | 46 ++++++++++++++++++++++++++++++---------------- - 1 files changed, 30 insertions(+), 16 deletions(-) - -diff --git a/bus/engineproxy.c b/bus/engineproxy.c -index 0c6f45d..f74af12 100644 ---- a/bus/engineproxy.c -+++ b/bus/engineproxy.c -@@ -603,7 +603,8 @@ bus_engine_proxy_new_internal (const gchar *path, - g_assert (IBUS_IS_ENGINE_DESC (desc)); - g_assert (G_IS_DBUS_CONNECTION (connection)); + src/ibusserializable.c | 176 ++++++----------------------------------- + src/ibusserializable.h | 81 +++++++++---------- + src/tests/ibus-serializable.c | 47 ++++++++---- + 3 files changed, 98 insertions(+), 206 deletions(-) + +diff --git a/src/ibusserializable.c b/src/ibusserializable.c +index ed89534..6251c89 100644 +--- a/src/ibusserializable.c ++++ b/src/ibusserializable.c +@@ -124,114 +124,13 @@ ibus_serializable_destroy (IBusSerializable *serializable) + parent_class->destroy (IBUS_OBJECT (serializable)); + } +-static GValue * +-ibus_g_value_dup (const GValue *value) +-{ +- GValue *new_value; +- +- new_value = g_slice_new0 (GValue); +- g_value_init (new_value, G_VALUE_TYPE (value)); +- g_value_copy (value, new_value); +- +- return new_value; +-} +- +-static void +-ibus_g_value_free (GValue *value) +-{ +- g_value_unset (value); +- g_slice_free (GValue, value); +-} +- +-static GVariant * +-_g_value_serialize (GValue *value) +-{ +- GType type; +- +- type = G_VALUE_TYPE (value); +- g_return_val_if_fail (type != G_TYPE_INVALID, FALSE); - -+ GDBusProxyFlags flags = G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START | -+ G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES; - BusEngineProxy *engine = - (BusEngineProxy *) g_initable_new (BUS_TYPE_ENGINE_PROXY, - NULL, -@@ -613,7 +614,7 @@ bus_engine_proxy_new_internal (const gchar *path, - "g-interface-name", IBUS_INTERFACE_ENGINE, - "g-object-path", path, - "g-default-timeout", g_gdbus_timeout, -- "g-flags", G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START | G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, -+ "g-flags", flags, - NULL); - const gchar *layout = ibus_engine_desc_get_layout (desc); - if (layout != NULL && layout[0] != '\0') { -@@ -638,24 +639,33 @@ static void - engine_proxy_new_data_free (EngineProxyNewData *data) +- if (g_type_is_a (type, IBUS_TYPE_SERIALIZABLE)) { +- IBusSerializable *object; +- object = IBUS_SERIALIZABLE (g_value_get_object (value)); +- return ibus_serializable_serialize (object); +- } +- +- typedef const gchar *gstring; +- switch (type) { +-#define CASE_ENTRY(TYPE, _type, signature) \ +- case G_TYPE_##TYPE: \ +- { \ +- g##_type v; \ +- v = g_value_get_##_type (value); \ +- return g_variant_new (signature, v); \ +- } +- CASE_ENTRY(CHAR, char, "y"); +- CASE_ENTRY(BOOLEAN, boolean, "b"); +- CASE_ENTRY(INT, int, "i"); +- CASE_ENTRY(UINT, uint, "u"); +- CASE_ENTRY(INT64, int64, "x"); +- CASE_ENTRY(UINT64, uint64, "t"); +- CASE_ENTRY(FLOAT, float, "d"); +- CASE_ENTRY(DOUBLE, double, "d"); +- CASE_ENTRY(STRING, string, "s"); +-#undef CASE_ENTRY +- } +- +- g_assert_not_reached (); +-} +- +-static GValue * +-_g_value_deserialize (GVariant *variant) +-{ +- GValue *value = NULL; +- const GVariantType *type; +- +- type = g_variant_get_type (variant); +- if (type == G_VARIANT_TYPE_TUPLE) { +- IBusSerializable *object; +- object = ibus_serializable_deserialize (variant); +- value = g_slice_new0 (GValue); +- g_value_init (value, G_OBJECT_TYPE (object)); +- g_value_take_object (value, object); +- return value; +- } +- +- typedef gchar *gstring; +-#define IF_ENTRY(TYPE, _type, signature) \ +- if (g_variant_type_equal(type, G_VARIANT_TYPE_##TYPE)) { \ +- g##_type v; \ +- g_variant_get (variant, signature, &v); \ +- value = g_slice_new0 (GValue); \ +- g_value_init (value, G_TYPE_##TYPE); \ +- g_value_set_##_type (value, v); \ +- return value; \ +- } +-#define G_VARIANT_TYPE_CHAR G_VARIANT_TYPE_BYTE +- IF_ENTRY(CHAR, char, "y"); +-#undef G_VARIANT_TYPE_CHAR +- IF_ENTRY(BOOLEAN, boolean, "b"); +-#define G_VARIANT_TYPE_INT G_VARIANT_TYPE_INT32 +-#define G_VARIANT_TYPE_UINT G_VARIANT_TYPE_UINT32 +- IF_ENTRY(INT, int, "i"); +- IF_ENTRY(UINT, uint, "u"); +-#undef G_VARIANT_TYPE_INT +-#undef G_VARIANT_TYPE_UINT +- IF_ENTRY(INT64, int64, "x"); +- IF_ENTRY(UINT64, uint64, "t"); +- IF_ENTRY(DOUBLE, double, "d"); +- IF_ENTRY(STRING, string, "s"); +- +- g_return_val_if_reached (NULL); +-} +- + static void + _serialize_cb (GQuark key, +- GValue *value, ++ GVariant *value, + GVariantBuilder *array) { - if (data->simple != NULL) { -- if (data->handler_id != 0) -- g_signal_handler_disconnect (data->component, data->handler_id); - g_object_unref (data->simple); - } - -- if (data->component != NULL) -+ if (data->desc != NULL) { -+ g_object_unref (data->desc); -+ } -+ -+ if (data->component != NULL) { -+ if (data->handler_id != 0) { -+ g_signal_handler_disconnect (data->component, data->handler_id); -+ } - g_object_unref (data->component); -+ } - -- if (data->factory != NULL) -+ if (data->factory != NULL) { - g_object_unref (data->factory); -+ } - -- if (data->timeout_id != 0) -+ if (data->timeout_id != 0) { - g_source_remove (data->timeout_id); -+ } + g_variant_builder_add (array, "{sv}", +- g_quark_to_string (key), _g_value_serialize (value)); ++ g_quark_to_string (key), g_variant_new_variant (value)); + } - if (data->cancellable != NULL) { -- if (data->cancelled_handler_id != 0) -+ if (data->cancelled_handler_id != 0) { - g_cancellable_disconnect (data->cancellable, -- data->cancelled_handler_id); -+ data->cancelled_handler_id); -+ } - g_object_unref (data->cancellable); + static gboolean +@@ -257,21 +156,26 @@ ibus_serializable_real_deserialize (IBusSerializable *object, + GVariantIter *iter = NULL; + g_variant_get_child (variant, 1, "a{sv}", &iter); + while (g_variant_iter_loop (iter, "{&sv}", &key, &value)) { +- ibus_serializable_set_attachment (object, key, _g_value_deserialize (value)); ++ GVariant *attachment = g_variant_get_variant (value); ++ ibus_serializable_set_attachment (object, ++ key, ++ attachment); ++ g_variant_unref (attachment); ++ g_variant_unref (value); } + g_variant_iter_free (iter); + return 2; + } -@@ -772,7 +782,8 @@ timeout_cb (EngineProxyNewData *data) - /** - * cancelled_cb: - * -- * A callback function to be called when someone calls g_cancellable_cancel() for the cancellable object for bus_engine_proxy_new. -+ * A callback function to be called when someone calls g_cancellable_cancel() -+ * for the cancellable object for bus_engine_proxy_new. - * Call the GAsyncReadyCallback. - */ - static gboolean -@@ -793,8 +804,12 @@ static void - cancelled_cb (GCancellable *cancellable, - EngineProxyNewData *data) + static void +-_copy_cb (GQuark key, +- GValue *value, +- GData **datalist) ++_copy_cb (GQuark key, ++ GVariant *value, ++ GData **datalist) { -- /* Cancel the bus_engine_proxy_new() in idle to avoid deadlock */ -- g_idle_add ((GSourceFunc) cancelled_idle_cb, data); -+ /* Cancel the bus_engine_proxy_new() in idle to avoid deadlock. -+ * And use HIGH priority to avoid timeout event happening before -+ * idle callback. */ -+ g_idle_add_full (G_PRIORITY_HIGH, -+ (GSourceFunc) cancelled_idle_cb, -+ data, NULL); + g_datalist_id_set_data_full (datalist, + key, +- ibus_g_value_dup (value), +- (GDestroyNotify) ibus_g_value_free); ++ g_variant_ref (value), ++ (GDestroyNotify) g_variant_unref); } - void -@@ -831,13 +846,12 @@ bus_engine_proxy_new (IBusEngineDesc *desc, - data->simple = simple; - data->timeout = timeout; - -- g_object_set_data ((GObject *)data->simple, "EngineProxyNewData", data); -- - data->factory = bus_component_get_factory (data->component); - - if (data->factory == NULL) { -- /* The factory is not ready yet. Create the factory first, and wait for the "notify::factory" signal. -- * In the handler of "notify::factory", we'll create the engine proxy. */ -+ /* The factory is not ready yet. Create the factory first, and wait for -+ * the "notify::factory" signal. In the handler of "notify::factory", -+ * we'll create the engine proxy. */ - data->handler_id = g_signal_connect (data->component, - "notify::factory", - G_CALLBACK (notify_factory_cb), --- -1.7.4.4 - -From fc9dedec30f724e91e7b3bb9111177e96b58ee43 Mon Sep 17 00:00:00 2001 -From: Peng Huang -Date: Wed, 15 Jun 2011 10:38:17 -0400 -Subject: [PATCH] Add IBUS_ERROR domain and reply IBUS_ERROR_NO_ENGINE - in org.freedesktop.IBus.InputContext.GetEngine - -BUG=None -TEST=Manually - -Review URL: http://codereview.appspot.com/4528140 ---- - bus/inputcontext.c | 7 ++++- - src/Makefile.am | 2 + - src/ibus.h | 1 + - src/ibuserror.c | 41 +++++++++++++++++++++++++++++++++ - src/ibuserror.h | 46 +++++++++++++++++++++++++++++++++++++ - src/ibusinputcontext.c | 15 +++++++++-- - src/ibusshare.c | 1 + - src/ibustypes.h | 9 +++++++ - src/tests/ibus-gi-inputcontext.py | 34 +++++++++++++++++++++++++++ - 9 files changed, 151 insertions(+), 5 deletions(-) - create mode 100644 src/ibuserror.c - create mode 100644 src/ibuserror.h - create mode 100755 src/tests/ibus-gi-inputcontext.py - -diff --git a/bus/inputcontext.c b/bus/inputcontext.c -index bad90ec..1567c5f 100644 ---- a/bus/inputcontext.c -+++ b/bus/inputcontext.c -@@ -1040,8 +1040,11 @@ _ic_get_engine (BusInputContext *context, - g_variant_new ("(v)", ibus_serializable_serialize ((IBusSerializable *)desc))); - } - else { -- g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, -- "Input context does not have engine."); -+ g_dbus_method_invocation_return_error ( -+ invocation, -+ IBUS_ERROR, -+ IBUS_ERROR_NO_ENGINE, -+ "Input context does not have engine."); - } + static gboolean +@@ -289,50 +193,21 @@ ibus_serializable_real_copy (IBusSerializable *dest, + return TRUE; } -diff --git a/src/Makefile.am b/src/Makefile.am -index 632fc72..a53bd23 100644 ---- a/src/Makefile.am -+++ b/src/Makefile.am -@@ -70,6 +70,7 @@ ibus_sources = \ - ibusservice.c \ - ibusfactory.c \ - ibusengine.c \ -+ ibuserror.c \ - ibustext.c \ - ibuskeymap.c \ - ibusattribute.c \ -@@ -114,6 +115,7 @@ ibus_headers = \ - ibusservice.h \ - ibusfactory.h \ - ibusengine.h \ -+ ibuserror.h \ - ibustext.h \ - ibuskeymap.h \ - ibusattribute.h \ -diff --git a/src/ibus.h b/src/ibus.h -index 8df7160..c408f3d 100644 ---- a/src/ibus.h -+++ b/src/ibus.h -@@ -35,6 +35,7 @@ - #include - #include - #include -+#include - #include - #include - #include -diff --git a/src/ibuserror.c b/src/ibuserror.c -new file mode 100644 -index 0000000..c50c164 ---- /dev/null -+++ b/src/ibuserror.c -@@ -0,0 +1,41 @@ -+/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */ -+/* vim:set et sts=4: */ -+/* ibus - The Input Bus -+ * Copyright (C) 2011 Peng Huang -+ * -+ * This library is free software; you can redistribute it and/or -+ * modify it under the terms of the GNU Lesser General Public -+ * License as published by the Free Software Foundation; either -+ * version 2 of the License, or (at your option) any later version. -+ * -+ * This library is distributed in the hope that it will be useful, -+ * but WITHOUT ANY WARRANTY; without even the implied warranty of -+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -+ * Lesser General Public License for more details. -+ * -+ * You should have received a copy of the GNU Lesser General Public -+ * License along with this library; if not, write to the -+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330, -+ * Boston, MA 02111-1307, USA. -+ */ -+ -+#include "ibuserror.h" -+ -+#include -+#include "ibustypes.h" -+ -+static const GDBusErrorEntry ibus_error_entries[] = -+{ -+ { IBUS_ERROR_NO_ENGINE, "org.freedesktop.IBus.Error.NoEngine" }, -+}; -+ -+GQuark -+ibus_error_quark (void) -+{ -+ static volatile gsize quark_volatile = 0; -+ g_dbus_error_register_error_domain ("ibus-error-quark", -+ &quark_volatile, -+ ibus_error_entries, -+ G_N_ELEMENTS (ibus_error_entries)); -+ return (GQuark) quark_volatile; -+} -diff --git a/src/ibuserror.h b/src/ibuserror.h -new file mode 100644 -index 0000000..75c64b9 ---- /dev/null -+++ b/src/ibuserror.h -@@ -0,0 +1,46 @@ -+/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */ -+/* vim:set et sts=4: */ -+/* ibus - The Input Bus -+ * Copyright (C) 2011 Peng Huang -+ * -+ * This library is free software; you can redistribute it and/or -+ * modify it under the terms of the GNU Lesser General Public -+ * License as published by the Free Software Foundation; either -+ * version 2 of the License, or (at your option) any later version. -+ * -+ * This library is distributed in the hope that it will be useful, -+ * but WITHOUT ANY WARRANTY; without even the implied warranty of -+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -+ * Lesser General Public License for more details. -+ * -+ * You should have received a copy of the GNU Lesser General Public -+ * License along with this library; if not, write to the -+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330, -+ * Boston, MA 02111-1307, USA. -+ */ -+ -+#if !defined (__IBUS_H_INSIDE__) && !defined (IBUS_COMPILATION) -+#error "Only can be included directly" -+#endif -+ -+/** -+ * SECTION: ibusshare -+ * @short_description: Shared utility functions and definition. -+ * @stability: Stable -+ * -+ * This file defines some utility functions and definition -+ * which are shared among ibus component and services. -+ */ -+ -+#ifndef __IBUS_ERROR_H_ -+#define __IBUS_ERROR_H_ -+ -+#include -+ -+G_BEGIN_DECLS -+ -+#define IBUS_ERROR ibus_error_quark() -+GQuark ibus_error_quark (void); -+ -+G_END_DECLS -+#endif -diff --git a/src/ibusinputcontext.c b/src/ibusinputcontext.c -index e6f97e8..78d454e 100644 ---- a/src/ibusinputcontext.c -+++ b/src/ibusinputcontext.c -@@ -27,6 +27,7 @@ - #include "ibusattribute.h" - #include "ibuslookuptable.h" - #include "ibusproplist.h" -+#include "ibuserror.h" - - #define IBUS_INPUT_CONTEXT_GET_PRIVATE(o) \ - (G_TYPE_INSTANCE_GET_PRIVATE ((o), IBUS_TYPE_INPUT_CONTEXT, IBusInputContextPrivate)) -@@ -1164,7 +1165,7 @@ IBusEngineDesc * - ibus_input_context_get_engine (IBusInputContext *context) +-gboolean +-ibus_serializable_set_qattachment (IBusSerializable *object, ++void ++ibus_serializable_set_qattachment (IBusSerializable *serializable, + GQuark key, +- const GValue *value) ++ GVariant *value) { - g_assert (IBUS_IS_INPUT_CONTEXT (context)); -- GVariant *result; -+ GVariant *result = NULL; - GError *error = NULL; - result = g_dbus_proxy_call_sync ((GDBusProxy *) context, - "GetEngine", /* method_name */ -@@ -1174,9 +1175,17 @@ ibus_input_context_get_engine (IBusInputContext *context) - NULL, /* cancellable */ - &error /* error */ - ); +- g_return_val_if_fail (IBUS_IS_SERIALIZABLE (object), FALSE); +- g_return_val_if_fail (key != 0, FALSE); +- g_return_val_if_fail (G_IS_VALUE (value), FALSE); - - if (result == NULL) { -- g_warning ("%s.GetEngine: %s", IBUS_INTERFACE_INPUT_CONTEXT, error->message); -+ if (g_error_matches (error, IBUS_ERROR, IBUS_ERROR_NO_ENGINE)) { -+ g_debug ("%s.GetEngine: %s", -+ IBUS_INTERFACE_INPUT_CONTEXT, -+ error->message); -+ } -+ else { -+ g_warning ("%s.GetEngine: %s", -+ IBUS_INTERFACE_INPUT_CONTEXT, -+ error->message); -+ } - g_error_free (error); - return NULL; - } -diff --git a/src/ibusshare.c b/src/ibusshare.c -index 1b8ae2a..19f9f65 100644 ---- a/src/ibusshare.c -+++ b/src/ibusshare.c -@@ -318,6 +318,7 @@ void - ibus_init (void) - { - g_type_init (); -+ IBUS_ERROR; - IBUS_TYPE_TEXT; - IBUS_TYPE_ATTRIBUTE; - IBUS_TYPE_ATTR_LIST; -diff --git a/src/ibustypes.h b/src/ibustypes.h -index 6a31847..8146719 100644 ---- a/src/ibustypes.h -+++ b/src/ibustypes.h -@@ -177,6 +177,15 @@ typedef enum { - } IBusBusRequestNameReply; - - /** -+ * IBusError: -+ * @IBUS_ERROR_NO_ENGINE: -+ * There is no engine associated with input context. -+ */ -+typedef enum { -+ IBUS_ERROR_NO_ENGINE, -+} IBusError; -+ -+/** - * IBusRectangle: - * @x: x coordinate. - * @y: y coordinate. -diff --git a/src/tests/ibus-gi-inputcontext.py b/src/tests/ibus-gi-inputcontext.py -new file mode 100755 -index 0000000..80fb97b ---- /dev/null -+++ b/src/tests/ibus-gi-inputcontext.py -@@ -0,0 +1,34 @@ -+#!/usr/bin/env python -+# vim:set et sts=4 sw=4: -+# -+# ibus - The Input Bus -+# -+# Copyright (c) 2011 Peng Huang -+# -+# This library is free software; you can redistribute it and/or -+# modify it under the terms of the GNU Lesser General Public -+# License as published by the Free Software Foundation; either -+# version 2 of the License, or (at your option) any later version. -+# -+# This library is distributed in the hope that it will be useful, -+# but WITHOUT ANY WARRANTY; without even the implied warranty of -+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -+# GNU Lesser General Public License for more details. -+# -+# You should have received a copy of the GNU Lesser General Public -+# License along with this program; if not, write to the -+# Free Software Foundation, Inc., 59 Temple Place, Suite 330, -+# Boston, MA 02111-1307 USA -+ -+ -+import glib -+import gio -+from gi.repository import IBus -+IBus.init() -+main = glib.MainLoop() -+bus = IBus.Bus() -+ic = bus.create_input_context("ibus-test") -+ic.get_engine() -+ic.get_engine() -+ic.get_engine() -+ic.get_engine() --- -1.7.4.4 - -From aec97ac090980dfcd7eeef55c1755f6cd3f87a01 Mon Sep 17 00:00:00 2001 -From: Daiki Ueno -Date: Sat, 18 Jun 2011 00:03:07 -0400 -Subject: [PATCH] Simplify surrounding-text initialization. - -Currently the immodule tries to retrieve surrounding-text unconditionally -on focus_in and enabled. These calls could be eliminated if engine were -able to proclaim that it will need surrounding-text. - -This patch extends ibus_engine_get_surrounding_text() to allow this. -Engines that need surrounding-text are expected to have: - - /* Indicate we will use surrounding-text. */ - ibus_engine_get_surrounding_text (engine, NULL, NULL); - -in their enable() method. This would work because enable() is called before -SetCapabilities DBus call. - -BUG=none -TEST=manually with ibus-m17n, with the above change. - -Review URL: http://codereview.appspot.com/4613043 -Patch from Daiki Ueno . ---- - client/gtk2/ibusimcontext.c | 23 +++++++++-------------- - src/ibusengine.c | 10 ++++++---- - src/ibusengine.h | 9 +++++++-- - 3 files changed, 22 insertions(+), 20 deletions(-) - -diff --git a/client/gtk2/ibusimcontext.c b/client/gtk2/ibusimcontext.c -index ec764ef..a4e7a16 100644 ---- a/client/gtk2/ibusimcontext.c -+++ b/client/gtk2/ibusimcontext.c -@@ -147,8 +147,7 @@ static gboolean _slave_delete_surroundin - gint offset_from_cursor, - guint nchars, - IBusIMContext *context); --static void _request_surrounding_text (IBusIMContext *context, -- gboolean force); -+static void _request_surrounding_text (IBusIMContext *context); - static void _create_fake_input_context (void); - - -@@ -263,17 +262,13 @@ _process_key_event_done (GObject *o - /* emit "retrieve-surrounding" glib signal of GtkIMContext, if - * context->caps has IBUS_CAP_SURROUNDING_TEXT and the current IBus - * engine needs surrounding-text. -- * -- * if "force" is TRUE, emit the signal regardless of whether the -- * engine needs surrounding-text. - */ - static void --_request_surrounding_text (IBusIMContext *context, gboolean force) -+_request_surrounding_text (IBusIMContext *context) - { -- if (context->enable && -+ if (context && context->enable && - (context->caps & IBUS_CAP_SURROUNDING_TEXT) != 0 && -- (force || -- ibus_input_context_needs_surrounding_text (context->ibuscontext))) { -+ ibus_input_context_needs_surrounding_text (context->ibuscontext)) { - gboolean return_value; - IDEBUG ("requesting surrounding text"); - g_signal_emit (context, _signal_retrieve_surrounding_id, 0, -@@ -368,9 +363,8 @@ _key_snooper_cb (GtkWidget *widget, - - } while (0); - -- _request_surrounding_text (ibusimcontext, FALSE); +- IBusSerializablePrivate *priv; +- priv = IBUS_SERIALIZABLE_GET_PRIVATE (object); - - if (ibusimcontext != NULL) { -+ _request_surrounding_text (ibusimcontext); - ibusimcontext->time = event->time; - } - -@@ -680,7 +674,7 @@ ibus_im_context_filter_keypress (GtkIMCo - if (ibusimcontext->client_window == NULL && event->window != NULL) - gtk_im_context_set_client_window ((GtkIMContext *)ibusimcontext, event->window); - -- _request_surrounding_text (ibusimcontext, FALSE); -+ _request_surrounding_text (ibusimcontext); - - if (ibusimcontext != NULL) { - ibusimcontext->time = event->time; -@@ -763,7 +757,7 @@ ibus_im_context_focus_in (GtkIMContext * - - /* retrieve the initial surrounding-text (regardless of whether - * the current IBus engine needs surrounding-text) */ -- _request_surrounding_text (ibusimcontext, TRUE); -+ _request_surrounding_text (ibusimcontext); - - g_object_add_weak_pointer ((GObject *) context, - (gpointer *) &_focus_im_context); -@@ -1000,7 +996,7 @@ _ibus_context_commit_text_cb (IBusInputC - - g_signal_emit (ibusimcontext, _signal_commit_id, 0, text->text); - -- _request_surrounding_text (ibusimcontext, FALSE); -+ _request_surrounding_text (ibusimcontext); +- GType type = G_VALUE_TYPE (value); +- +- switch (type) { +- case G_TYPE_CHAR: +- case G_TYPE_INT: +- case G_TYPE_INT64: +- case G_TYPE_UINT: +- case G_TYPE_UINT64: +- case G_TYPE_BOOLEAN: +- case G_TYPE_DOUBLE: +- case G_TYPE_FLOAT: +- case G_TYPE_STRING: +- g_datalist_id_set_data_full (&priv->attachments, +- key, +- ibus_g_value_dup (value), +- (GDestroyNotify) ibus_g_value_free); +- return TRUE; +- } +- +- if (g_type_is_a (type, IBUS_TYPE_SERIALIZABLE)) { +- g_datalist_id_set_data_full (&priv->attachments, +- key, +- ibus_g_value_dup (value), +- (GDestroyNotify) ibus_g_value_free); +- return TRUE; +- } ++ g_return_if_fail (IBUS_IS_SERIALIZABLE (serializable)); ++ g_return_if_fail (key != 0); + +- g_warning ("The value of %s is not support serializing", g_type_name (type)); +- return FALSE; ++ g_datalist_id_set_data_full (&serializable->priv->attachments, ++ key, ++ value ? g_variant_ref_sink (value) : NULL, ++ (GDestroyNotify) g_variant_unref); } - static gboolean -@@ -1296,7 +1292,7 @@ _ibus_context_show_preedit_text_cb (IBus - g_signal_emit (ibusimcontext, _signal_preedit_start_id, 0); - g_signal_emit (ibusimcontext, _signal_preedit_changed_id, 0); +-const GValue * ++GVariant * + ibus_serializable_get_qattachment (IBusSerializable *serializable, + GQuark key) + { +@@ -340,7 +215,8 @@ ibus_serializable_get_qattachment (IBusSerializable *serializable, + g_return_val_if_fail (IBUS_IS_SERIALIZABLE (serializable), NULL); + g_return_val_if_fail (key != 0, NULL); -- _request_surrounding_text (ibusimcontext, FALSE); -+ _request_surrounding_text (ibusimcontext); +- return (const GValue *) g_datalist_id_get_data (&serializable->priv->attachments, key); ++ return (GVariant *) g_datalist_id_get_data ( ++ &serializable->priv->attachments, key); } - static void -@@ -1323,7 +1319,7 @@ _ibus_context_enabled_cb (IBusInputConte + void +@@ -351,7 +227,7 @@ ibus_serializable_remove_qattachment (IBusSerializable *serializable, + g_return_if_fail (IBUS_IS_SERIALIZABLE (serializable)); + g_return_if_fail (key != 0); - /* retrieve the initial surrounding-text (regardless of whether - * the current IBus engine needs surrounding-text) */ -- _request_surrounding_text (ibusimcontext, TRUE); -+ _request_surrounding_text (ibusimcontext); +- g_datalist_id_remove_no_notify (&serializable->priv->attachments, key); ++ g_datalist_id_set_data (&serializable->priv->attachments, key, NULL); } - static void -diff --git a/src/ibusengine.c b/src/ibusengine.c -index f545bef..620d07f 100644 ---- a/src/ibusengine.c -+++ b/src/ibusengine.c -@@ -1382,13 +1382,15 @@ ibus_engine_get_surrounding_text (IBusEngine *engine, - IBusEnginePrivate *priv; - - g_return_if_fail (IBUS_IS_ENGINE (engine)); -- g_return_if_fail (text != NULL); -- g_return_if_fail (cursor_pos != NULL); -+ g_return_if_fail ((text != NULL && cursor_pos != NULL) || -+ (text == NULL && cursor_pos == NULL)); + IBusSerializable * +diff --git a/src/ibusserializable.h b/src/ibusserializable.h +index 8fd9f8a..7a100c2 100644 +--- a/src/ibusserializable.h ++++ b/src/ibusserializable.h +@@ -126,39 +126,40 @@ struct _IBusSerializable { - priv = IBUS_ENGINE_GET_PRIVATE (engine); + /** + * IBusSerializableSerializeFunc: +- * @object: An IBusSerializable. +- * @iter: An IBusMessageIter. +- * @returns: TRUE if succeed; FALSE otherwise. ++ * @serializable: An #IBusSerializable. ++ * @builder: A #GVariantBuilder. ++ * @returns: %TRUE if succeed; %FALSE otherwise. + * + * Prototype of serialize function. + * Serialize function convert an IBusSerializable to IBusMessageIter. + * Returns a gboolean value which indicates whether the conversion is success. +- * Return TRUE if succeed. ++ * Return %TRUE if succeed. + */ +-typedef gboolean (* IBusSerializableSerializeFunc) (IBusSerializable *object, ++typedef gboolean (* IBusSerializableSerializeFunc) (IBusSerializable *serializable, + GVariantBuilder *builder); -- *text = g_object_ref (priv->surrounding_text); -- *cursor_pos = priv->surrounding_cursor_pos; -+ if (text && cursor_pos) { -+ *text = g_object_ref (priv->surrounding_text); -+ *cursor_pos = priv->surrounding_cursor_pos; -+ } + /** + * IBusSerializableDeserializeFunc: +- * @object: An IBusSerializable. +- * @iter: An IBusMessageIter. +- * @returns: TRUE if succeed; FALSE otherwise. ++ * @serializable: An #IBusSerializable. ++ * @variant: A #GVariant contains a tuple. ++ * @returns: The number of values in the variant(tuple) are consumed. + * + * Prototype of deserialize function. + * Deserialize function convert an IBusMessageIter to IBusSerializable. +- * Returns a gboolean value which indicates whether the conversion is success. ++ * Returns an integer value which indicates how many values in ++ * the variant(tuple) are consumed. + */ +-typedef gint (* IBusSerializableDeserializeFunc) (IBusSerializable *object, ++typedef gint (* IBusSerializableDeserializeFunc) (IBusSerializable *serializable, + GVariant *variant); - /* tell the client that this engine will utilize surrounding-text - * feature, which causes periodical update. Note that the client -diff --git a/src/ibusengine.h b/src/ibusengine.h -index 29b8f1d..6da342a 100644 ---- a/src/ibusengine.h -+++ b/src/ibusengine.h -@@ -407,11 +407,16 @@ void ibus_engine_delete_surrounding_text(IBusEngine *engine, /** - * ibus_engine_get_surrounding_text: - * @engine: An IBusEngine. -- * @text: Location to store surrounding text. -- * @cursor_pos: Cursor position in characters in @text. -+ * @text: (allow-none): Location to store surrounding text. -+ * @cursor_pos: (allow-none): Cursor position in characters in @text. + * IBusSerializableCopyFunc: +- * @dest: The destination IBusSerializable. +- * @src: A source IBusMessageIter. +- * @returns: TRUE if succeed; FALSE otherwise. ++ * @dest: The destination #IBusSerializable. ++ * @src: A source #IBusMessageIter. ++ * @returns: %TRUE if succeed; %FALSE otherwise. * - * Get surrounding text. + * Prototype of copy function. +- * Copy function copy from source IBusSerializable to the destination one. ++ * Copy function copy from source #IBusSerializable to the destination one. + * Returns a gboolean value which indicates whether the copying is success. + */ + typedef gboolean (* IBusSerializableCopyFunc) (IBusSerializable *dest, +@@ -188,79 +189,77 @@ GType ibus_serializable_get_type (void); * -+ * It is also used to tell the input-context that the engine will -+ * utilize surrounding-text. In that case, it must be called in -+ * #IBusEngine::enable handler, with both @text and @cursor set to -+ * %NULL. -+ * - * @see_also #IBusEngine::set-surrounding-text + * Returns: a new instance of #IBusSerializable. */ - void ibus_engine_get_surrounding_text(IBusEngine *engine, --- -1.7.4.4 - -From a25187a315e9dfbb36a3e4a4f8e96f18e2cc6e0d Mon Sep 17 00:00:00 2001 -From: fujiwarat -Date: Tue, 5 Jul 2011 12:15:55 +0900 -Subject: [PATCH] Fix SEGV in ibus_keymap_lookup_keysym - ---- - bus/engineproxy.c | 2 +- - 1 files changed, 1 insertions(+), 1 deletions(-) - -diff --git a/bus/engineproxy.c b/bus/engineproxy.c -index 95e9e0b..a49d6fd 100644 ---- a/bus/engineproxy.c -+++ b/bus/engineproxy.c -@@ -907,7 +907,7 @@ bus_engine_proxy_process_key_event (BusEngineProxy *engine, - if (keymap == NULL) - keymap = BUS_DEFAULT_KEYMAP; - if (keymap != NULL) { -- guint t = ibus_keymap_lookup_keysym (engine->keymap, keycode, state); -+ guint t = ibus_keymap_lookup_keysym (keymap, keycode, state); - if (t != IBUS_VoidSymbol) { - keyval = t; - } --- -1.7.5.4 - -From 83d4b3ac538320bfb8e872dd9282ca5bbedf4652 Mon Sep 17 00:00:00 2001 -From: Peng Huang -Date: Mon, 4 Jul 2011 03:27:23 +0800 -Subject: [PATCH] Fix BusEngineProxy instance leak. - -BUG=none -TEST=manually with / without global-engine setting - -Review URL: http://codereview.appspot.com/4662043 ---- - bus/engineproxy.c | 9 --------- - bus/inputcontext.c | 5 +---- - 2 files changed, 1 insertions(+), 13 deletions(-) - -diff --git a/bus/engineproxy.c b/bus/engineproxy.c -index f74af12..95e9e0b 100644 ---- a/bus/engineproxy.c -+++ b/bus/engineproxy.c -@@ -397,15 +397,6 @@ bus_engine_proxy_real_destroy (IBusProxy *proxy) - { - BusEngineProxy *engine = (BusEngineProxy *)proxy; - -- g_dbus_proxy_call ((GDBusProxy *)proxy, -- "org.freedesktop.IBus.Service.Destroy", -- NULL, -- G_DBUS_CALL_FLAGS_NONE, -- -1, -- NULL, -- NULL, -- NULL); -- - if (engine->desc) { - g_object_unref (engine->desc); - engine->desc = NULL; -diff --git a/bus/inputcontext.c b/bus/inputcontext.c -index 1567c5f..2164e7c 100644 ---- a/bus/inputcontext.c -+++ b/bus/inputcontext.c -@@ -1020,8 +1020,6 @@ _ic_set_engine (BusInputContext *context, - NULL, - (GAsyncReadyCallback)_ic_set_engine_done, - invocation); -- -- g_object_unref (desc); - } +-IBusSerializable * ibus_serializable_new (void); ++IBusSerializable *ibus_serializable_new (void); /** -@@ -2091,7 +2089,6 @@ bus_input_context_enable (BusInputContext *context) - NULL, /* we do not cancel the call. */ - NULL, /* use the default callback function. */ - NULL); -- g_object_unref (desc); - } - } - -@@ -2192,7 +2189,6 @@ bus_input_context_unset_engine (BusInputContext *context) - for (i = 0; engine_signals[i].name != NULL; i++) { - g_signal_handlers_disconnect_by_func (context->engine, engine_signals[i].callback, context); - } -- /* Do not destroy the engine anymore, because of global engine feature */ - g_object_unref (context->engine); - context->engine = NULL; - } -@@ -2291,6 +2287,7 @@ new_engine_cb (GObject *obj, - } - else { - bus_input_context_set_engine (data->context, engine); -+ g_object_unref (engine); - bus_input_context_enable (data->context); - g_simple_async_result_set_op_res_gboolean (data->simple, TRUE); - } --- -1.7.5.4 - -From 624c4451da2bd171bd8ac53a9b9dd2a4227ef67f Mon Sep 17 00:00:00 2001 -From: Peng Huang -Date: Thu, 7 Jul 2011 12:42:52 -0400 -Subject: [PATCH] Fix several GVariant related issues. And remove a wrong - unref. - -BUG=None -TEST=Linux desktop - -Review URL: http://codereview.appspot.com/4667067 ---- - bus/ibusimpl.c | 11 +++++------ - bus/inputcontext.c | 1 - - src/ibusconfig.c | 8 ++------ - 3 files changed, 7 insertions(+), 13 deletions(-) - -diff --git a/bus/ibusimpl.c b/bus/ibusimpl.c -index b356b2c..42afeec 100644 ---- a/bus/ibusimpl.c -+++ b/bus/ibusimpl.c -@@ -2183,8 +2183,8 @@ bus_ibus_impl_save_global_engine_name_to_config (BusIBusImpl *ibus) - ibus->use_global_engine && - ibus->global_engine_name) { - ibus_config_set_value (ibus->config, -- "general", "global_engine", -- g_variant_new ("s", ibus->global_engine_name)); -+ "general", "global_engine", -+ g_variant_new_string (ibus->global_engine_name)); - } - } - -@@ -2206,8 +2206,7 @@ bus_ibus_impl_load_global_previous_engine_name_from_config (BusIBusImpl *ibus) - GVariant *value = ibus_config_get_value (ibus->config, "general", "global_previous_engine"); - if (value == NULL) - return NULL; -- gchar *engine_name = NULL; -- g_variant_get (value, "(s)", &engine_name); -+ gchar *engine_name = g_variant_dup_string (value, NULL); - g_variant_unref (value); - return engine_name; - } -@@ -2226,8 +2225,8 @@ bus_ibus_impl_save_global_previous_engine_name_to_config (BusIBusImpl *ibus) - ibus->use_global_engine && - ibus->global_previous_engine_name) { - ibus_config_set_value (ibus->config, -- "general", "global_previous_engine", -- g_variant_new ("s", ibus->global_previous_engine_name)); -+ "general", "global_previous_engine", -+ g_variant_new_string (ibus->global_previous_engine_name)); - } - } - -diff --git a/bus/inputcontext.c b/bus/inputcontext.c -index 2164e7c..47ac9d5 100644 ---- a/bus/inputcontext.c -+++ b/bus/inputcontext.c -@@ -1171,7 +1171,6 @@ bus_input_context_focus_in (BusInputContext *context) - NULL, /* we do not cancel the call. */ - NULL, /* use the default callback function. */ - NULL); -- g_object_unref (desc); - } - } - -diff --git a/src/ibusconfig.c b/src/ibusconfig.c -index 36ef44b..b691277 100644 ---- a/src/ibusconfig.c -+++ b/src/ibusconfig.c -@@ -191,7 +191,6 @@ ibus_config_get_value (IBusConfig *conf - - GVariant *value = NULL; - g_variant_get (result, "(v)", &value); -- g_variant_ref (value); - g_variant_unref (result); + * ibus_serializable_set_qattachment: +- * @object: An IBusSerializable. ++ * @serializable: An #IBusSerializable. + * @key: String formatted key for indexing value. +- * @value: Value to be attached. Should be also serializable. +- * @returns: TRUE if succeed; FALSE otherwise. ++ * @value: Value to be attached or %NULL to remove any prevoius value. + * +- * Attach a value to an IBusSerializable. The value should be serializable as well. +- * Basic type such as integer, string are deemed to be serializable. ++ * Attach a value to an IBusSerializable. If the value is floating, ++ * the serializable will take the ownership. + * + * @see_also: ibus_serializable_set_attachment(). + */ +-gboolean ibus_serializable_set_qattachment (IBusSerializable *object, ++void ibus_serializable_set_qattachment (IBusSerializable *serializable, + GQuark key, +- const GValue *value); ++ GVariant *value); - return value; -@@ -235,7 +234,6 @@ ibus_config_get_value_async_finish (IBus - error); - if (retval != NULL) { - g_variant_get (retval, "(v)", &value); -- g_variant_ref (value); - g_variant_unref (retval); - } + /** + * ibus_serializable_get_qattachment: +- * @object: An IBusSerializable. ++ * @serializable: An #IBusSerializable. + * @key: String formatted key for indexing value. +- * @returns: The attached value; or NULL if fail to retrieve the value. ++ * @returns: The attached value; or %NULL if fail to retrieve the value. + * +- * Get a value from attachment of an IBusSerializable. ++ * Get a value from attachment of an #IBusSerializable. + * @see_also: ibus_serializable_set_attachment(). + */ +-const GValue *ibus_serializable_get_qattachment (IBusSerializable *object, ++GVariant *ibus_serializable_get_qattachment (IBusSerializable *serializable, + GQuark key); --- -1.7.5.4 - -From 55a5652ac7d91fb319ef6576500e421eb53e80f4 Mon Sep 17 00:00:00 2001 -From: Yusuke Sato -Date: Mon, 11 Jul 2011 11:55:19 +0900 -Subject: [PATCH] Remove the callback on destroy. - -BUG=crosbug.com/17293 -TEST=src/tests/ibus-bus.c - -Review URL: http://codereview.appspot.com/4675074 ---- - src/ibusbus.c | 4 ++++ - 1 files changed, 6 insertions(+), 0 deletions(-) - -diff --git a/src/ibusbus.c b/src/ibusbus.c -index 39ad784..2607448 100644 ---- a/src/ibusbus.c -+++ b/src/ibusbus.c -@@ -398,8 +398,12 @@ ibus_bus_destroy (IBusObject *object) - } + /** + * ibus_serializable_remove_qattachment: +- * @object: An IBusSerializable. ++ * @serializable: An #IBusSerializable. + * @key: String formatted key for indexing value. + * +- * Remove a value from attachment of an IBusSerializable. ++ * Remove a value from attachment of an #IBusSerializable. + * @see_also: ibus_serializable_remove_attachment(). + */ + void ibus_serializable_remove_qattachment +- (IBusSerializable *object, ++ (IBusSerializable *serializable, + GQuark key); - if (bus->priv->connection) { -+ g_signal_handlers_disconnect_by_func (bus->priv->connection, -+ G_CALLBACK (_connection_closed_cb), -+ bus); - /* FIXME should use async close function */ - g_dbus_connection_close_sync (bus->priv->connection, NULL, NULL); -+ g_object_unref (bus->priv->connection); - bus->priv->connection = NULL; - } + /** + * ibus_serializable_copy: +- * @object: An IBusSerializable. +- * @returns: A newly allocated clone object; or NULL if @object is not serializable. ++ * @serializable: An #IBusSerializable. ++ * @returns: A newly allocated clone object; or %NULL if @object is not serializable. + * +- * Clone an IBusSerializable. ++ * Clone an #IBusSerializable. + * The copy method should be implemented in extended class. + * + * @see_also: IBusSerializableCopyFunc(). + */ +-IBusSerializable *ibus_serializable_copy (IBusSerializable *object); ++IBusSerializable *ibus_serializable_copy (IBusSerializable *serializable); --- -1.7.5.4 - -From 290a37e1d4e3ec44dfea4b99744520f781c92592 Mon Sep 17 00:00:00 2001 -From: Yusuke Sato -Date: Tue, 12 Jul 2011 14:04:30 +0900 -Subject: [PATCH] Use g_variant_dup_string for consistency. - -This fix is similar to https://github.com/ibus/ibus/commit/624c4451da2bd171bd8ac53a9b9dd2a4227ef67f . - -BUG=None -TEST=None - -Review URL: http://codereview.appspot.com/4641101 ---- - bus/ibusimpl.c | 2 +- - 1 files changed, 1 insertions(+), 1 deletions(-) - -diff --git a/bus/ibusimpl.c b/bus/ibusimpl.c -index 42afeec..b6b2441 100644 ---- a/bus/ibusimpl.c -+++ b/bus/ibusimpl.c -@@ -2163,7 +2163,7 @@ bus_ibus_impl_load_global_engine_name_from_config (BusIBusImpl *ibus) - GVariant *variant = ibus_config_get_value (ibus->config, "general", "global_engine"); - gchar *engine_name = NULL; - if (variant != NULL) { -- g_variant_get (variant, "s", &engine_name); -+ engine_name = g_variant_dup_string (variant, NULL); - g_variant_unref (variant); - } - return engine_name; --- -1.7.5.4 - -From 48cc200d7dbe999f92b05507a7c59bea42ac6f1c Mon Sep 17 00:00:00 2001 -From: fujiwarat -Date: Tue, 12 Jul 2011 15:14:59 +0900 -Subject: [PATCH] Fixed an error in IBus.Bus.register_component - -TEST=Linux desktop - -Review URL: http://codereview.appspot.com/4668060 ---- - ibus/component.py | 9 +++++---- - 1 files changed, 5 insertions(+), 4 deletions(-) - -diff --git a/ibus/component.py b/ibus/component.py -index 12f593d..7255ee1 100644 ---- a/ibus/component.py -+++ b/ibus/component.py -@@ -94,6 +94,11 @@ class Component(Serializable): - engine = EngineDesc(name, longname, description, language, license, author, icon, layout, hotkeys) - self.__engines.append(engine) + /** + * ibus_serializable_serialize: +- * @object: An IBusSerializable. +- * @iter: An IBusMessageIter. +- * @returns: TRUE if succeed; FALSE otherwise. ++ * @serializable: An #IBusSerializable. ++ * @returns: A #GVariant. + * +- * Serialize an IBusSerializable to an IBusMessageIter. ++ * Serialize an #IBusSerializable to a #GVariant. + * The serialize method should be implemented in extended class. + * + * @see_also: IBusSerializableCopyFunc(). + */ +-GVariant *ibus_serializable_serialize (IBusSerializable *object); ++GVariant *ibus_serializable_serialize (IBusSerializable *serializable); -+ def add_engines(self, engines): -+ if not isinstance(engines, list): -+ raise TypeError("engines must be an instance of list") -+ self.__engines.extend(engines) + /** + * ibus_serializable_deserialize: +- * @iter: An IBusMessageIter. +- * @returns: The deserialized IBusSerializable. ++ * @variant: A #GVariant. ++ * @returns: The deserialized #IBusSerializable. + * +- * Deserialize an IBusMessageIter to an IBusSerializable/ ++ * Deserialize a #GVariant to an #IBusSerializable/ + * The deserialize method should be implemented in extended class. + * + * @see_also: IBusSerializableCopyFunc(). +diff --git a/src/tests/ibus-serializable.c b/src/tests/ibus-serializable.c +index e2541ec..d2bd61a 100644 +--- a/src/tests/ibus-serializable.c ++++ b/src/tests/ibus-serializable.c +@@ -12,7 +12,7 @@ void test_serializable (IBusSerializable *object) + g_variant_get_data (variant); + s1 = g_variant_print (variant, TRUE); + +- object = (IBusSerializable *) ibus_serializable_deserialize (variant); ++ object = ibus_serializable_deserialize (variant); + g_variant_unref (variant); + + variant = ibus_serializable_serialize (object); +@@ -131,34 +131,51 @@ test_property (void) + static void + test_attachment (void) + { +- IBusText *text = ibus_text_new_from_string ("main text"); ++ IBusText *text = ibus_text_new_from_static_string ("main text"); + +- GValue value1 = { 0 }; +- g_value_init(&value1, G_TYPE_INT); +- g_value_set_int(&value1, 100); +- ibus_serializable_set_attachment ((IBusSerializable *)text, "key1", &value1); ++ ibus_serializable_set_attachment ((IBusSerializable *)text, ++ "key1", ++ g_variant_new_int32 (100)); + +- GValue value2 = { 0 }; +- g_value_init(&value2, G_TYPE_STRING); +- g_value_set_string(&value2, "value string"); +- ibus_serializable_set_attachment ((IBusSerializable *)text, "key2", &value2); ++ ibus_serializable_set_attachment ((IBusSerializable *)text, ++ "key2", ++ g_variant_new_string ("value string")); + - def serialize(self, struct): - super(Component, self).serialize(struct) - struct.append (dbus.String(self.__name)) -@@ -106,8 +111,6 @@ class Component(Serializable): - struct.append (dbus.String(self.__textdomain)) - struct.append (dbus.Array(map(serialize_object,self.__observed_paths), signature="v")) - struct.append (dbus.Array(map(serialize_object,self.__engines), signature="v")) -- # New properties of Component will use dict for serialize -- struct.append(dbus.Array({}, signature=None)) - - def deserialize(self, struct): - super(Component, self).deserialize(struct) -@@ -123,8 +126,6 @@ class Component(Serializable): - - self.__observed_paths = map(deserialize_object, struct.pop(0)) - self.__engines = map(deserialize_object, struct.pop(0)) -- # New properties of Component will use dict for serialize -- #value = struct.pop(0) - - def test(): - text = Component("Hello", "", "", "", "", "", "", "") --- -1.7.5.4 - -From 88a44759ce5d3d785c7be96525130c67e8c63e1e Mon Sep 17 00:00:00 2001 -From: Daiki Ueno -Date: Fri, 15 Jul 2011 09:51:07 +0900 -Subject: [PATCH] Fix GObject ref/unref issues. - -BUG=none -TEST=manual - -Review URL: http://codereview.appspot.com/4700048 ---- - bus/registry.c | 5 +++-- - 2 files changed, 3 insertions(+), 3 deletions(-) - -diff --git a/bus/registry.c b/bus/registry.c -index bc6680d..7b74781 100644 ---- a/bus/registry.c -+++ b/bus/registry.c -@@ -424,7 +424,9 @@ bus_registry_load_in_dir (BusRegistry *registry, - if (component != NULL) { - BusComponent *buscomp = bus_component_new (component, - NULL /* factory */); -- registry->components = g_list_append (registry->components, buscomp); -+ g_object_ref_sink (buscomp); -+ registry->components = -+ g_list_append (registry->components, buscomp); - } ++ ibus_serializable_set_attachment ((IBusSerializable *)text, ++ "key3", ++ g_variant_new ("(iuds)",1, 2, 3.333, "test value")); + + GVariant *variant = ibus_serializable_serialize ((IBusSerializable *)text); + g_object_unref ((IBusSerializable *)text); + +- IBusSerializable *object = (IBusSerializable *) ibus_serializable_deserialize (variant); ++ IBusSerializable *object = ibus_serializable_deserialize (variant); + g_variant_unref (variant); + + g_assert_cmpstr (((IBusText *)object)->text, ==, "main text"); + +- const GValue *newvalue1 = ibus_serializable_get_attachment (object, "key1"); ++ GVariant *newvalue1 = ibus_serializable_get_attachment (object, "key1"); + g_assert (newvalue1 != NULL); +- g_assert (g_value_get_int (newvalue1) == 100); ++ g_assert_cmpint (g_variant_get_int32 (newvalue1), ==, 100); + +- const GValue *newvalue2 = ibus_serializable_get_attachment (object, "key2"); ++ GVariant *newvalue2 = ibus_serializable_get_attachment (object, "key2"); + g_assert (newvalue2 != NULL); +- g_assert_cmpstr (g_value_get_string (newvalue2), ==, "value string"); ++ g_assert_cmpstr (g_variant_get_string (newvalue2, NULL), ==, "value string"); ++ ++ { ++ GVariant *newvalue3 = ibus_serializable_get_attachment (object, "key3"); ++ g_assert (newvalue3 != NULL); ++ gint32 i; ++ guint32 u; ++ gdouble d; ++ const gchar *s; ++ g_variant_get (newvalue3, "(iud&s)", &i, &u, &d, &s); ++ g_assert_cmpint (i, ==, 1); ++ g_assert_cmpuint (u, ==, 2); ++ g_assert_cmpfloat (d, ==, 3.333); ++ g_assert_cmpstr (s, ==, "test value"); ++ } - g_free (path); -@@ -654,7 +656,6 @@ bus_registry_name_owner_changed (BusRegistry *registry, - factory = bus_factory_proxy_new (connection); - if (factory == NULL) - return; -- g_object_ref_sink (factory); - bus_component_set_factory (component, factory); - g_object_unref (factory); - } --- -1.7.5.4 - -From 0cb912cfe5664714e612206d955d458532adc707 Mon Sep 17 00:00:00 2001 -From: Peng Huang -Date: Sat, 23 Jul 2011 09:23:41 +0800 -Subject: [PATCH] Always enable the new focused BusInputContext - -BUG=http://crosbug.com/17013 -TEST=On ChromeOS - -Review URL: http://codereview.appspot.com/4816047 ---- - bus/ibusimpl.c | 3 +-- - 1 files changed, 1 insertions(+), 2 deletions(-) - -diff --git a/bus/ibusimpl.c b/bus/ibusimpl.c -index b6b2441..853465c 100644 ---- a/bus/ibusimpl.c -+++ b/bus/ibusimpl.c -@@ -1203,8 +1203,7 @@ bus_ibus_impl_set_focused_context (BusIBusImpl *ibus, - /* attach engine to the focused context */ - if (engine != NULL) { - bus_input_context_set_engine (context, engine); -- if (bus_engine_proxy_is_enabled (engine)) -- bus_input_context_enable (context); -+ bus_input_context_enable (context); - g_object_unref (engine); - } ++ g_object_unref (object); + g_variant_type_info_assert_no_infos (); + } -- 1.7.5.4 -From 52804b99ba639e17a8a2563f3e2c6e76b79fcdef Mon Sep 17 00:00:00 2001 +From adcf71e6e5de45530a09e7b9f310f2e489cd9631 Mon Sep 17 00:00:00 2001 From: fujiwarat -Date: Fri, 19 Aug 2011 12:02:51 +0900 +Date: Wed, 24 Aug 2011 11:44:21 +0900 Subject: [PATCH] Check if BusInputContext has an enabled engine in global input method. +BUG=RH#731610 +TEST=Linux desktop + +Review URL: http://codereview.appspot.com/4917041 --- bus/ibusimpl.c | 6 +++++- 1 files changed, 5 insertions(+), 1 deletions(-) @@ -1378,3 +664,33 @@ index 853465c..1942504 100644 -- 1.7.5.4 +From 894ecc8e16b01d5594ef9b8f9c5530bb2e9d0502 Mon Sep 17 00:00:00 2001 +From: fujiwarat +Date: Thu, 25 Aug 2011 09:59:42 +0900 +Subject: [PATCH] Add Disable signal when + bus_ibus_impl_set_context_engine_from_desc is called. + +BUG=#1261 +TEST=Linux desktop + +Review URL: http://codereview.appspot.com/4875049 +--- + bus/inputcontext.c | 2 ++ + 1 files changed, 2 insertions(+), 0 deletions(-) + +diff --git a/bus/inputcontext.c b/bus/inputcontext.c +index 723b5fd..3c81688 100644 +--- a/bus/inputcontext.c ++++ b/bus/inputcontext.c +@@ -2292,6 +2292,8 @@ new_engine_cb (GObject *obj, + "Opertation was cancelled"); + } + else { ++ /* Let BusEngineProxy call a Disable signal. */ ++ bus_input_context_disable (data->context); + bus_input_context_set_engine (data->context, engine); + g_object_unref (engine); + bus_input_context_enable (data->context); +-- +1.7.5.4 + diff --git a/ibus-xx-bridge-hotkey.patch b/ibus-xx-bridge-hotkey.patch index a204596..39e6a7d 100644 --- a/ibus-xx-bridge-hotkey.patch +++ b/ibus-xx-bridge-hotkey.patch @@ -921,7 +921,7 @@ diff --git a/configure.ac b/configure.ac index 4c20ae7..21d35c3 100644 --- a/configure.ac +++ b/configure.ac -@@ -456,6 +456,34 @@ else +@@ -462,6 +462,34 @@ else enable_surrounding_text="no (disabled, use --enable-surrounding-text to enable)" fi @@ -956,15 +956,15 @@ index 4c20ae7..21d35c3 100644 # check iso-codes PKG_CHECK_MODULES(ISOCODES, [ iso-codes -@@ -482,6 +510,7 @@ bus/Makefile +@@ -488,6 +516,7 @@ bus/Makefile util/Makefile util/IMdkit/Makefile data/Makefile +data/ibus.schemas.in data/icons/Makefile data/keymaps/Makefile - docs/Makefile -@@ -534,5 +563,7 @@ Build options: + data/dconf/Makefile +@@ -540,5 +569,7 @@ Build options: No snooper regexes "$NO_SNOOPER_APPS" Panel icon "$IBUS_ICON_KEYBOARD" Enable surrounding-text $enable_surrounding_text @@ -976,8 +976,8 @@ diff --git a/data/Makefile.am b/data/Makefile.am index 99be41c..824da76 100644 --- a/data/Makefile.am +++ b/data/Makefile.am -@@ -26,7 +26,8 @@ SUBDIRS = \ - $(NULL) +@@ -30,7 +30,8 @@ SUBDIRS += dconf + endif schemasdir = $(GCONF_SCHEMA_FILE_DIR) -schemas_in_files = ibus.schemas.in @@ -986,7 +986,7 @@ index 99be41c..824da76 100644 schemas_DATA = $(schemas_in_files:.schemas.in=.schemas) @INTLTOOL_SCHEMAS_RULE@ -@@ -41,11 +42,12 @@ if GCONF_SCHEMAS_INSTALL +@@ -45,11 +46,12 @@ if GCONF_SCHEMAS_INSTALL endif EXTRA_DIST = \ @@ -1780,15 +1780,7 @@ diff --git a/xkb/ibus-engine-xkb-main.c b/xkb/ibus-engine-xkb-main.c index 0fb0f0c..4787bf2 100644 --- a/xkb/ibus-engine-xkb-main.c +++ b/xkb/ibus-engine-xkb-main.c -@@ -25,6 +25,7 @@ - #endif - - #include -+#include - #include - - #ifdef ENABLE_NLS -@@ -290,6 +291,9 @@ print_component () +@@ -290,6 +290,9 @@ print_component () const gchar *desc; gchar *output; GString *str; @@ -1798,7 +1790,7 @@ index 0fb0f0c..4787bf2 100644 #ifdef XKBLAYOUTCONFIG_FILE layout_config = ibus_xkb_layout_config_new (XKBLAYOUTCONFIG_FILE); -@@ -302,6 +306,19 @@ print_component () +@@ -302,6 +305,19 @@ print_component () layout_desc = (GHashTable *) ibus_xkb_config_registry_get_layout_desc (config_registry); variant_desc = (GHashTable *) ibus_xkb_config_registry_get_variant_desc (config_registry); component = ibus_xkb_component_new (); @@ -1818,15 +1810,6 @@ index 0fb0f0c..4787bf2 100644 for (keys = g_hash_table_get_keys (layout_list); keys; keys = keys->next) { if (keys->data == NULL) { continue; -@@ -390,6 +407,8 @@ main (int argc, char **argv) - - #ifdef ENABLE_NLS - setlocale (LC_ALL, ""); -+ bindtextdomain (GETTEXT_PACKAGE, IBUS_LOCALEDIR); -+ bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); - #endif - - g_type_init (); diff --git a/xkb/xkbxml.c b/xkb/xkbxml.c index d59a929..86bcf8f 100644 --- a/xkb/xkbxml.c diff --git a/ibus-xx-factory-signal.patch b/ibus-xx-factory-signal.patch deleted file mode 100644 index 01b62c6..0000000 --- a/ibus-xx-factory-signal.patch +++ /dev/null @@ -1,261 +0,0 @@ -From 85d6a6d5d7e5673ac3bbc285589da18c48b562ae Mon Sep 17 00:00:00 2001 -From: fujiwarat -Date: Sun, 14 Aug 2011 08:44:35 +0900 -Subject: [PATCH] Add create-engine signal in IBusFactory for non-C - applications. - ---- - bus/inputcontext.c | 5 ++ - src/ibusfactory.c | 107 ++++++++++++++++++++++++++++++++++++++++------- - src/ibusfactory.h | 7 +++- - src/ibusmarshalers.list | 1 + - src/ibusservice.h | 5 +- - 5 files changed, 105 insertions(+), 20 deletions(-) - -diff --git a/bus/inputcontext.c b/bus/inputcontext.c -index 47ac9d5..4e8cdc5 100644 ---- a/bus/inputcontext.c -+++ b/bus/inputcontext.c -@@ -2285,6 +2285,11 @@ new_engine_cb (GObject *obj, - "Opertation was cancelled"); - } - else { -+ if (data->context->engine != NULL) { -+ /* Send a Disabled signal. */ -+ bus_input_context_unset_engine (data->context); -+ bus_input_context_disable (data->context); -+ } - bus_input_context_set_engine (data->context, engine); - g_object_unref (engine); - bus_input_context_enable (data->context); -diff --git a/src/ibusfactory.c b/src/ibusfactory.c -index 11d9a6d..f28f074 100644 ---- a/src/ibusfactory.c -+++ b/src/ibusfactory.c -@@ -21,6 +21,7 @@ - */ - #include "ibusfactory.h" - #include "ibusengine.h" -+#include "ibusmarshalers.h" - #include "ibusshare.h" - #include "ibusinternal.h" - -@@ -28,6 +29,7 @@ - (G_TYPE_INSTANCE_GET_PRIVATE ((o), IBUS_TYPE_FACTORY, IBusFactoryPrivate)) - - enum { -+ CREATE_ENGINE, - LAST_SIGNAL, - }; - -@@ -42,6 +44,8 @@ struct _IBusFactoryPrivate { - GHashTable *engine_table; - }; - -+static guint factory_signals[LAST_SIGNAL] = { 0 }; -+ - /* functions prototype */ - static void ibus_factory_destroy (IBusFactory *factory); - static void ibus_factory_set_property (IBusFactory *engine, -@@ -95,6 +99,47 @@ static const gchar introspection_xml[] = - " " - ""; - -+static IBusEngine * -+_ibus_factory_create_engine (IBusFactory *factory, -+ const gchar *engine_name) -+{ -+ GType engine_type; -+ gchar *object_path = NULL; -+ IBusEngine *engine = NULL; -+ -+ engine_type = (GType) g_hash_table_lookup (factory->priv->engine_table, -+ engine_name); -+ -+ g_return_val_if_fail (engine_type != G_TYPE_INVALID, NULL); -+ -+ object_path = g_strdup_printf ("/org/freedesktop/IBus/Engine/%d", -+ ++factory->priv->id); -+ engine = ibus_engine_new_type (engine_type, -+ engine_name, -+ object_path, -+ ibus_service_get_connection ((IBusService *)factory)); -+ g_free (object_path); -+ -+ return engine; -+} -+ -+static gboolean -+_ibus_factory_create_engine_accumulator (GSignalInvocationHint *ihint, -+ GValue *return_accu, -+ const GValue *handler_return, -+ gpointer dummy) -+{ -+ gboolean retval = TRUE; -+ GObject *object = g_value_get_object (handler_return); -+ -+ if (object != NULL) { -+ g_value_copy (handler_return, return_accu); -+ retval = FALSE; -+ } -+ -+ return retval; -+} -+ - static void - ibus_factory_class_init (IBusFactoryClass *class) - { -@@ -109,10 +154,34 @@ ibus_factory_class_init (IBusFactoryClass *class) - IBUS_SERVICE_CLASS (class)->service_method_call = ibus_factory_service_method_call; - IBUS_SERVICE_CLASS (class)->service_get_property = ibus_factory_service_get_property; - IBUS_SERVICE_CLASS (class)->service_set_property = ibus_factory_service_set_property; -+ class->create_engine = _ibus_factory_create_engine; - - ibus_service_class_add_interfaces (IBUS_SERVICE_CLASS (class), introspection_xml); - - g_type_class_add_private (class, sizeof (IBusFactoryPrivate)); -+ -+ /** -+ * IBusFactory::create-engine: -+ * @factory: the factory which received the signal -+ * @engine_name: the engine_name which received the signal -+ * @returns: (transfer none): An IBusEngine -+ * -+ * The ::create-engine signal is a signal to create IBusEngine -+ * with @engine_name, which gets emitted when IBusFactory -+ * received CreateEngine dbus method. The callback functions -+ * will be called until a callback returns a non-null object -+ * of IBusEngine. */ -+ factory_signals[CREATE_ENGINE] = -+ g_signal_new (I_("create-engine"), -+ G_TYPE_FROM_CLASS (gobject_class), -+ G_SIGNAL_RUN_LAST, -+ G_STRUCT_OFFSET (IBusFactoryClass, create_engine), -+ _ibus_factory_create_engine_accumulator, -+ NULL, -+ _ibus_marshal_OBJECT__STRING, -+ IBUS_TYPE_ENGINE, -+ 1, -+ G_TYPE_STRING); - } - - static void -@@ -190,25 +259,23 @@ ibus_factory_service_method_call (IBusService *service, - - if (g_strcmp0 (method_name, "CreateEngine") == 0) { - gchar *engine_name = NULL; -+ IBusEngine *engine = NULL; -+ - g_variant_get (parameters, "(&s)", &engine_name); -- GType engine_type = (GType )g_hash_table_lookup (factory->priv->engine_table, engine_name); -+ g_signal_emit (factory, factory_signals[CREATE_ENGINE], -+ 0, engine_name, &engine); -+ -+ if (engine != NULL) { -+ gchar *object_path = NULL; -+ GValue value = { 0, }; -+ -+ g_value_init (&value, G_TYPE_STRING); -+ g_object_get_property (G_OBJECT (engine), "object-path", &value); -+ object_path = g_value_dup_string (&value); -+ g_value_unset (&value); - -- if (engine_type == G_TYPE_INVALID) { -- gchar *error_message = g_strdup_printf ("Can not fond engine %s", engine_name); -- g_dbus_method_invocation_return_error (invocation, -- G_DBUS_ERROR, -- G_DBUS_ERROR_FAILED, -- error_message); -- g_free (error_message); -- } -- else { -- gchar *object_path = g_strdup_printf ("/org/freedesktop/IBus/Engine/%d", -- ++factory->priv->id); -- IBusEngine *engine = ibus_engine_new_type (engine_type, -- engine_name, -- object_path, -- ibus_service_get_connection ((IBusService *)factory)); - g_assert (engine != NULL); -+ g_assert (object_path != NULL); - g_object_ref_sink (engine); - factory->priv->engine_list = g_list_append (factory->priv->engine_list, engine); - g_signal_connect (engine, -@@ -219,6 +286,14 @@ ibus_factory_service_method_call (IBusService *service, - g_variant_new ("(o)", object_path)); - g_free (object_path); - } -+ else { -+ gchar *error_message = g_strdup_printf ("Can not fond engine %s", engine_name); -+ g_dbus_method_invocation_return_error (invocation, -+ G_DBUS_ERROR, -+ G_DBUS_ERROR_FAILED, -+ error_message); -+ g_free (error_message); -+ } - return; - } - -diff --git a/src/ibusfactory.h b/src/ibusfactory.h -index 47c06e0..03d1dea 100644 ---- a/src/ibusfactory.h -+++ b/src/ibusfactory.h -@@ -42,6 +42,7 @@ - - #include "ibusservice.h" - #include "ibusserializable.h" -+#include "ibusengine.h" - - G_BEGIN_DECLS - -@@ -127,10 +128,14 @@ struct _IBusFactoryClass { - IBusServiceClass parent; - - /* signals */ -+ IBusEngine * -+ (* create_engine) -+ (IBusFactory *factory, -+ const gchar *engine_name); - - /*< private >*/ - /* padding */ -- gpointer pdummy[8]; -+ gpointer pdummy[7]; - }; - - /** -diff --git a/src/ibusmarshalers.list b/src/ibusmarshalers.list -index c073c6e..82b4aea 100644 ---- a/src/ibusmarshalers.list -+++ b/src/ibusmarshalers.list -@@ -23,3 +23,4 @@ VOID:STRING,STRING,VARIANT - VOID:STRING,STRING,STRING - VOID:UINT - VOID:UINT,POINTER -+OBJECT:STRING -diff --git a/src/ibusservice.h b/src/ibusservice.h -index 7a3fea7..94f9bb7 100644 ---- a/src/ibusservice.h -+++ b/src/ibusservice.h -@@ -135,9 +135,9 @@ IBusService *ibus_service_new (GDBusConnection *connection, - const gchar *ibus_service_get_object_path (IBusService *service); - - /** -- * ibus_service_get_connections: -+ * ibus_service_get_connection: - * @service: An IBusService. -- * @returns: (transfer all) (element-type GDBusConnection): A newly allocated list of connections. -+ * @returns: (transfer none): A #GDBusConnection of an #IBusService instance. - * - * Returns a connections. - */ -@@ -190,7 +190,6 @@ gboolean ibus_service_emit_signal (IBusService *service, - * ibus_service_class_add_interfaces: - * @klass: An IBusServiceClass. - * @xml_data: The introspection xml data. -- * @error: Error. - * - * Set the interface introspection information with the service class. - */ --- -1.7.5.4 - diff --git a/ibus-xx-icon-symbol.patch b/ibus-xx-icon-symbol.patch deleted file mode 100644 index 0432938..0000000 --- a/ibus-xx-icon-symbol.patch +++ /dev/null @@ -1,255 +0,0 @@ -From cf1fa1bc72d6d7ad71e928df1c3aa938069cfd9e Mon Sep 17 00:00:00 2001 -From: fujiwarat -Date: Wed, 29 Jun 2011 16:50:51 +0900 -Subject: [PATCH] Add symbol property in IBusEngineDesc. - ---- - ibus/enginedesc.py | 15 +++++++++------ - src/ibusenginedesc.c | 40 ++++++++++++++++++++++++++++++++++++++++ - src/ibusenginedesc.h | 10 ++++++++++ - 3 files changed, 59 insertions(+), 6 deletions(-) - -diff --git a/ibus/enginedesc.py b/ibus/enginedesc.py -index e8a8982..3ca7f24 100644 ---- a/ibus/enginedesc.py -+++ b/ibus/enginedesc.py -@@ -31,7 +31,7 @@ from serializable import * - class EngineDesc(Serializable): - __gtype_name__ = "PYIBusEngineDesc" - __NAME__ = "IBusEngineDesc" -- def __init__(self, name="", longname="", description="", language="", license="", author="", icon="", layout="", hotkeys="", rank=0): -+ def __init__(self, name="", longname="", description="", language="", license="", author="", icon="", layout="", hotkeys="", rank=0, symbol=""): - super(EngineDesc, self).__init__() - self.__name = name - self.__longname = longname -@@ -43,6 +43,7 @@ class EngineDesc(Serializable): - self.__layout = layout - self.__rank = rank - self.__hotkeys = hotkeys -+ self.__symbol = symbol - - def get_name(self): - return self.__name -@@ -74,6 +75,9 @@ class EngineDesc(Serializable): - def get_hotkeys(self): - return self.__hotkeys - -+ def get_symbol(self): -+ return self.__symbol -+ - name = property(get_name) - longname = property(get_longname) - description = property(get_description) -@@ -84,6 +88,7 @@ class EngineDesc(Serializable): - layout = property(get_layout) - rank = property(get_rank) - hotkeys = property(get_hotkeys) -+ symbol = property(get_symbol) - - def serialize(self, struct): - super(EngineDesc, self).serialize(struct) -@@ -97,8 +102,7 @@ class EngineDesc(Serializable): - struct.append(dbus.String(self.__layout)) - struct.append(dbus.UInt32(self.__rank)) - struct.append(dbus.String(self.__hotkeys)) -- # New properties of EngineDesc will use dict for serialize -- struct.append(dbus.Array({}, signature=None)) -+ struct.append(dbus.String(self.__symbol)) - - def deserialize(self, struct): - super(EngineDesc, self).deserialize(struct) -@@ -112,11 +116,10 @@ class EngineDesc(Serializable): - self.__layout = struct.pop(0) - self.__rank = struct.pop(0) - self.__hotkeys = struct.pop(0) -- # New properties of EngineDesc will use dict for serialize -- #value = struct.pop(0) -+ self.__symbol = struct.pop(0) - - def test(): -- engine = EngineDesc("Hello", "", "", "", "", "", "", "", "") -+ engine = EngineDesc("Hello", "", "", "", "", "", "", "", "", 0, "") - value = serialize_object(engine) - engine = deserialize_object(value) - -diff --git a/src/ibusenginedesc.c b/src/ibusenginedesc.c -index ca5ef60..fa3a768 100644 ---- a/src/ibusenginedesc.c -+++ b/src/ibusenginedesc.c -@@ -39,6 +39,7 @@ enum { - PROP_LAYOUT, - PROP_RANK, - PROP_HOTKEYS, -+ PROP_SYMBOL, - }; - - -@@ -54,6 +55,7 @@ struct _IBusEngineDescPrivate { - gchar *layout; - guint rank; - gchar *hotkeys; -+ gchar *symbol; - }; - - #define IBUS_ENGINE_DESC_GET_PRIVATE(o) \ -@@ -232,6 +234,19 @@ ibus_engine_desc_class_init (IBusEngineDescClass *class) - "The hotkeys of engine description", - "", - G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); -+ -+ /** -+ * IBusEngineDesc:symbol: -+ * -+ * The symbol chars of engine description instead of icon image -+ */ -+ g_object_class_install_property (gobject_class, -+ PROP_SYMBOL, -+ g_param_spec_string ("symbol", -+ "description symbol", -+ "The icon symbol chars of engine description", -+ "", -+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); - } - - static void -@@ -249,6 +264,7 @@ ibus_engine_desc_init (IBusEngineDesc *desc) - desc->priv->layout = NULL; - desc->priv->rank = 0; - desc->priv->hotkeys = NULL; -+ desc->priv->symbol = NULL; - } - - static void -@@ -263,6 +279,7 @@ ibus_engine_desc_destroy (IBusEngineDesc *desc) - g_free (desc->priv->icon); - g_free (desc->priv->layout); - g_free (desc->priv->hotkeys); -+ g_free (desc->priv->symbol); - - IBUS_OBJECT_CLASS (ibus_engine_desc_parent_class)->destroy (IBUS_OBJECT (desc)); - } -@@ -313,6 +330,10 @@ ibus_engine_desc_set_property (IBusEngineDesc *desc, - g_assert (desc->priv->hotkeys == NULL); - desc->priv->hotkeys = g_value_dup_string (value); - break; -+ case PROP_SYMBOL: -+ g_assert (desc->priv->symbol == NULL); -+ desc->priv->symbol = g_value_dup_string (value); -+ break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (desc, prop_id, pspec); - } -@@ -355,6 +376,9 @@ ibus_engine_desc_get_property (IBusEngineDesc *desc, - case PROP_HOTKEYS: - g_value_set_string (value, ibus_engine_desc_get_hotkeys (desc)); - break; -+ case PROP_SYMBOL: -+ g_value_set_string (value, ibus_engine_desc_get_symbol (desc)); -+ break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (desc, prop_id, pspec); - } -@@ -371,6 +395,10 @@ ibus_engine_desc_serialize (IBusEngineDesc *desc, - /* End dict iter */ - - #define NOTNULL(s) ((s) != NULL ? (s) : "") -+ /* If you will add a new property, you can append it at the end and -+ * you should not change the serialized order of name, longname, -+ * description, ... because the order is also used in other applications -+ * likes ibus-qt. */ - g_variant_builder_add (builder, "s", NOTNULL (desc->priv->name)); - g_variant_builder_add (builder, "s", NOTNULL (desc->priv->longname)); - g_variant_builder_add (builder, "s", NOTNULL (desc->priv->description)); -@@ -381,7 +409,9 @@ ibus_engine_desc_serialize (IBusEngineDesc *desc, - g_variant_builder_add (builder, "s", NOTNULL (desc->priv->layout)); - g_variant_builder_add (builder, "u", desc->priv->rank); - g_variant_builder_add (builder, "s", NOTNULL (desc->priv->hotkeys)); -+ g_variant_builder_add (builder, "s", NOTNULL (desc->priv->symbol)); - #undef NOTNULL -+ - return TRUE; - } - -@@ -394,6 +424,10 @@ ibus_engine_desc_deserialize (IBusEngineDesc *desc, - retval = IBUS_SERIALIZABLE_CLASS (ibus_engine_desc_parent_class)->deserialize ((IBusSerializable *)desc, variant); - g_return_val_if_fail (retval, 0); - -+ /* If you will add a new property, you can append it at the end and -+ * you should not change the serialized order of name, longname, -+ * description, ... because the order is also used in other applications -+ * likes ibus-qt. */ - g_variant_get_child (variant, retval++, "s", &desc->priv->name); - g_variant_get_child (variant, retval++, "s", &desc->priv->longname); - g_variant_get_child (variant, retval++, "s", &desc->priv->description); -@@ -404,6 +438,7 @@ ibus_engine_desc_deserialize (IBusEngineDesc *desc, - g_variant_get_child (variant, retval++, "s", &desc->priv->layout); - g_variant_get_child (variant, retval++, "u", &desc->priv->rank); - g_variant_get_child (variant, retval++, "s", &desc->priv->hotkeys); -+ g_variant_get_child (variant, retval++, "s", &desc->priv->symbol); - - return retval; - } -@@ -428,6 +463,7 @@ ibus_engine_desc_copy (IBusEngineDesc *dest, - dest->priv->layout = g_strdup (src->priv->layout); - dest->priv->rank = src->priv->rank; - dest->priv->hotkeys = g_strdup (src->priv->hotkeys); -+ dest->priv->symbol = g_strdup (src->priv->symbol); - return TRUE; - } - -@@ -465,6 +501,7 @@ ibus_engine_desc_output (IBusEngineDesc *desc, - OUTPUT_ENTRY_1(icon); - OUTPUT_ENTRY_1(layout); - OUTPUT_ENTRY_1(hotkeys); -+ OUTPUT_ENTRY_1(symbol); - g_string_append_indent (output, indent + 1); - g_string_append_printf (output, "%u\n", desc->priv->rank); - #undef OUTPUT_ENTRY -@@ -498,6 +535,7 @@ ibus_engine_desc_parse_xml_node (IBusEngineDesc *desc, - PARSE_ENTRY_1(icon); - PARSE_ENTRY_1(layout); - PARSE_ENTRY_1(hotkeys); -+ PARSE_ENTRY_1(symbol); - #undef PARSE_ENTRY - #undef PARSE_ENTRY_1 - if (g_strcmp0 (sub_node->name , "rank") == 0) { -@@ -526,6 +564,7 @@ IBUS_ENGINE_DESC_GET_PROPERTY (icon, const gchar *) - IBUS_ENGINE_DESC_GET_PROPERTY (layout, const gchar *) - IBUS_ENGINE_DESC_GET_PROPERTY (rank, guint) - IBUS_ENGINE_DESC_GET_PROPERTY (hotkeys, const gchar *) -+IBUS_ENGINE_DESC_GET_PROPERTY (symbol, const gchar *) - #undef IBUS_ENGINE_DESC_GET_PROPERTY - - IBusEngineDesc * -@@ -573,6 +612,7 @@ ibus_engine_desc_new_varargs (const gchar *first_property_name, ...) - g_assert (desc->priv->icon); - g_assert (desc->priv->layout); - g_assert (desc->priv->hotkeys); -+ g_assert (desc->priv->symbol); - - return desc; - } -diff --git a/src/ibusenginedesc.h b/src/ibusenginedesc.h -index 9718b15..76a7adc 100644 ---- a/src/ibusenginedesc.h -+++ b/src/ibusenginedesc.h -@@ -249,6 +249,16 @@ guint ibus_engine_desc_get_rank (IBusEngineDesc *info); - const gchar *ibus_engine_desc_get_hotkeys (IBusEngineDesc *info); - - /** -+ * ibus_engine_desc_get_symbol: -+ * @info: An IBusEngineDesc -+ * @returns: symbol property in IBusEngineDesc -+ * -+ * Return the symbol property in IBusEngineDesc. It should not be freed. -+ */ -+const gchar *ibus_engine_desc_get_symbol -+ (IBusEngineDesc *info); -+ -+/** - * ibus_engine_desc_output: - * @info: An IBusEngineDesc - * @output: XML-formatted Input method engine description. --- -1.7.5.4 - diff --git a/ibus.spec b/ibus.spec index a6dd598..bba6a1c 100644 --- a/ibus.spec +++ b/ibus.spec @@ -21,8 +21,8 @@ %define gnome_icon_theme_legacy_version 2.91.6 Name: ibus -Version: 1.3.99.20110419 -Release: 18%{?dist} +Version: 1.3.99.20110817 +Release: 1%{?dist} Summary: Intelligent Input Bus for Linux OS License: LGPLv2+ Group: System Environment/Libraries @@ -32,14 +32,11 @@ Source1: xinput-ibus %if %have_gjsfile Source2: http://fujiwara.fedorapeople.org/ibus/gnome-shell/ibus-gjs-%{ibus_gjs_version}.tar.gz %endif -Source3: https://www.transifex.net/projects/p/ibus/resource/master/l/da/download/ibus_master_da.po Patch0: ibus-HEAD.patch Patch1: ibus-530711-preload-sys.patch -Patch2: ibus-xx-icon-symbol.patch -Patch3: ibus-xx-factory-signal.patch -Patch4: ibus-541492-xkb.patch -Patch5: ibus-xx-bridge-hotkey.patch -Patch6: ibus-xx-setup-frequent-lang.patch +Patch2: ibus-541492-xkb.patch +Patch3: ibus-xx-bridge-hotkey.patch +Patch4: ibus-xx-setup-frequent-lang.patch # Workaround for oxygen-gtk icon theme until bug 699103 is fixed. Patch91: ibus-711632-fedora-fallback-icon.patch @@ -173,18 +170,15 @@ The ibus-devel-docs package contains developer documentation for ibus %if %have_gjsfile zcat %SOURCE2 | tar xf - %endif -cp %SOURCE3 po/da.po %patch0 -p1 cp client/gtk2/ibusimcontext.c client/gtk3/ibusimcontext.c %patch1 -p1 -b .preload-sys -%patch2 -p1 -b .icon-symbol -%patch3 -p1 -b .factory %if %have_libxkbfile -%patch4 -p1 -b .xkb +%patch2 -p1 -b .xkb %endif mv data/ibus.schemas.in data/ibus.schemas.in.in -%patch5 -p1 -b .bridge-key -%patch6 -p1 -b .setup-frequent-lang +%patch3 -p1 -b .bridge-key +%patch4 -p1 -b .setup-frequent-lang %patch91 -p1 -b .fallback-icon @@ -371,13 +365,12 @@ fi %{_datadir}/gtk-doc/html/* %changelog -* Tue Aug 23 2011 Takao Fujiwara - 1.3.99.20110419-18 +* Thu Sep 01 2011 Takao Fujiwara - 1.3.99.20110817-1 +- Fixed Bug 700472 Use a symbol icon instead of an image icon. - Updated ibus-HEAD.patch for upstream. - Removed ibus-435880-surrounding-text.patch as upstream. - Added ibus-711632-fedora-fallback-icon.patch Fixed SEGV with no icon in oxygen-gtk icon theme. -- Added ibus-xx-icon-symbol.patch - Fixed Bug 700472 Use a symbol icon instead of an image icon. - Added ibus-xx-bridge-hotkey.patch Triaged Bug 707370 SetEngine timeout Fixed Bug 731610 Keep IM state when text input focus changes diff --git a/sources b/sources index 4d85974..39c9118 100644 --- a/sources +++ b/sources @@ -1,4 +1,3 @@ -d4f2729fecb92ae6b41f26c770b1a772 ibus-1.3.99.20110419.tar.gz +52614e55e966b7c7101a19b276c51f10 ibus-1.3.99.20110817.tar.gz c4df79742fb0de4d2794c6800a493d20 ibus-gjs-3.0.2.20110823.tar.gz e97be8e1d0b22531b5000d4a6349dbbe ibus-gjs-3.1.4.20110823.tar.gz -698c90edf0f037488e1aa969804e891f ibus_master_da.po