Der »alte« AHK-Treiber ist als »deprecated« einzustufen. Der Namenswechsel des Verzeichnis soll dies wiederspielen und eventuelle »Gewohnheitsfehler« vermeiden.

git-svn-id: https://svn.neo-layout.org@1423 b9310e46-f624-0410-8ea1-cfbb3a30dc96

16 files changed, 0 insertions, 5383 deletions

diff --git a/windows/autohotkey/Source/All.ahk b/windows/autohotkey/Source/All.ahk
deleted file mode 100644
index 55f8a4b..0000000
--- a/windows/autohotkey/Source/All.ahk
+++ /dev/null
@@ -1,22 +0,0 @@
-/* 

-  All.ahk:

-  Diese Datei ist für Entwickler zum schnellen Testen von Änderungen vorgesehen. Bei Syntaxfehlern bietet sie zudem den Vorteil, dass die Zeilennummern relativ zu den einzelnen Modulen angezeigt werden.

-  Die Reihenfolge der Includes *ist* relevant! Denn: Vor dem Menü in der Global-Part.ahk dürfen keine Tastenkombinationen definiert werden. Ansonsten kannst du die Dateien hier beliebig anordnen.

-*/

-

-#Include %a_scriptdir%\Warning.ahk

-#Include %a_scriptdir%\Global-Part.ahk

-#Include %a_scriptdir%\Methods-Layers.ahk

-#Include %a_scriptdir%\Keys-Qwert-to-Neo.ahk

-#Include %a_scriptdir%\Keys-Neo.ahk

-#Include %a_scriptdir%\Keys-Numbers.ahk

-#Include %a_scriptdir%\Keys-Special.ahk

-#Include %a_scriptdir%\Keys-NumPad.ahk

-#Include %a_scriptdir%\Keys-DeadKeys.ahk

-#Include %a_scriptdir%\Methods-Lights.ahk

-#Include %a_scriptdir%\Methods-Other.ahk

-#Include %a_scriptdir%\Compose.ahk

-#Include %a_scriptdir%\Methods-Unicode.ahk

-#Include %a_scriptdir%\Methods-ScreenKeyboard.ahk

-

-

diff --git a/windows/autohotkey/Source/Compose.ahk b/windows/autohotkey/Source/Compose.ahk
deleted file mode 100644
index a1b2962..0000000
--- a/windows/autohotkey/Source/Compose.ahk
+++ /dev/null
@@ -1,2853 +0,0 @@
-CheckCompose() {

-CheckCompUni("<G> <A>", 0x391)

-CheckCompUni("<G> <B>", 0x392)

-CheckCompUni("<G> <E>", 0x395)

-CheckCompUni("<G> <Z>", 0x396)

-CheckCompUni("<G> <H>", 0x397)

-CheckCompUni("<G> <I>", 0x399)

-CheckCompUni("<G> <K>", 0x39A)

-CheckCompUni("<G> <M>", 0x39C)

-CheckCompUni("<G> <N>", 0x39D)

-CheckCompUni("<G> <O>", 0x39F)

-CheckCompUni("<G> <P>", 0x3A1)

-CheckCompUni("<G> <T>", 0x3A4)

-CheckCompUni("<G> <Y>", 0x3A5)

-CheckCompUni("<G> <X>", 0x3A7)

-CheckCompUni("<f> <f>", 0xFB00)

-CheckCompUni("<f> <i>", 0xFB01)

-CheckCompUni("<f> <l>", 0xFB02)

-CheckCompUni("<F> <i>", 0xFB03)

-CheckCompUni("<F> <l>", 0xFB04)

-CheckCompUni("<17F> <t>", 0xFB05)

-CheckCompUni("<s> <t>", 0xFB06)

-CheckCompUni("<f> <b>", 0xE030)

-CheckCompUni("<F> <b>", 0xE031)

-CheckCompUni("<F> <h>", 0xE032)

-CheckCompUni("<F> <j>", 0xE033)

-CheckCompUni("<F> <k>", 0xE034)

-CheckCompUni("<F> <t>", 0xE035)

-CheckCompUni("<f> <h>", 0xE036)

-CheckCompUni("<f> <j>", 0xE037)

-CheckCompUni("<f> <k>", 0xE038)

-CheckCompUni("<f> <t>", 0xE039)

-CheckCompUni("<l> <c> <k>", 0xE03A)

-CheckCompUni("<l> <c> <h>", 0xE03B)

-CheckCompUni("<t> <t>", 0xE03C)

-CheckCompUni("<l> <c> <t>", 0xE03D)

-CheckCompUni("<17F> <i>", 0xE03E)

-CheckCompUni("<17F> <17F>", 0xE03F)

-CheckCompUni("<17F> <l>", 0xE043)

-CheckCompUni("<S> <i>", 0xE044)

-CheckCompUni("<17F> <s>", 0xE045)

-CheckCompUni("<t> <z>", 0xE04A)

-CheckCompUni("<Q> <u>", 0xE048)

-CheckCompUni("<T> <h>", 0xE049)

-CheckCompUni("<I> <J>", 0x132)

-CheckCompUni("<i> <j>", 0x133)

-CheckCompUni("<D> <Z>", 0x1C4)

-CheckCompUni("<D> <z>", 0x1C5)

-CheckCompUni("<d> <z>", 0x1C6)

-CheckCompUni("<L> <J>", 0x1C7)

-CheckCompUni("<L> <j>", 0x1C8)

-CheckCompUni("<l> <j>", 0x1C9)

-CheckCompUni("<N> <J>", 0x1CA)

-CheckCompUni("<N> <j>", 0x1CB)

-CheckCompUni("<n> <j>", 0x1CC)

-CheckCompUni("<minus> <H>", 0x126)

-CheckCompUni("<minus> <h>", 0x127)

-CheckCompUni("<E> <E>", 0x18F)

-CheckCompUni("<L> <period>", 0x13F)

-CheckCompUni("<l> <period>", 0x140)

-CheckCompUni("<2> <exclam>", 0x203C)

-CheckCompUni("<exclam> <2>", 0x203C)

-CheckCompUni("<KP_2> <exclam>", 0x203C)

-CheckCompUni("<exclam> <KP_2>", 0x203C)

-CheckCompUni("<2> <question>", 0x2047)

-CheckCompUni("<question> <2>", 0x2047)

-CheckCompUni("<KP_2> <question>", 0x2047)

-CheckCompUni("<question> <KP_2>", 0x2047)

-CheckCompUni("<question> <exclam>", 0x2048)

-CheckCompUni("<exclam> <question>", 0x2049)

-CheckCompUni("<1> <question> <exclam>", 0x203D)

-CheckCompUni("<1> <exclam> <question>", 0x203D)

-CheckCompUni("<KP_1> <question> <exclam>", 0x203D)

-CheckCompUni("<KP_1> <exclam> <question>", 0x203D)

-CheckCompUni("<1> <questiondown> <exclamdown>", 0x2E18)

-CheckCompUni("<1> <exclamdown> <questiondown>", 0x2E18)

-CheckCompUni("<KP_1> <questiondown> <exclamdown>", 0x2E18)

-CheckCompUni("<KP_1> <exclamdown> <questiondown>", 0x2E18)

-CheckCompUni("<dagger> <dagger>", 0x2021)

-CheckCompUni("<colon> <colon>", 0x2025)

-CheckCompUni("<nobreakspace> <nobreakspace>", 0x2D)

-CheckCompUni("<R> <1> <space>", 0x2160)

-CheckCompUni("<R> <2>", 0x2161)

-CheckCompUni("<R> <3>", 0x2162)

-CheckCompUni("<R> <4>", 0x2163)

-CheckCompUni("<R> <5>", 0x2164)

-CheckCompUni("<R> <6>", 0x2165)

-CheckCompUni("<R> <7>", 0x2166)

-CheckCompUni("<R> <8>", 0x2167)

-CheckCompUni("<R> <9>", 0x2168)

-CheckCompUni("<R> <1> <0>", 0x2169)

-CheckCompUni("<R> <1> <1>", 0x216A)

-CheckCompUni("<R> <1> <2>", 0x216B)

-CheckCompUni("<R> <KP_1> <space>", 0x2160)

-CheckCompUni("<R> <KP_2>", 0x2161)

-CheckCompUni("<R> <KP_3>", 0x2162)

-CheckCompUni("<R> <KP_4>", 0x2163)

-CheckCompUni("<R> <KP_5>", 0x2164)

-CheckCompUni("<R> <KP_6>", 0x2165)

-CheckCompUni("<R> <KP_7>", 0x2166)

-CheckCompUni("<R> <KP_8>", 0x2167)

-CheckCompUni("<R> <KP_9>", 0x2168)

-CheckCompUni("<R> <KP_1> <KP_0>", 0x2169)

-CheckCompUni("<R> <KP_1> <KP_1>", 0x216A)

-CheckCompUni("<R> <KP_1> <KP_2>", 0x216B)

-CheckCompUni("<r> <1> <space>", 0x2170)

-CheckCompUni("<r> <2>", 0x2171)

-CheckCompUni("<r> <3>", 0x2172)

-CheckCompUni("<r> <4>", 0x2173)

-CheckCompUni("<r> <5>", 0x2174)

-CheckCompUni("<r> <6>", 0x2175)

-CheckCompUni("<r> <7>", 0x2176)

-CheckCompUni("<r> <8>", 0x2177)

-CheckCompUni("<r> <9>", 0x2178)

-CheckCompUni("<r> <1> <0>", 0x2179)

-CheckCompUni("<r> <1> <1>", 0x217A)

-CheckCompUni("<r> <1> <2>", 0x217B)

-CheckCompUni("<r> <KP_1> <space>", 0x2170)

-CheckCompUni("<r> <KP_2>", 0x2171)

-CheckCompUni("<r> <KP_3>", 0x2172)

-CheckCompUni("<r> <KP_4>", 0x2173)

-CheckCompUni("<r> <KP_5>", 0x2174)

-CheckCompUni("<r> <KP_6>", 0x2175)

-CheckCompUni("<r> <KP_7>", 0x2176)

-CheckCompUni("<r> <KP_8>", 0x2177)

-CheckCompUni("<r> <KP_9>", 0x2178)

-CheckCompUni("<r> <KP_1> <KP_0>", 0x2179)

-CheckCompUni("<r> <KP_1> <KP_1>", 0x217A)

-CheckCompUni("<r> <KP_1> <KP_2>", 0x217B)

-CheckCompUni("<a> <0>", 0x660)

-CheckCompUni("<a> <1>", 0x661)

-CheckCompUni("<a> <2>", 0x662)

-CheckCompUni("<a> <3>", 0x663)

-CheckCompUni("<a> <4>", 0x664)

-CheckCompUni("<a> <5>", 0x665)

-CheckCompUni("<a> <6>", 0x666)

-CheckCompUni("<a> <7>", 0x667)

-CheckCompUni("<a> <8>", 0x668)

-CheckCompUni("<a> <9>", 0x669)

-CheckCompUni("<a> <KP_0>", 0x660)

-CheckCompUni("<a> <KP_1>", 0x661)

-CheckCompUni("<a> <KP_2>", 0x662)

-CheckCompUni("<a> <KP_3>", 0x663)

-CheckCompUni("<a> <KP_4>", 0x664)

-CheckCompUni("<a> <KP_5>", 0x665)

-CheckCompUni("<a> <KP_6>", 0x666)

-CheckCompUni("<a> <KP_7>", 0x667)

-CheckCompUni("<a> <KP_8>", 0x668)

-CheckCompUni("<a> <KP_9>", 0x669)

-CheckCompUni("<1> <3>", 0x2153)

-CheckCompUni("<2> <3>", 0x2154)

-CheckCompUni("<1> <5>", 0x2155)

-CheckCompUni("<2> <5>", 0x2156)

-CheckCompUni("<3> <5>", 0x2157)

-CheckCompUni("<4> <5>", 0x2158)

-CheckCompUni("<1> <6>", 0x2159)

-CheckCompUni("<5> <6>", 0x215A)

-CheckCompUni("<1> <8>", 0x215B)

-CheckCompUni("<3> <8>", 0x215C)

-CheckCompUni("<5> <8>", 0x215D)

-CheckCompUni("<7> <8>", 0x215E)

-CheckCompUni("<1> <slash>", 0x215F)

-CheckCompUni("<1> <KP_Divide>", 0x215F)

-CheckCompUni("<KP_1> <KP_3>", 0x2153)

-CheckCompUni("<KP_2> <KP_3>", 0x2154)

-CheckCompUni("<KP_1> <KP_5>", 0x2155)

-CheckCompUni("<KP_2> <KP_5>", 0x2156)

-CheckCompUni("<KP_3> <KP_5>", 0x2157)

-CheckCompUni("<KP_4> <KP_5>", 0x2158)

-CheckCompUni("<KP_1> <KP_6>", 0x2159)

-CheckCompUni("<KP_5> <KP_6>", 0x215A)

-CheckCompUni("<KP_1> <KP_8>", 0x215B)

-CheckCompUni("<KP_3> <KP_8>", 0x215C)

-CheckCompUni("<KP_5> <KP_8>", 0x215D)

-CheckCompUni("<KP_7> <KP_8>", 0x215E)

-CheckCompUni("<KP_1> <slash>", 0x215F)

-CheckCompUni("<KP_1> <KP_Divide>", 0x215F)

-CheckCompUni("<KP_1> <KP_4>", 0xBC)

-CheckCompUni("<KP_1> <KP_2>", 0xBD)

-CheckCompUni("<KP_3> <KP_4>", 0xBE)

-CheckCompUni("<3> <radical>", 0x221B)

-CheckCompUni("<radical> <3>", 0x221B)

-CheckCompUni("<KP_3> <radical>", 0x221B)

-CheckCompUni("<radical> <KP_3>", 0x221B)

-CheckCompUni("<4> <radical>", 0x221C)

-CheckCompUni("<radical> <4>", 0x221C)

-CheckCompUni("<KP_4> <radical>", 0x221C)

-CheckCompUni("<radical> <KP_4>", 0x221C)

-CheckCompUni("<integral> <2>", 0x222C)

-CheckCompUni("<2> <integral>", 0x222C)

-CheckCompUni("<integral> <integral>", 0x222C)

-CheckCompUni("<integral> <KP_2>", 0x222C)

-CheckCompUni("<KP_2> <integral>", 0x222C)

-CheckCompUni("<integral> <3>", 0x222D)

-CheckCompUni("<3> <integral>", 0x222D)

-CheckCompUni("<integral> <KP_3>", 0x222D)

-CheckCompUni("<KP_3> <integral>", 0x222D)

-CheckCompUni("<integral> <4>", 0x2A0C)

-CheckCompUni("<4> <integral>", 0x2A0C)

-CheckCompUni("<integral> <KP_4>", 0x2A0C)

-CheckCompUni("<KP_4> <integral>", 0x2A0C)

-CheckCompUni("<U222E> <2>", 0x222F)

-CheckCompUni("<2> <U222E>", 0x222F)

-CheckCompUni("<U222E> <U222E>", 0x222F)

-CheckCompUni("<U222E> <KP_2>", 0x222F)

-CheckCompUni("<KP_2> <U222E>", 0x222F)

-CheckCompUni("<U222E> <3>", 0x2230)

-CheckCompUni("<3> <U222E>", 0x2230)

-CheckCompUni("<U222E> <KP_3>", 0x2230)

-CheckCompUni("<KP_3> <U222E>", 0x2230)

-CheckCompUni("<l> <n>", 0x33D1)

-CheckCompUni("<l> <o> <g>", 0x33D2)

-CheckCompUni("<asciicircum> <bracketleft>", 0x2308)

-CheckCompUni("<underscore> <bracketleft>", 0x230A)

-CheckCompUni("<asciicircum> <bracketright>", 0x2309)

-CheckCompUni("<underscore> <bracketright>", 0x230B)

-CheckCompUni("<greater> <period>", 0x2234)

-CheckCompUni("<less> <period>", 0x2235)

-CheckCompUni("<asciitilde> <equal>", 0x2245)

-CheckCompUni("<equal> <asciitilde>", 0x2245)

-CheckCompUni("<asciitilde> <asciitilde>", 0x2248)

-CheckCompUni("<greater> <equal>", 0x2265)

-CheckCompUni("<equal> <greater>", 0x2265)

-CheckCompUni("<less> <equal>", 0x2264)

-CheckCompUni("<equal> <less>", 0x2264)

-CheckCompUni("<equal> <degree>", 0x2257)

-CheckCompUni("<degree> <equal>", 0x2257)

-CheckCompUni("<KP_Add> <KP_Subtract>", 0xB1)

-CheckCompUni("<KP_Subtract> <KP_Add>", 0x2213)

-CheckCompUni("<minus> <plus>", 0x2213)

-CheckCompUni("<equal> <slash>", 0x2260)

-CheckCompUni("<equal> <dead_stroke> <dead_stroke>", 0x2260)

-CheckCompUni("<KP_equal> <KP_Divide>", 0x2260)

-CheckCompUni("<KP_equal> <dead_stroke> <dead_stroke>", 0x2260)

-CheckCompUni("<less> <greater>", 0x2260)

-CheckCompUni("<U2203> <slash>", 0x2204)

-CheckCompUni("<U2203> <dead_stroke> <dead_stroke>", 0x2204)

-CheckCompUni("<elementof> <slash>", 0x2209)

-CheckCompUni("<elementof> <dead_stroke> <dead_stroke>", 0x2209)

-CheckCompUni("<containsas> <slash>", 0x220C)

-CheckCompUni("<containsas> <dead_stroke> <dead_stroke>", 0x220C)

-CheckCompUni("<bar> <slash>", 0x2224)

-CheckCompUni("<bar> <dead_stroke> <dead_stroke>", 0x2224)

-CheckCompUni("<U2225> <slash>", 0x2226)

-CheckCompUni("<U2225> <dead_stroke> <dead_stroke>", 0x2226)

-CheckCompUni("<asciitilde> <slash>", 0x2241)

-CheckCompUni("<asciitilde> <dead_stroke> <dead_stroke>", 0x2241)

-CheckCompUni("<less> <slash>", 0x226E)

-CheckCompUni("<less> <dead_stroke> <dead_stroke>", 0x226E)

-CheckCompUni("<greater> <slash>", 0x226F)

-CheckCompUni("<greater> <dead_stroke> <dead_stroke>", 0x226F)

-CheckCompUni("<lessthanequal> <slash>", 0x2270)

-CheckCompUni("<lessthanequal> <dead_stroke> <dead_stroke>", 0x2270)

-CheckCompUni("<greaterthanequal> <slash>", 0x2271)

-CheckCompUni("<greaterthanequal> <dead_stroke> <dead_stroke>", 0x2271)

-CheckCompUni("<includedin> <slash>", 0x2284)

-CheckCompUni("<includedin> <dead_stroke> <dead_stroke>", 0x2284)

-CheckCompUni("<includes> <slash>", 0x2285)

-CheckCompUni("<includes> <dead_stroke> <dead_stroke>", 0x2285)

-CheckCompUni("<rightarrow>", 0x20D7)

-CheckCompUni("<asciicircum> <greater>", 0x20D7)

-CheckCompUni("<asciicircum> <rightarrow>", 0x20D7)

-CheckCompUni("<asciicircum> <minus>", 0x207B)

-CheckCompUni("<asciicircum> <KP_Subtract>", 0x207B)

-CheckCompUni("<underscore> <minus>", 0x208B)

-CheckCompUni("<underbar> <minus>", 0x208B)

-CheckCompUni("<underscore> <KP_Subtract>", 0x208B)

-CheckCompUni("<underbar> <KP_Subtract>", 0x208B)

-CheckCompUni("<asciicircum> <Greek_beta>", 0x1D5D)

-CheckCompUni("<asciicircum> <Greek_gamma>", 0x1D5E)

-CheckCompUni("<asciicircum> <Greek_delta>", 0x1D5F)

-CheckCompUni("<asciicircum> <Greek_phi>", 0x1D60)

-CheckCompUni("<asciicircum> <Greek_chi>", 0x1D61)

-CheckCompUni("<asciicircum> <Greek_theta>", 0x1DBF)

-CheckCompUni("<underscore> <Greek_beta>", 0x1D66)

-CheckCompUni("<underbar> <Greek_beta>", 0x1D66)

-CheckCompUni("<underscore> <Greek_gamma>", 0x1D67)

-CheckCompUni("<underbar> <Greek_gamma>", 0x1D67)

-CheckCompUni("<underscore> <Greek_rho>", 0x1D68)

-CheckCompUni("<underbar> <Greek_rho>", 0x1D68)

-CheckCompUni("<underscore> <Greek_phi>", 0x1D69)

-CheckCompUni("<underbar> <Greek_phi>", 0x1D69)

-CheckCompUni("<underscore> <Greek_chi>", 0x1D6A)

-CheckCompUni("<underbar> <Greek_chi>", 0x1D6A)

-CheckCompUni("<s> <c> <g>", 0x210A)

-CheckCompUni("<s> <c> <H>", 0x210B)

-CheckCompUni("<s> <c> <I>", 0x2110)

-CheckCompUni("<s> <c> <L>", 0x2112)

-CheckCompUni("<s> <c> <l>", 0x2113)

-CheckCompUni("<e> <l> <l>", 0x2113)

-CheckCompUni("<s> <c> <P>", 0x2118)

-CheckCompUni("<s> <c> <R>", 0x211B)

-CheckCompUni("<s> <c> <B>", 0x212C)

-CheckCompUni("<s> <c> <e>", 0x212F)

-CheckCompUni("<s> <c> <E>", 0x2130)

-CheckCompUni("<s> <c> <F>", 0x2131)

-CheckCompUni("<s> <c> <M>", 0x2133)

-CheckCompUni("<s> <c> <o>", 0x2134)

-CheckCompUni("<p> <h> <space>", 0x210E)

-CheckCompUni("<minus> <p> <h>", 0x210F)

-CheckCompUni("<p> <h> <minus>", 0x210F)

-CheckCompUni("<KP_Subtract> <p> <h>", 0x210F)

-CheckCompUni("<p> <h> <KP_Subtract>", 0x210F)

-CheckCompUni("<degree> <C>", 0x2103)

-CheckCompUni("<degree> <F>", 0x2109)

-CheckCompUni("<w> <degree>", 0xB0)

-CheckCompUni("<w> <apostrophe>", 0x2032)

-CheckCompUni("<w> <quotedbl>", 0x2033)

-CheckCompUni("<Greek_mu> <l>", 0x3395)

-CheckCompUni("<Greek_mu> <U2113>", 0x3395)

-CheckCompUni("<m> <l>", 0x3396)

-CheckCompUni("<m> <U2113>", 0x3396)

-CheckCompUni("<d> <l>", 0x3397)

-CheckCompUni("<d> <U2113>", 0x3397)

-CheckCompUni("<k> <l>", 0x3398)

-CheckCompUni("<k> <U2113>", 0x3398)

-CheckCompUni("<f> <m>", 0x3399)

-CheckCompUni("<n> <m>", 0x339A)

-CheckCompUni("<Greek_mu> <m>", 0x339B)

-CheckCompUni("<m> <m>", 0x339C)

-CheckCompUni("<c> <m>", 0x339D)

-CheckCompUni("<k> <m>", 0x339E)

-CheckCompUni("<Greek_mu> <g>", 0x338D)

-CheckCompUni("<m> <g>", 0x338E)

-CheckCompUni("<k> <g>", 0x338F)

-CheckCompUni("<H> <z>", 0x3390)

-CheckCompUni("<k> <H> <z>", 0x3391)

-CheckCompUni("<M> <H> <z>", 0x3392)

-CheckCompUni("<2> <m> <m>", 0x339F)

-CheckCompUni("<2> <c> <m>", 0x33A0)

-CheckCompUni("<2> <m> <space>", 0x33A1)

-CheckCompUni("<2> <k> <m>", 0x33A2)

-CheckCompUni("<KP_2> <m> <m>", 0x339F)

-CheckCompUni("<KP_2> <c> <m>", 0x33A0)

-CheckCompUni("<KP_2> <m> <space>", 0x33A1)

-CheckCompUni("<KP_2> <k> <m>", 0x33A2)

-CheckCompUni("<3> <m> <m>", 0x33A3)

-CheckCompUni("<3> <c> <m>", 0x33A4)

-CheckCompUni("<3> <m> <space>", 0x33A5)

-CheckCompUni("<3> <k> <m>", 0x33A6)

-CheckCompUni("<KP_3> <m> <m>", 0x33A3)

-CheckCompUni("<KP_3> <c> <m>", 0x33A4)

-CheckCompUni("<KP_3> <m> <space>", 0x33A5)

-CheckCompUni("<KP_3> <k> <m>", 0x33A6)

-CheckCompUni("<m> <s>", 0x33A7)

-CheckCompUni("<m> <2> <s>", 0x33A8)

-CheckCompUni("<m> <KP_2> <s>", 0x33A8)

-CheckCompUni("<m> <o> <l>", 0x33D6)

-CheckCompUni("<colon> <parenright>", 0x263A)

-CheckCompUni("<colon> <parenleft>", 0x2639)

-CheckCompUni("<t> <m>", 0x2122)

-CheckCompUni("<c> <KP_Divide> <o>", 0x2105)

-CheckCompUni("<femalesymbol> <femalesymbol>", 0x26A2)

-CheckCompUni("<malesymbol> <malesymbol>", 0x26A3)

-CheckCompUni("<femalesymbol> <malesymbol>", 0x26A4)

-CheckCompUni("<malesymbol> <femalesymbol>", 0x26A5)

-CheckCompUni("<underscore> <underscore>", 0x332)

-CheckCompUni("<apostrophe> <space>", 0x27)

-CheckCompUni("<space> <greater>", 0x5E)

-CheckCompUni("<greater> <space>", 0x5E)

-CheckCompUni("<space> <asciicircum>", 0x5E)

-CheckCompUni("<asciicircum> <space>", 0x5E)

-CheckCompUni("<space> <minus>", 0x7E)

-CheckCompUni("<minus> <space>", 0x7E)

-CheckCompUni("<space> <asciitilde>", 0x7E)

-CheckCompUni("<asciitilde> <space>", 0x7E)

-CheckCompUni("<A> <T>", 0x40)

-CheckCompUni("<less> <slash>", 0x5C5C)

-CheckCompUni("<slash> <less>", 0x5C5C)

-CheckCompUni("<slash> <slash>", 0x5C5C)

-CheckCompUni("<l> <v>", 0x7C)

-CheckCompUni("<v> <l>", 0x7C)

-CheckCompUni("<L> <V>", 0x7C)

-CheckCompUni("<V> <L>", 0x7C)

-CheckCompUni("<asciicircum> <slash>", 0x7C)

-CheckCompUni("<slash> <asciicircum>", 0x7C)

-CheckCompUni("<minus> <parenleft>", 0x7B)

-CheckCompUni("<parenleft> <minus>", 0x7B)

-CheckCompUni("<minus> <parenright>", 0x7D)

-CheckCompUni("<parenright> <minus>", 0x7D)

-CheckCompUni("<parenleft> <parenleft>", 0x5B)

-CheckCompUni("<parenright> <parenright>", 0x5D)

-CheckCompUni("<space> <comma>", 0xB8)

-CheckCompUni("<comma> <space>", 0xB8)

-CheckCompUni("<space> <grave>", 0x60)

-CheckCompUni("<grave> <space>", 0x60)

-CheckCompUni("<plus> <plus>", 0x23)

-CheckCompUni("<apostrophe> <A>", 0xC1)

-CheckCompUni("<acute> <A>", 0xC1)

-CheckCompUni("<apostrophe> <a>", 0xE1)

-CheckCompUni("<acute> <a>", 0xE1)

-CheckCompUni("<b> <A>", 0x102)

-CheckCompUni("<U> <A>", 0x102)

-CheckCompUni("<b> <a>", 0x103)

-CheckCompUni("<U> <a>", 0x103)

-CheckCompUni("<asciicircum> <A>", 0xC2)

-CheckCompUni("<asciicircum> <a>", 0xE2)

-CheckCompUni("<quotedbl> <A>", 0xC4)

-CheckCompUni("<quotedbl> <a>", 0xE4)

-CheckCompUni("<A> <E>", 0xC6)

-CheckCompUni("<a> <e>", 0xE6)

-CheckCompUni("<grave> <A>", 0xC0)

-CheckCompUni("<grave> <a>", 0xE0)

-CheckCompUni("<underscore> <A>", 0x100)

-CheckCompUni("<macron> <A>", 0x100)

-CheckCompUni("<underscore> <a>", 0x101)

-CheckCompUni("<macron> <a>", 0x101)

-CheckCompUni("<semicolon> <A>", 0x104)

-CheckCompUni("<semicolon> <a>", 0x105)

-CheckCompUni("<o> <A>", 0xC5)

-CheckCompUni("<o> <a>", 0xE5)

-CheckCompUni("<asciitilde> <A>", 0xC3)

-CheckCompUni("<asciitilde> <a>", 0xE3)

-CheckCompUni("<exclam> <asciicircum>", 0xA6)

-CheckCompUni("<period> <C>", 0x10A)

-CheckCompUni("<period> <c>", 0x10B)

-CheckCompUni("<apostrophe> <C>", 0x106)

-CheckCompUni("<acute> <C>", 0x106)

-CheckCompUni("<apostrophe> <c>", 0x107)

-CheckCompUni("<acute> <c>", 0x107)

-CheckCompUni("<c> <C>", 0x10C)

-CheckCompUni("<c> <c>", 0x10D)

-CheckCompUni("<comma> <C>", 0xC7)

-CheckCompUni("<comma> <c>", 0xE7)

-CheckCompUni("<asciicircum> <C>", 0x108)

-CheckCompUni("<asciicircum> <c>", 0x109)

-CheckCompUni("<slash> <C>", 0xA2)

-CheckCompUni("<slash> <c>", 0xA2)

-CheckCompUni("<C> <slash>", 0xA2)

-CheckCompUni("<c> <slash>", 0xA2)

-CheckCompUni("<C> <bar>", 0xA2)

-CheckCompUni("<c> <bar>", 0xA2)

-CheckCompUni("<bar> <C>", 0xA2)

-CheckCompUni("<bar> <c>", 0xA2)

-CheckCompUni("<slash> <C>", 0x20A1)

-CheckCompUni("<C> <slash>", 0x20A1)

-CheckCompUni("<O> <C>", 0xA9)

-CheckCompUni("<O> <c>", 0xA9)

-CheckCompUni("<o> <C>", 0xA9)

-CheckCompUni("<o> <c>", 0xA9)

-CheckCompUni("<C> <r>", 0x20A2)

-CheckCompUni("<x> <o>", 0xA4)

-CheckCompUni("<o> <x>", 0xA4)

-CheckCompUni("<c> <D>", 0x10E)

-CheckCompUni("<c> <d>", 0x10F)

-CheckCompUni("<o> <o>", 0xB0)

-CheckCompUni("<minus> <colon>", 0xF7)

-CheckCompUni("<colon> <minus>", 0xF7)

-CheckCompUni("<d> <minus>", 0x20AB)

-CheckCompUni("<quotedbl> <comma>", 0x201E)

-CheckCompUni("<comma> <quotedbl>", 0x201E)

-CheckCompUni("<minus> <D>", 0x110)

-CheckCompUni("<minus> <d>", 0x111)

-CheckCompUni("<KP_Divide> <D>", 0x110)

-CheckCompUni("<slash> <D>", 0x110)

-CheckCompUni("<KP_Divide> <d>", 0x111)

-CheckCompUni("<slash> <d>", 0x111)

-CheckCompUni("<period> <E>", 0x116)

-CheckCompUni("<period> <e>", 0x117)

-CheckCompUni("<apostrophe> <E>", 0xC9)

-CheckCompUni("<acute> <E>", 0xC9)

-CheckCompUni("<apostrophe> <e>", 0xE9)

-CheckCompUni("<acute> <e>", 0xE9)

-CheckCompUni("<c> <E>", 0x11A)

-CheckCompUni("<c> <e>", 0x11B)

-CheckCompUni("<asciicircum> <E>", 0xCA)

-CheckCompUni("<asciicircum> <e>", 0xEA)

-CheckCompUni("<C> <E>", 0x20A0)

-CheckCompUni("<quotedbl> <E>", 0xCB)

-CheckCompUni("<quotedbl> <e>", 0xEB)

-CheckCompUni("<grave> <E>", 0xC8)

-CheckCompUni("<grave> <e>", 0xE8)

-CheckCompUni("<underscore> <E>", 0x112)

-CheckCompUni("<macron> <E>", 0x112)

-CheckCompUni("<underscore> <e>", 0x113)

-CheckCompUni("<macron> <e>", 0x113)

-CheckCompUni("<minus> <minus> <minus>", 0x2014)

-CheckCompUni("<minus> <minus> <period>", 0x2013)

-CheckCompUni("<N> <G>", 0x14A)

-CheckCompUni("<n> <g>", 0x14B)

-CheckCompUni("<semicolon> <E>", 0x118)

-CheckCompUni("<semicolon> <e>", 0x119)

-CheckCompUni("<D> <H>", 0xD0)

-CheckCompUni("<d> <h>", 0xF0)

-CheckCompUni("<equal> <E>", 0x20AC)

-CheckCompUni("<E> <equal>", 0x20AC)

-CheckCompUni("<equal> <C>", 0x20AC)

-CheckCompUni("<C> <equal>", 0x20AC)

-CheckCompUni("<exclam> <exclam>", 0xA1)

-CheckCompUni("<F> <r>", 0x20A3)

-CheckCompUni("<period> <G>", 0x120)

-CheckCompUni("<period> <g>", 0x121)

-CheckCompUni("<b> <G>", 0x11E)

-CheckCompUni("<U> <G>", 0x11E)

-CheckCompUni("<b> <g>", 0x11F)

-CheckCompUni("<U> <g>", 0x11F)

-CheckCompUni("<comma> <G>", 0x122)

-CheckCompUni("<comma> <g>", 0x123)

-CheckCompUni("<asciicircum> <G>", 0x11C)

-CheckCompUni("<asciicircum> <g>", 0x11D)

-CheckCompUni("<diaeresis> <combining_acute>", 0x385)

-CheckCompUni("<diaeresis> <apostrophe>", 0x385)

-CheckCompUni("<diaeresis> <acute>", 0x385)

-CheckCompUni("<diaeresis> <dead_acute>", 0x385)

-CheckCompUni("<apostrophe> <Greek_ALPHA>", 0x386)

-CheckCompUni("<acute> <Greek_ALPHA>", 0x386)

-CheckCompUni("<apostrophe> <Greek_alpha>", 0x3AC)

-CheckCompUni("<acute> <Greek_alpha>", 0x3AC)

-CheckCompUni("<apostrophe> <Greek_EPSILON>", 0x388)

-CheckCompUni("<acute> <Greek_EPSILON>", 0x388)

-CheckCompUni("<apostrophe> <Greek_epsilon>", 0x3AD)

-CheckCompUni("<acute> <Greek_epsilon>", 0x3AD)

-CheckCompUni("<apostrophe> <Greek_ETA>", 0x389)

-CheckCompUni("<acute> <Greek_ETA>", 0x389)

-CheckCompUni("<apostrophe> <Greek_eta>", 0x3AE)

-CheckCompUni("<acute> <Greek_eta>", 0x3AE)

-CheckCompUni("<apostrophe> <Greek_IOTA>", 0x38A)

-CheckCompUni("<acute> <Greek_IOTA>", 0x38A)

-CheckCompUni("<apostrophe> <Greek_iota>", 0x3AF)

-CheckCompUni("<acute> <Greek_iota>", 0x3AF)

-CheckCompUni("<apostrophe> <quotedbl> <Greek_iota>", 0x390)

-CheckCompUni("<apostrophe> <dead_diaeresis> <Greek_iota>", 0x390)

-CheckCompUni("<acute> <quotedbl> <Greek_iota>", 0x390)

-CheckCompUni("<acute> <dead_diaeresis> <Greek_iota>", 0x390)

-CheckCompUni("<apostrophe> <Greek_iotadieresis>", 0x390)

-CheckCompUni("<acute> <Greek_iotadieresis>", 0x390)

-CheckCompUni("<quotedbl> <Greek_IOTA>", 0x3AA)

-CheckCompUni("<quotedbl> <Greek_iota>", 0x3CA)

-CheckCompUni("<apostrophe> <Greek_OMEGA>", 0x38F)

-CheckCompUni("<acute> <Greek_OMEGA>", 0x38F)

-CheckCompUni("<apostrophe> <Greek_omega>", 0x3CE)

-CheckCompUni("<acute> <Greek_omega>", 0x3CE)

-CheckCompUni("<apostrophe> <Greek_OMICRON>", 0x38C)

-CheckCompUni("<acute> <Greek_OMICRON>", 0x38C)

-CheckCompUni("<apostrophe> <Greek_omicron>", 0x3CC)

-CheckCompUni("<acute> <Greek_omicron>", 0x3CC)

-CheckCompUni("<apostrophe> <Greek_UPSILON>", 0x38E)

-CheckCompUni("<acute> <Greek_UPSILON>", 0x38E)

-CheckCompUni("<apostrophe> <Greek_upsilon>", 0x3CD)

-CheckCompUni("<acute> <Greek_upsilon>", 0x3CD)

-CheckCompUni("<apostrophe> <quotedbl> <Greek_upsilon>", 0x3B0)

-CheckCompUni("<apostrophe> <dead_diaeresis> <Greek_upsilon>", 0x3B0)

-CheckCompUni("<acute> <quotedbl> <Greek_upsilon>", 0x3B0)

-CheckCompUni("<acute> <dead_diaeresis> <Greek_upsilon>", 0x3B0)

-CheckCompUni("<apostrophe> <Greek_upsilondieresis>", 0x3B0)

-CheckCompUni("<acute> <Greek_upsilondieresis>", 0x3B0)

-CheckCompUni("<quotedbl> <Greek_UPSILON>", 0x3AB)

-CheckCompUni("<quotedbl> <Greek_upsilon>", 0x3CB)

-CheckCompUni("<less> <less>", 0xAB)

-CheckCompUni("<greater> <greater>", 0xBB)

-CheckCompUni("<asciicircum> <H>", 0x124)

-CheckCompUni("<asciicircum> <h>", 0x125)

-CheckCompUni("<KP_Divide> <H>", 0x126)

-CheckCompUni("<slash> <H>", 0x126)

-CheckCompUni("<KP_Divide> <h>", 0x127)

-CheckCompUni("<slash> <h>", 0x127)

-CheckCompUni("<period> <I>", 0x130)

-CheckCompUni("<apostrophe> <I>", 0xCD)

-CheckCompUni("<acute> <I>", 0xCD)

-CheckCompUni("<apostrophe> <i>", 0xED)

-CheckCompUni("<acute> <i>", 0xED)

-CheckCompUni("<asciicircum> <I>", 0xCE)

-CheckCompUni("<asciicircum> <i>", 0xEE)

-CheckCompUni("<quotedbl> <I>", 0xCF)

-CheckCompUni("<quotedbl> <i>", 0xEF)

-CheckCompUni("<i> <period>", 0x131)

-CheckCompUni("<grave> <I>", 0xCC)

-CheckCompUni("<grave> <i>", 0xEC)

-CheckCompUni("<underscore> <I>", 0x12A)

-CheckCompUni("<macron> <I>", 0x12A)

-CheckCompUni("<underscore> <i>", 0x12B)

-CheckCompUni("<macron> <i>", 0x12B)

-CheckCompUni("<semicolon> <I>", 0x12E)

-CheckCompUni("<semicolon> <i>", 0x12F)

-CheckCompUni("<asciitilde> <I>", 0x128)

-CheckCompUni("<asciitilde> <i>", 0x129)

-CheckCompUni("<asciicircum> <J>", 0x134)

-CheckCompUni("<asciicircum> <j>", 0x135)

-CheckCompUni("<comma> <K>", 0x136)

-CheckCompUni("<comma> <k>", 0x137)

-CheckCompUni("<k> <k>", 0x138)

-CheckCompUni("<apostrophe> <L>", 0x139)

-CheckCompUni("<acute> <L>", 0x139)

-CheckCompUni("<apostrophe> <l>", 0x13A)

-CheckCompUni("<acute> <l>", 0x13A)

-CheckCompUni("<c> <L>", 0x13D)

-CheckCompUni("<c> <l>", 0x13E)

-CheckCompUni("<comma> <L>", 0x13B)

-CheckCompUni("<comma> <l>", 0x13C)

-CheckCompUni("<quotedbl> <less>", 0x201C)

-CheckCompUni("<less> <quotedbl>", 0x201C)

-CheckCompUni("<apostrophe> <less>", 0x2018)

-CheckCompUni("<less> <apostrophe>", 0x2018)

-CheckCompUni("<equal> <L>", 0x20A4)

-CheckCompUni("<L> <equal>", 0x20A4)

-CheckCompUni("<KP_Divide> <L>", 0x141)

-CheckCompUni("<slash> <L>", 0x141)

-CheckCompUni("<KP_Divide> <l>", 0x142)

-CheckCompUni("<slash> <l>", 0x142)

-CheckCompUni("<asciicircum> <underbar> <o>", 0xBA)

-CheckCompUni("<asciicircum> <underscore> <o>", 0xBA)

-CheckCompUni("<slash> <m>", 0x20A5)

-CheckCompUni("<m> <slash>", 0x20A5)

-CheckCompUni("<m> <u>", 0xB5)

-CheckCompUni("<x> <x>", 0xD7)

-CheckCompUni("<numbersign> <b>", 0x266D)

-CheckCompUni("<numbersign> <numbersign>", 0x266F)

-CheckCompUni("<apostrophe> <N>", 0x143)

-CheckCompUni("<acute> <N>", 0x143)

-CheckCompUni("<apostrophe> <n>", 0x144)

-CheckCompUni("<acute> <n>", 0x144)

-CheckCompUni("<equal> <N>", 0x20A6)

-CheckCompUni("<N> <equal>", 0x20A6)

-CheckCompUni("<c> <N>", 0x147)

-CheckCompUni("<c> <n>", 0x148)

-CheckCompUni("<comma> <N>", 0x145)

-CheckCompUni("<comma> <n>", 0x146)

-CheckCompUni("<space> <space>", 0xA0)

-CheckCompUni("<KP_Equal> <U0338>", 0x2260)

-CheckCompUni("<equal> <U0338>", 0x2260)

-CheckCompUni("<minus> <comma>", 0xAC)

-CheckCompUni("<comma> <minus>", 0xAC)

-CheckCompUni("<asciitilde> <N>", 0xD1)

-CheckCompUni("<asciitilde> <n>", 0xF1)

-CheckCompUni("<apostrophe> <O>", 0xD3)

-CheckCompUni("<acute> <O>", 0xD3)

-CheckCompUni("<apostrophe> <o>", 0xF3)

-CheckCompUni("<acute> <o>", 0xF3)

-CheckCompUni("<asciicircum> <O>", 0xD4)

-CheckCompUni("<asciicircum> <o>", 0xF4)

-CheckCompUni("<quotedbl> <O>", 0xD6)

-CheckCompUni("<quotedbl> <o>", 0xF6)

-CheckCompUni("<equal> <O>", 0x150)

-CheckCompUni("<equal> <o>", 0x151)

-CheckCompUni("<O> <E>", 0x152)

-CheckCompUni("<o> <e>", 0x153)

-CheckCompUni("<grave> <O>", 0xD2)

-CheckCompUni("<grave> <o>", 0xF2)

-CheckCompUni("<underscore> <O>", 0x14C)

-CheckCompUni("<macron> <O>", 0x14C)

-CheckCompUni("<underscore> <o>", 0x14D)

-CheckCompUni("<macron> <o>", 0x14D)

-CheckCompUni("<1> <2>", 0xBD)

-CheckCompUni("<1> <4>", 0xBC)

-CheckCompUni("<asciicircum> <KP_1>", 0xB9)

-CheckCompUni("<asciicircum> <1>", 0xB9)

-CheckCompUni("<KP_Divide> <O>", 0xD8)

-CheckCompUni("<slash> <O>", 0xD8)

-CheckCompUni("<asciicircum> <underbar> <a>", 0xAA)

-CheckCompUni("<asciicircum> <underscore> <a>", 0xAA)

-CheckCompUni("<KP_Divide> <o>", 0xF8)

-CheckCompUni("<slash> <o>", 0xF8)

-CheckCompUni("<asciitilde> <O>", 0xD5)

-CheckCompUni("<asciitilde> <o>", 0xF5)

-CheckCompUni("<P> <exclam>", 0xB6)

-CheckCompUni("<p> <exclam>", 0xB6)

-CheckCompUni("<P> <P>", 0xB6)

-CheckCompUni("<period> <period>", 0xB7)

-CheckCompUni("<P> <t>", 0x20A7)

-CheckCompUni("<plus> <minus>", 0xB1)

-CheckCompUni("<space> <period>", 0x2008)

-CheckCompUni("<question> <question>", 0xBF)

-CheckCompUni("<apostrophe> <R>", 0x154)

-CheckCompUni("<acute> <R>", 0x154)

-CheckCompUni("<apostrophe> <r>", 0x155)

-CheckCompUni("<acute> <r>", 0x155)

-CheckCompUni("<c> <R>", 0x158)

-CheckCompUni("<c> <r>", 0x159)

-CheckCompUni("<comma> <R>", 0x156)

-CheckCompUni("<comma> <r>", 0x157)

-CheckCompUni("<O> <R>", 0xAE)

-CheckCompUni("<O> <r>", 0xAE)

-CheckCompUni("<o> <R>", 0xAE)

-CheckCompUni("<o> <r>", 0xAE)

-CheckCompUni("<quotedbl> <greater>", 0x201D)

-CheckCompUni("<greater> <quotedbl>", 0x201D)

-CheckCompUni("<apostrophe> <greater>", 0x2019)

-CheckCompUni("<greater> <apostrophe>", 0x2019)

-CheckCompUni("<R> <s>", 0x20A8)

-CheckCompUni("<apostrophe> <S>", 0x15A)

-CheckCompUni("<acute> <S>", 0x15A)

-CheckCompUni("<apostrophe> <s>", 0x15B)

-CheckCompUni("<acute> <s>", 0x15B)

-CheckCompUni("<c> <S>", 0x160)

-CheckCompUni("<c> <s>", 0x161)

-CheckCompUni("<comma> <S>", 0x15E)

-CheckCompUni("<comma> <s>", 0x15F)

-CheckCompUni("<asciicircum> <S>", 0x15C)

-CheckCompUni("<asciicircum> <s>", 0x15D)

-CheckCompUni("<o> <s>", 0xA7)

-CheckCompUni("<s> <o>", 0xA7)

-CheckCompUni("<apostrophe> <comma>", 0x201A)

-CheckCompUni("<comma> <apostrophe>", 0x201A)

-CheckCompUni("<s> <s>", 0xDF)

-CheckCompUni("<minus> <L>", 0xA3)

-CheckCompUni("<L> <minus>", 0xA3)

-CheckCompUni("<c> <T>", 0x164)

-CheckCompUni("<c> <t>", 0x165)

-CheckCompUni("<comma> <T>", 0x162)

-CheckCompUni("<comma> <t>", 0x163)

-CheckCompUni("<T> <H>", 0xDE)

-CheckCompUni("<t> <h>", 0xFE)

-CheckCompUni("<3> <4>", 0xBE)

-CheckCompUni("<asciicircum> <KP_3>", 0xB3)

-CheckCompUni("<asciicircum> <3>", 0xB3)

-CheckCompUni("<asciicircum> <T> <M>", 0x2122)

-CheckCompUni("<KP_Divide> <T>", 0x166)

-CheckCompUni("<slash> <T>", 0x166)

-CheckCompUni("<KP_Divide> <t>", 0x167)

-CheckCompUni("<slash> <t>", 0x167)

-CheckCompUni("<asciicircum> <KP_2>", 0xB2)

-CheckCompUni("<asciicircum> <KP_Space>", 0xB2)

-CheckCompUni("<asciicircum> <2>", 0xB2)

-CheckCompUni("<b> <E>", 0x114)

-CheckCompUni("<U> <E>", 0x114)

-CheckCompUni("<b> <e>", 0x115)

-CheckCompUni("<U> <e>", 0x115)

-CheckCompUni("<b> <I>", 0x12C)

-CheckCompUni("<U> <I>", 0x12C)

-CheckCompUni("<b> <i>", 0x12D)

-CheckCompUni("<U> <i>", 0x12D)

-CheckCompUni("<b> <O>", 0x14E)

-CheckCompUni("<U> <O>", 0x14E)

-CheckCompUni("<b> <o>", 0x14F)

-CheckCompUni("<U> <o>", 0x14F)

-CheckCompUni("<asciicircum> <W>", 0x174)

-CheckCompUni("<asciicircum> <w>", 0x175)

-CheckCompUni("<asciicircum> <Y>", 0x176)

-CheckCompUni("<asciicircum> <y>", 0x177)

-CheckCompUni("<f> <S>", 0x17F)

-CheckCompUni("<f> <s>", 0x17F)

-CheckCompUni("<KP_Divide> <b>", 0x180)

-CheckCompUni("<slash> <b>", 0x180)

-CheckCompUni("<KP_Divide> <I>", 0x197)

-CheckCompUni("<slash> <I>", 0x197)

-CheckCompUni("<plus> <O>", 0x1A0)

-CheckCompUni("<plus> <o>", 0x1A1)

-CheckCompUni("<plus> <U>", 0x1AF)

-CheckCompUni("<plus> <u>", 0x1B0)

-CheckCompUni("<KP_Divide> <Z>", 0x1B5)

-CheckCompUni("<slash> <Z>", 0x1B5)

-CheckCompUni("<KP_Divide> <z>", 0x1B6)

-CheckCompUni("<slash> <z>", 0x1B6)

-CheckCompUni("<c> <A>", 0x1CD)

-CheckCompUni("<c> <a>", 0x1CE)

-CheckCompUni("<c> <I>", 0x1CF)

-CheckCompUni("<c> <i>", 0x1D0)

-CheckCompUni("<c> <O>", 0x1D1)

-CheckCompUni("<c> <o>", 0x1D2)

-CheckCompUni("<c> <U>", 0x1D3)

-CheckCompUni("<c> <u>", 0x1D4)

-CheckCompUni("<underscore> <quotedbl> <U>", 0x1D5)

-CheckCompUni("<underscore> <dead_diaeresis> <U>", 0x1D5)

-CheckCompUni("<macron> <quotedbl> <U>", 0x1D5)

-CheckCompUni("<macron> <dead_diaeresis> <U>", 0x1D5)

-CheckCompUni("<underscore> <Udiaeresis>", 0x1D5)

-CheckCompUni("<macron> <Udiaeresis>", 0x1D5)

-CheckCompUni("<underscore> <quotedbl> <u>", 0x1D6)

-CheckCompUni("<underscore> <dead_diaeresis> <u>", 0x1D6)

-CheckCompUni("<macron> <quotedbl> <u>", 0x1D6)

-CheckCompUni("<macron> <dead_diaeresis> <u>", 0x1D6)

-CheckCompUni("<underscore> <udiaeresis>", 0x1D6)

-CheckCompUni("<macron> <udiaeresis>", 0x1D6)

-CheckCompUni("<apostrophe> <quotedbl> <U>", 0x1D7)

-CheckCompUni("<apostrophe> <dead_diaeresis> <U>", 0x1D7)

-CheckCompUni("<acute> <quotedbl> <U>", 0x1D7)

-CheckCompUni("<acute> <dead_diaeresis> <U>", 0x1D7)

-CheckCompUni("<apostrophe> <Udiaeresis>", 0x1D7)

-CheckCompUni("<acute> <Udiaeresis>", 0x1D7)

-CheckCompUni("<apostrophe> <quotedbl> <u>", 0x1D8)

-CheckCompUni("<apostrophe> <dead_diaeresis> <u>", 0x1D8)

-CheckCompUni("<acute> <quotedbl> <u>", 0x1D8)

-CheckCompUni("<acute> <dead_diaeresis> <u>", 0x1D8)

-CheckCompUni("<apostrophe> <udiaeresis>", 0x1D8)

-CheckCompUni("<acute> <udiaeresis>", 0x1D8)

-CheckCompUni("<c> <quotedbl> <U>", 0x1D9)

-CheckCompUni("<c> <dead_diaeresis> <U>", 0x1D9)

-CheckCompUni("<c> <Udiaeresis>", 0x1D9)

-CheckCompUni("<c> <quotedbl> <u>", 0x1DA)

-CheckCompUni("<c> <dead_diaeresis> <u>", 0x1DA)

-CheckCompUni("<c> <udiaeresis>", 0x1DA)

-CheckCompUni("<grave> <quotedbl> <U>", 0x1DB)

-CheckCompUni("<grave> <dead_diaeresis> <U>", 0x1DB)

-CheckCompUni("<grave> <Udiaeresis>", 0x1DB)

-CheckCompUni("<grave> <quotedbl> <u>", 0x1DC)

-CheckCompUni("<grave> <dead_diaeresis> <u>", 0x1DC)

-CheckCompUni("<grave> <udiaeresis>", 0x1DC)

-CheckCompUni("<underscore> <quotedbl> <A>", 0x1DE)

-CheckCompUni("<underscore> <dead_diaeresis> <A>", 0x1DE)

-CheckCompUni("<macron> <quotedbl> <A>", 0x1DE)

-CheckCompUni("<macron> <dead_diaeresis> <A>", 0x1DE)

-CheckCompUni("<underscore> <Adiaeresis>", 0x1DE)

-CheckCompUni("<macron> <Adiaeresis>", 0x1DE)

-CheckCompUni("<underscore> <quotedbl> <a>", 0x1DF)

-CheckCompUni("<underscore> <dead_diaeresis> <a>", 0x1DF)

-CheckCompUni("<macron> <quotedbl> <a>", 0x1DF)

-CheckCompUni("<macron> <dead_diaeresis> <a>", 0x1DF)

-CheckCompUni("<underscore> <adiaeresis>", 0x1DF)

-CheckCompUni("<macron> <adiaeresis>", 0x1DF)

-CheckCompUni("<underscore> <period> <A>", 0x1E0)

-CheckCompUni("<underscore> <dead_abovedot> <A>", 0x1E0)

-CheckCompUni("<macron> <period> <A>", 0x1E0)

-CheckCompUni("<macron> <dead_abovedot> <A>", 0x1E0)

-CheckCompUni("<underscore> <U0226>", 0x1E0)

-CheckCompUni("<macron> <U0226>", 0x1E0)

-CheckCompUni("<underscore> <period> <a>", 0x1E1)

-CheckCompUni("<underscore> <dead_abovedot> <a>", 0x1E1)

-CheckCompUni("<macron> <period> <a>", 0x1E1)

-CheckCompUni("<macron> <dead_abovedot> <a>", 0x1E1)

-CheckCompUni("<underscore> <U0227>", 0x1E1)

-CheckCompUni("<macron> <U0227>", 0x1E1)

-CheckCompUni("<underscore> <AE>", 0x1E2)

-CheckCompUni("<macron> <AE>", 0x1E2)

-CheckCompUni("<underscore> <ae>", 0x1E3)

-CheckCompUni("<macron> <ae>", 0x1E3)

-CheckCompUni("<KP_Divide> <G>", 0x1E4)

-CheckCompUni("<slash> <G>", 0x1E4)

-CheckCompUni("<KP_Divide> <g>", 0x1E5)

-CheckCompUni("<slash> <g>", 0x1E5)

-CheckCompUni("<c> <G>", 0x1E6)

-CheckCompUni("<c> <g>", 0x1E7)

-CheckCompUni("<c> <K>", 0x1E8)

-CheckCompUni("<c> <k>", 0x1E9)

-CheckCompUni("<semicolon> <O>", 0x1EA)

-CheckCompUni("<semicolon> <o>", 0x1EB)

-CheckCompUni("<underscore> <semicolon> <O>", 0x1EC)

-CheckCompUni("<underscore> <dead_ogonek> <O>", 0x1EC)

-CheckCompUni("<macron> <semicolon> <O>", 0x1EC)

-CheckCompUni("<macron> <dead_ogonek> <O>", 0x1EC)

-CheckCompUni("<underscore> <U01ea>", 0x1EC)

-CheckCompUni("<macron> <U01ea>", 0x1EC)

-CheckCompUni("<underscore> <semicolon> <o>", 0x1ED)

-CheckCompUni("<underscore> <dead_ogonek> <o>", 0x1ED)

-CheckCompUni("<macron> <semicolon> <o>", 0x1ED)

-CheckCompUni("<macron> <dead_ogonek> <o>", 0x1ED)

-CheckCompUni("<underscore> <U01eb>", 0x1ED)

-CheckCompUni("<macron> <U01eb>", 0x1ED)

-CheckCompUni("<c> <U01b7>", 0x1EE)

-CheckCompUni("<c> <U0292>", 0x1EF)

-CheckCompUni("<c> <j>", 0x1F0)

-CheckCompUni("<apostrophe> <G>", 0x1F4)

-CheckCompUni("<acute> <G>", 0x1F4)

-CheckCompUni("<apostrophe> <g>", 0x1F5)

-CheckCompUni("<acute> <g>", 0x1F5)

-CheckCompUni("<grave> <N>", 0x1F8)

-CheckCompUni("<grave> <n>", 0x1F9)

-CheckCompUni("<o> <apostrophe> <A>", 0x1FA)

-CheckCompUni("<apostrophe> <dead_abovering> <A>", 0x1FA)

-CheckCompUni("<acute> <o> <A>", 0x1FA)

-CheckCompUni("<acute> <dead_abovering> <A>", 0x1FA)

-CheckCompUni("<apostrophe> <Aring>", 0x1FA)

-CheckCompUni("<acute> <Aring>", 0x1FA)

-CheckCompUni("<o> <apostrophe> <a>", 0x1FB)

-CheckCompUni("<apostrophe> <dead_abovering> <a>", 0x1FB)

-CheckCompUni("<acute> <o> <a>", 0x1FB)

-CheckCompUni("<acute> <dead_abovering> <a>", 0x1FB)

-CheckCompUni("<apostrophe> <aring>", 0x1FB)

-CheckCompUni("<acute> <aring>", 0x1FB)

-CheckCompUni("<apostrophe> <AE>", 0x1FC)

-CheckCompUni("<acute> <AE>", 0x1FC)

-CheckCompUni("<apostrophe> <ae>", 0x1FD)

-CheckCompUni("<acute> <ae>", 0x1FD)

-CheckCompUni("<apostrophe> <KP_Divide> <O>", 0x1FE)

-CheckCompUni("<acute> <KP_Divide> <O>", 0x1FE)

-CheckCompUni("<apostrophe> <slash> <O>", 0x1FE)

-CheckCompUni("<acute> <slash> <O>", 0x1FE)

-CheckCompUni("<apostrophe> <Ooblique>", 0x1FE)

-CheckCompUni("<acute> <Ooblique>", 0x1FE)

-CheckCompUni("<apostrophe> <KP_Divide> <o>", 0x1FF)

-CheckCompUni("<acute> <KP_Divide> <o>", 0x1FF)

-CheckCompUni("<apostrophe> <slash> <o>", 0x1FF)

-CheckCompUni("<acute> <slash> <o>", 0x1FF)

-CheckCompUni("<apostrophe> <oslash>", 0x1FF)

-CheckCompUni("<acute> <oslash>", 0x1FF)

-CheckCompUni("<c> <H>", 0x21E)

-CheckCompUni("<c> <h>", 0x21F)

-CheckCompUni("<period> <A>", 0x226)

-CheckCompUni("<period> <a>", 0x227)

-CheckCompUni("<comma> <E>", 0x228)

-CheckCompUni("<comma> <e>", 0x229)

-CheckCompUni("<underscore> <quotedbl> <O>", 0x22A)

-CheckCompUni("<underscore> <dead_diaeresis> <O>", 0x22A)

-CheckCompUni("<macron> <quotedbl> <O>", 0x22A)

-CheckCompUni("<macron> <dead_diaeresis> <O>", 0x22A)

-CheckCompUni("<underscore> <Odiaeresis>", 0x22A)

-CheckCompUni("<macron> <Odiaeresis>", 0x22A)

-CheckCompUni("<underscore> <quotedbl> <o>", 0x22B)

-CheckCompUni("<underscore> <dead_diaeresis> <o>", 0x22B)

-CheckCompUni("<macron> <quotedbl> <o>", 0x22B)

-CheckCompUni("<macron> <dead_diaeresis> <o>", 0x22B)

-CheckCompUni("<underscore> <odiaeresis>", 0x22B)

-CheckCompUni("<macron> <odiaeresis>", 0x22B)

-CheckCompUni("<underscore> <combining_tilde> <O>", 0x22C)

-CheckCompUni("<macron> <combining_tilde> <O>", 0x22C)

-CheckCompUni("<underscore> <asciitilde> <O>", 0x22C)

-CheckCompUni("<underscore> <dead_tilde> <O>", 0x22C)

-CheckCompUni("<macron> <asciitilde> <O>", 0x22C)

-CheckCompUni("<macron> <dead_tilde> <O>", 0x22C)

-CheckCompUni("<underscore> <Otilde>", 0x22C)

-CheckCompUni("<macron> <Otilde>", 0x22C)

-CheckCompUni("<underscore> <combining_tilde> <o>", 0x22D)

-CheckCompUni("<macron> <combining_tilde> <o>", 0x22D)

-CheckCompUni("<underscore> <asciitilde> <o>", 0x22D)

-CheckCompUni("<underscore> <dead_tilde> <o>", 0x22D)

-CheckCompUni("<macron> <asciitilde> <o>", 0x22D)

-CheckCompUni("<macron> <dead_tilde> <o>", 0x22D)

-CheckCompUni("<underscore> <otilde>", 0x22D)

-CheckCompUni("<macron> <otilde>", 0x22D)

-CheckCompUni("<period> <O>", 0x22E)

-CheckCompUni("<period> <o>", 0x22F)

-CheckCompUni("<underscore> <period> <O>", 0x230)

-CheckCompUni("<underscore> <dead_abovedot> <O>", 0x230)

-CheckCompUni("<macron> <period> <O>", 0x230)

-CheckCompUni("<macron> <dead_abovedot> <O>", 0x230)

-CheckCompUni("<underscore> <U022e>", 0x230)

-CheckCompUni("<macron> <U022e>", 0x230)

-CheckCompUni("<underscore> <period> <o>", 0x231)

-CheckCompUni("<underscore> <dead_abovedot> <o>", 0x231)

-CheckCompUni("<macron> <period> <o>", 0x231)

-CheckCompUni("<macron> <dead_abovedot> <o>", 0x231)

-CheckCompUni("<underscore> <U022f>", 0x231)

-CheckCompUni("<macron> <U022f>", 0x231)

-CheckCompUni("<underscore> <Y>", 0x232)

-CheckCompUni("<macron> <Y>", 0x232)

-CheckCompUni("<underscore> <y>", 0x233)

-CheckCompUni("<macron> <y>", 0x233)

-CheckCompUni("<e> <e>", 0x259)

-CheckCompUni("<KP_Divide> <i>", 0x268)

-CheckCompUni("<slash> <i>", 0x268)

-CheckCompUni("<KP_Divide> <U0294>", 0x2A1)

-CheckCompUni("<slash> <U0294>", 0x2A1)

-CheckCompUni("<asciicircum> <underbar> <h>", 0x2B0)

-CheckCompUni("<asciicircum> <underscore> <h>", 0x2B0)

-CheckCompUni("<asciicircum> <underbar> <U0266>", 0x2B1)

-CheckCompUni("<asciicircum> <underscore> <U0266>", 0x2B1)

-CheckCompUni("<asciicircum> <underbar> <j>", 0x2B2)

-CheckCompUni("<asciicircum> <underscore> <j>", 0x2B2)

-CheckCompUni("<asciicircum> <underbar> <r>", 0x2B3)

-CheckCompUni("<asciicircum> <underscore> <r>", 0x2B3)

-CheckCompUni("<asciicircum> <underbar> <U0279>", 0x2B4)

-CheckCompUni("<asciicircum> <underscore> <U0279>", 0x2B4)

-CheckCompUni("<asciicircum> <underbar> <U027b>", 0x2B5)

-CheckCompUni("<asciicircum> <underscore> <U027b>", 0x2B5)

-CheckCompUni("<asciicircum> <underbar> <U0281>", 0x2B6)

-CheckCompUni("<asciicircum> <underscore> <U0281>", 0x2B6)

-CheckCompUni("<asciicircum> <underbar> <w>", 0x2B7)

-CheckCompUni("<asciicircum> <underscore> <w>", 0x2B7)

-CheckCompUni("<asciicircum> <underbar> <y>", 0x2B8)

-CheckCompUni("<asciicircum> <underscore> <y>", 0x2B8)

-CheckCompUni("<asciicircum> <underbar> <U0263>", 0x2E0)

-CheckCompUni("<asciicircum> <underscore> <U0263>", 0x2E0)

-CheckCompUni("<asciicircum> <underbar> <l>", 0x2E1)

-CheckCompUni("<asciicircum> <underscore> <l>", 0x2E1)

-CheckCompUni("<asciicircum> <underbar> <s>", 0x2E2)

-CheckCompUni("<asciicircum> <underscore> <s>", 0x2E2)

-CheckCompUni("<asciicircum> <underbar> <x>", 0x2E3)

-CheckCompUni("<asciicircum> <underscore> <x>", 0x2E3)

-CheckCompUni("<asciicircum> <underbar> <U0295>", 0x2E4)

-CheckCompUni("<asciicircum> <underscore> <U0295>", 0x2E4)

-CheckCompUni("<quotedbl> <combining_acute>", 0x344)

-CheckCompUni("<quotedbl> <apostrophe>", 0x344)

-CheckCompUni("<quotedbl> <acute>", 0x344)

-CheckCompUni("<quotedbl> <dead_acute>", 0x344)

-CheckCompUni("<apostrophe> <U03d2>", 0x3D3)

-CheckCompUni("<acute> <U03d2>", 0x3D3)

-CheckCompUni("<quotedbl> <U03d2>", 0x3D4)

-CheckCompUni("<period> <B>", 0x1E02)

-CheckCompUni("<period> <b>", 0x1E03)

-CheckCompUni("<exclam> <B>", 0x1E04)

-CheckCompUni("<exclam> <b>", 0x1E05)

-CheckCompUni("<apostrophe> <comma> <C>", 0x1E08)

-CheckCompUni("<apostrophe> <dead_cedilla> <C>", 0x1E08)

-CheckCompUni("<acute> <comma> <C>", 0x1E08)

-CheckCompUni("<acute> <dead_cedilla> <C>", 0x1E08)

-CheckCompUni("<apostrophe> <Ccedilla>", 0x1E08)

-CheckCompUni("<acute> <Ccedilla>", 0x1E08)

-CheckCompUni("<apostrophe> <comma> <c>", 0x1E09)

-CheckCompUni("<apostrophe> <dead_cedilla> <c>", 0x1E09)

-CheckCompUni("<acute> <comma> <c>", 0x1E09)

-CheckCompUni("<acute> <dead_cedilla> <c>", 0x1E09)

-CheckCompUni("<apostrophe> <ccedilla>", 0x1E09)

-CheckCompUni("<acute> <ccedilla>", 0x1E09)

-CheckCompUni("<period> <D>", 0x1E0A)

-CheckCompUni("<period> <d>", 0x1E0B)

-CheckCompUni("<exclam> <D>", 0x1E0C)

-CheckCompUni("<exclam> <d>", 0x1E0D)

-CheckCompUni("<comma> <D>", 0x1E10)

-CheckCompUni("<comma> <d>", 0x1E11)

-CheckCompUni("<grave> <underscore> <E>", 0x1E14)

-CheckCompUni("<grave> <macron> <E>", 0x1E14)

-CheckCompUni("<grave> <dead_macron> <E>", 0x1E14)

-CheckCompUni("<grave> <Emacron>", 0x1E14)

-CheckCompUni("<grave> <underscore> <e>", 0x1E15)

-CheckCompUni("<grave> <macron> <e>", 0x1E15)

-CheckCompUni("<grave> <dead_macron> <e>", 0x1E15)

-CheckCompUni("<grave> <emacron>", 0x1E15)

-CheckCompUni("<apostrophe> <underscore> <E>", 0x1E16)

-CheckCompUni("<apostrophe> <macron> <E>", 0x1E16)

-CheckCompUni("<apostrophe> <dead_macron> <E>", 0x1E16)

-CheckCompUni("<acute> <underscore> <E>", 0x1E16)

-CheckCompUni("<acute> <macron> <E>", 0x1E16)

-CheckCompUni("<acute> <dead_macron> <E>", 0x1E16)

-CheckCompUni("<apostrophe> <Emacron>", 0x1E16)

-CheckCompUni("<acute> <Emacron>", 0x1E16)

-CheckCompUni("<apostrophe> <underscore> <e>", 0x1E17)

-CheckCompUni("<apostrophe> <macron> <e>", 0x1E17)

-CheckCompUni("<apostrophe> <dead_macron> <e>", 0x1E17)

-CheckCompUni("<acute> <underscore> <e>", 0x1E17)

-CheckCompUni("<acute> <macron> <e>", 0x1E17)

-CheckCompUni("<acute> <dead_macron> <e>", 0x1E17)

-CheckCompUni("<apostrophe> <emacron>", 0x1E17)

-CheckCompUni("<acute> <emacron>", 0x1E17)

-CheckCompUni("<b> <comma> <E>", 0x1E1C)

-CheckCompUni("<b> <dead_cedilla> <E>", 0x1E1C)

-CheckCompUni("<U> <comma> <E>", 0x1E1C)

-CheckCompUni("<U> <dead_cedilla> <E>", 0x1E1C)

-CheckCompUni("<b> <U0228>", 0x1E1C)

-CheckCompUni("<U> <U0228>", 0x1E1C)

-CheckCompUni("<b> <comma> <e>", 0x1E1D)

-CheckCompUni("<b> <dead_cedilla> <e>", 0x1E1D)

-CheckCompUni("<U> <comma> <e>", 0x1E1D)

-CheckCompUni("<U> <dead_cedilla> <e>", 0x1E1D)

-CheckCompUni("<b> <U0229>", 0x1E1D)

-CheckCompUni("<U> <U0229>", 0x1E1D)

-CheckCompUni("<period> <F>", 0x1E1E)

-CheckCompUni("<period> <f>", 0x1E1F)

-CheckCompUni("<underscore> <G>", 0x1E20)

-CheckCompUni("<macron> <G>", 0x1E20)

-CheckCompUni("<underscore> <g>", 0x1E21)

-CheckCompUni("<macron> <g>", 0x1E21)

-CheckCompUni("<period> <H>", 0x1E22)

-CheckCompUni("<period> <h>", 0x1E23)

-CheckCompUni("<exclam> <H>", 0x1E24)

-CheckCompUni("<exclam> <h>", 0x1E25)

-CheckCompUni("<quotedbl> <H>", 0x1E26)

-CheckCompUni("<quotedbl> <h>", 0x1E27)

-CheckCompUni("<comma> <H>", 0x1E28)

-CheckCompUni("<comma> <h>", 0x1E29)

-CheckCompUni("<apostrophe> <quotedbl> <I>", 0x1E2E)

-CheckCompUni("<apostrophe> <dead_diaeresis> <I>", 0x1E2E)

-CheckCompUni("<acute> <quotedbl> <I>", 0x1E2E)

-CheckCompUni("<acute> <dead_diaeresis> <I>", 0x1E2E)

-CheckCompUni("<apostrophe> <Idiaeresis>", 0x1E2E)

-CheckCompUni("<acute> <Idiaeresis>", 0x1E2E)

-CheckCompUni("<apostrophe> <quotedbl> <i>", 0x1E2F)

-CheckCompUni("<apostrophe> <dead_diaeresis> <i>", 0x1E2F)

-CheckCompUni("<acute> <quotedbl> <i>", 0x1E2F)

-CheckCompUni("<acute> <dead_diaeresis> <i>", 0x1E2F)

-CheckCompUni("<apostrophe> <idiaeresis>", 0x1E2F)

-CheckCompUni("<acute> <idiaeresis>", 0x1E2F)

-CheckCompUni("<apostrophe> <K>", 0x1E30)

-CheckCompUni("<acute> <K>", 0x1E30)

-CheckCompUni("<apostrophe> <k>", 0x1E31)

-CheckCompUni("<acute> <k>", 0x1E31)

-CheckCompUni("<exclam> <K>", 0x1E32)

-CheckCompUni("<exclam> <k>", 0x1E33)

-CheckCompUni("<exclam> <L>", 0x1E36)

-CheckCompUni("<exclam> <l>", 0x1E37)

-CheckCompUni("<underscore> <combining_belowdot> <L>", 0x1E38)

-CheckCompUni("<macron> <combining_belowdot> <L>", 0x1E38)

-CheckCompUni("<underscore> <exclam> <L>", 0x1E38)

-CheckCompUni("<underscore> <dead_belowdot> <L>", 0x1E38)

-CheckCompUni("<macron> <exclam> <L>", 0x1E38)

-CheckCompUni("<macron> <dead_belowdot> <L>", 0x1E38)

-CheckCompUni("<underscore> <U1e36>", 0x1E38)

-CheckCompUni("<macron> <U1e36>", 0x1E38)

-CheckCompUni("<underscore> <combining_belowdot> <l>", 0x1E39)

-CheckCompUni("<macron> <combining_belowdot> <l>", 0x1E39)

-CheckCompUni("<underscore> <exclam> <l>", 0x1E39)

-CheckCompUni("<underscore> <dead_belowdot> <l>", 0x1E39)

-CheckCompUni("<macron> <exclam> <l>", 0x1E39)

-CheckCompUni("<macron> <dead_belowdot> <l>", 0x1E39)

-CheckCompUni("<underscore> <U1e37>", 0x1E39)

-CheckCompUni("<macron> <U1e37>", 0x1E39)

-CheckCompUni("<apostrophe> <M>", 0x1E3E)

-CheckCompUni("<acute> <M>", 0x1E3E)

-CheckCompUni("<apostrophe> <m>", 0x1E3F)

-CheckCompUni("<acute> <m>", 0x1E3F)

-CheckCompUni("<period> <M>", 0x1E40)

-CheckCompUni("<period> <m>", 0x1E41)

-CheckCompUni("<exclam> <M>", 0x1E42)

-CheckCompUni("<exclam> <m>", 0x1E43)

-CheckCompUni("<period> <N>", 0x1E44)

-CheckCompUni("<period> <n>", 0x1E45)

-CheckCompUni("<exclam> <N>", 0x1E46)

-CheckCompUni("<exclam> <n>", 0x1E47)

-CheckCompUni("<apostrophe> <combining_tilde> <O>", 0x1E4C)

-CheckCompUni("<acute> <combining_tilde> <O>", 0x1E4C)

-CheckCompUni("<apostrophe> <asciitilde> <O>", 0x1E4C)

-CheckCompUni("<apostrophe> <dead_tilde> <O>", 0x1E4C)

-CheckCompUni("<acute> <asciitilde> <O>", 0x1E4C)

-CheckCompUni("<acute> <dead_tilde> <O>", 0x1E4C)

-CheckCompUni("<apostrophe> <Otilde>", 0x1E4C)

-CheckCompUni("<acute> <Otilde>", 0x1E4C)

-CheckCompUni("<apostrophe> <combining_tilde> <o>", 0x1E4D)

-CheckCompUni("<acute> <combining_tilde> <o>", 0x1E4D)

-CheckCompUni("<apostrophe> <asciitilde> <o>", 0x1E4D)

-CheckCompUni("<apostrophe> <dead_tilde> <o>", 0x1E4D)

-CheckCompUni("<acute> <asciitilde> <o>", 0x1E4D)

-CheckCompUni("<acute> <dead_tilde> <o>", 0x1E4D)

-CheckCompUni("<apostrophe> <otilde>", 0x1E4D)

-CheckCompUni("<acute> <otilde>", 0x1E4D)

-CheckCompUni("<quotedbl> <combining_tilde> <O>", 0x1E4E)

-CheckCompUni("<quotedbl> <asciitilde> <O>", 0x1E4E)

-CheckCompUni("<quotedbl> <dead_tilde> <O>", 0x1E4E)

-CheckCompUni("<quotedbl> <Otilde>", 0x1E4E)

-CheckCompUni("<quotedbl> <combining_tilde> <o>", 0x1E4F)

-CheckCompUni("<quotedbl> <asciitilde> <o>", 0x1E4F)

-CheckCompUni("<quotedbl> <dead_tilde> <o>", 0x1E4F)

-CheckCompUni("<quotedbl> <otilde>", 0x1E4F)

-CheckCompUni("<grave> <underscore> <O>", 0x1E50)

-CheckCompUni("<grave> <macron> <O>", 0x1E50)

-CheckCompUni("<grave> <dead_macron> <O>", 0x1E50)

-CheckCompUni("<grave> <Omacron>", 0x1E50)

-CheckCompUni("<grave> <underscore> <o>", 0x1E51)

-CheckCompUni("<grave> <macron> <o>", 0x1E51)

-CheckCompUni("<grave> <dead_macron> <o>", 0x1E51)

-CheckCompUni("<grave> <omacron>", 0x1E51)

-CheckCompUni("<apostrophe> <underscore> <O>", 0x1E52)

-CheckCompUni("<apostrophe> <macron> <O>", 0x1E52)

-CheckCompUni("<apostrophe> <dead_macron> <O>", 0x1E52)

-CheckCompUni("<acute> <underscore> <O>", 0x1E52)

-CheckCompUni("<acute> <macron> <O>", 0x1E52)

-CheckCompUni("<acute> <dead_macron> <O>", 0x1E52)

-CheckCompUni("<apostrophe> <Omacron>", 0x1E52)

-CheckCompUni("<acute> <Omacron>", 0x1E52)

-CheckCompUni("<apostrophe> <underscore> <o>", 0x1E53)

-CheckCompUni("<apostrophe> <macron> <o>", 0x1E53)

-CheckCompUni("<apostrophe> <dead_macron> <o>", 0x1E53)

-CheckCompUni("<acute> <underscore> <o>", 0x1E53)

-CheckCompUni("<acute> <macron> <o>", 0x1E53)

-CheckCompUni("<acute> <dead_macron> <o>", 0x1E53)

-CheckCompUni("<apostrophe> <omacron>", 0x1E53)

-CheckCompUni("<acute> <omacron>", 0x1E53)

-CheckCompUni("<apostrophe> <P>", 0x1E54)

-CheckCompUni("<acute> <P>", 0x1E54)

-CheckCompUni("<apostrophe> <p>", 0x1E55)

-CheckCompUni("<acute> <p>", 0x1E55)

-CheckCompUni("<period> <P>", 0x1E56)

-CheckCompUni("<period> <p>", 0x1E57)

-CheckCompUni("<period> <R>", 0x1E58)

-CheckCompUni("<period> <r>", 0x1E59)

-CheckCompUni("<exclam> <R>", 0x1E5A)

-CheckCompUni("<exclam> <r>", 0x1E5B)

-CheckCompUni("<underscore> <combining_belowdot> <R>", 0x1E5C)

-CheckCompUni("<macron> <combining_belowdot> <R>", 0x1E5C)

-CheckCompUni("<underscore> <exclam> <R>", 0x1E5C)

-CheckCompUni("<underscore> <dead_belowdot> <R>", 0x1E5C)

-CheckCompUni("<macron> <exclam> <R>", 0x1E5C)

-CheckCompUni("<macron> <dead_belowdot> <R>", 0x1E5C)

-CheckCompUni("<underscore> <U1e5a>", 0x1E5C)

-CheckCompUni("<macron> <U1e5a>", 0x1E5C)

-CheckCompUni("<underscore> <combining_belowdot> <r>", 0x1E5D)

-CheckCompUni("<macron> <combining_belowdot> <r>", 0x1E5D)

-CheckCompUni("<underscore> <exclam> <r>", 0x1E5D)

-CheckCompUni("<underscore> <dead_belowdot> <r>", 0x1E5D)

-CheckCompUni("<macron> <exclam> <r>", 0x1E5D)

-CheckCompUni("<macron> <dead_belowdot> <r>", 0x1E5D)

-CheckCompUni("<underscore> <U1e5b>", 0x1E5D)

-CheckCompUni("<macron> <U1e5b>", 0x1E5D)

-CheckCompUni("<period> <S>", 0x1E60)

-CheckCompUni("<period> <s>", 0x1E61)

-CheckCompUni("<exclam> <S>", 0x1E62)

-CheckCompUni("<exclam> <s>", 0x1E63)

-CheckCompUni("<period> <combining_acute> <S>", 0x1E64)

-CheckCompUni("<period> <apostrophe> <S>", 0x1E64)

-CheckCompUni("<period> <acute> <S>", 0x1E64)

-CheckCompUni("<period> <dead_acute> <S>", 0x1E64)

-CheckCompUni("<period> <Sacute>", 0x1E64)

-CheckCompUni("<period> <combining_acute> <s>", 0x1E65)

-CheckCompUni("<period> <apostrophe> <s>", 0x1E65)

-CheckCompUni("<period> <acute> <s>", 0x1E65)

-CheckCompUni("<period> <dead_acute> <s>", 0x1E65)

-CheckCompUni("<period> <sacute>", 0x1E65)

-CheckCompUni("<period> <c> <S>", 0x1E66)

-CheckCompUni("<period> <dead_caron> <S>", 0x1E66)

-CheckCompUni("<period> <Scaron>", 0x1E66)

-CheckCompUni("<period> <c> <s>", 0x1E67)

-CheckCompUni("<period> <dead_caron> <s>", 0x1E67)

-CheckCompUni("<period> <scaron>", 0x1E67)

-CheckCompUni("<period> <combining_belowdot> <S>", 0x1E68)

-CheckCompUni("<period> <exclam> <S>", 0x1E68)

-CheckCompUni("<period> <dead_belowdot> <S>", 0x1E68)

-CheckCompUni("<period> <U1e62>", 0x1E68)

-CheckCompUni("<period> <combining_belowdot> <s>", 0x1E69)

-CheckCompUni("<period> <exclam> <s>", 0x1E69)

-CheckCompUni("<period> <dead_belowdot> <s>", 0x1E69)

-CheckCompUni("<period> <U1e63>", 0x1E69)

-CheckCompUni("<period> <T>", 0x1E6A)

-CheckCompUni("<period> <t>", 0x1E6B)

-CheckCompUni("<exclam> <T>", 0x1E6C)

-CheckCompUni("<exclam> <t>", 0x1E6D)

-CheckCompUni("<apostrophe> <combining_tilde> <U>", 0x1E78)

-CheckCompUni("<acute> <combining_tilde> <U>", 0x1E78)

-CheckCompUni("<apostrophe> <asciitilde> <U>", 0x1E78)

-CheckCompUni("<apostrophe> <dead_tilde> <U>", 0x1E78)

-CheckCompUni("<acute> <asciitilde> <U>", 0x1E78)

-CheckCompUni("<acute> <dead_tilde> <U>", 0x1E78)

-CheckCompUni("<apostrophe> <Utilde>", 0x1E78)

-CheckCompUni("<acute> <Utilde>", 0x1E78)

-CheckCompUni("<apostrophe> <combining_tilde> <u>", 0x1E79)

-CheckCompUni("<acute> <combining_tilde> <u>", 0x1E79)

-CheckCompUni("<apostrophe> <asciitilde> <u>", 0x1E79)

-CheckCompUni("<apostrophe> <dead_tilde> <u>", 0x1E79)

-CheckCompUni("<acute> <asciitilde> <u>", 0x1E79)

-CheckCompUni("<acute> <dead_tilde> <u>", 0x1E79)

-CheckCompUni("<apostrophe> <utilde>", 0x1E79)

-CheckCompUni("<acute> <utilde>", 0x1E79)

-CheckCompUni("<quotedbl> <underscore> <U>", 0x1E7A)

-CheckCompUni("<quotedbl> <macron> <U>", 0x1E7A)

-CheckCompUni("<quotedbl> <dead_macron> <U>", 0x1E7A)

-CheckCompUni("<quotedbl> <Umacron>", 0x1E7A)

-CheckCompUni("<quotedbl> <underscore> <u>", 0x1E7B)

-CheckCompUni("<quotedbl> <macron> <u>", 0x1E7B)

-CheckCompUni("<quotedbl> <dead_macron> <u>", 0x1E7B)

-CheckCompUni("<quotedbl> <umacron>", 0x1E7B)

-CheckCompUni("<asciitilde> <V>", 0x1E7C)

-CheckCompUni("<asciitilde> <v>", 0x1E7D)

-CheckCompUni("<exclam> <V>", 0x1E7E)

-CheckCompUni("<exclam> <v>", 0x1E7F)

-CheckCompUni("<grave> <W>", 0x1E80)

-CheckCompUni("<grave> <w>", 0x1E81)

-CheckCompUni("<apostrophe> <W>", 0x1E82)

-CheckCompUni("<acute> <W>", 0x1E82)

-CheckCompUni("<apostrophe> <w>", 0x1E83)

-CheckCompUni("<acute> <w>", 0x1E83)

-CheckCompUni("<quotedbl> <W>", 0x1E84)

-CheckCompUni("<quotedbl> <w>", 0x1E85)

-CheckCompUni("<period> <W>", 0x1E86)

-CheckCompUni("<period> <w>", 0x1E87)

-CheckCompUni("<exclam> <W>", 0x1E88)

-CheckCompUni("<exclam> <w>", 0x1E89)

-CheckCompUni("<period> <X>", 0x1E8A)

-CheckCompUni("<period> <x>", 0x1E8B)

-CheckCompUni("<quotedbl> <X>", 0x1E8C)

-CheckCompUni("<quotedbl> <x>", 0x1E8D)

-CheckCompUni("<period> <Y>", 0x1E8E)

-CheckCompUni("<period> <y>", 0x1E8F)

-CheckCompUni("<asciicircum> <Z>", 0x1E90)

-CheckCompUni("<asciicircum> <z>", 0x1E91)

-CheckCompUni("<exclam> <Z>", 0x1E92)

-CheckCompUni("<exclam> <z>", 0x1E93)

-CheckCompUni("<quotedbl> <t>", 0x1E97)

-CheckCompUni("<o> <w>", 0x1E98)

-CheckCompUni("<o> <y>", 0x1E99)

-CheckCompUni("<period> <U017f>", 0x1E9B)

-CheckCompUni("<exclam> <A>", 0x1EA0)

-CheckCompUni("<exclam> <a>", 0x1EA1)

-CheckCompUni("<question> <A>", 0x1EA2)

-CheckCompUni("<question> <a>", 0x1EA3)

-CheckCompUni("<apostrophe> <asciicircum> <A>", 0x1EA4)

-CheckCompUni("<apostrophe> <dead_circumflex> <A>", 0x1EA4)

-CheckCompUni("<acute> <asciicircum> <A>", 0x1EA4)

-CheckCompUni("<acute> <dead_circumflex> <A>", 0x1EA4)

-CheckCompUni("<apostrophe> <Acircumflex>", 0x1EA4)

-CheckCompUni("<acute> <Acircumflex>", 0x1EA4)

-CheckCompUni("<apostrophe> <asciicircum> <a>", 0x1EA5)

-CheckCompUni("<apostrophe> <dead_circumflex> <a>", 0x1EA5)

-CheckCompUni("<acute> <asciicircum> <a>", 0x1EA5)

-CheckCompUni("<acute> <dead_circumflex> <a>", 0x1EA5)

-CheckCompUni("<apostrophe> <acircumflex>", 0x1EA5)

-CheckCompUni("<acute> <acircumflex>", 0x1EA5)

-CheckCompUni("<grave> <asciicircum> <A>", 0x1EA6)

-CheckCompUni("<grave> <dead_circumflex> <A>", 0x1EA6)

-CheckCompUni("<grave> <Acircumflex>", 0x1EA6)

-CheckCompUni("<grave> <asciicircum> <a>", 0x1EA7)

-CheckCompUni("<grave> <dead_circumflex> <a>", 0x1EA7)

-CheckCompUni("<grave> <acircumflex>", 0x1EA7)

-CheckCompUni("<question> <asciicircum> <A>", 0x1EA8)

-CheckCompUni("<question> <dead_circumflex> <A>", 0x1EA8)

-CheckCompUni("<question> <Acircumflex>", 0x1EA8)

-CheckCompUni("<question> <asciicircum> <a>", 0x1EA9)

-CheckCompUni("<question> <dead_circumflex> <a>", 0x1EA9)

-CheckCompUni("<question> <acircumflex>", 0x1EA9)

-CheckCompUni("<asciitilde> <asciicircum> <A>", 0x1EAA)

-CheckCompUni("<asciitilde> <dead_circumflex> <A>", 0x1EAA)

-CheckCompUni("<asciitilde> <Acircumflex>", 0x1EAA)

-CheckCompUni("<asciitilde> <asciicircum> <a>", 0x1EAB)

-CheckCompUni("<asciitilde> <dead_circumflex> <a>", 0x1EAB)

-CheckCompUni("<asciitilde> <acircumflex>", 0x1EAB)

-CheckCompUni("<asciicircum> <combining_belowdot> <A>", 0x1EAC)

-CheckCompUni("<asciicircum> <exclam> <A>", 0x1EAC)

-CheckCompUni("<asciicircum> <dead_belowdot> <A>", 0x1EAC)

-CheckCompUni("<asciicircum> <U1ea0>", 0x1EAC)

-CheckCompUni("<asciicircum> <combining_belowdot> <a>", 0x1EAD)

-CheckCompUni("<asciicircum> <exclam> <a>", 0x1EAD)

-CheckCompUni("<asciicircum> <dead_belowdot> <a>", 0x1EAD)

-CheckCompUni("<asciicircum> <U1ea1>", 0x1EAD)

-CheckCompUni("<apostrophe> <b> <A>", 0x1EAE)

-CheckCompUni("<apostrophe> <U> <A>", 0x1EAE)

-CheckCompUni("<apostrophe> <dead_breve> <A>", 0x1EAE)

-CheckCompUni("<acute> <b> <A>", 0x1EAE)

-CheckCompUni("<acute> <U> <A>", 0x1EAE)

-CheckCompUni("<acute> <dead_breve> <A>", 0x1EAE)

-CheckCompUni("<apostrophe> <Abreve>", 0x1EAE)

-CheckCompUni("<acute> <Abreve>", 0x1EAE)

-CheckCompUni("<apostrophe> <b> <a>", 0x1EAF)

-CheckCompUni("<apostrophe> <U> <a>", 0x1EAF)

-CheckCompUni("<apostrophe> <dead_breve> <a>", 0x1EAF)

-CheckCompUni("<acute> <b> <a>", 0x1EAF)

-CheckCompUni("<acute> <U> <a>", 0x1EAF)

-CheckCompUni("<acute> <dead_breve> <a>", 0x1EAF)

-CheckCompUni("<apostrophe> <abreve>", 0x1EAF)

-CheckCompUni("<acute> <abreve>", 0x1EAF)

-CheckCompUni("<grave> <b> <A>", 0x1EB0)

-CheckCompUni("<grave> <U> <A>", 0x1EB0)

-CheckCompUni("<grave> <dead_breve> <A>", 0x1EB0)

-CheckCompUni("<grave> <Abreve>", 0x1EB0)

-CheckCompUni("<grave> <b> <a>", 0x1EB1)

-CheckCompUni("<grave> <U> <a>", 0x1EB1)

-CheckCompUni("<grave> <dead_breve> <a>", 0x1EB1)

-CheckCompUni("<grave> <abreve>", 0x1EB1)

-CheckCompUni("<question> <b> <A>", 0x1EB2)

-CheckCompUni("<question> <U> <A>", 0x1EB2)

-CheckCompUni("<question> <dead_breve> <A>", 0x1EB2)

-CheckCompUni("<question> <Abreve>", 0x1EB2)

-CheckCompUni("<question> <b> <a>", 0x1EB3)

-CheckCompUni("<question> <U> <a>", 0x1EB3)

-CheckCompUni("<question> <dead_breve> <a>", 0x1EB3)

-CheckCompUni("<question> <abreve>", 0x1EB3)

-CheckCompUni("<asciitilde> <b> <A>", 0x1EB4)

-CheckCompUni("<asciitilde> <U> <A>", 0x1EB4)

-CheckCompUni("<asciitilde> <dead_breve> <A>", 0x1EB4)

-CheckCompUni("<asciitilde> <Abreve>", 0x1EB4)

-CheckCompUni("<asciitilde> <b> <a>", 0x1EB5)

-CheckCompUni("<asciitilde> <U> <a>", 0x1EB5)

-CheckCompUni("<asciitilde> <dead_breve> <a>", 0x1EB5)

-CheckCompUni("<asciitilde> <abreve>", 0x1EB5)

-CheckCompUni("<b> <combining_belowdot> <A>", 0x1EB6)

-CheckCompUni("<U> <combining_belowdot> <A>", 0x1EB6)

-CheckCompUni("<b> <exclam> <A>", 0x1EB6)

-CheckCompUni("<b> <dead_belowdot> <A>", 0x1EB6)

-CheckCompUni("<U> <exclam> <A>", 0x1EB6)

-CheckCompUni("<U> <dead_belowdot> <A>", 0x1EB6)

-CheckCompUni("<b> <U1ea0>", 0x1EB6)

-CheckCompUni("<U> <U1ea0>", 0x1EB6)

-CheckCompUni("<b> <combining_belowdot> <a>", 0x1EB7)

-CheckCompUni("<U> <combining_belowdot> <a>", 0x1EB7)

-CheckCompUni("<b> <exclam> <a>", 0x1EB7)

-CheckCompUni("<b> <dead_belowdot> <a>", 0x1EB7)

-CheckCompUni("<U> <exclam> <a>", 0x1EB7)

-CheckCompUni("<U> <dead_belowdot> <a>", 0x1EB7)

-CheckCompUni("<b> <U1ea1>", 0x1EB7)

-CheckCompUni("<U> <U1ea1>", 0x1EB7)

-CheckCompUni("<exclam> <E>", 0x1EB8)

-CheckCompUni("<exclam> <e>", 0x1EB9)

-CheckCompUni("<question> <E>", 0x1EBA)

-CheckCompUni("<question> <e>", 0x1EBB)

-CheckCompUni("<asciitilde> <E>", 0x1EBC)

-CheckCompUni("<asciitilde> <e>", 0x1EBD)

-CheckCompUni("<apostrophe> <asciicircum> <E>", 0x1EBE)

-CheckCompUni("<apostrophe> <dead_circumflex> <E>", 0x1EBE)

-CheckCompUni("<acute> <asciicircum> <E>", 0x1EBE)

-CheckCompUni("<acute> <dead_circumflex> <E>", 0x1EBE)

-CheckCompUni("<apostrophe> <Ecircumflex>", 0x1EBE)

-CheckCompUni("<acute> <Ecircumflex>", 0x1EBE)

-CheckCompUni("<apostrophe> <asciicircum> <e>", 0x1EBF)

-CheckCompUni("<apostrophe> <dead_circumflex> <e>", 0x1EBF)

-CheckCompUni("<acute> <asciicircum> <e>", 0x1EBF)

-CheckCompUni("<acute> <dead_circumflex> <e>", 0x1EBF)

-CheckCompUni("<apostrophe> <ecircumflex>", 0x1EBF)

-CheckCompUni("<acute> <ecircumflex>", 0x1EBF)

-CheckCompUni("<grave> <asciicircum> <E>", 0x1EC0)

-CheckCompUni("<grave> <dead_circumflex> <E>", 0x1EC0)

-CheckCompUni("<grave> <Ecircumflex>", 0x1EC0)

-CheckCompUni("<grave> <asciicircum> <e>", 0x1EC1)

-CheckCompUni("<grave> <dead_circumflex> <e>", 0x1EC1)

-CheckCompUni("<grave> <ecircumflex>", 0x1EC1)

-CheckCompUni("<question> <asciicircum> <E>", 0x1EC2)

-CheckCompUni("<question> <dead_circumflex> <E>", 0x1EC2)

-CheckCompUni("<question> <Ecircumflex>", 0x1EC2)

-CheckCompUni("<question> <asciicircum> <e>", 0x1EC3)

-CheckCompUni("<question> <dead_circumflex> <e>", 0x1EC3)

-CheckCompUni("<question> <ecircumflex>", 0x1EC3)

-CheckCompUni("<asciitilde> <asciicircum> <E>", 0x1EC4)

-CheckCompUni("<asciitilde> <dead_circumflex> <E>", 0x1EC4)

-CheckCompUni("<asciitilde> <Ecircumflex>", 0x1EC4)

-CheckCompUni("<asciitilde> <asciicircum> <e>", 0x1EC5)

-CheckCompUni("<asciitilde> <dead_circumflex> <e>", 0x1EC5)

-CheckCompUni("<asciitilde> <ecircumflex>", 0x1EC5)

-CheckCompUni("<asciicircum> <combining_belowdot> <E>", 0x1EC6)

-CheckCompUni("<asciicircum> <exclam> <E>", 0x1EC6)

-CheckCompUni("<asciicircum> <dead_belowdot> <E>", 0x1EC6)

-CheckCompUni("<asciicircum> <U1eb8>", 0x1EC6)

-CheckCompUni("<asciicircum> <combining_belowdot> <e>", 0x1EC7)

-CheckCompUni("<asciicircum> <exclam> <e>", 0x1EC7)

-CheckCompUni("<asciicircum> <dead_belowdot> <e>", 0x1EC7)

-CheckCompUni("<asciicircum> <U1eb9>", 0x1EC7)

-CheckCompUni("<question> <I>", 0x1EC8)

-CheckCompUni("<question> <i>", 0x1EC9)

-CheckCompUni("<exclam> <I>", 0x1ECA)

-CheckCompUni("<exclam> <i>", 0x1ECB)

-CheckCompUni("<exclam> <O>", 0x1ECC)

-CheckCompUni("<exclam> <o>", 0x1ECD)

-CheckCompUni("<question> <O>", 0x1ECE)

-CheckCompUni("<question> <o>", 0x1ECF)

-CheckCompUni("<apostrophe> <asciicircum> <O>", 0x1ED0)

-CheckCompUni("<apostrophe> <dead_circumflex> <O>", 0x1ED0)

-CheckCompUni("<acute> <asciicircum> <O>", 0x1ED0)

-CheckCompUni("<acute> <dead_circumflex> <O>", 0x1ED0)

-CheckCompUni("<apostrophe> <Ocircumflex>", 0x1ED0)

-CheckCompUni("<acute> <Ocircumflex>", 0x1ED0)

-CheckCompUni("<apostrophe> <asciicircum> <o>", 0x1ED1)

-CheckCompUni("<apostrophe> <dead_circumflex> <o>", 0x1ED1)

-CheckCompUni("<acute> <asciicircum> <o>", 0x1ED1)

-CheckCompUni("<acute> <dead_circumflex> <o>", 0x1ED1)

-CheckCompUni("<apostrophe> <ocircumflex>", 0x1ED1)

-CheckCompUni("<acute> <ocircumflex>", 0x1ED1)

-CheckCompUni("<grave> <asciicircum> <O>", 0x1ED2)

-CheckCompUni("<grave> <dead_circumflex> <O>", 0x1ED2)

-CheckCompUni("<grave> <Ocircumflex>", 0x1ED2)

-CheckCompUni("<grave> <asciicircum> <o>", 0x1ED3)

-CheckCompUni("<grave> <dead_circumflex> <o>", 0x1ED3)

-CheckCompUni("<grave> <ocircumflex>", 0x1ED3)

-CheckCompUni("<question> <asciicircum> <O>", 0x1ED4)

-CheckCompUni("<question> <dead_circumflex> <O>", 0x1ED4)

-CheckCompUni("<question> <Ocircumflex>", 0x1ED4)

-CheckCompUni("<question> <asciicircum> <o>", 0x1ED5)

-CheckCompUni("<question> <dead_circumflex> <o>", 0x1ED5)

-CheckCompUni("<question> <ocircumflex>", 0x1ED5)

-CheckCompUni("<asciitilde> <asciicircum> <O>", 0x1ED6)

-CheckCompUni("<asciitilde> <dead_circumflex> <O>", 0x1ED6)

-CheckCompUni("<asciitilde> <Ocircumflex>", 0x1ED6)

-CheckCompUni("<asciitilde> <asciicircum> <o>", 0x1ED7)

-CheckCompUni("<asciitilde> <dead_circumflex> <o>", 0x1ED7)

-CheckCompUni("<asciitilde> <ocircumflex>", 0x1ED7)

-CheckCompUni("<asciicircum> <combining_belowdot> <O>", 0x1ED8)

-CheckCompUni("<asciicircum> <exclam> <O>", 0x1ED8)

-CheckCompUni("<asciicircum> <dead_belowdot> <O>", 0x1ED8)

-CheckCompUni("<asciicircum> <U1ecc>", 0x1ED8)

-CheckCompUni("<asciicircum> <combining_belowdot> <o>", 0x1ED9)

-CheckCompUni("<asciicircum> <exclam> <o>", 0x1ED9)

-CheckCompUni("<asciicircum> <dead_belowdot> <o>", 0x1ED9)

-CheckCompUni("<asciicircum> <U1ecd>", 0x1ED9)

-CheckCompUni("<apostrophe> <plus> <O>", 0x1EDA)

-CheckCompUni("<apostrophe> <dead_horn> <O>", 0x1EDA)

-CheckCompUni("<acute> <plus> <O>", 0x1EDA)

-CheckCompUni("<acute> <dead_horn> <O>", 0x1EDA)

-CheckCompUni("<apostrophe> <Ohorn>", 0x1EDA)

-CheckCompUni("<acute> <Ohorn>", 0x1EDA)

-CheckCompUni("<apostrophe> <plus> <o>", 0x1EDB)

-CheckCompUni("<apostrophe> <dead_horn> <o>", 0x1EDB)

-CheckCompUni("<acute> <plus> <o>", 0x1EDB)

-CheckCompUni("<acute> <dead_horn> <o>", 0x1EDB)

-CheckCompUni("<apostrophe> <ohorn>", 0x1EDB)

-CheckCompUni("<acute> <ohorn>", 0x1EDB)

-CheckCompUni("<grave> <plus> <O>", 0x1EDC)

-CheckCompUni("<grave> <dead_horn> <O>", 0x1EDC)

-CheckCompUni("<grave> <Ohorn>", 0x1EDC)

-CheckCompUni("<grave> <plus> <o>", 0x1EDD)

-CheckCompUni("<grave> <dead_horn> <o>", 0x1EDD)

-CheckCompUni("<grave> <ohorn>", 0x1EDD)

-CheckCompUni("<question> <plus> <O>", 0x1EDE)

-CheckCompUni("<question> <dead_horn> <O>", 0x1EDE)

-CheckCompUni("<question> <Ohorn>", 0x1EDE)

-CheckCompUni("<question> <plus> <o>", 0x1EDF)

-CheckCompUni("<question> <dead_horn> <o>", 0x1EDF)

-CheckCompUni("<question> <ohorn>", 0x1EDF)

-CheckCompUni("<asciitilde> <plus> <O>", 0x1EE0)

-CheckCompUni("<asciitilde> <dead_horn> <O>", 0x1EE0)

-CheckCompUni("<asciitilde> <Ohorn>", 0x1EE0)

-CheckCompUni("<asciitilde> <plus> <o>", 0x1EE1)

-CheckCompUni("<asciitilde> <dead_horn> <o>", 0x1EE1)

-CheckCompUni("<asciitilde> <ohorn>", 0x1EE1)

-CheckCompUni("<exclam> <plus> <O>", 0x1EE2)

-CheckCompUni("<exclam> <dead_horn> <O>", 0x1EE2)

-CheckCompUni("<exclam> <Ohorn>", 0x1EE2)

-CheckCompUni("<exclam> <plus> <o>", 0x1EE3)

-CheckCompUni("<exclam> <dead_horn> <o>", 0x1EE3)

-CheckCompUni("<exclam> <ohorn>", 0x1EE3)

-CheckCompUni("<exclam> <U>", 0x1EE4)

-CheckCompUni("<exclam> <u>", 0x1EE5)

-CheckCompUni("<question> <U>", 0x1EE6)

-CheckCompUni("<question> <u>", 0x1EE7)

-CheckCompUni("<apostrophe> <plus> <U>", 0x1EE8)

-CheckCompUni("<apostrophe> <dead_horn> <U>", 0x1EE8)

-CheckCompUni("<acute> <plus> <U>", 0x1EE8)

-CheckCompUni("<acute> <dead_horn> <U>", 0x1EE8)

-CheckCompUni("<apostrophe> <Uhorn>", 0x1EE8)

-CheckCompUni("<acute> <Uhorn>", 0x1EE8)

-CheckCompUni("<apostrophe> <plus> <u>", 0x1EE9)

-CheckCompUni("<apostrophe> <dead_horn> <u>", 0x1EE9)

-CheckCompUni("<acute> <plus> <u>", 0x1EE9)

-CheckCompUni("<acute> <dead_horn> <u>", 0x1EE9)

-CheckCompUni("<apostrophe> <uhorn>", 0x1EE9)

-CheckCompUni("<acute> <uhorn>", 0x1EE9)

-CheckCompUni("<grave> <plus> <U>", 0x1EEA)

-CheckCompUni("<grave> <dead_horn> <U>", 0x1EEA)

-CheckCompUni("<grave> <Uhorn>", 0x1EEA)

-CheckCompUni("<grave> <plus> <u>", 0x1EEB)

-CheckCompUni("<grave> <dead_horn> <u>", 0x1EEB)

-CheckCompUni("<grave> <uhorn>", 0x1EEB)

-CheckCompUni("<question> <plus> <U>", 0x1EEC)

-CheckCompUni("<question> <dead_horn> <U>", 0x1EEC)

-CheckCompUni("<question> <Uhorn>", 0x1EEC)

-CheckCompUni("<question> <plus> <u>", 0x1EED)

-CheckCompUni("<question> <dead_horn> <u>", 0x1EED)

-CheckCompUni("<question> <uhorn>", 0x1EED)

-CheckCompUni("<asciitilde> <plus> <U>", 0x1EEE)

-CheckCompUni("<asciitilde> <dead_horn> <U>", 0x1EEE)

-CheckCompUni("<asciitilde> <Uhorn>", 0x1EEE)

-CheckCompUni("<asciitilde> <plus> <u>", 0x1EEF)

-CheckCompUni("<asciitilde> <dead_horn> <u>", 0x1EEF)

-CheckCompUni("<asciitilde> <uhorn>", 0x1EEF)

-CheckCompUni("<exclam> <plus> <U>", 0x1EF0)

-CheckCompUni("<exclam> <dead_horn> <U>", 0x1EF0)

-CheckCompUni("<exclam> <Uhorn>", 0x1EF0)

-CheckCompUni("<exclam> <plus> <u>", 0x1EF1)

-CheckCompUni("<exclam> <dead_horn> <u>", 0x1EF1)

-CheckCompUni("<exclam> <uhorn>", 0x1EF1)

-CheckCompUni("<grave> <Y>", 0x1EF2)

-CheckCompUni("<grave> <y>", 0x1EF3)

-CheckCompUni("<exclam> <Y>", 0x1EF4)

-CheckCompUni("<exclam> <y>", 0x1EF5)

-CheckCompUni("<question> <Y>", 0x1EF6)

-CheckCompUni("<question> <y>", 0x1EF7)

-CheckCompUni("<asciitilde> <Y>", 0x1EF8)

-CheckCompUni("<asciitilde> <y>", 0x1EF9)

-CheckCompUni("<parenright> <Greek_alpha>", 0x1F00)

-CheckCompUni("<parenleft> <Greek_alpha>", 0x1F01)

-CheckCompUni("<grave> <parenright> <Greek_alpha>", 0x1F02)

-CheckCompUni("<grave> <U0313> <Greek_alpha>", 0x1F02)

-CheckCompUni("<grave> <U1f00>", 0x1F02)

-CheckCompUni("<grave> <parenleft> <Greek_alpha>", 0x1F03)

-CheckCompUni("<grave> <U0314> <Greek_alpha>", 0x1F03)

-CheckCompUni("<grave> <U1f01>", 0x1F03)

-CheckCompUni("<apostrophe> <parenright> <Greek_alpha>", 0x1F04)

-CheckCompUni("<apostrophe> <U0313> <Greek_alpha>", 0x1F04)

-CheckCompUni("<acute> <parenright> <Greek_alpha>", 0x1F04)

-CheckCompUni("<acute> <U0313> <Greek_alpha>", 0x1F04)

-CheckCompUni("<apostrophe> <U1f00>", 0x1F04)

-CheckCompUni("<acute> <U1f00>", 0x1F04)

-CheckCompUni("<apostrophe> <parenleft> <Greek_alpha>", 0x1F05)

-CheckCompUni("<apostrophe> <U0314> <Greek_alpha>", 0x1F05)

-CheckCompUni("<acute> <parenleft> <Greek_alpha>", 0x1F05)

-CheckCompUni("<acute> <U0314> <Greek_alpha>", 0x1F05)

-CheckCompUni("<apostrophe> <U1f01>", 0x1F05)

-CheckCompUni("<acute> <U1f01>", 0x1F05)

-CheckCompUni("<asciitilde> <parenright> <Greek_alpha>", 0x1F06)

-CheckCompUni("<asciitilde> <U0313> <Greek_alpha>", 0x1F06)

-CheckCompUni("<asciitilde> <U1f00>", 0x1F06)

-CheckCompUni("<asciitilde> <parenleft> <Greek_alpha>", 0x1F07)

-CheckCompUni("<asciitilde> <U0314> <Greek_alpha>", 0x1F07)

-CheckCompUni("<asciitilde> <U1f01>", 0x1F07)

-CheckCompUni("<parenright> <Greek_ALPHA>", 0x1F08)

-CheckCompUni("<parenleft> <Greek_ALPHA>", 0x1F09)

-CheckCompUni("<grave> <parenright> <Greek_ALPHA>", 0x1F0A)

-CheckCompUni("<grave> <U0313> <Greek_ALPHA>", 0x1F0A)

-CheckCompUni("<grave> <U1f08>", 0x1F0A)

-CheckCompUni("<grave> <parenleft> <Greek_ALPHA>", 0x1F0B)

-CheckCompUni("<grave> <U0314> <Greek_ALPHA>", 0x1F0B)

-CheckCompUni("<grave> <U1f09>", 0x1F0B)

-CheckCompUni("<apostrophe> <parenright> <Greek_ALPHA>", 0x1F0C)

-CheckCompUni("<apostrophe> <U0313> <Greek_ALPHA>", 0x1F0C)

-CheckCompUni("<acute> <parenright> <Greek_ALPHA>", 0x1F0C)

-CheckCompUni("<acute> <U0313> <Greek_ALPHA>", 0x1F0C)

-CheckCompUni("<apostrophe> <U1f08>", 0x1F0C)

-CheckCompUni("<acute> <U1f08>", 0x1F0C)

-CheckCompUni("<apostrophe> <parenleft> <Greek_ALPHA>", 0x1F0D)

-CheckCompUni("<apostrophe> <U0314> <Greek_ALPHA>", 0x1F0D)

-CheckCompUni("<acute> <parenleft> <Greek_ALPHA>", 0x1F0D)

-CheckCompUni("<acute> <U0314> <Greek_ALPHA>", 0x1F0D)

-CheckCompUni("<apostrophe> <U1f09>", 0x1F0D)

-CheckCompUni("<acute> <U1f09>", 0x1F0D)

-CheckCompUni("<asciitilde> <parenright> <Greek_ALPHA>", 0x1F0E)

-CheckCompUni("<asciitilde> <U0313> <Greek_ALPHA>", 0x1F0E)

-CheckCompUni("<asciitilde> <U1f08>", 0x1F0E)

-CheckCompUni("<asciitilde> <parenleft> <Greek_ALPHA>", 0x1F0F)

-CheckCompUni("<asciitilde> <U0314> <Greek_ALPHA>", 0x1F0F)

-CheckCompUni("<asciitilde> <U1f09>", 0x1F0F)

-CheckCompUni("<parenright> <Greek_epsilon>", 0x1F10)

-CheckCompUni("<parenleft> <Greek_epsilon>", 0x1F11)

-CheckCompUni("<grave> <parenright> <Greek_epsilon>", 0x1F12)

-CheckCompUni("<grave> <U0313> <Greek_epsilon>", 0x1F12)

-CheckCompUni("<grave> <U1f10>", 0x1F12)

-CheckCompUni("<grave> <parenleft> <Greek_epsilon>", 0x1F13)

-CheckCompUni("<grave> <U0314> <Greek_epsilon>", 0x1F13)

-CheckCompUni("<grave> <U1f11>", 0x1F13)

-CheckCompUni("<apostrophe> <parenright> <Greek_epsilon>", 0x1F14)

-CheckCompUni("<apostrophe> <U0313> <Greek_epsilon>", 0x1F14)

-CheckCompUni("<acute> <parenright> <Greek_epsilon>", 0x1F14)

-CheckCompUni("<acute> <U0313> <Greek_epsilon>", 0x1F14)

-CheckCompUni("<apostrophe> <U1f10>", 0x1F14)

-CheckCompUni("<acute> <U1f10>", 0x1F14)

-CheckCompUni("<apostrophe> <parenleft> <Greek_epsilon>", 0x1F15)

-CheckCompUni("<apostrophe> <U0314> <Greek_epsilon>", 0x1F15)

-CheckCompUni("<acute> <parenleft> <Greek_epsilon>", 0x1F15)

-CheckCompUni("<acute> <U0314> <Greek_epsilon>", 0x1F15)

-CheckCompUni("<apostrophe> <U1f11>", 0x1F15)

-CheckCompUni("<acute> <U1f11>", 0x1F15)

-CheckCompUni("<parenright> <Greek_EPSILON>", 0x1F18)

-CheckCompUni("<parenleft> <Greek_EPSILON>", 0x1F19)

-CheckCompUni("<grave> <parenright> <Greek_EPSILON>", 0x1F1A)

-CheckCompUni("<grave> <U0313> <Greek_EPSILON>", 0x1F1A)

-CheckCompUni("<grave> <U1f18>", 0x1F1A)

-CheckCompUni("<grave> <parenleft> <Greek_EPSILON>", 0x1F1B)

-CheckCompUni("<grave> <U0314> <Greek_EPSILON>", 0x1F1B)

-CheckCompUni("<grave> <U1f19>", 0x1F1B)

-CheckCompUni("<apostrophe> <parenright> <Greek_EPSILON>", 0x1F1C)

-CheckCompUni("<apostrophe> <U0313> <Greek_EPSILON>", 0x1F1C)

-CheckCompUni("<acute> <parenright> <Greek_EPSILON>", 0x1F1C)

-CheckCompUni("<acute> <U0313> <Greek_EPSILON>", 0x1F1C)

-CheckCompUni("<apostrophe> <U1f18>", 0x1F1C)

-CheckCompUni("<acute> <U1f18>", 0x1F1C)

-CheckCompUni("<apostrophe> <parenleft> <Greek_EPSILON>", 0x1F1D)

-CheckCompUni("<apostrophe> <U0314> <Greek_EPSILON>", 0x1F1D)

-CheckCompUni("<acute> <parenleft> <Greek_EPSILON>", 0x1F1D)

-CheckCompUni("<acute> <U0314> <Greek_EPSILON>", 0x1F1D)

-CheckCompUni("<apostrophe> <U1f19>", 0x1F1D)

-CheckCompUni("<acute> <U1f19>", 0x1F1D)

-CheckCompUni("<parenright> <Greek_eta>", 0x1F20)

-CheckCompUni("<parenleft> <Greek_eta>", 0x1F21)

-CheckCompUni("<grave> <parenright> <Greek_eta>", 0x1F22)

-CheckCompUni("<grave> <U0313> <Greek_eta>", 0x1F22)

-CheckCompUni("<grave> <U1f20>", 0x1F22)

-CheckCompUni("<grave> <parenleft> <Greek_eta>", 0x1F23)

-CheckCompUni("<grave> <U0314> <Greek_eta>", 0x1F23)

-CheckCompUni("<grave> <U1f21>", 0x1F23)

-CheckCompUni("<apostrophe> <parenright> <Greek_eta>", 0x1F24)

-CheckCompUni("<apostrophe> <U0313> <Greek_eta>", 0x1F24)

-CheckCompUni("<acute> <parenright> <Greek_eta>", 0x1F24)

-CheckCompUni("<acute> <U0313> <Greek_eta>", 0x1F24)

-CheckCompUni("<apostrophe> <U1f20>", 0x1F24)

-CheckCompUni("<acute> <U1f20>", 0x1F24)

-CheckCompUni("<apostrophe> <parenleft> <Greek_eta>", 0x1F25)

-CheckCompUni("<apostrophe> <U0314> <Greek_eta>", 0x1F25)

-CheckCompUni("<acute> <parenleft> <Greek_eta>", 0x1F25)

-CheckCompUni("<acute> <U0314> <Greek_eta>", 0x1F25)

-CheckCompUni("<apostrophe> <U1f21>", 0x1F25)

-CheckCompUni("<acute> <U1f21>", 0x1F25)

-CheckCompUni("<asciitilde> <parenright> <Greek_eta>", 0x1F26)

-CheckCompUni("<asciitilde> <U0313> <Greek_eta>", 0x1F26)

-CheckCompUni("<asciitilde> <U1f20>", 0x1F26)

-CheckCompUni("<asciitilde> <parenleft> <Greek_eta>", 0x1F27)

-CheckCompUni("<asciitilde> <U0314> <Greek_eta>", 0x1F27)

-CheckCompUni("<asciitilde> <U1f21>", 0x1F27)

-CheckCompUni("<parenright> <Greek_ETA>", 0x1F28)

-CheckCompUni("<parenleft> <Greek_ETA>", 0x1F29)

-CheckCompUni("<grave> <parenright> <Greek_ETA>", 0x1F2A)

-CheckCompUni("<grave> <U0313> <Greek_ETA>", 0x1F2A)

-CheckCompUni("<grave> <U1f28>", 0x1F2A)

-CheckCompUni("<grave> <parenleft> <Greek_ETA>", 0x1F2B)

-CheckCompUni("<grave> <U0314> <Greek_ETA>", 0x1F2B)

-CheckCompUni("<grave> <U1f29>", 0x1F2B)

-CheckCompUni("<apostrophe> <parenright> <Greek_ETA>", 0x1F2C)

-CheckCompUni("<apostrophe> <U0313> <Greek_ETA>", 0x1F2C)

-CheckCompUni("<acute> <parenright> <Greek_ETA>", 0x1F2C)

-CheckCompUni("<acute> <U0313> <Greek_ETA>", 0x1F2C)

-CheckCompUni("<apostrophe> <U1f28>", 0x1F2C)

-CheckCompUni("<acute> <U1f28>", 0x1F2C)

-CheckCompUni("<apostrophe> <parenleft> <Greek_ETA>", 0x1F2D)

-CheckCompUni("<apostrophe> <U0314> <Greek_ETA>", 0x1F2D)

-CheckCompUni("<acute> <parenleft> <Greek_ETA>", 0x1F2D)

-CheckCompUni("<acute> <U0314> <Greek_ETA>", 0x1F2D)

-CheckCompUni("<apostrophe> <U1f29>", 0x1F2D)

-CheckCompUni("<acute> <U1f29>", 0x1F2D)

-CheckCompUni("<asciitilde> <parenright> <Greek_ETA>", 0x1F2E)

-CheckCompUni("<asciitilde> <U0313> <Greek_ETA>", 0x1F2E)

-CheckCompUni("<asciitilde> <U1f28>", 0x1F2E)

-CheckCompUni("<asciitilde> <parenleft> <Greek_ETA>", 0x1F2F)

-CheckCompUni("<asciitilde> <U0314> <Greek_ETA>", 0x1F2F)

-CheckCompUni("<asciitilde> <U1f29>", 0x1F2F)

-CheckCompUni("<parenright> <Greek_iota>", 0x1F30)

-CheckCompUni("<parenleft> <Greek_iota>", 0x1F31)

-CheckCompUni("<grave> <parenright> <Greek_iota>", 0x1F32)

-CheckCompUni("<grave> <U0313> <Greek_iota>", 0x1F32)

-CheckCompUni("<grave> <U1f30>", 0x1F32)

-CheckCompUni("<grave> <parenleft> <Greek_iota>", 0x1F33)

-CheckCompUni("<grave> <U0314> <Greek_iota>", 0x1F33)

-CheckCompUni("<grave> <U1f31>", 0x1F33)

-CheckCompUni("<apostrophe> <parenright> <Greek_iota>", 0x1F34)

-CheckCompUni("<apostrophe> <U0313> <Greek_iota>", 0x1F34)

-CheckCompUni("<acute> <parenright> <Greek_iota>", 0x1F34)

-CheckCompUni("<acute> <U0313> <Greek_iota>", 0x1F34)

-CheckCompUni("<apostrophe> <U1f30>", 0x1F34)

-CheckCompUni("<acute> <U1f30>", 0x1F34)

-CheckCompUni("<apostrophe> <parenleft> <Greek_iota>", 0x1F35)

-CheckCompUni("<apostrophe> <U0314> <Greek_iota>", 0x1F35)

-CheckCompUni("<acute> <parenleft> <Greek_iota>", 0x1F35)

-CheckCompUni("<acute> <U0314> <Greek_iota>", 0x1F35)

-CheckCompUni("<apostrophe> <U1f31>", 0x1F35)

-CheckCompUni("<acute> <U1f31>", 0x1F35)

-CheckCompUni("<asciitilde> <parenright> <Greek_iota>", 0x1F36)

-CheckCompUni("<asciitilde> <U0313> <Greek_iota>", 0x1F36)

-CheckCompUni("<asciitilde> <U1f30>", 0x1F36)

-CheckCompUni("<asciitilde> <parenleft> <Greek_iota>", 0x1F37)

-CheckCompUni("<asciitilde> <U0314> <Greek_iota>", 0x1F37)

-CheckCompUni("<asciitilde> <U1f31>", 0x1F37)

-CheckCompUni("<parenright> <Greek_IOTA>", 0x1F38)

-CheckCompUni("<parenleft> <Greek_IOTA>", 0x1F39)

-CheckCompUni("<grave> <parenright> <Greek_IOTA>", 0x1F3A)

-CheckCompUni("<grave> <U0313> <Greek_IOTA>", 0x1F3A)

-CheckCompUni("<grave> <U1f38>", 0x1F3A)

-CheckCompUni("<grave> <parenleft> <Greek_IOTA>", 0x1F3B)

-CheckCompUni("<grave> <U0314> <Greek_IOTA>", 0x1F3B)

-CheckCompUni("<grave> <U1f39>", 0x1F3B)

-CheckCompUni("<apostrophe> <parenright> <Greek_IOTA>", 0x1F3C)

-CheckCompUni("<apostrophe> <U0313> <Greek_IOTA>", 0x1F3C)

-CheckCompUni("<acute> <parenright> <Greek_IOTA>", 0x1F3C)

-CheckCompUni("<acute> <U0313> <Greek_IOTA>", 0x1F3C)

-CheckCompUni("<apostrophe> <U1f38>", 0x1F3C)

-CheckCompUni("<acute> <U1f38>", 0x1F3C)

-CheckCompUni("<apostrophe> <parenleft> <Greek_IOTA>", 0x1F3D)

-CheckCompUni("<apostrophe> <U0314> <Greek_IOTA>", 0x1F3D)

-CheckCompUni("<acute> <parenleft> <Greek_IOTA>", 0x1F3D)

-CheckCompUni("<acute> <U0314> <Greek_IOTA>", 0x1F3D)

-CheckCompUni("<apostrophe> <U1f39>", 0x1F3D)

-CheckCompUni("<acute> <U1f39>", 0x1F3D)

-CheckCompUni("<asciitilde> <parenright> <Greek_IOTA>", 0x1F3E)

-CheckCompUni("<asciitilde> <U0313> <Greek_IOTA>", 0x1F3E)

-CheckCompUni("<asciitilde> <U1f38>", 0x1F3E)

-CheckCompUni("<asciitilde> <parenleft> <Greek_IOTA>", 0x1F3F)

-CheckCompUni("<asciitilde> <U0314> <Greek_IOTA>", 0x1F3F)

-CheckCompUni("<asciitilde> <U1f39>", 0x1F3F)

-CheckCompUni("<parenright> <Greek_omicron>", 0x1F40)

-CheckCompUni("<parenleft> <Greek_omicron>", 0x1F41)

-CheckCompUni("<grave> <parenright> <Greek_omicron>", 0x1F42)

-CheckCompUni("<grave> <U0313> <Greek_omicron>", 0x1F42)

-CheckCompUni("<grave> <U1f40>", 0x1F42)

-CheckCompUni("<grave> <parenleft> <Greek_omicron>", 0x1F43)

-CheckCompUni("<grave> <U0314> <Greek_omicron>", 0x1F43)

-CheckCompUni("<grave> <U1f41>", 0x1F43)

-CheckCompUni("<apostrophe> <parenright> <Greek_omicron>", 0x1F44)

-CheckCompUni("<apostrophe> <U0313> <Greek_omicron>", 0x1F44)

-CheckCompUni("<acute> <parenright> <Greek_omicron>", 0x1F44)

-CheckCompUni("<acute> <U0313> <Greek_omicron>", 0x1F44)

-CheckCompUni("<apostrophe> <U1f40>", 0x1F44)

-CheckCompUni("<acute> <U1f40>", 0x1F44)

-CheckCompUni("<apostrophe> <parenleft> <Greek_omicron>", 0x1F45)

-CheckCompUni("<apostrophe> <U0314> <Greek_omicron>", 0x1F45)

-CheckCompUni("<acute> <parenleft> <Greek_omicron>", 0x1F45)

-CheckCompUni("<acute> <U0314> <Greek_omicron>", 0x1F45)

-CheckCompUni("<apostrophe> <U1f41>", 0x1F45)

-CheckCompUni("<acute> <U1f41>", 0x1F45)

-CheckCompUni("<parenright> <Greek_OMICRON>", 0x1F48)

-CheckCompUni("<parenleft> <Greek_OMICRON>", 0x1F49)

-CheckCompUni("<grave> <parenright> <Greek_OMICRON>", 0x1F4A)

-CheckCompUni("<grave> <U0313> <Greek_OMICRON>", 0x1F4A)

-CheckCompUni("<grave> <U1f48>", 0x1F4A)

-CheckCompUni("<grave> <parenleft> <Greek_OMICRON>", 0x1F4B)

-CheckCompUni("<grave> <U0314> <Greek_OMICRON>", 0x1F4B)

-CheckCompUni("<grave> <U1f49>", 0x1F4B)

-CheckCompUni("<apostrophe> <parenright> <Greek_OMICRON>", 0x1F4C)

-CheckCompUni("<apostrophe> <U0313> <Greek_OMICRON>", 0x1F4C)

-CheckCompUni("<acute> <parenright> <Greek_OMICRON>", 0x1F4C)

-CheckCompUni("<acute> <U0313> <Greek_OMICRON>", 0x1F4C)

-CheckCompUni("<apostrophe> <U1f48>", 0x1F4C)

-CheckCompUni("<acute> <U1f48>", 0x1F4C)

-CheckCompUni("<apostrophe> <parenleft> <Greek_OMICRON>", 0x1F4D)

-CheckCompUni("<apostrophe> <U0314> <Greek_OMICRON>", 0x1F4D)

-CheckCompUni("<acute> <parenleft> <Greek_OMICRON>", 0x1F4D)

-CheckCompUni("<acute> <U0314> <Greek_OMICRON>", 0x1F4D)

-CheckCompUni("<apostrophe> <U1f49>", 0x1F4D)

-CheckCompUni("<acute> <U1f49>", 0x1F4D)

-CheckCompUni("<parenright> <Greek_upsilon>", 0x1F50)

-CheckCompUni("<parenleft> <Greek_upsilon>", 0x1F51)

-CheckCompUni("<grave> <parenright> <Greek_upsilon>", 0x1F52)

-CheckCompUni("<grave> <U0313> <Greek_upsilon>", 0x1F52)

-CheckCompUni("<grave> <U1f50>", 0x1F52)

-CheckCompUni("<grave> <parenleft> <Greek_upsilon>", 0x1F53)

-CheckCompUni("<grave> <U0314> <Greek_upsilon>", 0x1F53)

-CheckCompUni("<grave> <U1f51>", 0x1F53)

-CheckCompUni("<apostrophe> <parenright> <Greek_upsilon>", 0x1F54)

-CheckCompUni("<apostrophe> <U0313> <Greek_upsilon>", 0x1F54)

-CheckCompUni("<acute> <parenright> <Greek_upsilon>", 0x1F54)

-CheckCompUni("<acute> <U0313> <Greek_upsilon>", 0x1F54)

-CheckCompUni("<apostrophe> <U1f50>", 0x1F54)

-CheckCompUni("<acute> <U1f50>", 0x1F54)

-CheckCompUni("<apostrophe> <parenleft> <Greek_upsilon>", 0x1F55)

-CheckCompUni("<apostrophe> <U0314> <Greek_upsilon>", 0x1F55)

-CheckCompUni("<acute> <parenleft> <Greek_upsilon>", 0x1F55)

-CheckCompUni("<acute> <U0314> <Greek_upsilon>", 0x1F55)

-CheckCompUni("<apostrophe> <U1f51>", 0x1F55)

-CheckCompUni("<acute> <U1f51>", 0x1F55)

-CheckCompUni("<asciitilde> <parenright> <Greek_upsilon>", 0x1F56)

-CheckCompUni("<asciitilde> <U0313> <Greek_upsilon>", 0x1F56)

-CheckCompUni("<asciitilde> <U1f50>", 0x1F56)

-CheckCompUni("<asciitilde> <parenleft> <Greek_upsilon>", 0x1F57)

-CheckCompUni("<asciitilde> <U0314> <Greek_upsilon>", 0x1F57)

-CheckCompUni("<asciitilde> <U1f51>", 0x1F57)

-CheckCompUni("<parenleft> <Greek_UPSILON>", 0x1F59)

-CheckCompUni("<grave> <parenleft> <Greek_UPSILON>", 0x1F5B)

-CheckCompUni("<grave> <U0314> <Greek_UPSILON>", 0x1F5B)

-CheckCompUni("<grave> <U1f59>", 0x1F5B)

-CheckCompUni("<apostrophe> <parenleft> <Greek_UPSILON>", 0x1F5D)

-CheckCompUni("<apostrophe> <U0314> <Greek_UPSILON>", 0x1F5D)

-CheckCompUni("<acute> <parenleft> <Greek_UPSILON>", 0x1F5D)

-CheckCompUni("<acute> <U0314> <Greek_UPSILON>", 0x1F5D)

-CheckCompUni("<apostrophe> <U1f59>", 0x1F5D)

-CheckCompUni("<acute> <U1f59>", 0x1F5D)

-CheckCompUni("<asciitilde> <parenleft> <Greek_UPSILON>", 0x1F5F)

-CheckCompUni("<asciitilde> <U0314> <Greek_UPSILON>", 0x1F5F)

-CheckCompUni("<asciitilde> <U1f59>", 0x1F5F)

-CheckCompUni("<parenright> <Greek_omega>", 0x1F60)

-CheckCompUni("<parenleft> <Greek_omega>", 0x1F61)

-CheckCompUni("<grave> <parenright> <Greek_omega>", 0x1F62)

-CheckCompUni("<grave> <U0313> <Greek_omega>", 0x1F62)

-CheckCompUni("<grave> <U1f60>", 0x1F62)

-CheckCompUni("<grave> <parenleft> <Greek_omega>", 0x1F63)

-CheckCompUni("<grave> <U0314> <Greek_omega>", 0x1F63)

-CheckCompUni("<grave> <U1f61>", 0x1F63)

-CheckCompUni("<apostrophe> <parenright> <Greek_omega>", 0x1F64)

-CheckCompUni("<apostrophe> <U0313> <Greek_omega>", 0x1F64)

-CheckCompUni("<acute> <parenright> <Greek_omega>", 0x1F64)

-CheckCompUni("<acute> <U0313> <Greek_omega>", 0x1F64)

-CheckCompUni("<apostrophe> <U1f60>", 0x1F64)

-CheckCompUni("<acute> <U1f60>", 0x1F64)

-CheckCompUni("<apostrophe> <parenleft> <Greek_omega>", 0x1F65)

-CheckCompUni("<apostrophe> <U0314> <Greek_omega>", 0x1F65)

-CheckCompUni("<acute> <parenleft> <Greek_omega>", 0x1F65)

-CheckCompUni("<acute> <U0314> <Greek_omega>", 0x1F65)

-CheckCompUni("<apostrophe> <U1f61>", 0x1F65)

-CheckCompUni("<acute> <U1f61>", 0x1F65)

-CheckCompUni("<asciitilde> <parenright> <Greek_omega>", 0x1F66)

-CheckCompUni("<asciitilde> <U0313> <Greek_omega>", 0x1F66)

-CheckCompUni("<asciitilde> <U1f60>", 0x1F66)

-CheckCompUni("<asciitilde> <parenleft> <Greek_omega>", 0x1F67)

-CheckCompUni("<asciitilde> <U0314> <Greek_omega>", 0x1F67)

-CheckCompUni("<asciitilde> <U1f61>", 0x1F67)

-CheckCompUni("<parenright> <Greek_OMEGA>", 0x1F68)

-CheckCompUni("<parenleft> <Greek_OMEGA>", 0x1F69)

-CheckCompUni("<grave> <parenright> <Greek_OMEGA>", 0x1F6A)

-CheckCompUni("<grave> <U0313> <Greek_OMEGA>", 0x1F6A)

-CheckCompUni("<grave> <U1f68>", 0x1F6A)

-CheckCompUni("<grave> <parenleft> <Greek_OMEGA>", 0x1F6B)

-CheckCompUni("<grave> <U0314> <Greek_OMEGA>", 0x1F6B)

-CheckCompUni("<grave> <U1f69>", 0x1F6B)

-CheckCompUni("<apostrophe> <parenright> <Greek_OMEGA>", 0x1F6C)

-CheckCompUni("<apostrophe> <U0313> <Greek_OMEGA>", 0x1F6C)

-CheckCompUni("<acute> <parenright> <Greek_OMEGA>", 0x1F6C)

-CheckCompUni("<acute> <U0313> <Greek_OMEGA>", 0x1F6C)

-CheckCompUni("<apostrophe> <U1f68>", 0x1F6C)

-CheckCompUni("<acute> <U1f68>", 0x1F6C)

-CheckCompUni("<apostrophe> <parenleft> <Greek_OMEGA>", 0x1F6D)

-CheckCompUni("<apostrophe> <U0314> <Greek_OMEGA>", 0x1F6D)

-CheckCompUni("<acute> <parenleft> <Greek_OMEGA>", 0x1F6D)

-CheckCompUni("<acute> <U0314> <Greek_OMEGA>", 0x1F6D)

-CheckCompUni("<apostrophe> <U1f69>", 0x1F6D)

-CheckCompUni("<acute> <U1f69>", 0x1F6D)

-CheckCompUni("<asciitilde> <parenright> <Greek_OMEGA>", 0x1F6E)

-CheckCompUni("<asciitilde> <U0313> <Greek_OMEGA>", 0x1F6E)

-CheckCompUni("<asciitilde> <U1f68>", 0x1F6E)

-CheckCompUni("<asciitilde> <parenleft> <Greek_OMEGA>", 0x1F6F)

-CheckCompUni("<asciitilde> <U0314> <Greek_OMEGA>", 0x1F6F)

-CheckCompUni("<asciitilde> <U1f69>", 0x1F6F)

-CheckCompUni("<grave> <Greek_alpha>", 0x1F70)

-CheckCompUni("<grave> <Greek_epsilon>", 0x1F72)

-CheckCompUni("<grave> <Greek_eta>", 0x1F74)

-CheckCompUni("<grave> <Greek_iota>", 0x1F76)

-CheckCompUni("<grave> <Greek_omicron>", 0x1F78)

-CheckCompUni("<grave> <Greek_upsilon>", 0x1F7A)

-CheckCompUni("<grave> <Greek_omega>", 0x1F7C)

-CheckCompUni("<Greek_iota> <parenright> <Greek_alpha>", 0x1F80)

-CheckCompUni("<Greek_iota> <U0313> <Greek_alpha>", 0x1F80)

-CheckCompUni("<Greek_iota> <U1f00>", 0x1F80)

-CheckCompUni("<Greek_iota> <parenleft> <Greek_alpha>", 0x1F81)

-CheckCompUni("<Greek_iota> <U0314> <Greek_alpha>", 0x1F81)

-CheckCompUni("<Greek_iota> <U1f01>", 0x1F81)

-CheckCompUni("<Greek_iota> <combining_grave> <parenright> <Greek_alpha>", 0x1F82)

-CheckCompUni("<Greek_iota> <combining_grave> <U0313> <Greek_alpha>", 0x1F82)

-CheckCompUni("<Greek_iota> <combining_grave> <U1f00>", 0x1F82)

-CheckCompUni("<Greek_iota> <grave> <parenright> <Greek_alpha>", 0x1F82)

-CheckCompUni("<Greek_iota> <grave> <U0313> <Greek_alpha>", 0x1F82)

-CheckCompUni("<Greek_iota> <dead_grave> <parenright> <Greek_alpha>", 0x1F82)

-CheckCompUni("<Greek_iota> <dead_grave> <U0313> <Greek_alpha>", 0x1F82)

-CheckCompUni("<Greek_iota> <grave> <U1f00>", 0x1F82)

-CheckCompUni("<Greek_iota> <dead_grave> <U1f00>", 0x1F82)

-CheckCompUni("<Greek_iota> <U1f02>", 0x1F82)

-CheckCompUni("<Greek_iota> <combining_grave> <parenleft> <Greek_alpha>", 0x1F83)

-CheckCompUni("<Greek_iota> <combining_grave> <U0314> <Greek_alpha>", 0x1F83)

-CheckCompUni("<Greek_iota> <combining_grave> <U1f01>", 0x1F83)

-CheckCompUni("<Greek_iota> <grave> <parenleft> <Greek_alpha>", 0x1F83)

-CheckCompUni("<Greek_iota> <grave> <U0314> <Greek_alpha>", 0x1F83)

-CheckCompUni("<Greek_iota> <dead_grave> <parenleft> <Greek_alpha>", 0x1F83)

-CheckCompUni("<Greek_iota> <dead_grave> <U0314> <Greek_alpha>", 0x1F83)

-CheckCompUni("<Greek_iota> <grave> <U1f01>", 0x1F83)

-CheckCompUni("<Greek_iota> <dead_grave> <U1f01>", 0x1F83)

-CheckCompUni("<Greek_iota> <U1f03>", 0x1F83)

-CheckCompUni("<Greek_iota> <combining_acute> <parenright> <Greek_alpha>", 0x1F84)

-CheckCompUni("<Greek_iota> <combining_acute> <U0313> <Greek_alpha>", 0x1F84)

-CheckCompUni("<Greek_iota> <combining_acute> <U1f00>", 0x1F84)

-CheckCompUni("<Greek_iota> <apostrophe> <parenright> <Greek_alpha>", 0x1F84)

-CheckCompUni("<Greek_iota> <apostrophe> <U0313> <Greek_alpha>", 0x1F84)

-CheckCompUni("<Greek_iota> <acute> <parenright> <Greek_alpha>", 0x1F84)

-CheckCompUni("<Greek_iota> <acute> <U0313> <Greek_alpha>", 0x1F84)

-CheckCompUni("<Greek_iota> <dead_acute> <parenright> <Greek_alpha>", 0x1F84)

-CheckCompUni("<Greek_iota> <dead_acute> <U0313> <Greek_alpha>", 0x1F84)

-CheckCompUni("<Greek_iota> <apostrophe> <U1f00>", 0x1F84)

-CheckCompUni("<Greek_iota> <acute> <U1f00>", 0x1F84)

-CheckCompUni("<Greek_iota> <dead_acute> <U1f00>", 0x1F84)

-CheckCompUni("<Greek_iota> <U1f04>", 0x1F84)

-CheckCompUni("<Greek_iota> <combining_acute> <parenleft> <Greek_alpha>", 0x1F85)

-CheckCompUni("<Greek_iota> <combining_acute> <U0314> <Greek_alpha>", 0x1F85)

-CheckCompUni("<Greek_iota> <combining_acute> <U1f01>", 0x1F85)

-CheckCompUni("<Greek_iota> <apostrophe> <parenleft> <Greek_alpha>", 0x1F85)

-CheckCompUni("<Greek_iota> <apostrophe> <U0314> <Greek_alpha>", 0x1F85)

-CheckCompUni("<Greek_iota> <acute> <parenleft> <Greek_alpha>", 0x1F85)

-CheckCompUni("<Greek_iota> <acute> <U0314> <Greek_alpha>", 0x1F85)

-CheckCompUni("<Greek_iota> <dead_acute> <parenleft> <Greek_alpha>", 0x1F85)

-CheckCompUni("<Greek_iota> <dead_acute> <U0314> <Greek_alpha>", 0x1F85)

-CheckCompUni("<Greek_iota> <apostrophe> <U1f01>", 0x1F85)

-CheckCompUni("<Greek_iota> <acute> <U1f01>", 0x1F85)

-CheckCompUni("<Greek_iota> <dead_acute> <U1f01>", 0x1F85)

-CheckCompUni("<Greek_iota> <U1f05>", 0x1F85)

-CheckCompUni("<Greek_iota> <asciitilde> <parenright> <Greek_alpha>", 0x1F86)

-CheckCompUni("<Greek_iota> <asciitilde> <U0313> <Greek_alpha>", 0x1F86)

-CheckCompUni("<Greek_iota> <dead_tilde> <parenright> <Greek_alpha>", 0x1F86)

-CheckCompUni("<Greek_iota> <dead_tilde> <U0313> <Greek_alpha>", 0x1F86)

-CheckCompUni("<Greek_iota> <U0342> <parenright> <Greek_alpha>", 0x1F86)

-CheckCompUni("<Greek_iota> <U0342> <U0313> <Greek_alpha>", 0x1F86)

-CheckCompUni("<Greek_iota> <asciitilde> <U1f00>", 0x1F86)

-CheckCompUni("<Greek_iota> <dead_tilde> <U1f00>", 0x1F86)

-CheckCompUni("<Greek_iota> <U0342> <U1f00>", 0x1F86)

-CheckCompUni("<Greek_iota> <U1f06>", 0x1F86)

-CheckCompUni("<Greek_iota> <asciitilde> <parenleft> <Greek_alpha>", 0x1F87)

-CheckCompUni("<Greek_iota> <asciitilde> <U0314> <Greek_alpha>", 0x1F87)

-CheckCompUni("<Greek_iota> <dead_tilde> <parenleft> <Greek_alpha>", 0x1F87)

-CheckCompUni("<Greek_iota> <dead_tilde> <U0314> <Greek_alpha>", 0x1F87)

-CheckCompUni("<Greek_iota> <U0342> <parenleft> <Greek_alpha>", 0x1F87)

-CheckCompUni("<Greek_iota> <U0342> <U0314> <Greek_alpha>", 0x1F87)

-CheckCompUni("<Greek_iota> <asciitilde> <U1f01>", 0x1F87)

-CheckCompUni("<Greek_iota> <dead_tilde> <U1f01>", 0x1F87)

-CheckCompUni("<Greek_iota> <U0342> <U1f01>", 0x1F87)

-CheckCompUni("<Greek_iota> <U1f07>", 0x1F87)

-CheckCompUni("<Greek_iota> <parenright> <Greek_ALPHA>", 0x1F88)

-CheckCompUni("<Greek_iota> <U0313> <Greek_ALPHA>", 0x1F88)

-CheckCompUni("<Greek_iota> <U1f08>", 0x1F88)

-CheckCompUni("<Greek_iota> <parenleft> <Greek_ALPHA>", 0x1F89)

-CheckCompUni("<Greek_iota> <U0314> <Greek_ALPHA>", 0x1F89)

-CheckCompUni("<Greek_iota> <U1f09>", 0x1F89)

-CheckCompUni("<Greek_iota> <combining_grave> <parenright> <Greek_ALPHA>", 0x1F8A)

-CheckCompUni("<Greek_iota> <combining_grave> <U0313> <Greek_ALPHA>", 0x1F8A)

-CheckCompUni("<Greek_iota> <combining_grave> <U1f08>", 0x1F8A)

-CheckCompUni("<Greek_iota> <grave> <parenright> <Greek_ALPHA>", 0x1F8A)

-CheckCompUni("<Greek_iota> <grave> <U0313> <Greek_ALPHA>", 0x1F8A)

-CheckCompUni("<Greek_iota> <dead_grave> <parenright> <Greek_ALPHA>", 0x1F8A)

-CheckCompUni("<Greek_iota> <dead_grave> <U0313> <Greek_ALPHA>", 0x1F8A)

-CheckCompUni("<Greek_iota> <grave> <U1f08>", 0x1F8A)

-CheckCompUni("<Greek_iota> <dead_grave> <U1f08>", 0x1F8A)

-CheckCompUni("<Greek_iota> <U1f0a>", 0x1F8A)

-CheckCompUni("<Greek_iota> <combining_grave> <parenleft> <Greek_ALPHA>", 0x1F8B)

-CheckCompUni("<Greek_iota> <combining_grave> <U0314> <Greek_ALPHA>", 0x1F8B)

-CheckCompUni("<Greek_iota> <combining_grave> <U1f09>", 0x1F8B)

-CheckCompUni("<Greek_iota> <grave> <parenleft> <Greek_ALPHA>", 0x1F8B)

-CheckCompUni("<Greek_iota> <grave> <U0314> <Greek_ALPHA>", 0x1F8B)

-CheckCompUni("<Greek_iota> <dead_grave> <parenleft> <Greek_ALPHA>", 0x1F8B)

-CheckCompUni("<Greek_iota> <dead_grave> <U0314> <Greek_ALPHA>", 0x1F8B)

-CheckCompUni("<Greek_iota> <grave> <U1f09>", 0x1F8B)

-CheckCompUni("<Greek_iota> <dead_grave> <U1f09>", 0x1F8B)

-CheckCompUni("<Greek_iota> <U1f0b>", 0x1F8B)

-CheckCompUni("<Greek_iota> <combining_acute> <parenright> <Greek_ALPHA>", 0x1F8C)

-CheckCompUni("<Greek_iota> <combining_acute> <U0313> <Greek_ALPHA>", 0x1F8C)

-CheckCompUni("<Greek_iota> <combining_acute> <U1f08>", 0x1F8C)

-CheckCompUni("<Greek_iota> <apostrophe> <parenright> <Greek_ALPHA>", 0x1F8C)

-CheckCompUni("<Greek_iota> <apostrophe> <U0313> <Greek_ALPHA>", 0x1F8C)

-CheckCompUni("<Greek_iota> <acute> <parenright> <Greek_ALPHA>", 0x1F8C)

-CheckCompUni("<Greek_iota> <acute> <U0313> <Greek_ALPHA>", 0x1F8C)

-CheckCompUni("<Greek_iota> <dead_acute> <parenright> <Greek_ALPHA>", 0x1F8C)

-CheckCompUni("<Greek_iota> <dead_acute> <U0313> <Greek_ALPHA>", 0x1F8C)

-CheckCompUni("<Greek_iota> <apostrophe> <U1f08>", 0x1F8C)

-CheckCompUni("<Greek_iota> <acute> <U1f08>", 0x1F8C)

-CheckCompUni("<Greek_iota> <dead_acute> <U1f08>", 0x1F8C)

-CheckCompUni("<Greek_iota> <U1f0c>", 0x1F8C)

-CheckCompUni("<Greek_iota> <combining_acute> <parenleft> <Greek_ALPHA>", 0x1F8D)

-CheckCompUni("<Greek_iota> <combining_acute> <U0314> <Greek_ALPHA>", 0x1F8D)

-CheckCompUni("<Greek_iota> <combining_acute> <U1f09>", 0x1F8D)

-CheckCompUni("<Greek_iota> <apostrophe> <parenleft> <Greek_ALPHA>", 0x1F8D)

-CheckCompUni("<Greek_iota> <apostrophe> <U0314> <Greek_ALPHA>", 0x1F8D)

-CheckCompUni("<Greek_iota> <acute> <parenleft> <Greek_ALPHA>", 0x1F8D)

-CheckCompUni("<Greek_iota> <acute> <U0314> <Greek_ALPHA>", 0x1F8D)

-CheckCompUni("<Greek_iota> <dead_acute> <parenleft> <Greek_ALPHA>", 0x1F8D)

-CheckCompUni("<Greek_iota> <dead_acute> <U0314> <Greek_ALPHA>", 0x1F8D)

-CheckCompUni("<Greek_iota> <apostrophe> <U1f09>", 0x1F8D)

-CheckCompUni("<Greek_iota> <acute> <U1f09>", 0x1F8D)

-CheckCompUni("<Greek_iota> <dead_acute> <U1f09>", 0x1F8D)

-CheckCompUni("<Greek_iota> <U1f0d>", 0x1F8D)

-CheckCompUni("<Greek_iota> <asciitilde> <parenright> <Greek_ALPHA>", 0x1F8E)

-CheckCompUni("<Greek_iota> <asciitilde> <U0313> <Greek_ALPHA>", 0x1F8E)

-CheckCompUni("<Greek_iota> <dead_tilde> <parenright> <Greek_ALPHA>", 0x1F8E)

-CheckCompUni("<Greek_iota> <dead_tilde> <U0313> <Greek_ALPHA>", 0x1F8E)

-CheckCompUni("<Greek_iota> <U0342> <parenright> <Greek_ALPHA>", 0x1F8E)

-CheckCompUni("<Greek_iota> <U0342> <U0313> <Greek_ALPHA>", 0x1F8E)

-CheckCompUni("<Greek_iota> <asciitilde> <U1f08>", 0x1F8E)

-CheckCompUni("<Greek_iota> <dead_tilde> <U1f08>", 0x1F8E)

-CheckCompUni("<Greek_iota> <U0342> <U1f08>", 0x1F8E)

-CheckCompUni("<Greek_iota> <U1f0e>", 0x1F8E)

-CheckCompUni("<Greek_iota> <asciitilde> <parenleft> <Greek_ALPHA>", 0x1F8F)

-CheckCompUni("<Greek_iota> <asciitilde> <U0314> <Greek_ALPHA>", 0x1F8F)

-CheckCompUni("<Greek_iota> <dead_tilde> <parenleft> <Greek_ALPHA>", 0x1F8F)

-CheckCompUni("<Greek_iota> <dead_tilde> <U0314> <Greek_ALPHA>", 0x1F8F)

-CheckCompUni("<Greek_iota> <U0342> <parenleft> <Greek_ALPHA>", 0x1F8F)

-CheckCompUni("<Greek_iota> <U0342> <U0314> <Greek_ALPHA>", 0x1F8F)

-CheckCompUni("<Greek_iota> <asciitilde> <U1f09>", 0x1F8F)

-CheckCompUni("<Greek_iota> <dead_tilde> <U1f09>", 0x1F8F)

-CheckCompUni("<Greek_iota> <U0342> <U1f09>", 0x1F8F)

-CheckCompUni("<Greek_iota> <U1f0f>", 0x1F8F)

-CheckCompUni("<Greek_iota> <parenright> <Greek_eta>", 0x1F90)

-CheckCompUni("<Greek_iota> <U0313> <Greek_eta>", 0x1F90)

-CheckCompUni("<Greek_iota> <U1f20>", 0x1F90)

-CheckCompUni("<Greek_iota> <parenleft> <Greek_eta>", 0x1F91)

-CheckCompUni("<Greek_iota> <U0314> <Greek_eta>", 0x1F91)

-CheckCompUni("<Greek_iota> <U1f21>", 0x1F91)

-CheckCompUni("<Greek_iota> <combining_grave> <parenright> <Greek_eta>", 0x1F92)

-CheckCompUni("<Greek_iota> <combining_grave> <U0313> <Greek_eta>", 0x1F92)

-CheckCompUni("<Greek_iota> <combining_grave> <U1f20>", 0x1F92)

-CheckCompUni("<Greek_iota> <grave> <parenright> <Greek_eta>", 0x1F92)

-CheckCompUni("<Greek_iota> <grave> <U0313> <Greek_eta>", 0x1F92)

-CheckCompUni("<Greek_iota> <dead_grave> <parenright> <Greek_eta>", 0x1F92)

-CheckCompUni("<Greek_iota> <dead_grave> <U0313> <Greek_eta>", 0x1F92)

-CheckCompUni("<Greek_iota> <grave> <U1f20>", 0x1F92)

-CheckCompUni("<Greek_iota> <dead_grave> <U1f20>", 0x1F92)

-CheckCompUni("<Greek_iota> <U1f22>", 0x1F92)

-CheckCompUni("<Greek_iota> <combining_grave> <parenleft> <Greek_eta>", 0x1F93)

-CheckCompUni("<Greek_iota> <combining_grave> <U0314> <Greek_eta>", 0x1F93)

-CheckCompUni("<Greek_iota> <combining_grave> <U1f21>", 0x1F93)

-CheckCompUni("<Greek_iota> <grave> <parenleft> <Greek_eta>", 0x1F93)

-CheckCompUni("<Greek_iota> <grave> <U0314> <Greek_eta>", 0x1F93)

-CheckCompUni("<Greek_iota> <dead_grave> <parenleft> <Greek_eta>", 0x1F93)

-CheckCompUni("<Greek_iota> <dead_grave> <U0314> <Greek_eta>", 0x1F93)

-CheckCompUni("<Greek_iota> <grave> <U1f21>", 0x1F93)

-CheckCompUni("<Greek_iota> <dead_grave> <U1f21>", 0x1F93)

-CheckCompUni("<Greek_iota> <U1f23>", 0x1F93)

-CheckCompUni("<Greek_iota> <combining_acute> <parenright> <Greek_eta>", 0x1F94)

-CheckCompUni("<Greek_iota> <combining_acute> <U0313> <Greek_eta>", 0x1F94)

-CheckCompUni("<Greek_iota> <combining_acute> <U1f20>", 0x1F94)

-CheckCompUni("<Greek_iota> <apostrophe> <parenright> <Greek_eta>", 0x1F94)

-CheckCompUni("<Greek_iota> <apostrophe> <U0313> <Greek_eta>", 0x1F94)

-CheckCompUni("<Greek_iota> <acute> <parenright> <Greek_eta>", 0x1F94)

-CheckCompUni("<Greek_iota> <acute> <U0313> <Greek_eta>", 0x1F94)

-CheckCompUni("<Greek_iota> <dead_acute> <parenright> <Greek_eta>", 0x1F94)

-CheckCompUni("<Greek_iota> <dead_acute> <U0313> <Greek_eta>", 0x1F94)

-CheckCompUni("<Greek_iota> <apostrophe> <U1f20>", 0x1F94)

-CheckCompUni("<Greek_iota> <acute> <U1f20>", 0x1F94)

-CheckCompUni("<Greek_iota> <dead_acute> <U1f20>", 0x1F94)

-CheckCompUni("<Greek_iota> <U1f24>", 0x1F94)

-CheckCompUni("<Greek_iota> <combining_acute> <parenleft> <Greek_eta>", 0x1F95)

-CheckCompUni("<Greek_iota> <combining_acute> <U0314> <Greek_eta>", 0x1F95)

-CheckCompUni("<Greek_iota> <combining_acute> <U1f21>", 0x1F95)

-CheckCompUni("<Greek_iota> <apostrophe> <parenleft> <Greek_eta>", 0x1F95)

-CheckCompUni("<Greek_iota> <apostrophe> <U0314> <Greek_eta>", 0x1F95)

-CheckCompUni("<Greek_iota> <acute> <parenleft> <Greek_eta>", 0x1F95)

-CheckCompUni("<Greek_iota> <acute> <U0314> <Greek_eta>", 0x1F95)

-CheckCompUni("<Greek_iota> <dead_acute> <parenleft> <Greek_eta>", 0x1F95)

-CheckCompUni("<Greek_iota> <dead_acute> <U0314> <Greek_eta>", 0x1F95)

-CheckCompUni("<Greek_iota> <apostrophe> <U1f21>", 0x1F95)

-CheckCompUni("<Greek_iota> <acute> <U1f21>", 0x1F95)

-CheckCompUni("<Greek_iota> <dead_acute> <U1f21>", 0x1F95)

-CheckCompUni("<Greek_iota> <U1f25>", 0x1F95)

-CheckCompUni("<Greek_iota> <asciitilde> <parenright> <Greek_eta>", 0x1F96)

-CheckCompUni("<Greek_iota> <asciitilde> <U0313> <Greek_eta>", 0x1F96)

-CheckCompUni("<Greek_iota> <dead_tilde> <parenright> <Greek_eta>", 0x1F96)

-CheckCompUni("<Greek_iota> <dead_tilde> <U0313> <Greek_eta>", 0x1F96)

-CheckCompUni("<Greek_iota> <U0342> <parenright> <Greek_eta>", 0x1F96)

-CheckCompUni("<Greek_iota> <U0342> <U0313> <Greek_eta>", 0x1F96)

-CheckCompUni("<Greek_iota> <asciitilde> <U1f20>", 0x1F96)

-CheckCompUni("<Greek_iota> <dead_tilde> <U1f20>", 0x1F96)

-CheckCompUni("<Greek_iota> <U0342> <U1f20>", 0x1F96)

-CheckCompUni("<Greek_iota> <U1f26>", 0x1F96)

-CheckCompUni("<Greek_iota> <asciitilde> <parenleft> <Greek_eta>", 0x1F97)

-CheckCompUni("<Greek_iota> <asciitilde> <U0314> <Greek_eta>", 0x1F97)

-CheckCompUni("<Greek_iota> <dead_tilde> <parenleft> <Greek_eta>", 0x1F97)

-CheckCompUni("<Greek_iota> <dead_tilde> <U0314> <Greek_eta>", 0x1F97)

-CheckCompUni("<Greek_iota> <U0342> <parenleft> <Greek_eta>", 0x1F97)

-CheckCompUni("<Greek_iota> <U0342> <U0314> <Greek_eta>", 0x1F97)

-CheckCompUni("<Greek_iota> <asciitilde> <U1f21>", 0x1F97)

-CheckCompUni("<Greek_iota> <dead_tilde> <U1f21>", 0x1F97)

-CheckCompUni("<Greek_iota> <U0342> <U1f21>", 0x1F97)

-CheckCompUni("<Greek_iota> <U1f27>", 0x1F97)

-CheckCompUni("<Greek_iota> <parenright> <Greek_ETA>", 0x1F98)

-CheckCompUni("<Greek_iota> <U0313> <Greek_ETA>", 0x1F98)

-CheckCompUni("<Greek_iota> <U1f28>", 0x1F98)

-CheckCompUni("<Greek_iota> <parenleft> <Greek_ETA>", 0x1F99)

-CheckCompUni("<Greek_iota> <U0314> <Greek_ETA>", 0x1F99)

-CheckCompUni("<Greek_iota> <U1f29>", 0x1F99)

-CheckCompUni("<Greek_iota> <combining_grave> <parenright> <Greek_ETA>", 0x1F9A)

-CheckCompUni("<Greek_iota> <combining_grave> <U0313> <Greek_ETA>", 0x1F9A)

-CheckCompUni("<Greek_iota> <combining_grave> <U1f28>", 0x1F9A)

-CheckCompUni("<Greek_iota> <grave> <parenright> <Greek_ETA>", 0x1F9A)

-CheckCompUni("<Greek_iota> <grave> <U0313> <Greek_ETA>", 0x1F9A)

-CheckCompUni("<Greek_iota> <dead_grave> <parenright> <Greek_ETA>", 0x1F9A)

-CheckCompUni("<Greek_iota> <dead_grave> <U0313> <Greek_ETA>", 0x1F9A)

-CheckCompUni("<Greek_iota> <grave> <U1f28>", 0x1F9A)

-CheckCompUni("<Greek_iota> <dead_grave> <U1f28>", 0x1F9A)

-CheckCompUni("<Greek_iota> <U1f2a>", 0x1F9A)

-CheckCompUni("<Greek_iota> <combining_grave> <parenleft> <Greek_ETA>", 0x1F9B)

-CheckCompUni("<Greek_iota> <combining_grave> <U0314> <Greek_ETA>", 0x1F9B)

-CheckCompUni("<Greek_iota> <combining_grave> <U1f29>", 0x1F9B)

-CheckCompUni("<Greek_iota> <grave> <parenleft> <Greek_ETA>", 0x1F9B)

-CheckCompUni("<Greek_iota> <grave> <U0314> <Greek_ETA>", 0x1F9B)

-CheckCompUni("<Greek_iota> <dead_grave> <parenleft> <Greek_ETA>", 0x1F9B)

-CheckCompUni("<Greek_iota> <dead_grave> <U0314> <Greek_ETA>", 0x1F9B)

-CheckCompUni("<Greek_iota> <grave> <U1f29>", 0x1F9B)

-CheckCompUni("<Greek_iota> <dead_grave> <U1f29>", 0x1F9B)

-CheckCompUni("<Greek_iota> <U1f2b>", 0x1F9B)

-CheckCompUni("<Greek_iota> <combining_acute> <parenright> <Greek_ETA>", 0x1F9C)

-CheckCompUni("<Greek_iota> <combining_acute> <U0313> <Greek_ETA>", 0x1F9C)

-CheckCompUni("<Greek_iota> <combining_acute> <U1f28>", 0x1F9C)

-CheckCompUni("<Greek_iota> <apostrophe> <parenright> <Greek_ETA>", 0x1F9C)

-CheckCompUni("<Greek_iota> <apostrophe> <U0313> <Greek_ETA>", 0x1F9C)

-CheckCompUni("<Greek_iota> <acute> <parenright> <Greek_ETA>", 0x1F9C)

-CheckCompUni("<Greek_iota> <acute> <U0313> <Greek_ETA>", 0x1F9C)

-CheckCompUni("<Greek_iota> <dead_acute> <parenright> <Greek_ETA>", 0x1F9C)

-CheckCompUni("<Greek_iota> <dead_acute> <U0313> <Greek_ETA>", 0x1F9C)

-CheckCompUni("<Greek_iota> <apostrophe> <U1f28>", 0x1F9C)

-CheckCompUni("<Greek_iota> <acute> <U1f28>", 0x1F9C)

-CheckCompUni("<Greek_iota> <dead_acute> <U1f28>", 0x1F9C)

-CheckCompUni("<Greek_iota> <U1f2c>", 0x1F9C)

-CheckCompUni("<Greek_iota> <combining_acute> <parenleft> <Greek_ETA>", 0x1F9D)

-CheckCompUni("<Greek_iota> <combining_acute> <U0314> <Greek_ETA>", 0x1F9D)

-CheckCompUni("<Greek_iota> <combining_acute> <U1f29>", 0x1F9D)

-CheckCompUni("<Greek_iota> <apostrophe> <parenleft> <Greek_ETA>", 0x1F9D)

-CheckCompUni("<Greek_iota> <apostrophe> <U0314> <Greek_ETA>", 0x1F9D)

-CheckCompUni("<Greek_iota> <acute> <parenleft> <Greek_ETA>", 0x1F9D)

-CheckCompUni("<Greek_iota> <acute> <U0314> <Greek_ETA>", 0x1F9D)

-CheckCompUni("<Greek_iota> <dead_acute> <parenleft> <Greek_ETA>", 0x1F9D)

-CheckCompUni("<Greek_iota> <dead_acute> <U0314> <Greek_ETA>", 0x1F9D)

-CheckCompUni("<Greek_iota> <apostrophe> <U1f29>", 0x1F9D)

-CheckCompUni("<Greek_iota> <acute> <U1f29>", 0x1F9D)

-CheckCompUni("<Greek_iota> <dead_acute> <U1f29>", 0x1F9D)

-CheckCompUni("<Greek_iota> <U1f2d>", 0x1F9D)

-CheckCompUni("<Greek_iota> <asciitilde> <parenright> <Greek_ETA>", 0x1F9E)

-CheckCompUni("<Greek_iota> <asciitilde> <U0313> <Greek_ETA>", 0x1F9E)

-CheckCompUni("<Greek_iota> <dead_tilde> <parenright> <Greek_ETA>", 0x1F9E)

-CheckCompUni("<Greek_iota> <dead_tilde> <U0313> <Greek_ETA>", 0x1F9E)

-CheckCompUni("<Greek_iota> <U0342> <parenright> <Greek_ETA>", 0x1F9E)

-CheckCompUni("<Greek_iota> <U0342> <U0313> <Greek_ETA>", 0x1F9E)

-CheckCompUni("<Greek_iota> <asciitilde> <U1f28>", 0x1F9E)

-CheckCompUni("<Greek_iota> <dead_tilde> <U1f28>", 0x1F9E)

-CheckCompUni("<Greek_iota> <U0342> <U1f28>", 0x1F9E)

-CheckCompUni("<Greek_iota> <U1f2e>", 0x1F9E)

-CheckCompUni("<Greek_iota> <asciitilde> <parenleft> <Greek_ETA>", 0x1F9F)

-CheckCompUni("<Greek_iota> <asciitilde> <U0314> <Greek_ETA>", 0x1F9F)

-CheckCompUni("<Greek_iota> <dead_tilde> <parenleft> <Greek_ETA>", 0x1F9F)

-CheckCompUni("<Greek_iota> <dead_tilde> <U0314> <Greek_ETA>", 0x1F9F)

-CheckCompUni("<Greek_iota> <U0342> <parenleft> <Greek_ETA>", 0x1F9F)

-CheckCompUni("<Greek_iota> <U0342> <U0314> <Greek_ETA>", 0x1F9F)

-CheckCompUni("<Greek_iota> <asciitilde> <U1f29>", 0x1F9F)

-CheckCompUni("<Greek_iota> <dead_tilde> <U1f29>", 0x1F9F)

-CheckCompUni("<Greek_iota> <U0342> <U1f29>", 0x1F9F)

-CheckCompUni("<Greek_iota> <U1f2f>", 0x1F9F)

-CheckCompUni("<Greek_iota> <parenright> <Greek_omega>", 0x1FA0)

-CheckCompUni("<Greek_iota> <U0313> <Greek_omega>", 0x1FA0)

-CheckCompUni("<Greek_iota> <U1f60>", 0x1FA0)

-CheckCompUni("<Greek_iota> <parenleft> <Greek_omega>", 0x1FA1)

-CheckCompUni("<Greek_iota> <U0314> <Greek_omega>", 0x1FA1)

-CheckCompUni("<Greek_iota> <U1f61>", 0x1FA1)

-CheckCompUni("<Greek_iota> <combining_grave> <parenright> <Greek_omega>", 0x1FA2)

-CheckCompUni("<Greek_iota> <combining_grave> <U0313> <Greek_omega>", 0x1FA2)

-CheckCompUni("<Greek_iota> <combining_grave> <U1f60>", 0x1FA2)

-CheckCompUni("<Greek_iota> <grave> <parenright> <Greek_omega>", 0x1FA2)

-CheckCompUni("<Greek_iota> <grave> <U0313> <Greek_omega>", 0x1FA2)

-CheckCompUni("<Greek_iota> <dead_grave> <parenright> <Greek_omega>", 0x1FA2)

-CheckCompUni("<Greek_iota> <dead_grave> <U0313> <Greek_omega>", 0x1FA2)

-CheckCompUni("<Greek_iota> <grave> <U1f60>", 0x1FA2)

-CheckCompUni("<Greek_iota> <dead_grave> <U1f60>", 0x1FA2)

-CheckCompUni("<Greek_iota> <U1f62>", 0x1FA2)

-CheckCompUni("<Greek_iota> <combining_grave> <parenleft> <Greek_omega>", 0x1FA3)

-CheckCompUni("<Greek_iota> <combining_grave> <U0314> <Greek_omega>", 0x1FA3)

-CheckCompUni("<Greek_iota> <combining_grave> <U1f61>", 0x1FA3)

-CheckCompUni("<Greek_iota> <grave> <parenleft> <Greek_omega>", 0x1FA3)

-CheckCompUni("<Greek_iota> <grave> <U0314> <Greek_omega>", 0x1FA3)

-CheckCompUni("<Greek_iota> <dead_grave> <parenleft> <Greek_omega>", 0x1FA3)

-CheckCompUni("<Greek_iota> <dead_grave> <U0314> <Greek_omega>", 0x1FA3)

-CheckCompUni("<Greek_iota> <grave> <U1f61>", 0x1FA3)

-CheckCompUni("<Greek_iota> <dead_grave> <U1f61>", 0x1FA3)

-CheckCompUni("<Greek_iota> <U1f63>", 0x1FA3)

-CheckCompUni("<Greek_iota> <combining_acute> <parenright> <Greek_omega>", 0x1FA4)

-CheckCompUni("<Greek_iota> <combining_acute> <U0313> <Greek_omega>", 0x1FA4)

-CheckCompUni("<Greek_iota> <combining_acute> <U1f60>", 0x1FA4)

-CheckCompUni("<Greek_iota> <apostrophe> <parenright> <Greek_omega>", 0x1FA4)

-CheckCompUni("<Greek_iota> <apostrophe> <U0313> <Greek_omega>", 0x1FA4)

-CheckCompUni("<Greek_iota> <acute> <parenright> <Greek_omega>", 0x1FA4)

-CheckCompUni("<Greek_iota> <acute> <U0313> <Greek_omega>", 0x1FA4)

-CheckCompUni("<Greek_iota> <dead_acute> <parenright> <Greek_omega>", 0x1FA4)

-CheckCompUni("<Greek_iota> <dead_acute> <U0313> <Greek_omega>", 0x1FA4)

-CheckCompUni("<Greek_iota> <apostrophe> <U1f60>", 0x1FA4)

-CheckCompUni("<Greek_iota> <acute> <U1f60>", 0x1FA4)

-CheckCompUni("<Greek_iota> <dead_acute> <U1f60>", 0x1FA4)

-CheckCompUni("<Greek_iota> <U1f64>", 0x1FA4)

-CheckCompUni("<Greek_iota> <combining_acute> <parenleft> <Greek_omega>", 0x1FA5)

-CheckCompUni("<Greek_iota> <combining_acute> <U0314> <Greek_omega>", 0x1FA5)

-CheckCompUni("<Greek_iota> <combining_acute> <U1f61>", 0x1FA5)

-CheckCompUni("<Greek_iota> <apostrophe> <parenleft> <Greek_omega>", 0x1FA5)

-CheckCompUni("<Greek_iota> <apostrophe> <U0314> <Greek_omega>", 0x1FA5)

-CheckCompUni("<Greek_iota> <acute> <parenleft> <Greek_omega>", 0x1FA5)

-CheckCompUni("<Greek_iota> <acute> <U0314> <Greek_omega>", 0x1FA5)

-CheckCompUni("<Greek_iota> <dead_acute> <parenleft> <Greek_omega>", 0x1FA5)

-CheckCompUni("<Greek_iota> <dead_acute> <U0314> <Greek_omega>", 0x1FA5)

-CheckCompUni("<Greek_iota> <apostrophe> <U1f61>", 0x1FA5)

-CheckCompUni("<Greek_iota> <acute> <U1f61>", 0x1FA5)

-CheckCompUni("<Greek_iota> <dead_acute> <U1f61>", 0x1FA5)

-CheckCompUni("<Greek_iota> <U1f65>", 0x1FA5)

-CheckCompUni("<Greek_iota> <asciitilde> <parenright> <Greek_omega>", 0x1FA6)

-CheckCompUni("<Greek_iota> <asciitilde> <U0313> <Greek_omega>", 0x1FA6)

-CheckCompUni("<Greek_iota> <dead_tilde> <parenright> <Greek_omega>", 0x1FA6)

-CheckCompUni("<Greek_iota> <dead_tilde> <U0313> <Greek_omega>", 0x1FA6)

-CheckCompUni("<Greek_iota> <U0342> <parenright> <Greek_omega>", 0x1FA6)

-CheckCompUni("<Greek_iota> <U0342> <U0313> <Greek_omega>", 0x1FA6)

-CheckCompUni("<Greek_iota> <asciitilde> <U1f60>", 0x1FA6)

-CheckCompUni("<Greek_iota> <dead_tilde> <U1f60>", 0x1FA6)

-CheckCompUni("<Greek_iota> <U0342> <U1f60>", 0x1FA6)

-CheckCompUni("<Greek_iota> <U1f66>", 0x1FA6)

-CheckCompUni("<Greek_iota> <asciitilde> <parenleft> <Greek_omega>", 0x1FA7)

-CheckCompUni("<Greek_iota> <asciitilde> <U0314> <Greek_omega>", 0x1FA7)

-CheckCompUni("<Greek_iota> <dead_tilde> <parenleft> <Greek_omega>", 0x1FA7)

-CheckCompUni("<Greek_iota> <dead_tilde> <U0314> <Greek_omega>", 0x1FA7)

-CheckCompUni("<Greek_iota> <U0342> <parenleft> <Greek_omega>", 0x1FA7)

-CheckCompUni("<Greek_iota> <U0342> <U0314> <Greek_omega>", 0x1FA7)

-CheckCompUni("<Greek_iota> <asciitilde> <U1f61>", 0x1FA7)

-CheckCompUni("<Greek_iota> <dead_tilde> <U1f61>", 0x1FA7)

-CheckCompUni("<Greek_iota> <U0342> <U1f61>", 0x1FA7)

-CheckCompUni("<Greek_iota> <U1f67>", 0x1FA7)

-CheckCompUni("<Greek_iota> <parenright> <Greek_OMEGA>", 0x1FA8)

-CheckCompUni("<Greek_iota> <U0313> <Greek_OMEGA>", 0x1FA8)

-CheckCompUni("<Greek_iota> <U1f68>", 0x1FA8)

-CheckCompUni("<Greek_iota> <parenleft> <Greek_OMEGA>", 0x1FA9)

-CheckCompUni("<Greek_iota> <U0314> <Greek_OMEGA>", 0x1FA9)

-CheckCompUni("<Greek_iota> <U1f69>", 0x1FA9)

-CheckCompUni("<Greek_iota> <combining_grave> <parenright> <Greek_OMEGA>", 0x1FAA)

-CheckCompUni("<Greek_iota> <combining_grave> <U0313> <Greek_OMEGA>", 0x1FAA)

-CheckCompUni("<Greek_iota> <combining_grave> <U1f68>", 0x1FAA)

-CheckCompUni("<Greek_iota> <grave> <parenright> <Greek_OMEGA>", 0x1FAA)

-CheckCompUni("<Greek_iota> <grave> <U0313> <Greek_OMEGA>", 0x1FAA)

-CheckCompUni("<Greek_iota> <dead_grave> <parenright> <Greek_OMEGA>", 0x1FAA)

-CheckCompUni("<Greek_iota> <dead_grave> <U0313> <Greek_OMEGA>", 0x1FAA)

-CheckCompUni("<Greek_iota> <grave> <U1f68>", 0x1FAA)

-CheckCompUni("<Greek_iota> <dead_grave> <U1f68>", 0x1FAA)

-CheckCompUni("<Greek_iota> <U1f6a>", 0x1FAA)

-CheckCompUni("<Greek_iota> <combining_grave> <parenleft> <Greek_OMEGA>", 0x1FAB)

-CheckCompUni("<Greek_iota> <combining_grave> <U0314> <Greek_OMEGA>", 0x1FAB)

-CheckCompUni("<Greek_iota> <combining_grave> <U1f69>", 0x1FAB)

-CheckCompUni("<Greek_iota> <grave> <parenleft> <Greek_OMEGA>", 0x1FAB)

-CheckCompUni("<Greek_iota> <grave> <U0314> <Greek_OMEGA>", 0x1FAB)

-CheckCompUni("<Greek_iota> <dead_grave> <parenleft> <Greek_OMEGA>", 0x1FAB)

-CheckCompUni("<Greek_iota> <dead_grave> <U0314> <Greek_OMEGA>", 0x1FAB)

-CheckCompUni("<Greek_iota> <grave> <U1f69>", 0x1FAB)

-CheckCompUni("<Greek_iota> <dead_grave> <U1f69>", 0x1FAB)

-CheckCompUni("<Greek_iota> <U1f6b>", 0x1FAB)

-CheckCompUni("<Greek_iota> <combining_acute> <parenright> <Greek_OMEGA>", 0x1FAC)

-CheckCompUni("<Greek_iota> <combining_acute> <U0313> <Greek_OMEGA>", 0x1FAC)

-CheckCompUni("<Greek_iota> <combining_acute> <U1f68>", 0x1FAC)

-CheckCompUni("<Greek_iota> <apostrophe> <parenright> <Greek_OMEGA>", 0x1FAC)

-CheckCompUni("<Greek_iota> <apostrophe> <U0313> <Greek_OMEGA>", 0x1FAC)

-CheckCompUni("<Greek_iota> <acute> <parenright> <Greek_OMEGA>", 0x1FAC)

-CheckCompUni("<Greek_iota> <acute> <U0313> <Greek_OMEGA>", 0x1FAC)

-CheckCompUni("<Greek_iota> <dead_acute> <parenright> <Greek_OMEGA>", 0x1FAC)

-CheckCompUni("<Greek_iota> <dead_acute> <U0313> <Greek_OMEGA>", 0x1FAC)

-CheckCompUni("<Greek_iota> <apostrophe> <U1f68>", 0x1FAC)

-CheckCompUni("<Greek_iota> <acute> <U1f68>", 0x1FAC)

-CheckCompUni("<Greek_iota> <dead_acute> <U1f68>", 0x1FAC)

-CheckCompUni("<Greek_iota> <U1f6c>", 0x1FAC)

-CheckCompUni("<Greek_iota> <combining_acute> <parenleft> <Greek_OMEGA>", 0x1FAD)

-CheckCompUni("<Greek_iota> <combining_acute> <U0314> <Greek_OMEGA>", 0x1FAD)

-CheckCompUni("<Greek_iota> <combining_acute> <U1f69>", 0x1FAD)

-CheckCompUni("<Greek_iota> <apostrophe> <parenleft> <Greek_OMEGA>", 0x1FAD)

-CheckCompUni("<Greek_iota> <apostrophe> <U0314> <Greek_OMEGA>", 0x1FAD)

-CheckCompUni("<Greek_iota> <acute> <parenleft> <Greek_OMEGA>", 0x1FAD)

-CheckCompUni("<Greek_iota> <acute> <U0314> <Greek_OMEGA>", 0x1FAD)

-CheckCompUni("<Greek_iota> <dead_acute> <parenleft> <Greek_OMEGA>", 0x1FAD)

-CheckCompUni("<Greek_iota> <dead_acute> <U0314> <Greek_OMEGA>", 0x1FAD)

-CheckCompUni("<Greek_iota> <apostrophe> <U1f69>", 0x1FAD)

-CheckCompUni("<Greek_iota> <acute> <U1f69>", 0x1FAD)

-CheckCompUni("<Greek_iota> <dead_acute> <U1f69>", 0x1FAD)

-CheckCompUni("<Greek_iota> <U1f6d>", 0x1FAD)

-CheckCompUni("<Greek_iota> <asciitilde> <parenright> <Greek_OMEGA>", 0x1FAE)

-CheckCompUni("<Greek_iota> <asciitilde> <U0313> <Greek_OMEGA>", 0x1FAE)

-CheckCompUni("<Greek_iota> <dead_tilde> <parenright> <Greek_OMEGA>", 0x1FAE)

-CheckCompUni("<Greek_iota> <dead_tilde> <U0313> <Greek_OMEGA>", 0x1FAE)

-CheckCompUni("<Greek_iota> <U0342> <parenright> <Greek_OMEGA>", 0x1FAE)

-CheckCompUni("<Greek_iota> <U0342> <U0313> <Greek_OMEGA>", 0x1FAE)

-CheckCompUni("<Greek_iota> <asciitilde> <U1f68>", 0x1FAE)

-CheckCompUni("<Greek_iota> <dead_tilde> <U1f68>", 0x1FAE)

-CheckCompUni("<Greek_iota> <U0342> <U1f68>", 0x1FAE)

-CheckCompUni("<Greek_iota> <U1f6e>", 0x1FAE)

-CheckCompUni("<Greek_iota> <asciitilde> <parenleft> <Greek_OMEGA>", 0x1FAF)

-CheckCompUni("<Greek_iota> <asciitilde> <U0314> <Greek_OMEGA>", 0x1FAF)

-CheckCompUni("<Greek_iota> <dead_tilde> <parenleft> <Greek_OMEGA>", 0x1FAF)

-CheckCompUni("<Greek_iota> <dead_tilde> <U0314> <Greek_OMEGA>", 0x1FAF)

-CheckCompUni("<Greek_iota> <U0342> <parenleft> <Greek_OMEGA>", 0x1FAF)

-CheckCompUni("<Greek_iota> <U0342> <U0314> <Greek_OMEGA>", 0x1FAF)

-CheckCompUni("<Greek_iota> <asciitilde> <U1f69>", 0x1FAF)

-CheckCompUni("<Greek_iota> <dead_tilde> <U1f69>", 0x1FAF)

-CheckCompUni("<Greek_iota> <U0342> <U1f69>", 0x1FAF)

-CheckCompUni("<Greek_iota> <U1f6f>", 0x1FAF)

-CheckCompUni("<b> <Greek_alpha>", 0x1FB0)

-CheckCompUni("<U> <Greek_alpha>", 0x1FB0)

-CheckCompUni("<underscore> <Greek_alpha>", 0x1FB1)

-CheckCompUni("<macron> <Greek_alpha>", 0x1FB1)

-CheckCompUni("<Greek_iota> <combining_grave> <Greek_alpha>", 0x1FB2)

-CheckCompUni("<Greek_iota> <grave> <Greek_alpha>", 0x1FB2)

-CheckCompUni("<Greek_iota> <dead_grave> <Greek_alpha>", 0x1FB2)

-CheckCompUni("<Greek_iota> <U1f70>", 0x1FB2)

-CheckCompUni("<Greek_iota> <Greek_alpha>", 0x1FB3)

-CheckCompUni("<Greek_iota> <combining_acute> <Greek_alpha>", 0x1FB4)

-CheckCompUni("<Greek_iota> <apostrophe> <Greek_alpha>", 0x1FB4)

-CheckCompUni("<Greek_iota> <acute> <Greek_alpha>", 0x1FB4)

-CheckCompUni("<Greek_iota> <dead_acute> <Greek_alpha>", 0x1FB4)

-CheckCompUni("<Greek_iota> <Greek_alphaaccent>", 0x1FB4)

-CheckCompUni("<asciitilde> <Greek_alpha>", 0x1FB6)

-CheckCompUni("<Greek_iota> <asciitilde> <Greek_alpha>", 0x1FB7)

-CheckCompUni("<Greek_iota> <dead_tilde> <Greek_alpha>", 0x1FB7)

-CheckCompUni("<Greek_iota> <U0342> <Greek_alpha>", 0x1FB7)

-CheckCompUni("<Greek_iota> <U1fb6>", 0x1FB7)

-CheckCompUni("<b> <Greek_ALPHA>", 0x1FB8)

-CheckCompUni("<U> <Greek_ALPHA>", 0x1FB8)

-CheckCompUni("<underscore> <Greek_ALPHA>", 0x1FB9)

-CheckCompUni("<macron> <Greek_ALPHA>", 0x1FB9)

-CheckCompUni("<grave> <Greek_ALPHA>", 0x1FBA)

-CheckCompUni("<Greek_iota> <Greek_ALPHA>", 0x1FBC)

-CheckCompUni("<diaeresis> <asciitilde>", 0x1FC1)

-CheckCompUni("<diaeresis> <dead_tilde>", 0x1FC1)

-CheckCompUni("<diaeresis> <U0342>", 0x1FC1)

-CheckCompUni("<Greek_iota> <combining_grave> <Greek_eta>", 0x1FC2)

-CheckCompUni("<Greek_iota> <grave> <Greek_eta>", 0x1FC2)

-CheckCompUni("<Greek_iota> <dead_grave> <Greek_eta>", 0x1FC2)

-CheckCompUni("<Greek_iota> <U1f74>", 0x1FC2)

-CheckCompUni("<Greek_iota> <Greek_eta>", 0x1FC3)

-CheckCompUni("<Greek_iota> <combining_acute> <Greek_eta>", 0x1FC4)

-CheckCompUni("<Greek_iota> <apostrophe> <Greek_eta>", 0x1FC4)

-CheckCompUni("<Greek_iota> <acute> <Greek_eta>", 0x1FC4)

-CheckCompUni("<Greek_iota> <dead_acute> <Greek_eta>", 0x1FC4)

-CheckCompUni("<Greek_iota> <Greek_etaaccent>", 0x1FC4)

-CheckCompUni("<asciitilde> <Greek_eta>", 0x1FC6)

-CheckCompUni("<Greek_iota> <asciitilde> <Greek_eta>", 0x1FC7)

-CheckCompUni("<Greek_iota> <dead_tilde> <Greek_eta>", 0x1FC7)

-CheckCompUni("<Greek_iota> <U0342> <Greek_eta>", 0x1FC7)

-CheckCompUni("<Greek_iota> <U1fc6>", 0x1FC7)

-CheckCompUni("<grave> <Greek_EPSILON>", 0x1FC8)

-CheckCompUni("<grave> <Greek_ETA>", 0x1FCA)

-CheckCompUni("<Greek_iota> <Greek_ETA>", 0x1FCC)

-CheckCompUni("<U1fbf> <combining_grave>", 0x1FCD)

-CheckCompUni("<U1fbf> <grave>", 0x1FCD)

-CheckCompUni("<U1fbf> <dead_grave>", 0x1FCD)

-CheckCompUni("<U1fbf> <combining_acute>", 0x1FCE)

-CheckCompUni("<U1fbf> <apostrophe>", 0x1FCE)

-CheckCompUni("<U1fbf> <acute>", 0x1FCE)

-CheckCompUni("<U1fbf> <dead_acute>", 0x1FCE)

-CheckCompUni("<U1fbf> <asciitilde>", 0x1FCF)

-CheckCompUni("<U1fbf> <dead_tilde>", 0x1FCF)

-CheckCompUni("<U1fbf> <U0342>", 0x1FCF)

-CheckCompUni("<b> <Greek_iota>", 0x1FD0)

-CheckCompUni("<U> <Greek_iota>", 0x1FD0)

-CheckCompUni("<underscore> <Greek_iota>", 0x1FD1)

-CheckCompUni("<macron> <Greek_iota>", 0x1FD1)

-CheckCompUni("<grave> <quotedbl> <Greek_iota>", 0x1FD2)

-CheckCompUni("<grave> <dead_diaeresis> <Greek_iota>", 0x1FD2)

-CheckCompUni("<grave> <Greek_iotadieresis>", 0x1FD2)

-CheckCompUni("<asciitilde> <Greek_iota>", 0x1FD6)

-CheckCompUni("<asciitilde> <quotedbl> <Greek_iota>", 0x1FD7)

-CheckCompUni("<asciitilde> <dead_diaeresis> <Greek_iota>", 0x1FD7)

-CheckCompUni("<asciitilde> <Greek_iotadieresis>", 0x1FD7)

-CheckCompUni("<b> <Greek_IOTA>", 0x1FD8)

-CheckCompUni("<U> <Greek_IOTA>", 0x1FD8)

-CheckCompUni("<underscore> <Greek_IOTA>", 0x1FD9)

-CheckCompUni("<macron> <Greek_IOTA>", 0x1FD9)

-CheckCompUni("<grave> <Greek_IOTA>", 0x1FDA)

-CheckCompUni("<U1ffe> <combining_grave>", 0x1FDD)

-CheckCompUni("<U1ffe> <grave>", 0x1FDD)

-CheckCompUni("<U1ffe> <dead_grave>", 0x1FDD)

-CheckCompUni("<U1ffe> <combining_acute>", 0x1FDE)

-CheckCompUni("<U1ffe> <apostrophe>", 0x1FDE)

-CheckCompUni("<U1ffe> <acute>", 0x1FDE)

-CheckCompUni("<U1ffe> <dead_acute>", 0x1FDE)

-CheckCompUni("<U1ffe> <asciitilde>", 0x1FDF)

-CheckCompUni("<U1ffe> <dead_tilde>", 0x1FDF)

-CheckCompUni("<U1ffe> <U0342>", 0x1FDF)

-CheckCompUni("<b> <Greek_upsilon>", 0x1FE0)

-CheckCompUni("<U> <Greek_upsilon>", 0x1FE0)

-CheckCompUni("<underscore> <Greek_upsilon>", 0x1FE1)

-CheckCompUni("<macron> <Greek_upsilon>", 0x1FE1)

-CheckCompUni("<grave> <quotedbl> <Greek_upsilon>", 0x1FE2)

-CheckCompUni("<grave> <dead_diaeresis> <Greek_upsilon>", 0x1FE2)

-CheckCompUni("<grave> <Greek_upsilondieresis>", 0x1FE2)

-CheckCompUni("<parenright> <Greek_rho>", 0x1FE4)

-CheckCompUni("<parenleft> <Greek_rho>", 0x1FE5)

-CheckCompUni("<asciitilde> <Greek_upsilon>", 0x1FE6)

-CheckCompUni("<asciitilde> <quotedbl> <Greek_upsilon>", 0x1FE7)

-CheckCompUni("<asciitilde> <dead_diaeresis> <Greek_upsilon>", 0x1FE7)

-CheckCompUni("<asciitilde> <Greek_upsilondieresis>", 0x1FE7)

-CheckCompUni("<b> <Greek_UPSILON>", 0x1FE8)

-CheckCompUni("<U> <Greek_UPSILON>", 0x1FE8)

-CheckCompUni("<underscore> <Greek_UPSILON>", 0x1FE9)

-CheckCompUni("<macron> <Greek_UPSILON>", 0x1FE9)

-CheckCompUni("<grave> <Greek_UPSILON>", 0x1FEA)

-CheckCompUni("<parenleft> <Greek_RHO>", 0x1FEC)

-CheckCompUni("<diaeresis> <combining_grave>", 0x1FED)

-CheckCompUni("<diaeresis> <grave>", 0x1FED)

-CheckCompUni("<diaeresis> <dead_grave>", 0x1FED)

-CheckCompUni("<Greek_iota> <combining_grave> <Greek_omega>", 0x1FF2)

-CheckCompUni("<Greek_iota> <grave> <Greek_omega>", 0x1FF2)

-CheckCompUni("<Greek_iota> <dead_grave> <Greek_omega>", 0x1FF2)

-CheckCompUni("<Greek_iota> <U1f7c>", 0x1FF2)

-CheckCompUni("<Greek_iota> <Greek_omega>", 0x1FF3)

-CheckCompUni("<Greek_iota> <combining_acute> <Greek_omega>", 0x1FF4)

-CheckCompUni("<Greek_iota> <apostrophe> <Greek_omega>", 0x1FF4)

-CheckCompUni("<Greek_iota> <acute> <Greek_omega>", 0x1FF4)

-CheckCompUni("<Greek_iota> <dead_acute> <Greek_omega>", 0x1FF4)

-CheckCompUni("<Greek_iota> <Greek_omegaaccent>", 0x1FF4)

-CheckCompUni("<asciitilde> <Greek_omega>", 0x1FF6)

-CheckCompUni("<Greek_iota> <asciitilde> <Greek_omega>", 0x1FF7)

-CheckCompUni("<Greek_iota> <dead_tilde> <Greek_omega>", 0x1FF7)

-CheckCompUni("<Greek_iota> <U0342> <Greek_omega>", 0x1FF7)

-CheckCompUni("<Greek_iota> <U1ff6>", 0x1FF7)

-CheckCompUni("<grave> <Greek_OMICRON>", 0x1FF8)

-CheckCompUni("<grave> <Greek_OMEGA>", 0x1FFA)

-CheckCompUni("<Greek_iota> <Greek_OMEGA>", 0x1FFC)

-CheckCompUni("<percent> <o>", 0x2030)

-CheckCompUni("<period> <less>", 0x2039)

-CheckCompUni("<period> <greater>", 0x203A)

-CheckCompUni("<asciicircum> <KP_0>", 0x2070)

-CheckCompUni("<asciicircum> <0>", 0x2070)

-CheckCompUni("<asciicircum> <underbar> <i>", 0x2071)

-CheckCompUni("<asciicircum> <underscore> <i>", 0x2071)

-CheckCompUni("<asciicircum> <KP_4>", 0x2074)

-CheckCompUni("<asciicircum> <4>", 0x2074)

-CheckCompUni("<asciicircum> <KP_5>", 0x2075)

-CheckCompUni("<asciicircum> <5>", 0x2075)

-CheckCompUni("<asciicircum> <KP_6>", 0x2076)

-CheckCompUni("<asciicircum> <6>", 0x2076)

-CheckCompUni("<asciicircum> <KP_7>", 0x2077)

-CheckCompUni("<asciicircum> <7>", 0x2077)

-CheckCompUni("<asciicircum> <KP_8>", 0x2078)

-CheckCompUni("<asciicircum> <8>", 0x2078)

-CheckCompUni("<asciicircum> <KP_9>", 0x2079)

-CheckCompUni("<asciicircum> <9>", 0x2079)

-CheckCompUni("<asciicircum> <KP_Add>", 0x207A)

-CheckCompUni("<asciicircum> <plus>", 0x207A)

-CheckCompUni("<asciicircum> <U2212>", 0x207B)

-CheckCompUni("<asciicircum> <KP_Equal>", 0x207C)

-CheckCompUni("<asciicircum> <equal>", 0x207C)

-CheckCompUni("<asciicircum> <parenleft>", 0x207D)

-CheckCompUni("<asciicircum> <parenright>", 0x207E)

-CheckCompUni("<asciicircum> <underbar> <n>", 0x207F)

-CheckCompUni("<asciicircum> <underscore> <n>", 0x207F)

-CheckCompUni("<underbar> <KP_0>", 0x2080)

-CheckCompUni("<underbar> <0>", 0x2080)

-CheckCompUni("<underscore> <KP_0>", 0x2080)

-CheckCompUni("<underscore> <0>", 0x2080)

-CheckCompUni("<underbar> <KP_1>", 0x2081)

-CheckCompUni("<underbar> <1>", 0x2081)

-CheckCompUni("<underscore> <KP_1>", 0x2081)

-CheckCompUni("<underscore> <1>", 0x2081)

-CheckCompUni("<underbar> <KP_2>", 0x2082)

-CheckCompUni("<underbar> <KP_Space>", 0x2082)

-CheckCompUni("<underbar> <2>", 0x2082)

-CheckCompUni("<underscore> <KP_2>", 0x2082)

-CheckCompUni("<underscore> <KP_Space>", 0x2082)

-CheckCompUni("<underscore> <2>", 0x2082)

-CheckCompUni("<underbar> <KP_3>", 0x2083)

-CheckCompUni("<underbar> <3>", 0x2083)

-CheckCompUni("<underscore> <KP_3>", 0x2083)

-CheckCompUni("<underscore> <3>", 0x2083)

-CheckCompUni("<underbar> <KP_4>", 0x2084)

-CheckCompUni("<underbar> <4>", 0x2084)

-CheckCompUni("<underscore> <KP_4>", 0x2084)

-CheckCompUni("<underscore> <4>", 0x2084)

-CheckCompUni("<underbar> <KP_5>", 0x2085)

-CheckCompUni("<underbar> <5>", 0x2085)

-CheckCompUni("<underscore> <KP_5>", 0x2085)

-CheckCompUni("<underscore> <5>", 0x2085)

-CheckCompUni("<underbar> <KP_6>", 0x2086)

-CheckCompUni("<underbar> <6>", 0x2086)

-CheckCompUni("<underscore> <KP_6>", 0x2086)

-CheckCompUni("<underscore> <6>", 0x2086)

-CheckCompUni("<underbar> <KP_7>", 0x2087)

-CheckCompUni("<underbar> <7>", 0x2087)

-CheckCompUni("<underscore> <KP_7>", 0x2087)

-CheckCompUni("<underscore> <7>", 0x2087)

-CheckCompUni("<underbar> <KP_8>", 0x2088)

-CheckCompUni("<underbar> <8>", 0x2088)

-CheckCompUni("<underscore> <KP_8>", 0x2088)

-CheckCompUni("<underscore> <8>", 0x2088)

-CheckCompUni("<underbar> <KP_9>", 0x2089)

-CheckCompUni("<underbar> <9>", 0x2089)

-CheckCompUni("<underscore> <KP_9>", 0x2089)

-CheckCompUni("<underscore> <9>", 0x2089)

-CheckCompUni("<underbar> <KP_Add>", 0x208A)

-CheckCompUni("<underbar> <plus>", 0x208A)

-CheckCompUni("<underscore> <KP_Add>", 0x208A)

-CheckCompUni("<underscore> <plus>", 0x208A)

-CheckCompUni("<underbar> <U2212>", 0x208B)

-CheckCompUni("<underscore> <U2212>", 0x208B)

-CheckCompUni("<underbar> <KP_Equal>", 0x208C)

-CheckCompUni("<underbar> <equal>", 0x208C)

-CheckCompUni("<underscore> <KP_Equal>", 0x208C)

-CheckCompUni("<underscore> <equal>", 0x208C)

-CheckCompUni("<underbar> <parenleft>", 0x208D)

-CheckCompUni("<underscore> <parenleft>", 0x208D)

-CheckCompUni("<underbar> <parenright>", 0x208E)

-CheckCompUni("<underscore> <parenright>", 0x208E)

-CheckCompUni("<asciicircum> <S> <M>", 0x2120)

-CheckCompUni("<KP_Divide> <leftarrow>", 0x219A)

-CheckCompUni("<slash> <leftarrow>", 0x219A)

-CheckCompUni("<KP_Divide> <rightarrow>", 0x219B)

-CheckCompUni("<slash> <rightarrow>", 0x219B)

-CheckCompUni("<KP_Divide> <U2194>", 0x21AE)

-CheckCompUni("<slash> <U2194>", 0x21AE)

-CheckCompUni("<U2203> <U0338>", 0x2204)

-CheckCompUni("<U2208> <U0338>", 0x2209)

-CheckCompUni("<U220b> <U0338>", 0x220C)

-CheckCompUni("<U2223> <U0338>", 0x2224)

-CheckCompUni("<U2225> <U0338>", 0x2226)

-CheckCompUni("<U223c> <U0338>", 0x2241)

-CheckCompUni("<U2243> <U0338>", 0x2244)

-CheckCompUni("<approximate> <U0338>", 0x2247)

-CheckCompUni("<U2248> <U0338>", 0x2249)

-CheckCompUni("<identical> <U0338>", 0x2262)

-CheckCompUni("<U224d> <U0338>", 0x226D)

-CheckCompUni("<leftcaret> <U0338>", 0x226E)

-CheckCompUni("<less> <U0338>", 0x226E)

-CheckCompUni("<rightcaret> <U0338>", 0x226F)

-CheckCompUni("<greater> <U0338>", 0x226F)

-CheckCompUni("<lessthanequal> <U0338>", 0x2270)

-CheckCompUni("<greaterthanequal> <U0338>", 0x2271)

-CheckCompUni("<U2272> <U0338>", 0x2274)

-CheckCompUni("<U2273> <U0338>", 0x2275)

-CheckCompUni("<U2276> <U0338>", 0x2278)

-CheckCompUni("<U2277> <U0338>", 0x2279)

-CheckCompUni("<U227a> <U0338>", 0x2280)

-CheckCompUni("<U227b> <U0338>", 0x2281)

-CheckCompUni("<leftshoe> <U0338>", 0x2284)

-CheckCompUni("<includedin> <U0338>", 0x2284)

-CheckCompUni("<rightshoe> <U0338>", 0x2285)

-CheckCompUni("<includes> <U0338>", 0x2285)

-CheckCompUni("<U2286> <U0338>", 0x2288)

-CheckCompUni("<U2287> <U0338>", 0x2289)

-CheckCompUni("<righttack> <U0338>", 0x22AC)

-CheckCompUni("<U22a8> <U0338>", 0x22AD)

-CheckCompUni("<U22a9> <U0338>", 0x22AE)

-CheckCompUni("<U22ab> <U0338>", 0x22AF)

-CheckCompUni("<U227c> <U0338>", 0x22E0)

-CheckCompUni("<U227d> <U0338>", 0x22E1)

-CheckCompUni("<U2291> <U0338>", 0x22E2)

-CheckCompUni("<U2292> <U0338>", 0x22E3)

-CheckCompUni("<U22b2> <U0338>", 0x22EA)

-CheckCompUni("<U22b3> <U0338>", 0x22EB)

-CheckCompUni("<U22b4> <U0338>", 0x22EC)

-CheckCompUni("<U22b5> <U0338>", 0x22ED)

-CheckCompUni("<parenleft> <KP_1> <parenright>", 0x2460)

-CheckCompUni("<parenleft> <1> <parenright>", 0x2460)

-CheckCompUni("<parenleft> <KP_2> <parenright>", 0x2461)

-CheckCompUni("<parenleft> <KP_Space> <parenright>", 0x2461)

-CheckCompUni("<parenleft> <2> <parenright>", 0x2461)

-CheckCompUni("<parenleft> <KP_3> <parenright>", 0x2462)

-CheckCompUni("<parenleft> <3> <parenright>", 0x2462)

-CheckCompUni("<parenleft> <KP_4> <parenright>", 0x2463)

-CheckCompUni("<parenleft> <4> <parenright>", 0x2463)

-CheckCompUni("<parenleft> <KP_5> <parenright>", 0x2464)

-CheckCompUni("<parenleft> <5> <parenright>", 0x2464)

-CheckCompUni("<parenleft> <KP_6> <parenright>", 0x2465)

-CheckCompUni("<parenleft> <6> <parenright>", 0x2465)

-CheckCompUni("<parenleft> <KP_7> <parenright>", 0x2466)

-CheckCompUni("<parenleft> <7> <parenright>", 0x2466)

-CheckCompUni("<parenleft> <KP_8> <parenright>", 0x2467)

-CheckCompUni("<parenleft> <8> <parenright>", 0x2467)

-CheckCompUni("<parenleft> <KP_9> <parenright>", 0x2468)

-CheckCompUni("<parenleft> <9> <parenright>", 0x2468)

-CheckCompUni("<parenleft> <KP_1> <KP_0> <parenright>", 0x2469)

-CheckCompUni("<parenleft> <KP_1> <0> <parenright>", 0x2469)

-CheckCompUni("<parenleft> <1> <KP_0> <parenright>", 0x2469)

-CheckCompUni("<parenleft> <1> <0> <parenright>", 0x2469)

-CheckCompUni("<parenleft> <KP_1> <KP_1> <parenright>", 0x246A)

-CheckCompUni("<parenleft> <KP_1> <1> <parenright>", 0x246A)

-CheckCompUni("<parenleft> <1> <KP_1> <parenright>", 0x246A)

-CheckCompUni("<parenleft> <1> <1> <parenright>", 0x246A)

-CheckCompUni("<parenleft> <KP_1> <KP_2> <parenright>", 0x246B)

-CheckCompUni("<parenleft> <KP_1> <KP_Space> <parenright>", 0x246B)

-CheckCompUni("<parenleft> <KP_1> <2> <parenright>", 0x246B)

-CheckCompUni("<parenleft> <1> <KP_2> <parenright>", 0x246B)

-CheckCompUni("<parenleft> <1> <KP_Space> <parenright>", 0x246B)

-CheckCompUni("<parenleft> <1> <2> <parenright>", 0x246B)

-CheckCompUni("<parenleft> <KP_1> <KP_3> <parenright>", 0x246C)

-CheckCompUni("<parenleft> <KP_1> <3> <parenright>", 0x246C)

-CheckCompUni("<parenleft> <1> <KP_3> <parenright>", 0x246C)

-CheckCompUni("<parenleft> <1> <3> <parenright>", 0x246C)

-CheckCompUni("<parenleft> <KP_1> <KP_4> <parenright>", 0x246D)

-CheckCompUni("<parenleft> <KP_1> <4> <parenright>", 0x246D)

-CheckCompUni("<parenleft> <1> <KP_4> <parenright>", 0x246D)

-CheckCompUni("<parenleft> <1> <4> <parenright>", 0x246D)

-CheckCompUni("<parenleft> <KP_1> <KP_5> <parenright>", 0x246E)

-CheckCompUni("<parenleft> <KP_1> <5> <parenright>", 0x246E)

-CheckCompUni("<parenleft> <1> <KP_5> <parenright>", 0x246E)

-CheckCompUni("<parenleft> <1> <5> <parenright>", 0x246E)

-CheckCompUni("<parenleft> <KP_1> <KP_6> <parenright>", 0x246F)

-CheckCompUni("<parenleft> <KP_1> <6> <parenright>", 0x246F)

-CheckCompUni("<parenleft> <1> <KP_6> <parenright>", 0x246F)

-CheckCompUni("<parenleft> <1> <6> <parenright>", 0x246F)

-CheckCompUni("<parenleft> <KP_1> <KP_7> <parenright>", 0x2470)

-CheckCompUni("<parenleft> <KP_1> <7> <parenright>", 0x2470)

-CheckCompUni("<parenleft> <1> <KP_7> <parenright>", 0x2470)

-CheckCompUni("<parenleft> <1> <7> <parenright>", 0x2470)

-CheckCompUni("<parenleft> <KP_1> <KP_8> <parenright>", 0x2471)

-CheckCompUni("<parenleft> <KP_1> <8> <parenright>", 0x2471)

-CheckCompUni("<parenleft> <1> <KP_8> <parenright>", 0x2471)

-CheckCompUni("<parenleft> <1> <8> <parenright>", 0x2471)

-CheckCompUni("<parenleft> <KP_1> <KP_9> <parenright>", 0x2472)

-CheckCompUni("<parenleft> <KP_1> <9> <parenright>", 0x2472)

-CheckCompUni("<parenleft> <1> <KP_9> <parenright>", 0x2472)

-CheckCompUni("<parenleft> <1> <9> <parenright>", 0x2472)

-CheckCompUni("<parenleft> <KP_2> <KP_0> <parenright>", 0x2473)

-CheckCompUni("<parenleft> <KP_2> <0> <parenright>", 0x2473)

-CheckCompUni("<parenleft> <KP_Space> <KP_0> <parenright>", 0x2473)

-CheckCompUni("<parenleft> <KP_Space> <0> <parenright>", 0x2473)

-CheckCompUni("<parenleft> <2> <KP_0> <parenright>", 0x2473)

-CheckCompUni("<parenleft> <2> <0> <parenright>", 0x2473)

-CheckCompUni("<parenleft> <A> <parenright>", 0x24B6)

-CheckCompUni("<parenleft> <B> <parenright>", 0x24B7)

-CheckCompUni("<parenleft> <C> <parenright>", 0x24B8)

-CheckCompUni("<parenleft> <D> <parenright>", 0x24B9)

-CheckCompUni("<parenleft> <E> <parenright>", 0x24BA)

-CheckCompUni("<parenleft> <F> <parenright>", 0x24BB)

-CheckCompUni("<parenleft> <G> <parenright>", 0x24BC)

-CheckCompUni("<parenleft> <H> <parenright>", 0x24BD)

-CheckCompUni("<parenleft> <I> <parenright>", 0x24BE)

-CheckCompUni("<parenleft> <J> <parenright>", 0x24BF)

-CheckCompUni("<parenleft> <K> <parenright>", 0x24C0)

-CheckCompUni("<parenleft> <L> <parenright>", 0x24C1)

-CheckCompUni("<parenleft> <M> <parenright>", 0x24C2)

-CheckCompUni("<parenleft> <N> <parenright>", 0x24C3)

-CheckCompUni("<parenleft> <O> <parenright>", 0x24C4)

-CheckCompUni("<parenleft> <P> <parenright>", 0x24C5)

-CheckCompUni("<parenleft> <Q> <parenright>", 0x24C6)

-CheckCompUni("<parenleft> <R> <parenright>", 0x24C7)

-CheckCompUni("<parenleft> <S> <parenright>", 0x24C8)

-CheckCompUni("<parenleft> <T> <parenright>", 0x24C9)

-CheckCompUni("<parenleft> <U> <parenright>", 0x24CA)

-CheckCompUni("<parenleft> <V> <parenright>", 0x24CB)

-CheckCompUni("<parenleft> <W> <parenright>", 0x24CC)

-CheckCompUni("<parenleft> <X> <parenright>", 0x24CD)

-CheckCompUni("<parenleft> <Y> <parenright>", 0x24CE)

-CheckCompUni("<parenleft> <Z> <parenright>", 0x24CF)

-CheckCompUni("<parenleft> <a> <parenright>", 0x24D0)

-CheckCompUni("<parenleft> <b> <parenright>", 0x24D1)

-CheckCompUni("<parenleft> <c> <parenright>", 0x24D2)

-CheckCompUni("<parenleft> <d> <parenright>", 0x24D3)

-CheckCompUni("<parenleft> <e> <parenright>", 0x24D4)

-CheckCompUni("<parenleft> <f> <parenright>", 0x24D5)

-CheckCompUni("<parenleft> <g> <parenright>", 0x24D6)

-CheckCompUni("<parenleft> <h> <parenright>", 0x24D7)

-CheckCompUni("<parenleft> <i> <parenright>", 0x24D8)

-CheckCompUni("<parenleft> <j> <parenright>", 0x24D9)

-CheckCompUni("<parenleft> <k> <parenright>", 0x24DA)

-CheckCompUni("<parenleft> <l> <parenright>", 0x24DB)

-CheckCompUni("<parenleft> <m> <parenright>", 0x24DC)

-CheckCompUni("<parenleft> <n> <parenright>", 0x24DD)

-CheckCompUni("<parenleft> <o> <parenright>", 0x24DE)

-CheckCompUni("<parenleft> <p> <parenright>", 0x24DF)

-CheckCompUni("<parenleft> <q> <parenright>", 0x24E0)

-CheckCompUni("<parenleft> <r> <parenright>", 0x24E1)

-CheckCompUni("<parenleft> <s> <parenright>", 0x24E2)

-CheckCompUni("<parenleft> <t> <parenright>", 0x24E3)

-CheckCompUni("<parenleft> <u> <parenright>", 0x24E4)

-CheckCompUni("<parenleft> <v> <parenright>", 0x24E5)

-CheckCompUni("<parenleft> <w> <parenright>", 0x24E6)

-CheckCompUni("<parenleft> <x> <parenright>", 0x24E7)

-CheckCompUni("<parenleft> <y> <parenright>", 0x24E8)

-CheckCompUni("<parenleft> <z> <parenright>", 0x24E9)

-CheckCompUni("<parenleft> <KP_0> <parenright>", 0x24EA)

-CheckCompUni("<parenleft> <0> <parenright>", 0x24EA)

-CheckCompUni("<numbersign> <f>", 0x266E)

-CheckCompUni("<U2add> <U0338>", 0x2ADC)

-CheckCompUni("<quotedbl> <backslash>", 0x301D)

-CheckCompUni("<quotedbl> <slash>", 0x301E)

-CheckCompUni("<parenleft> <KP_2> <KP_1> <parenright>", 0x3251)

-CheckCompUni("<parenleft> <KP_2> <1> <parenright>", 0x3251)

-CheckCompUni("<parenleft> <KP_Space> <KP_1> <parenright>", 0x3251)

-CheckCompUni("<parenleft> <KP_Space> <1> <parenright>", 0x3251)

-CheckCompUni("<parenleft> <2> <KP_1> <parenright>", 0x3251)

-CheckCompUni("<parenleft> <2> <1> <parenright>", 0x3251)

-CheckCompUni("<parenleft> <KP_2> <KP_2> <parenright>", 0x3252)

-CheckCompUni("<parenleft> <KP_2> <KP_Space> <parenright>", 0x3252)

-CheckCompUni("<parenleft> <KP_2> <2> <parenright>", 0x3252)

-CheckCompUni("<parenleft> <KP_Space> <KP_2> <parenright>", 0x3252)

-CheckCompUni("<parenleft> <KP_Space> <KP_Space> <parenright>", 0x3252)

-CheckCompUni("<parenleft> <KP_Space> <2> <parenright>", 0x3252)

-CheckCompUni("<parenleft> <2> <KP_2> <parenright>", 0x3252)

-CheckCompUni("<parenleft> <2> <KP_Space> <parenright>", 0x3252)

-CheckCompUni("<parenleft> <2> <2> <parenright>", 0x3252)

-CheckCompUni("<parenleft> <KP_2> <KP_3> <parenright>", 0x3253)

-CheckCompUni("<parenleft> <KP_2> <3> <parenright>", 0x3253)

-CheckCompUni("<parenleft> <KP_Space> <KP_3> <parenright>", 0x3253)

-CheckCompUni("<parenleft> <KP_Space> <3> <parenright>", 0x3253)

-CheckCompUni("<parenleft> <2> <KP_3> <parenright>", 0x3253)

-CheckCompUni("<parenleft> <2> <3> <parenright>", 0x3253)

-CheckCompUni("<parenleft> <KP_2> <KP_4> <parenright>", 0x3254)

-CheckCompUni("<parenleft> <KP_2> <4> <parenright>", 0x3254)

-CheckCompUni("<parenleft> <KP_Space> <KP_4> <parenright>", 0x3254)

-CheckCompUni("<parenleft> <KP_Space> <4> <parenright>", 0x3254)

-CheckCompUni("<parenleft> <2> <KP_4> <parenright>", 0x3254)

-CheckCompUni("<parenleft> <2> <4> <parenright>", 0x3254)

-CheckCompUni("<parenleft> <KP_2> <KP_5> <parenright>", 0x3255)

-CheckCompUni("<parenleft> <KP_2> <5> <parenright>", 0x3255)

-CheckCompUni("<parenleft> <KP_Space> <KP_5> <parenright>", 0x3255)

-CheckCompUni("<parenleft> <KP_Space> <5> <parenright>", 0x3255)

-CheckCompUni("<parenleft> <2> <KP_5> <parenright>", 0x3255)

-CheckCompUni("<parenleft> <2> <5> <parenright>", 0x3255)

-CheckCompUni("<parenleft> <KP_2> <KP_6> <parenright>", 0x3256)

-CheckCompUni("<parenleft> <KP_2> <6> <parenright>", 0x3256)

-CheckCompUni("<parenleft> <KP_Space> <KP_6> <parenright>", 0x3256)

-CheckCompUni("<parenleft> <KP_Space> <6> <parenright>", 0x3256)

-CheckCompUni("<parenleft> <2> <KP_6> <parenright>", 0x3256)

-CheckCompUni("<parenleft> <2> <6> <parenright>", 0x3256)

-CheckCompUni("<parenleft> <KP_2> <KP_7> <parenright>", 0x3257)

-CheckCompUni("<parenleft> <KP_2> <7> <parenright>", 0x3257)

-CheckCompUni("<parenleft> <KP_Space> <KP_7> <parenright>", 0x3257)

-CheckCompUni("<parenleft> <KP_Space> <7> <parenright>", 0x3257)

-CheckCompUni("<parenleft> <2> <KP_7> <parenright>", 0x3257)

-CheckCompUni("<parenleft> <2> <7> <parenright>", 0x3257)

-CheckCompUni("<parenleft> <KP_2> <KP_8> <parenright>", 0x3258)

-CheckCompUni("<parenleft> <KP_2> <8> <parenright>", 0x3258)

-CheckCompUni("<parenleft> <KP_Space> <KP_8> <parenright>", 0x3258)

-CheckCompUni("<parenleft> <KP_Space> <8> <parenright>", 0x3258)

-CheckCompUni("<parenleft> <2> <KP_8> <parenright>", 0x3258)

-CheckCompUni("<parenleft> <2> <8> <parenright>", 0x3258)

-CheckCompUni("<parenleft> <KP_2> <KP_9> <parenright>", 0x3259)

-CheckCompUni("<parenleft> <KP_2> <9> <parenright>", 0x3259)

-CheckCompUni("<parenleft> <KP_Space> <KP_9> <parenright>", 0x3259)

-CheckCompUni("<parenleft> <KP_Space> <9> <parenright>", 0x3259)

-CheckCompUni("<parenleft> <2> <KP_9> <parenright>", 0x3259)

-CheckCompUni("<parenleft> <2> <9> <parenright>", 0x3259)

-CheckCompUni("<parenleft> <KP_3> <KP_0> <parenright>", 0x325A)

-CheckCompUni("<parenleft> <KP_3> <0> <parenright>", 0x325A)

-CheckCompUni("<parenleft> <3> <KP_0> <parenright>", 0x325A)

-CheckCompUni("<parenleft> <3> <0> <parenright>", 0x325A)

-CheckCompUni("<parenleft> <KP_3> <KP_1> <parenright>", 0x325B)

-CheckCompUni("<parenleft> <KP_3> <1> <parenright>", 0x325B)

-CheckCompUni("<parenleft> <3> <KP_1> <parenright>", 0x325B)

-CheckCompUni("<parenleft> <3> <1> <parenright>", 0x325B)

-CheckCompUni("<parenleft> <KP_3> <KP_2> <parenright>", 0x325C)

-CheckCompUni("<parenleft> <KP_3> <KP_Space> <parenright>", 0x325C)

-CheckCompUni("<parenleft> <KP_3> <2> <parenright>", 0x325C)

-CheckCompUni("<parenleft> <3> <KP_2> <parenright>", 0x325C)

-CheckCompUni("<parenleft> <3> <KP_Space> <parenright>", 0x325C)

-CheckCompUni("<parenleft> <3> <2> <parenright>", 0x325C)

-CheckCompUni("<parenleft> <KP_3> <KP_3> <parenright>", 0x325D)

-CheckCompUni("<parenleft> <KP_3> <3> <parenright>", 0x325D)

-CheckCompUni("<parenleft> <3> <KP_3> <parenright>", 0x325D)

-CheckCompUni("<parenleft> <3> <3> <parenright>", 0x325D)

-CheckCompUni("<parenleft> <KP_3> <KP_4> <parenright>", 0x325E)

-CheckCompUni("<parenleft> <KP_3> <4> <parenright>", 0x325E)

-CheckCompUni("<parenleft> <3> <KP_4> <parenright>", 0x325E)

-CheckCompUni("<parenleft> <3> <4> <parenright>", 0x325E)

-CheckCompUni("<parenleft> <KP_3> <KP_5> <parenright>", 0x325F)

-CheckCompUni("<parenleft> <KP_3> <5> <parenright>", 0x325F)

-CheckCompUni("<parenleft> <3> <KP_5> <parenright>", 0x325F)

-CheckCompUni("<parenleft> <3> <5> <parenright>", 0x325F)

-CheckCompUni("<parenleft> <KP_3> <KP_6> <parenright>", 0x32B1)

-CheckCompUni("<parenleft> <KP_3> <6> <parenright>", 0x32B1)

-CheckCompUni("<parenleft> <3> <KP_6> <parenright>", 0x32B1)

-CheckCompUni("<parenleft> <3> <6> <parenright>", 0x32B1)

-CheckCompUni("<parenleft> <KP_3> <KP_7> <parenright>", 0x32B2)

-CheckCompUni("<parenleft> <KP_3> <7> <parenright>", 0x32B2)

-CheckCompUni("<parenleft> <3> <KP_7> <parenright>", 0x32B2)

-CheckCompUni("<parenleft> <3> <7> <parenright>", 0x32B2)

-CheckCompUni("<parenleft> <KP_3> <KP_8> <parenright>", 0x32B3)

-CheckCompUni("<parenleft> <KP_3> <8> <parenright>", 0x32B3)

-CheckCompUni("<parenleft> <3> <KP_8> <parenright>", 0x32B3)

-CheckCompUni("<parenleft> <3> <8> <parenright>", 0x32B3)

-CheckCompUni("<parenleft> <KP_3> <KP_9> <parenright>", 0x32B4)

-CheckCompUni("<parenleft> <KP_3> <9> <parenright>", 0x32B4)

-CheckCompUni("<parenleft> <3> <KP_9> <parenright>", 0x32B4)

-CheckCompUni("<parenleft> <3> <9> <parenright>", 0x32B4)

-CheckCompUni("<parenleft> <KP_4> <KP_0> <parenright>", 0x32B5)

-CheckCompUni("<parenleft> <KP_4> <0> <parenright>", 0x32B5)

-CheckCompUni("<parenleft> <4> <KP_0> <parenright>", 0x32B5)

-CheckCompUni("<parenleft> <4> <0> <parenright>", 0x32B5)

-CheckCompUni("<parenleft> <KP_4> <KP_1> <parenright>", 0x32B6)

-CheckCompUni("<parenleft> <KP_4> <1> <parenright>", 0x32B6)

-CheckCompUni("<parenleft> <4> <KP_1> <parenright>", 0x32B6)

-CheckCompUni("<parenleft> <4> <1> <parenright>", 0x32B6)

-CheckCompUni("<parenleft> <KP_4> <KP_2> <parenright>", 0x32B7)

-CheckCompUni("<parenleft> <KP_4> <KP_Space> <parenright>", 0x32B7)

-CheckCompUni("<parenleft> <KP_4> <2> <parenright>", 0x32B7)

-CheckCompUni("<parenleft> <4> <KP_2> <parenright>", 0x32B7)

-CheckCompUni("<parenleft> <4> <KP_Space> <parenright>", 0x32B7)

-CheckCompUni("<parenleft> <4> <2> <parenright>", 0x32B7)

-CheckCompUni("<parenleft> <KP_4> <KP_3> <parenright>", 0x32B8)

-CheckCompUni("<parenleft> <KP_4> <3> <parenright>", 0x32B8)

-CheckCompUni("<parenleft> <4> <KP_3> <parenright>", 0x32B8)

-CheckCompUni("<parenleft> <4> <3> <parenright>", 0x32B8)

-CheckCompUni("<parenleft> <KP_4> <KP_4> <parenright>", 0x32B9)

-CheckCompUni("<parenleft> <KP_4> <4> <parenright>", 0x32B9)

-CheckCompUni("<parenleft> <4> <KP_4> <parenright>", 0x32B9)

-CheckCompUni("<parenleft> <4> <4> <parenright>", 0x32B9)

-CheckCompUni("<parenleft> <KP_4> <KP_5> <parenright>", 0x32BA)

-CheckCompUni("<parenleft> <KP_4> <5> <parenright>", 0x32BA)

-CheckCompUni("<parenleft> <4> <KP_5> <parenright>", 0x32BA)

-CheckCompUni("<parenleft> <4> <5> <parenright>", 0x32BA)

-CheckCompUni("<parenleft> <KP_4> <KP_6> <parenright>", 0x32BB)

-CheckCompUni("<parenleft> <KP_4> <6> <parenright>", 0x32BB)

-CheckCompUni("<parenleft> <4> <KP_6> <parenright>", 0x32BB)

-CheckCompUni("<parenleft> <4> <6> <parenright>", 0x32BB)

-CheckCompUni("<parenleft> <KP_4> <KP_7> <parenright>", 0x32BC)

-CheckCompUni("<parenleft> <KP_4> <7> <parenright>", 0x32BC)

-CheckCompUni("<parenleft> <4> <KP_7> <parenright>", 0x32BC)

-CheckCompUni("<parenleft> <4> <7> <parenright>", 0x32BC)

-CheckCompUni("<parenleft> <KP_4> <KP_8> <parenright>", 0x32BD)

-CheckCompUni("<parenleft> <KP_4> <8> <parenright>", 0x32BD)

-CheckCompUni("<parenleft> <4> <KP_8> <parenright>", 0x32BD)

-CheckCompUni("<parenleft> <4> <8> <parenright>", 0x32BD)

-CheckCompUni("<parenleft> <KP_4> <KP_9> <parenright>", 0x32BE)

-CheckCompUni("<parenleft> <KP_4> <9> <parenright>", 0x32BE)

-CheckCompUni("<parenleft> <4> <KP_9> <parenright>", 0x32BE)

-CheckCompUni("<parenleft> <4> <9> <parenright>", 0x32BE)

-CheckCompUni("<parenleft> <KP_5> <KP_0> <parenright>", 0x32BF)

-CheckCompUni("<parenleft> <KP_5> <0> <parenright>", 0x32BF)

-CheckCompUni("<parenleft> <5> <KP_0> <parenright>", 0x32BF)

-CheckCompUni("<parenleft> <5> <0> <parenright>", 0x32BF)

-CheckCompUni("<apostrophe> <U>", 0xDA)

-CheckCompUni("<acute> <U>", 0xDA)

-CheckCompUni("<apostrophe> <u>", 0xFA)

-CheckCompUni("<acute> <u>", 0xFA)

-CheckCompUni("<b> <U>", 0x16C)

-CheckCompUni("<U> <U>", 0x16C)

-CheckCompUni("<b> <u>", 0x16D)

-CheckCompUni("<U> <u>", 0x16D)

-CheckCompUni("<asciicircum> <U>", 0xDB)

-CheckCompUni("<asciicircum> <u>", 0xFB)

-CheckCompUni("<quotedbl> <U>", 0xDC)

-CheckCompUni("<quotedbl> <u>", 0xFC)

-CheckCompUni("<equal> <U>", 0x170)

-CheckCompUni("<equal> <u>", 0x171)

-CheckCompUni("<grave> <U>", 0xD9)

-CheckCompUni("<grave> <u>", 0xF9)

-CheckCompUni("<underscore> <U>", 0x16A)

-CheckCompUni("<macron> <U>", 0x16A)

-CheckCompUni("<underscore> <u>", 0x16B)

-CheckCompUni("<macron> <u>", 0x16B)

-CheckCompUni("<semicolon> <U>", 0x172)

-CheckCompUni("<semicolon> <u>", 0x173)

-CheckCompUni("<o> <U>", 0x16E)

-CheckCompUni("<o> <u>", 0x16F)

-CheckCompUni("<asciitilde> <U>", 0x168)

-CheckCompUni("<asciitilde> <u>", 0x169)

-CheckCompUni("<equal> <W>", 0x20A9)

-CheckCompUni("<W> <equal>", 0x20A9)

-CheckCompUni("<apostrophe> <Y>", 0xDD)

-CheckCompUni("<acute> <Y>", 0xDD)

-CheckCompUni("<apostrophe> <y>", 0xFD)

-CheckCompUni("<acute> <y>", 0xFD)

-CheckCompUni("<quotedbl> <Y>", 0x178)

-CheckCompUni("<quotedbl> <y>", 0xFF)

-CheckCompUni("<equal> <Y>", 0xA5)

-CheckCompUni("<Y> <equal>", 0xA5)

-CheckCompUni("<period> <Z>", 0x17B)

-CheckCompUni("<period> <z>", 0x17C)

-CheckCompUni("<apostrophe> <Z>", 0x179)

-CheckCompUni("<acute> <Z>", 0x179)

-CheckCompUni("<apostrophe> <z>", 0x17A)

-CheckCompUni("<acute> <z>", 0x17A)

-CheckCompUni("<c> <Z>", 0x17D)

-CheckCompUni("<c> <z>", 0x17E)

-}

diff --git a/windows/autohotkey/Source/Global-Part.ahk b/windows/autohotkey/Source/Global-Part.ahk
deleted file mode 100644
index 03ef728..0000000
--- a/windows/autohotkey/Source/Global-Part.ahk
+++ /dev/null
@@ -1,339 +0,0 @@
-/******************

-* Initialisierung *

-*******************

-*/

-DeadKey := ""

-CompKey := ""

-PriorDeadKey := ""

-PriorCompKey := ""

-Ebene12 = 0

-noCaps = 0

-isFurtherCompkey = 0

-

-EbeneAktualisieren()

-SetBatchLines -1

-SetCapsLockState Off

-KeyboardLED(4, "off")

-SetNumLockState Off

-SetScrollLockState Off

-

-name=Neo 2.0 (%A_ScriptName%) ($Revision$)

-enable=Aktiviere %name%

-disable=Deaktiviere %name%

-#usehook on

-#singleinstance force

-#LTrim ; Quelltext kann eingerückt werden

-Process,Priority,,High

-SendMode Input  

-

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

-* Verzeichnisse *

-*****************

-*/

-; Setzt den Pfad zu einem temporären Verzeichnis

-EnvGet,WindowsEnvTempFolder,TEMP

-ResourceFolder = %WindowsEnvTempFolder%\NEO2

-FileCreateDir,%ResourceFolder%

-

-; Setzt den Pfad zu den NEO-Anwendungsdateien

-EnvGet,WindowsEnvAppDataFolder,APPDATA

-ApplicationFolder = %WindowsEnvAppDataFolder%\NEO2

-FileCreateDir,%ApplicationFolder%

-ini = %ApplicationFolder%\NEO2.ini

-

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

-* Globale Schalter *

-********************

-*/

-; Im folgenden gilt (soweit nicht anders angegeben) Ja = 1, Nein = 0:

-

-; Sollen die Bilder für die Bildschirmtastatur in die compilierte EXE-Datei miteingebunden werden? 

-; (Nachteil: grössere Dateigrösse, Vorteil: Referenz für Anfänger stets einfach verfügbar)

-bildschirmTastaturEinbinden := 1

-

-; Syntaxhinweis: IniRead, Variable, InputFilename, Section, Key [, DefaultValue]

-

-; Soll der Treiber im Einhandmodus betrieben werden?

-IniRead,einHandNeo,%ini%,Global,einHandNeo,0

-

-; Soll der Lernmodus aktiviert werden?

-IniRead,lernModus,%ini%,Global,lernModus,0

-

-; Soll mit einer MsgBox explizit auf das Ein- und Ausschalten des Mod4-Locks hingewiesen werden?

-IniRead,zeigeLockBox,%ini%,Global,zeigeLockBox,1

-

-; Soll aktivierter Mod4-Lock über die Rollen-LED des Keybord angezeigt werden (analog zu CapsLock)?

-IniRead,UseMod4Light,%ini%,Global,UseMod4Light,1

-

-; Soll Lang-s auf s, s auf ß und ß auf Lang-s gelegt (bzw. vertauscht) werden?

-IniRead,LangSTastatur,%ini%,Global,LangSTastatur,0

-If LangSTastatur

-  KeyboardLED(2,"on")

-

-; Sollen tote Tasten blind angezeigt werden?

-IniRead,DeadSilence,%ini%,Global,DeadSilence,1

-

-;Sollen Compose-Tasten blind angezeigt werden?

-IniRead,DeadCompose,%ini%,Global,DeadCompose,1

-

-;Soll der Mod2Lock auch auf die Akzente, die Ziffernreihe und das Numpad angewandt werden?

-IniRead,striktesMod2Lock,%ini%,Global,striktesMod2Lock,0

-

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

-* Resourcen-Verwaltung *

-************************

-*/

-if (FileExist("ResourceFolder") <> false) {

-  ; Versuche, alle möglicherweise in die EXE eingebundenen Dateien zu extrahieren 

-  FileInstall,neo.ico,%ResourceFolder%\neo.ico,1

-  FileInstall,neo_disabled.ico,%ResourceFolder%\neo_disabled.ico,1

-  iconBenutzen=1

-  if (bildschirmTastaturEinbinden = 1) {

-    FileInstall,ebene1.png,%ResourceFolder%\ebene1.png,1

-    FileInstall,ebene2.png,%ResourceFolder%\ebene2.png,1

-    FileInstall,ebene3.png,%ResourceFolder%\ebene3.png,1

-    FileInstall,ebene4.png,%ResourceFolder%\ebene4.png,1

-    FileInstall,ebene5.png,%ResourceFolder%\ebene5.png,1

-    FileInstall,ebene6.png,%ResourceFolder%\ebene6.png,1

-    zeigeBildschirmTastatur = 1

-  }

-}

-

-; Benutze die Dateien auch dann, wenn sie eventuell im aktuellen Verzeichnis vorhanden sind 

-if (FileExist("ebene1.png")&&FileExist("ebene2.png")&&FileExist("ebene3.png")&&FileExist("ebene4.png")&&FileExist("ebene5.png")&&FileExist("ebene6.png"))

-  zeigeBildschirmTastatur = 1

-if (FileExist("neo.ico")&&FileExist("neo_disabled.ico"))

-  iconBenutzen=1

-

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

-* Überprüfung auf deutsches Tastaturlayout *

-********************************************

-*/

-regread,inputlocale,HKEY_CURRENT_USER,Keyboard Layout\Preload,1

-regread,inputlocalealias,HKEY_CURRENT_USER,Keyboard Layout\Substitutes,%inputlocale%

-if (inputlocalealias<>inputlocale=%inputlocalealias% and inputlocale<>00000407) {

-  suspend   

-  regread,inputlocale,HKEY_LOCAL_MACHINE,SYSTEM\CurrentControlSet\Control\Keyboard Layouts\%inputlocale%,Layout Text

-  msgbox, 48, Warnung!,

-    (

-    Nicht kompatibles Tastaturlayout:   

-    `t%inputlocale%   

-    `nDas deutsche QWERTZ muss als Standardlayout eingestellt  

-    sein, damit %name% wie erwartet funktioniert.   

-    `nÄndern Sie die Tastatureinstellung unter 

-    `tSystemsteuerung   

-    `t-> Regions- und Sprachoptionen   

-    `t-> Sprachen 

-    `t-> Details...   `n

-    )

-  exitapp

-}

-

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

-* Menü des Systray-Icons *

-**************************

-*/

-if (iconBenutzen)

-  menu,tray,icon,%ResourceFolder%\neo.ico,,1

-menu,tray,nostandard

-menu,tray,add,Öffnen,open

-  menu,helpmenu,add,About,about

-  menu,helpmenu,add,Autohotkey-Hilfe,help

-  menu,helpmenu,add

-  menu,helpmenu,add,http://autohotkey.com/,autohotkey

-  menu,helpmenu,add,http://www.neo-layout.org/,neo

-menu,tray,add,Hilfe,:helpmenu

-menu,tray,add

-menu,tray,add,%disable%,togglesuspend

-menu,tray,add

-menu,tray,add,Bearbeiten,edit

-menu,tray,add,Neu Laden,reload

-menu,tray,add

-menu,tray,add,Nicht im Systray anzeigen,hide

-menu,tray,add,%name% beenden,exitprogram

-menu,tray,default,%disable%

-menu,tray,tip,%name%

-

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

-* lernModus Konfiguration *

-* nur relevant wenn       *

-* lernModus = 1           *

-* Strg+Komma schaltet um  *

-***************************

-*/

-; 0 = aus, 1 = an

-

-; die Nachfolgenden sind nützlich um sich die Qwertz-Tasten abzugewöhnen, da alle auf der 4. Ebene vorhanden.

-lernModus_std_Return = 0

-lernModus_std_Backspace = 0

-lernModus_std_PgUp = 0

-lernModus_std_PgDn = 0

-lernModus_std_Einf = 0

-lernModus_std_Entf = 0

-lernModus_std_Pos0 = 0

-lernModus_std_Ende = 0

-lernModus_std_Hoch = 0

-lernModus_std_Runter = 0

-lernModus_std_Links = 0

-lernModus_std_Rechts = 0

-lernModus_std_ZahlenReihe = 0

-

-; im folgenden kann man auch noch ein paar Tasten der 4. Ebene deaktivieren

-; nützlich um sich zu zwingen, richtig zu schreiben

-lernModus_neo_Backspace = 0

-lernModus_neo_Entf = 1

-

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

-* EinHandNeo                *

-* Umschalten mit Strg+Punkt *

-*****************************

-*/

-spacepressed := 0

-keypressed := 0

-

-; Reihe 1

-gespiegelt_7 = neo_6

-gespiegelt_8 = neo_5

-gespiegelt_9 = neo_4

-gespiegelt_0 = neo_3

-gespiegelt_strich = neo_2

-gespiegelt_tot2 = neo_1

-

-; Reihe 2

-gespiegelt_k = neo_w

-gespiegelt_h = neo_c

-gespiegelt_g = neo_l

-gespiegelt_f = neo_v

-gespiegelt_q = neo_x

-gespiegelt_sz = neo_tab 

-gespiegelt_tot3 = neo_tot1

-

-; Reihe 3

-gespiegelt_s = neo_o

-gespiegelt_n = neo_e

-gespiegelt_r = neo_a

-gespiegelt_t = neo_i

-gespiegelt_d = neo_u

-

-; Reihe 4

-gespiegelt_b = neo_z

-gespiegelt_m = neo_p

-gespiegelt_komma = neo_ä

-gespiegelt_punkt = neo_ö

-gespiegelt_j = neo_ü

-

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

-* Tastenkombinationen *

-***********************

-*/

-;Blinde/Sichtbare Tote Tasten

-*F9::

-  if isMod4pressed()

-    DeadSilence := !DeadSilence

-  else send {blind}{F9}

-return

-

-;Blinde/Sichtbare Compose

-*F10::

-  if isMod4pressed()

-    DeadCompose := !DeadCompose

-  else send {blind}{F10}

-return

-

-;Lang-s-Tastatur:

-*F11::

-  if isMod4pressed() {

-    LangSTastatur := !LangSTastatur

-    if LangSTastatur

-      KeyboardLED(2,"on")

-    else KeyboardLED(2,"off")

-  } else send {blind}{F11}

-return

-

-;Alle Modi und Locks in den Normalzustand versetzen, bzw. Skript neu laden:

-*Esc::

-  if isMod4pressed()

-    reload

-  else send {blind}{Esc}

-return

-

-*pause::

-Suspend, Permit

-  if isShiftpressed()

-    goto togglesuspend

-  else send {blind}{pause}

-return

-

-^,::lernModus := !lernModus

-

-^.::einHandNeo := !einHandNeo

-

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

-* Menüfunktionen *

-******************

-*/

-togglesuspend:

-  if A_IsSuspended {

-    menu,tray,rename,%enable%,%disable%

-    menu,tray,tip,%name%

-    if (iconBenutzen)

-      menu,tray,icon,%ResourceFolder%\neo.ico,,1

-    suspend,off ; Schaltet Suspend aus -> NEO

-  } else {

-    menu,tray,rename,%disable%, %enable%

-    menu,tray,tip,%name% : Deaktiviert

-    if (iconBenutzen)

-      menu,tray,icon, %ResourceFolder%\neo_disabled.ico,,1

-    suspend,on ; Schaltet Suspend ein -> QWERTZ

-  } return

-

-help:

-  Run, %A_WinDir%\hh mk:@MSITStore:autohotkey.chm

-return

-

-about:

-  msgbox, 64, %name% – Ergonomische Tastaturbelegung, 

-  (

-  %name% 

-  `nDas Neo-Layout ersetzt das übliche deutsche 

-  Tastaturlayout mit der Alternative Neo, 

-  beschrieben auf http://neo-layout.org/. 

-  `nDazu sind keine Administratorrechte nötig. 

-  `nWenn Autohotkey aktiviert ist, werden alle Tastendrucke 

-  abgefangen und statt dessen eine Übersetzung weitergeschickt. 

-  `nDies geschieht transparent für den Anwender, 

-  es muss nichts installiert werden. 

-  `nDie Zeichenübersetzung kann leicht über das Icon im 

-  Systemtray deaktiviert werden.  `n

-  )

-return

-

-neo:

-  run http://neo-layout.org/

-return

-

-autohotkey:

-  run http://autohotkey.com/

-return

-

-open:

-  ListLines ; shows the Autohotkey window

-return

-

-edit:

-  edit

-return

-

-reload:

-  Reload

-return

-

-hide:

-  menu, tray, noicon

-return

-

-exitprogram:

-  exitapp

-return

-

-

diff --git a/windows/autohotkey/Source/Keys-DeadKeys.ahk b/windows/autohotkey/Source/Keys-DeadKeys.ahk
deleted file mode 100644
index 6a8a697..0000000
--- a/windows/autohotkey/Source/Keys-DeadKeys.ahk
+++ /dev/null
@@ -1,76 +0,0 @@
-neo_tot1:

-  noCaps = 1

-  EbeneAktualisieren()

-  if (Ebene = 1) and !CheckDeadUni("c1",0x0302)      ; Zirkumflex, tot

-

-    deadUni(0x02C6, "dead_circumflex", "c1")

-

-  else if (Ebene = 2) and !CheckDeadUni("c2",0x0303) ; Tilde, tot

-

-    deadUni(0x02DC, "dead_tilde", "c2")

-

-  else if (Ebene = 3) and !CheckDeadUni("c3",0x030A) ; Ring, tot

-

-    deadUni(0x02DA, "dead_breve", "c3")

-

-  else if (Ebene = 4) and !CheckDeadUni("c4",0x030C) ; Caron, tot

-

-    deadUni(0x02C7, "dead_caron", "c4")

-

-  else if (Ebene = 5) and !CheckDeadUni("c5",0x0306) ; Brevis, tot

-

-    deadUni(0x02D8, "dead_breve", "c5")

-

-  else if (Ebene = 6) and !CheckDeadUni("c6",0x0304) ; Makron, tot

-

-    deadAsc("¯", "dead_macron", "c6")

-return

-

-neo_tot2:

-  noCaps = 1

-  EbeneAktualisieren()

-  if (Ebene = 1) and !CheckDeadUni("g1",0x0300)      ; Gravis, tot

-

-    deadAsc("``{space}", "dead_grave", "g1")

-

-  else if (Ebene = 3) and !CheckDeadUni("g3",0x0308) ; Diärese, tot

-

-    deadUni(0x00A8, "dead_diaeresis", "g3")

-

-  else if (Ebene = 4) and !CheckDeadUni("g4",0x030F) ; Doppelgravis, tot

-

-    deadUni(0x02F5, "dead_doublegrave", "g4")

-

-  else if (Ebene = 5) and !CheckDeadUni("g5",0x0485) ; Spiritus asper, tot

-

-    deadUni(0x1FFE, "U1FFE", "g5")

-return

-

-neo_tot3:

-  noCaps = 1

-  EbeneAktualisieren()

-  if (Ebene = 1) and !CheckDeadUni("a1",0x0301)      ; Akut, tot

-

-    deadAsc("{´}{space}", "dead_acute", "a1")

-

-  else if (Ebene = 2) and !CheckDeadUni("a2",0x0327) ; Cedille, tot

-

-    deadAsc("¸", "dead_cedilla", "a2")

-

-  else if (Ebene = 3) and !CheckDeadUni("a3",0x0337) ; Strich, tot

-

-    deadUni(0x002F, "dead_stroke", "a3")

-

-  else if (Ebene = 4) and !CheckDeadUni("a4",0x0338) ; Doppelakut, tot

-

-    deadUni(0x02DD, "dead_doubleacute", "a4")

-

-  else if (Ebene = 5) and !CheckDeadUni("a5",0x0486) ; Spiritus lenis, tot

-

-    deadUni(0x1FBF, "U1FBF", "a5")

-

-  else if (Ebene = 6) and !CheckDeadUni("a6",0x0307) ; Punkt darüber, tot

-

-    deadUni(0x02D9, "dead_abovedot", "a6")

-return

-

diff --git a/windows/autohotkey/Source/Keys-Neo.ahk b/windows/autohotkey/Source/Keys-Neo.ahk
deleted file mode 100644
index cd610e7..0000000
--- a/windows/autohotkey/Source/Keys-Neo.ahk
+++ /dev/null
@@ -1,544 +0,0 @@
-neo_a:

-  EbeneAktualisieren()

-  if (((Ebene = 2) and !(CheckDeadUni("a5g1",0x1F02)

-                      or CheckDeadUni("g5g1",0x1F03)))

-       or (Ebene12 and !(CheckDeadUni12("c1",0x00E2,0x00C2)

-                      or CheckDeadUni12("c2",0x00E3,0x00C3)

-                      or CheckDeadAsc12("c3","å","Å")

-                      or CheckDeadUni12("c4",0x01CE,0x01CD)

-                      or CheckDeadUni12("c5",0x0103,0x0102)

-                      or CheckDeadUni12("c6",0x0101,0x0100)

-                      or CheckDeadUni12("g1",0x00E0,0x00C0)

-                      or CheckDeadAsc12("g3","ä","Ä")

-                      or CheckDeadUni12("g4",0x0201,0x0200)

-                      or CheckDeadUni12("a1",0x00E1,0x00C1)

-                      or CheckDeadUni12("a2",0x0105,0x0104)

-                      or CheckDeadUni12("a3",0x2C65,0x023A)

-                      or CheckDeadUni12("a6",0x0227,0x0226))))

-    OutputChar12("a","A","a","A")

-  else if (Ebene = 3)

-    OutputChar("{{}", "braceleft")

-  else if (Ebene = 4)

-    OutputChar("{Down}", "Down")

-  else if (Ebene = 5 and !(CheckDeadUni("c1",0x1FB6)

-                        or CheckDeadUni("c5",0x1FB0)

-                        or CheckDeadUni("c6",0x1FB1)

-                        or CheckDeadUni("g1",0x1F70)

-                        or CheckDeadUni("g5",0x1F01)

-                        or CheckDeadUni("a1",0x03AC)

-                        or CheckDeadUni("a2",0x1FB3)

-                        or CheckDeadUni("a5",0x1F00)))

-    SendUnicodeChar(0x03B1, "Greek_alpha") ; alpha

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2200, "U2200") ; für alle

-return

-

-neo_b:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("c6",0x1E07,0x1E06)

-                 or CheckDeadUni12("a6",0x1E03,0x1E02)))

-    OutputChar12("b","B","b","B")

-  else if (Ebene = 3)

-    if isMod2Locked

-      OutputChar("{Shift Up}{+}{Shift down}", "plus")

-    else OutputChar("{blind}{+}", "plus")

-  else if (Ebene = 4)

-    OutputChar(":", "colon")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03B2, "Greek_beta") ; beta

-  else if (Ebene = 6)

-    SendUnicodeChar(0x21D0, "U21D0") ; Doppelpfeil links

-return

-

-neo_c:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("c1",0x0109,0x0108)

-                 or CheckDeadUni12("c4",0x010D,0x010C)

-                 or CheckDeadUni12("a1",0x0107,0x0106)

-                 or CheckDeadUni12("a2",0x00E7,0x00E6)

-                 or CheckDeadUni12("a6",0x010B,0x010A)))

-    OutputChar12("c","C","c","C")

-  else if (Ebene = 3)

-    OutputChar("]", "bracketright")

-  else if (Ebene = 4) and (!lernModus or lernModus_neo_Entf)

-    OutputChar("{Del}", "Delete")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03C7, "Greek_chi") ; chi

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2102, "U2102") ; C (Komplexe Zahlen)]

-return

-

-neo_d:

-   EbeneAktualisieren()

-   if (Ebene12 and !(CheckDeadUni12("c1",0x1E13,0x1E12)

-                  or CheckDeadUni(  "c2",0x1D6D)

-                  or CheckDeadUni12("c4",0x010F,0x010E)

-                  or CheckDeadUni12("g3",0x1E0D,0x1E0C)

-                  or CheckDeadUni12("a1",0x00F0,0x00D0)

-                  or CheckDeadUni12("a2",0x1E11,0x1E10)

-                  or CheckDeadUni12("a3",0x0111,0x0110)

-                  or CheckDeadUni12("a6",0x1E0B,0x1E0A)))

-     OutputChar12("d","D","d","D")

-   else if (Ebene = 3)

-     OutputChar(":", "colon")

-   else if (Ebene = 4)

-     OutputChar("{NumpadDot}", "comma")

-   else if (Ebene = 5)

-      SendUnicodeChar(0x03B4, "Greek_delta") ; delta

-   else if (Ebene = 6)

-      SendUnicodeChar(0x0394, "Greek_DELTA") ; Delta

-return

-

-neo_e:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("c1",0x00EA,0x00CA)

-                 or CheckDeadUni12("c2",0x1EBD,0x1EBC)

-                 or CheckDeadUni12("c4",0x011B,0x011A)

-                 or CheckDeadUni12("c5",0x0115,0x0114)

-                 or CheckDeadUni12("c6",0x0113,0x0112)

-                 or CheckDeadUni12("g1",0x00E8,0x00C8)

-                 or CheckDeadAsc12("g3","ë","Ë")

-                 or CheckDeadUni12("g4",0x0205,0x0204)

-                 or CheckDeadUni12("a1",0x00E9,0x00C9)

-                 or CheckDeadUni12("a2",0x0119,0x0118)

-                 or CheckDeadUni12("a6",0x0117,0x0116)))

-    OutputChar12("e","E","e","E")

-  else if (Ebene = 3)

-    OutputChar("{}}", "braceright")

-  else if (Ebene = 4)

-    OutputChar("{Right}", "Right")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03B5, "Greek_epsilon") ; epsilon

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2203, "U2203") ; es existiert

-return

-

-neo_f:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("a6",0x1E1F,0x1E1E)))

-    OutputChar12("f","F","f","F")

-  else if ((Ebene = 3) and !(CheckDeadUni("c1",0x2259) ; entspricht

-                          or CheckDeadUni("c2",0x2245) ; ungefähr gleich

-                          or CheckDeadUni("c3",0x2257) ; ring equal to

-                          or CheckDeadUni("c4",0x225A) ; EQUIANGULAR TO

-                          or CheckDeadUni("c6",0x2261) ; identisch

-                          or CheckDeadUni("a3",0x2260))) ; ungleich

-    OutputChar("`=", "equal")

-  else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2079)

-                          or CheckDeadUni("a3",0x2089)))

-    OutputChar("{Numpad9}", "KP_9")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03C6, "Greek_phi") ; phi

-  else if (Ebene = 6)

-    SendUnicodeChar(0x03A6, "Greek_PHI") ; Phi

-return

-

-neo_g:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("c1",0x011D,0x011C)

-                 or CheckDeadUni12("c5",0x011F,0x011E)

-                 or CheckDeadUni12("a2",0x0123,0x0122)

-                 or CheckDeadUni12("a6",0x0121,0x0120)))

-    OutputChar12("g","G","g","G")

-  else if ((Ebene = 3) and !(CheckDeadUni("a3",0x2265))) ; größer gleich

-    OutputChar(">", "greater")

-  else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2078)

-                          or CheckDeadUni("a3",0x2088)))

-    OutputChar("{Numpad8}", "KP_8")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03B3, "Greek_gamma") ; gamma

-  else if (Ebene = 6)

-    SendUnicodeChar(0x0393, "Greek_GAMMA") ; Gamma

-return

-

-neo_h:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("c1",0x0125,0x0124)

-                 or CheckDeadUni12("a3",0x0127,0x0126)

-                 or CheckDeadUni12("a6",0x1E23,0x1E22)))

-    OutputChar12("h","H","h","H")

-  else if ((Ebene = 3) and !(CheckDeadUni("a3",0x2264))) ; kleiner gleich

-    OutputChar("<", "less")

-  else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2077)

-                          or CheckDeadUni("a3",0x2087)))

-    OutputChar("{Numpad7}", "KP_7")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03C8, "Greek_psi") ; psi

-  else if (Ebene = 6)

-    SendUnicodeChar(0x03A8, "Greek_PSI") ; Psi

-return

-

-neo_i:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("c1",0x00EE,0x00CE)

-                 or CheckDeadUni12("c2",0x0129,0x0128)

-                 or CheckDeadUni12("c4",0x01D0,0x01CF)

-                 or CheckDeadUni12("c5",0x012D,0x012C)

-                 or CheckDeadUni12("c6",0x012B,0x012A)

-                 or CheckDeadUni12("g1",0x00EC,0x00CC)

-                 or CheckDeadAsc12("g3","ï","Ï")

-                 or CheckDeadUni12("g4",0x0209,0x0208)

-                 or CheckDeadUni12("a1",0x00ED,0x00CD)

-                 or CheckDeadUni12("a2",0x012F,0x012E)

-                 or CheckDeadUni12("a3",0x0268,0x0197)

-                 or CheckDeadUni12("a6",0x0131,0x0130)))

-    OutputChar12("i","I","i","I")

-  else if (Ebene = 3)

-    OutputChar("`/", "slash")

-  else if (Ebene = 4)

-    OutputChar("{Left}", "Left")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03B9, "Greek_iota") ; iota

-  else if (Ebene = 6)

-    SendUnicodeChar(0x222B, "integral") ; integral

-return

-

-neo_j:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("c1",0x0135,0x0134)

-                 or CheckDeadUni(  "c4",0x01F0)

-                 or CheckDeadUni12("a3",0x0249,0x0248)))

-    OutputChar12("j","J","j","J")

-  else if (Ebene = 3)

-    OutputChar("`;", "semicolon")

-  else if (Ebene = 4)

-    OutputChar("`;", "semicolon")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03B8, "Greek_theta") ; theta

-  else if (Ebene = 6)

-    SendUnicodeChar(0x221D, "variation") ; proportional

-return

-

-neo_k:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("a2",0x0137,0x0136)

-                 or CheckDeadUni12("a6",0x1E33,0x1E32)))

-    OutputChar12("k","K","k","K")

-  else if (Ebene = 3)

-    OutputChar("{!}", "exclam")

-  else if (Ebene = 4)

-    OutputChar("¡", "exclamdown")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03F0, "U03F0") ; kappa symbol (varkappa)

-  else if (Ebene = 6)

-    SendUnicodeChar(0x221A, "radical") ; Wurzel

-return

-

-neo_l:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("c4",0x013E,0x013D)

-                 or CheckDeadUni12("a1",0x013A,0x0139)

-                 or CheckDeadUni12("a2",0x013C,0x013B)

-                 or CheckDeadUni12("a3",0x0142,0x0141)

-                 or CheckDeadUni12("a6",0x1E37,0x1E36)))

-    OutputChar12("l","L","l","L")

-  else if (Ebene = 3)

-    OutputChar("[", "bracketleft")

-  else if (Ebene = 4)

-    OutputChar("{Up}", "Up")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03BB, "Greek_lambda") ; lambda

-  else if (Ebene = 6)

-    SendUnicodeChar(0x039B, "Greek_LAMBDA") ; Lambda

-return

-

-neo_m:

-  EbeneAktualisieren()

-  if (Ebene12 and !CheckDeadUni12("a6",0x1E41,0x1E40))

-    OutputChar12("m","M","m","M")

-  else if (Ebene = 3)

-    OutputChar("`%", "percent")

-  else if ((Ebene = 4) and !(CheckDeadUni("c1",0x00B9)

-                          or CheckDeadUni("a3",0x2081)))

-    OutputChar("{Numpad1}", "KP_1")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03BC, "Greek_mu") ; griechisch mu, micro wäre 0x00B5

-  else if (Ebene = 6)

-    SendUnicodeChar(0x21D4, "ifonlyif") ; doppelter Doppelpfeil (genau dann wenn)

-return

-

-neo_n:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("c2",0x00F1,0x00D1)

-                 or CheckDeadUni12("c4",0x0148,0x0147)

-                 or CheckDeadUni12("a1",0x0144,0x0143)

-                 or CheckDeadUni12("a2",0x0146,0x0145)

-                 or CheckDeadUni12("a6",0x1E45,0x1E44)))

-    OutputChar12("n","N","n","N")

-  else if (Ebene = 3)

-    OutputChar("(", "parenleft")

-  else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2074)

-                          or CheckDeadUni("a3",0x2084)))

-    OutputChar("{Numpad4}", "KP_4")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03BD, "Greek_nu") ; nu

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2115, "U2115") ; N (natürliche Zahlen)

-return

-

-neo_o:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("c1",0x00F4,0x00D4)

-                 or CheckDeadUni12("c2",0x00F5,0x00D5)

-                 or CheckDeadUni12("c4",0x01D2,0x01D1)

-                 or CheckDeadUni12("c5",0x014F,0x014E)

-                 or CheckDeadUni12("c6",0x014D,0x014C)

-                 or CheckDeadUni12("g1",0x00F2,0x00D2)

-                 or CheckDeadAsc12("g3","ö","Ö")

-                 or CheckDeadUni12("a1",0x00F3,0x00D3)

-                 or CheckDeadUni12("a2",0x01EB,0x01EA)

-                 or CheckDeadUni12("a3",0x00F8,0x00D8)

-                 or CheckDeadUni12("a4",0x0151,0x0150)))

-    OutputChar12("o","O","o","O")

-  else if (Ebene = 3)

-    OutputChar("*", "asterisk")

-  else if (Ebene = 4)

-    OutputChar("{End}", "End")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03BF, "Greek_omicron") ; omicron

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2208, "elementof") ; element of

-return

-

-neo_p:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("a6",0x1E57,0x1E56)))

-    OutputChar12("p","P","p","P")

-  else if ((Ebene = 3) and !(CheckDeadUni("c2",0x2248)))

-    OutputChar("~", "asciitilde")

-  else if (Ebene = 4)

-    OutputChar("{Enter}", "Return")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03C0, "Greek_pi") ; pi

-  else if (Ebene = 6)

-    SendUnicodeChar(0x03A0, "Greek_PI") ; Pi

-return

-

-neo_q:

-  EbeneAktualisieren()

-  if (Ebene12)

-     OutputChar12("q","Q","q","Q")

-  else if (Ebene = 3)

-    OutputChar("{&}", "ampersand")

-  else if ((Ebene = 4) and !(CheckDeadUni("c1",0x207A)

-                          or CheckDeadUni("a3",0x208A)))

-    OutputChar("{NumPadAdd}", "KP_Add")

-  else if (Ebene = 5)

-     SendUnicodeChar(0x03D5, "U03D5") ; phi symbol (varphi)

-  else if (Ebene = 6)

-     SendUnicodeChar(0x211A, "U211A") ; Q (rationale Zahlen)

-return

-

-neo_r:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("c4",0x0159,0x0158)

-                 or CheckDeadUni12("g3",0x1E5B,0x1E5A)

-                 or CheckDeadUni12("a1",0x0155,0x0154)

-                 or CheckDeadUni12("a2",0x0157,0x0156)

-                 or CheckDeadUni12("a6",0x0E59,0x0E58)))

-    OutputChar12("r","R","r","R")

-  else if (Ebene = 3)

-    OutputChar(")", "parenright")

-  else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2075)

-                          or CheckDeadUni("a3",0x2085)))

-    OutputChar("{Numpad5}", "KP_5")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03F1, "U03F1") ; rho symbol (varrho)

-  else if (Ebene = 6)

-    SendUnicodeChar(0x211D, "U221D") ; R (reelle Zahlen)

-return

-

-neo_s:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("a1",0x015B,0x015A)

-                 or CheckDeadUni12("a2",0x015F,0x015E)

-                 or CheckDeadUni12("a6",0x1E61,0x1E60)

-                 or CheckDeadUni12("c1",0x015D,0x015C)

-                 or CheckDeadUni12("c4",0x0161,0x0160)

-                 or CheckDeadUni12("a6",0x1E63,0x1A62))) {

-    if (LangSTastatur and (Ebene = 1))

-      SendUnicodeChar(0x017F, "17F") ; langes s

-    else OutputChar12("s","S","s","S")

-  } else if (Ebene = 3)

-    OutputChar("?", "question")

-  else if (Ebene = 4)

-    OutputChar("¿", "questiondown")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03C3, "Greek_sigma") ;sigma

-  else if (Ebene = 6)

-    SendUnicodeChar(0x03A3, "Greek_SIGMA") ;Sigma

-return

-

-neo_t:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("a2",0x0163,0x0162)

-                 or CheckDeadUni12("a6",0x1E6B,0x1E6A)

-                 or CheckDeadUni12("c4",0x0165,0x0164)

-                 or CheckDeadUni(  "g3",0x1E97)))

-    OutputChar12("t","T","t","T")

-  else if (Ebene = 3)

-    OutputChar("-", "minus") ; Bisstrich

-  else if (Ebene = 4) and !(CheckDeadUni("c1",0x2076)

-                          or CheckDeadUni("c5",0x2086))

-    OutputChar("{Numpad6}", "KP_6")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03C4, "Greek_tau") ; tau

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2202, "partialderivative") ; partielle Ableitung

-return

-

-neo_u:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("c1",0x00FB,0x00DB)

-                 or CheckDeadUni12("c2",0x0169,0x0168)

-                 or CheckDeadUni12("c3",0x016F,0x016E)

-                 or CheckDeadUni12("c4",0x01D4,0x01D3)

-                 or CheckDeadUni12("c5",0x016D,0x016C)

-                 or CheckDeadUni12("c6",0x016B,0x016A)

-                 or CheckDeadUni12("g1",0x00F9,0x00D9)

-                 or CheckDeadAsc12("g3","ü","Ü")

-                 or CheckDeadUni12("a1",0x00FA,0x00DA)

-                 or CheckDeadUni12("a2",0x0173,0x0172)

-                 or CheckDeadUni12("a4",0x0171,0x0170)))

-    OutputChar12("u","U","u","U")

-  else if (Ebene = 3)

-    OutputChar("\", "backslash")

-  else if (Ebene = 4)

-    OutputChar("{Home}", "Home")

-  else if (Ebene = 6)

-    SendUnicodeChar(0x222E, "U222E") ; contour integral

-return

-

-neo_v:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("a6",0x1E7F,0x1E7E)))

-    OutputChar12("v","V","v","V")

-  else if (Ebene = 3)

-    OutputChar("_","underscore")

-  else if (Ebene = 4) and (!lernModus or lernModus_neo_Backspace)

-    OutputChar("{Backspace}", "BackSpace")

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2259, "U2259") ; estimates/entspricht

-return

-

-neo_w:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("c1",0x0175,0x0174)))

-    OutputChar12("w","W","w","W")

-  else if (Ebene = 3)

-    OutputChar("{^}{space}", "asciicircum") ; Zirkumflex

-  else if (Ebene = 4)

-    OutputChar("{Insert}", "Insert") ; Einfg

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03C9, "Greek_omega") ; omega

-  else if (Ebene = 6)

-    SendUnicodeChar(0x03A9, "Greek_OMEGA") ; Omega

-return

-

-neo_x:

-  EbeneAktualisieren()

-  if Ebene12

-    OutputChar12("x","X","x","X")

-  else if (Ebene = 3)

-    OutputChar("…", "ellipsis") ; Ellipse horizontal

-  else if (Ebene = 4)

-    SendUnicodeChar(0x22EE, "U22EE") ; Ellipse vertikal

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03BE, "Greek_xi") ; xi

-  else if (Ebene = 6)

-    SendUnicodeChar(0x039E, "Greek_XI") ; Xi

-return

-

-neo_y:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("c1",0x0177,0x0176)

-                 or CheckDeadAsc12("g3","ÿ","Ÿ")

-                 or CheckDeadUni12("a1",0x00FD,0x00DD)))

-    OutputChar12("y","Y","y","Y")

-  else if (Ebene = 3)

-    OutputChar("@", "at")

-  else if (Ebene = 4)

-    OutputChar(".", "period")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03C5, "Greek_upsilon") ; upsilon

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2207, "nabla") ; nabla

-return

-

-neo_z:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("a1",0x017A,0x0179)

-                 or CheckDeadUni12("a6",0x017C,0x017B)

-                 or CheckDeadUni12("c4",0x017E,0x017D)))

-    OutputChar12("z","Z","z","Z")

-  else if (Ebene = 3)

-    OutputChar("``{space}", "grave") ; untot

-  else if (Ebene = 4)

-    send {Ctrl down}z{Ctrl up}

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03B6, "Greek_zeta") ; zeta

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2124, "U2124") ; Z (ganze Zahlen)

-return

-

-neo_ä:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("c6",0x01DF,0x01DE)))

-    OutputChar12("ä","Ä","adiaeresis","Adiaeresis")

-  else if (Ebene = 3)

-    OutputChar("|", "bar")

-  else if (Ebene = 4)

-    OutputChar("{PgDn}", "Next")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03B7, "Greek_eta") ; eta

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2135, "U2135") ; Kardinalzahlen, Aleph-Symbol

-return

-

-neo_ö:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("c6",0x022B,0x022A)))

-    OutputChar12("ö","Ö","odiaeresis","Odiaeresis")

-  else if (Ebene = 3)

-    OutputChar("$", "dollar")

-  else if (Ebene = 4)

-    OutputChar("{Tab}", "Tab")

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2111, "U2221") ; Fraktur I

-return

-

-neo_ü:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni12("a1",0x01D8,0x01D7)

-                 or CheckDeadUni12("g1",0x01DC,0x01DB)

-                 or CheckDeadUni12("c4",0x01DA,0x01D9)

-                 or CheckDeadUni12("c6",0x01D6,0x01D5)))

-    OutputChar12("ü","Ü","udiaeresis","Udiaeresis")

-  else if (Ebene = 3)

-    if isMod2Locked

-      OutputChar("{Shift Up}{#}", "numbersign")

-    else OutputChar("{blind}{#}", "numbersign")

-  else if (Ebene = 4)

-    OutputChar("{Esc}", "Escape")

-  else if (Ebene = 6)

-    SendUnicodeChar(0x211C, "U221C") ; Fraktur R

-return

-

-neo_sz:

-  EbeneAktualisieren()

-  if (Ebene = 1)

-    if LangSTastatur

-      OutputChar("s", "s")

-    else OutputChar("ß", "ssharp")

-  else if (Ebene = 2)

-    SendUnicodeChar(0x1E9E, "U1E9E") ; versal-ß

-  else if (Ebene = 3)

-    if LangSTastatur

-      OutputChar("ß", "ssharp")

-    else SendUnicodeChar(0x017F, "17F") ; langes s

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03C2, "Greek_finalsmallsigma") ; varsigma

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2218, "jot") ; Verknüpfungsoperator

-return

-

diff --git a/windows/autohotkey/Source/Keys-NumPad.ahk b/windows/autohotkey/Source/Keys-NumPad.ahk
deleted file mode 100644
index 5f85a27..0000000
--- a/windows/autohotkey/Source/Keys-NumPad.ahk
+++ /dev/null
@@ -1,250 +0,0 @@
-neo_Numpad0:

-  EbeneAktualisieren()

-  if (Ebene = 1)

-    OutputChar("{Numpad0}", "KP_0")

-  else if (Ebene = 2)

-    SendUnicodeChar(0x2423, "U2423") ; space sign

-  else if (Ebene = 3)

-    SendUnicodeChar(0x0025, "percent") ; Prozent

-  else if (Ebene = 4)

-    send {blind}{NumpadIns}

-  else if (Ebene = 5)

-    OutputChar("‰", "U2030") ; Promille

-  else if (Ebene = 6)

-    SendUnicodeChar(0x25A1, "U25A1") ; white square

-return

-

-neo_Numpad1:

-  EbeneAktualisieren()

-  if (Ebene = 1)

-    OutputChar("{Numpad1}", "KP_1")

-  else if (Ebene = 2)

-    SendUnicodeChar(0x2666, "diamond") ; Karo

-  else if (Ebene = 3)

-    SendUnicodeChar(0x2194, "U2194") ; Links-Rechts-Pfeil

-  else if (Ebene = 4)

-    send {blind}{NumpadEnd}

-  else if (Ebene = 5)

-    SendUnicodeChar(0x2264, "lessthanequal")

-  else if (Ebene = 6)

-    SendUnicodeChar(0x230A, "downstile") ;linke Untergrenze

-return

-

-neo_Numpad2:

-  EbeneAktualisieren()

-  if (Ebene = 1)

-    OutputChar("{Numpad2}", "KP_2")

-  else if (Ebene = 2)

-    SendUnicodeChar(0x2265, "heart")

-  else if (Ebene = 3)

-    SendUnicodeChar(0x2192, "downarrow")

-  else if (Ebene = 4)

-    send {blind}{NumpadDown}

-  else if (Ebene = 5)

-    SendUnicodeChar(0x222A, "union") ; Vereinigung

-  else if (Ebene = 6)

-    SendUnicodeChar(0x22C3, "U22C3") ; n-ary union

-return

-

-neo_Numpad3:

-  EbeneAktualisieren()

-  if (Ebene = 1)

-    OutputChar("{Numpad3}", "KP_3")

-  else if (Ebene = 2)

-    SendUnicodeChar(0x2660, "U2660") ; Pik

-  else if (Ebene = 3)

-    SendUnicodeChar(0x21CC, "U21CC") ; Harpune

-  else if (Ebene = 4)

-    send {blind}{NumpadPgDn}

-  else if (Ebene = 5)

-    SendUnicodeChar(0x2265, "greaterthanequal")

-  else if (Ebene = 6)

-    SendUnicodeChar(0x230B, "U230B") ; rechte Untergrenze

-return

-

-neo_Numpad4:

-  EbeneAktualisieren()

-  if (Ebene = 1)

-    OutputChar("{Numpad4}", "KP_4")

-  else if (Ebene = 2)

-    SendUnicodeChar(0x2663, "club") ; schwarzes Kreuz

-  else if (Ebene = 3)

-    SendUnicodeChar(0x2190, "leftarrow") ; Linkspfeil

-  else if (Ebene = 4)

-    send {blind}{NumpadLeft}

-  else if (Ebene = 5)

-    SendUnicodeChar(0x2282, "includein") ; Teilmenge

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2286, "U2286") ; Teilmenge-gleich

-return

-

-neo_Numpad5:

-  EbeneAktualisieren()

-  if (Ebene = 1)

-    OutputChar("{Numpad5}", "KP_5")

-  else if (Ebene = 2)

-    SendUnicodeChar(0x20AC, "EuroSign") ; Euro

-  else if (Ebene = 3)

-    SendUnicodeChar(0x00A6, "brokenbar")

-  else if (Ebene = 4)

-    send {blind}{NumPadClear} ; begin

-  else if (Ebene = 5)

-    SendUnicodeChar(0x22B6, "U22B6") ; original of

-  else if (Ebene = 6)

-    SendUnicodeChar(0x22B7, "U22B7") ; image of

-return

-

-neo_Numpad6:

-  EbeneAktualisieren()

-  if (Ebene = 1)

-    OutputChar("{Numpad6}", "KP_6")

-  else if (Ebene = 3)

-    SendUnicodeChar(0x2192, "rightarrow") ; Rechtspfeil

-  else if (Ebene = 4)

-    send {blind}{NumpadRight}

-  else if (Ebene = 5)

-    SendUnicodeChar(0x2283, "includes") ; Obermenge

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2287, "U2287") ; Obermenge-gleich

-return

-

-neo_Numpad7:

-  EbeneAktualisieren()

-  if (Ebene = 1)

-    OutputChar("{Numpad7}", "KP_7")

-  else if (Ebene = 2)

-    SendUnicodeChar(0x2714, "U2714") ; check mark

-  else if (Ebene = 3)

-    SendUnicodeChar(0x2195, "U2195") ; Hoch-Runter-Pfeil

-  else if (Ebene = 4)

-    send {blind}{NumpadHome}

-  else if (Ebene = 5)

-    SendUnicodeChar(0x226A, "U226A") ; much less

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2308, "upstile") ; linke Obergrenze

-return

-

-neo_Numpad8:

-  EbeneAktualisieren()

-  if (Ebene = 1)

-    OutputChar("{Numpad8}", "KP_8")

-  else if (Ebene = 2)

-    SendUnicodeChar(0x2718, "U2718") ; ballot x

-  else if (Ebene = 3)

-    SendUnicodeChar(0x2191, "uparrow") ; Hochpfeil

-  else if (Ebene = 4)

-    send {blind}{NumpadUp}

-  else if (Ebene = 5)

-    SendUnicodeChar(0x2229, "intersection") ; Durchschnitt

-  else if (Ebene = 6)

-    SendUnicodeChar(0x22C2, "U22C2") ; n-ary intersection

-return

-

-neo_Numpad9:

-  EbeneAktualisieren()

-  if (Ebene = 1)

-    OutputChar("{Numpad9}", "KP_9")

-  else if (Ebene = 2)

-    SendUnicodeChar(0x2020, "dagger") ; Kreuz

-  else if (Ebene = 3)

-    SendUnicodeChar(0x20D7, "U20D7") ; Vektor

-  else if (Ebene = 4)

-    send {blind}{NumpadPgUp}

-  else if (Ebene = 5)

-    SendUnicodeChar(0x226B, "U226B") ; much greater

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2309, "U2309") ; rechte Obergrenze

-return

-

-neo_NumLock:

-  EbeneAktualisieren()

-  if Ebene12

-    OutputChar("{Tab}", "Tab")

-  else if (Ebene = 3)

-    OutputChar("`=", "equal")

-  else if (Ebene = 4)

-    SendUnicodeChar(0x2260, "notequal") ; Ungleich zu

-  else if (Ebene = 5)

-    SendUnicodeChar(0x2248, "approxeq") ; Fast gleich

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2261, "identical")

-return

-

-neo_NumpadDiv:

-  EbeneAktualisieren()

-  if Ebene12

-    OutputChar("{NumpadDiv}", "KP_Divide")

-  else if (Ebene = 3)

-    OutputChar("÷", "division")

-  else if (Ebene = 4)

-    SendUnicodeChar(0x2300, "U2300") ; diameter

-  else if (Ebene = 5)

-    SendUnicodeChar(0x2223, "U2223") ; divides

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2044, "U2044") ; fraction slash

-return

-

-neo_NumpadMult:

-  EbeneAktualisieren()

-  if Ebene12

-    send {blind}{NumpadMult}

-  else if (Ebene = 3)

-    SendUnicodeChar(0x22C5, "U22C5") ; multiplication dot

-  else if (Ebene = 4)

-    SendUnicodeChar(0x2299, "U2299") ; circled dot

-  else if (Ebene = 5)

-    OutputChar("×", "multiply")

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2297, "U2297") ; circled times

-return

-

-neo_NumpadSub:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni("c1",0x207B)

-                 or CheckDeadUni("a3",0x208B)))

-    send {blind}{NumpadSub}

-  else if (Ebene = 3)

-    SendUnicodeChar(0x2212, "U2212") ; Echtes Minus

-  else if (Ebene = 4)

-    SendUnicodeChar(0x2296, "U2296") ; circled minus

-  else if (Ebene = 5)

-    SendUnicodeChar(0x2216, "U2216") ; set minus

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2238, "U2238") ; dot minus

-return

-

-neo_NumpadAdd:

-  EbeneAktualisieren()

-  if (Ebene12 and !(CheckDeadUni("c1",0x207A)

-                 or CheckDeadUni("a3",0x208A)))

-    send {blind}{NumpadAdd}

-  else if (Ebene = 3)

-    OutputChar("±", "plusminus")

-  else if (Ebene = 4)

-    SendUnicodeChar(0x2295, "U2295") ; circled plus

-  else if (Ebene = 5)

-    SendUnicodeChar(0x2213, "U2213") ; minus-plus

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2214, "U2214") ; dot plus

-return

-

-neo_NumpadEnter:

-  send {blind}{NumpadEnter}

-return

-

-neo_NumpadDot:

-  EbeneAktualisieren()

-  if (Ebene = 1)

-    send {blind}{NumpadDot}

-  else if (Ebene = 2)

-    send {blind}.

-  else if (Ebene = 3)

-    send `,

-  else if (Ebene = 4)

-    send {blind}{NumpadDel}

-  else if (Ebene = 5)

-    SendUnicodeChar(0x2032, "minutes")

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2033, "seconds")

-return

-

diff --git a/windows/autohotkey/Source/Keys-Numbers.ahk b/windows/autohotkey/Source/Keys-Numbers.ahk
deleted file mode 100644
index 4f47afb..0000000
--- a/windows/autohotkey/Source/Keys-Numbers.ahk
+++ /dev/null
@@ -1,166 +0,0 @@
-neo_0:

-  noCaps = 1

-  EbeneAktualisieren()

-  if Ebene12 and !(CheckDeadUni("c1",0x2070) ; Hochgestellte 0

-                or CheckDeadUni("a3",0x2080)) ; Tiefgestellte 0 

-    OutputChar12(0,"”",0,"rightdoublequotemark")

-   else if (Ebene = 3)

-     OutputChar("’", "rightsingleqoutemark")

-   else if (Ebene = 4)

-     OutputChar("{NumpadSub}", "KP_Minus")

-   else if (Ebene = 5)

-     SendUnicodeChar(0x2080, "U2080")

-   else if (Ebene = 6)

-     SendUnicodeChar(0x2205, "emptyset") ; leere Menge

-return

-

-neo_1:

-  noCaps=1

-  EbeneAktualisieren()

-  if Ebene12 and !(CheckDeadUni("c1",0x00B9) ; Hochgestellte 1

-                or CheckDeadUni("a3",0x2081)) ; Tiefgestellte 1

-    OutputChar12(1,"°",1,"degree")

-  else if (Ebene = 3)

-    OutputChar("¹", "onesuperior") ; Hochgestellte 1

-  else if (Ebene = 4)

-    OutputChar("º", "U00BA") ; männlicher Ordinalindikator (º)

-  else if (Ebene = 5)

-    SendUnicodeChar(0x2081, "U2081") ; Tiefgestellte 1

-  else if (Ebene = 6)

-    OutputChar("¬", "notsign") ; Nicht-Symbol

-return

-

-neo_2:

-  noCaps = 1

-  EbeneAktualisieren()

-  if Ebene12 and !(CheckDeadUni("c1",0x00B2) ; Hochgestellte 2

-                or CheckDeadUni("a3",0x2082)) ; Tiefgestellte 2

-    OutputChar12(2,"§",2,"section")

-  else if (Ebene = 3)

-    OutputChar("²", "twosuperior") ; Hochgestellte 2

-  else if (Ebene = 4)

-    OutputChar("ª", "U00AA") ; weiblicher Ordinalindikator (ª)

-  else if (Ebene = 5)

-    SendUnicodeChar(0x2082, "U2082") ; Tiefgestellte 2

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2228, "logicalor") ; Logisches Oder

-return

-

-neo_3:

-  noCaps = 1

-  EbeneAktualisieren()

-  if (Ebene = 1) and !(CheckDeadUni("c1",0x00B3) ; Hochgestellte 3

-                    or CheckDeadUni("a3",0x2083)) ; Tiefgestellte 3

-    OutputChar(3,3)

-  else if (Ebene = 2)

-    SendUnicodeChar(0x2113, "U2113") ; kleines l (Skript)

-  else if (Ebene = 3)

-    OutputChar("³", "threesuperior") ; Hochgestellte 3

-  else if (Ebene = 4)

-    SendUnicodeChar(0x2116, "numerosign") ; Numero

-  else if (Ebene = 5)

-    SendUnicodeChar(0x2083, "U2083") ; Tiefgestellte 3

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2227, "logicaland") ; Logisches Und

-return

-

-neo_4:

-  noCaps = 1

-  EbeneAktualisieren()

-  if (Ebene = 1) and !(CheckDeadUni("c1",0x2074) ; Hochgestellte 4

-                    or CheckDeadUni("a3",0x2084)) ; Tiefgestellte 4

-    OutputChar(4,4)

-  else if (Ebene = 2)

-    OutputChar("»", "guillemotright")

-  else if (Ebene = 3)

-    OutputChar("›", "U230A") ; Single guillemot right

-  else if (Ebene = 4)

-    OutputChar("{PgUp}", "Prior") ; Bild auf

-  else if (Ebene = 5)

-    OutputChar("†", "dagger") ; Kreuz

-  else if (Ebene = 6)

-    SendUnicodeChar(0x22A5, "uptack") ; Senkrecht

-return

-

-neo_5:

-  noCaps = 1

-  EbeneAktualisieren()

-  if (Ebene = 1) and !(CheckDeadUni("c1",0x2075) ; Hochgestellte 5

-                    or CheckDeadUni("a3",0x2085)) ; Tiefgestellte 5

-    OutputChar(5,5)

-  else if (Ebene = 2)

-    OutputChar("«", "guillemotleft") ; Double guillemot left

-  else if (Ebene = 3)

-    OutputChar("‹", "U2039") ; Single guillemot left

-  else if (Ebene = 5)

-    SendUnicodeChar(0x2640, "femalesymbol")

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2221, "U2221") ; Winkel

-return

-

-neo_6:

-  noCaps = 1

-  EbeneAktualisieren()

-  if (Ebene = 1) and !(CheckDeadUni("c1",0x2076) ; Hochgestellte 6

-                    or CheckDeadUni("a3",0x2086)) ; Tiefgestellte 6

-    OutputChar(6,6)

-  else if (Ebene = 2)

-    SendUnicodeChar(0x20AC, "EuroSign")

-  else if (Ebene = 3)

-    OutputChar("¢", "cent")

-  else if (Ebene = 4)

-    OutputChar("£", "sterling")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x2642, "malesymbol")

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2225, "U2225") ; parallel

-return

-

-neo_7:

-  noCaps = 1

-  EbeneAktualisieren()

-  if Ebene12 and !(CheckDeadUni("c1",0x2077) ; Hochgestellte 7

-                or CheckDeadUni("a3",0x2087)) ; Tiefgestellte 7

-    OutputChar12(7,"$",7,"dollar")

-  else if (Ebene = 3)

-    OutputChar("¥", "yen")

-  else if (Ebene = 4)

-    OutputChar("¤", "currency")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03BA, "Greek_kappa") ; greek small letter kappa

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2192, "rightarrow") ; Rechtspfeil

-return

-

-neo_8:

-  noCaps = 1

-  EbeneAktualisieren()

-  if Ebene12 and !(CheckDeadUni("c1",0x2078) ; Hochgestellte 8

-                or CheckDeadUni("a3",0x2088)) ; Tiefgestellte 8

-    OutputChar12(8,"„",8,"doublelowquotemark")

-  else if (Ebene = 3)

-    OutputChar("‚", "singlelowquotemark")

-  else if (Ebene = 4)

-    OutputChar("{NumpadDiv}", "KP_Divide")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x27E8, "U27E8") ; bra (öffnende spitze Klammer)

-  else if (Ebene = 6)

-    SendUnicodeChar(0x221E, "infinity")

-return

-

-neo_9:

-  noCaps = 1

-  EbeneAktualisieren()

-  if Ebene12 and !(CheckDeadUni("c1",0x2079) ; Hochgestellte 9

-                or CheckDeadUni("a3",0x2089)) ; Tiefgestellte 9

-    OutputChar12(9,"“",9,"leftdoublequotemark")

-  else if (Ebene = 3)

-    OutputChar("‘", "leftsinglequotemark")

-  else if (Ebene = 4)

-    OutputChar("{NumpadMult}", "KP_Multiply")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x27E9, "U27E9") ; ket (schließende spitze Klammer)

-  else if (Ebene = 6)

-    SendUnicodeChar(0x2226, "U2226") ; nicht parallel

-return

-

diff --git a/windows/autohotkey/Source/Keys-Qwert-to-Neo.ahk b/windows/autohotkey/Source/Keys-Qwert-to-Neo.ahk
deleted file mode 100644
index 0b1e19e..0000000
--- a/windows/autohotkey/Source/Keys-Qwert-to-Neo.ahk
+++ /dev/null
@@ -1,241 +0,0 @@
-/*

-   ------------------------------------------------------

-   QWERTZ->Neo umwandlung

-   ------------------------------------------------------

-*/

-

-; Reihe 1

-*VKDCSC029::goto neo_tot1 ; Zirkumflex

-*VK31SC002::goto neo_1

-*VK32SC003::goto neo_2

-*VK33SC004::goto neo_3

-*VK34SC005::goto neo_4

-*VK35SC006::goto neo_5

-*VK36SC007::goto neo_6

-*VK37SC008::

-  if !einHandNeo or !spacepressed

-    goto neo_7

-  else {

-    keypressed := 1

-    goto %gespiegelt_7%

-  }

-*VK38SC009::

-  if !einHandNeo or !spacepressed

-    goto neo_8

-  else {

-    keypressed := 1

-    goto %gespiegelt_8%

-  }

-*VK39SC00A::

-  if !einHandNeo or !spacepressed

-    goto neo_9

-  else {

-    keypressed := 1

-    goto %gespiegelt_9%

-  }

-*VK30SC00B::

-  if !einHandNeo or !spacepressed

-    goto neo_0

-  else {

-    keypressed := 1

-    goto %gespiegelt_0%

-  }

-*VKDBSC00C:: ; ß

-  if !einHandNeo or !spacepressed

-    goto neo_strich

-  else {

-    keypressed := 1

-    goto %gespiegelt_strich%

-  }

-*VKDDSC00D::goto neo_tot2 ; Akut

-

-; Reihe 2

-

-VK09SC00F::goto neo_tab

-*VK51SC010:: ; q (x)

-  goto neo_x

-*VK57SC011:: ; w (v)

-  goto neo_v

-*VK45SC012:: ; e (l)

-  goto neo_l

-*VK52SC013:: ; r (c)

-  goto neo_c

-*VK54SC014:: ; t (w)

-  goto neo_w

-*VK5ASC015:: ; z (k) 

-  if !einHandNeo or !spacepressed

-    goto neo_k

-  else {

-    keypressed := 1

-    goto %gespiegelt_k%

-  }

-*VK55SC016:: ; u (h)

-  if !einHandNeo or !spacepressed

-    goto neo_h

-  else {

-    keypressed := 1

-    goto %gespiegelt_h%

-  }

-*VK49SC017:: ; i (g)

-  if !einHandNeo or !spacepressed

-    goto neo_g

-  else {

-    keypressed := 1

-    goto %gespiegelt_g%

-  }

-*VK4FSC018:: ; o (f)

-  if !einHandNeo or !spacepressed

-    goto neo_f

-  else {

-    keypressed := 1

-    goto %gespiegelt_f%

-  }

-*VK50SC019:: ; p (q)

-  if !einHandNeo or !spacepressed

-    goto neo_q

-  else {

-    keypressed := 1

-    goto %gespiegelt_q%

-  }

-*VKBASC01A:: ; ü (ß)

-  if !einHandNeo or !spacepressed

-    goto neo_sz

-  else {

-    keypressed := 1

-    goto %gespiegelt_sz%

-  }

-*VKBBSC01B:: ; + (tot3)

-  if !einHandNeo or !spacepressed

-    goto neo_tot3

-  else {

-    keypressed := 1

-    goto %gespiegelt_tot3%

-  }

-

-; Reihe 3

-*VK41SC01E:: ; a (u)

-  goto neo_u

-*VK53SC01F:: ; s (i)

-  goto neo_i

-*VK44SC020:: ; d (a)

-  goto neo_a

-*VK46SC021:: ; f (e)

-  goto neo_e

-*VK47SC022:: ; g (o)

-  goto neo_o

-*VK48SC023:: ; h (s)

-  if !einHandNeo or !spacepressed

-    goto neo_s

-  else {

-    keypressed := 1

-    goto %gespiegelt_s%

-  }

-*VK4ASC024:: ; j (n)

-  if !einHandNeo or !spacepressed

-    goto neo_n

-  else {

-    keypressed := 1

-    goto %gespiegelt_n%

-  }

-*VK4BSC025:: ; k (r)

-  if !einHandNeo or !spacepressed

-    goto neo_r

-  else {

-    keypressed := 1

-    goto %gespiegelt_r%

-  }

-*VK4CSC026:: ; l (t)

-  if !einHandNeo or !spacepressed

-    goto neo_t

-  else {

-    keypressed := 1

-    goto %gespiegelt_t%

-  }

-*VKC0SC027:: ; ö (d)

-  if !einHandNeo or !spacepressed

-    goto neo_d

-  else {

-    keypressed := 1

-    goto %gespiegelt_d%

-  }

-*VKDESC028:: ; ä (y)

-    goto neo_y

-

-; Reihe 4

-*VK59SC02C:: ; y (ü)

-  goto neo_ü

-*VK58SC02D:: ; x (ö)

-  goto neo_ö

-*VK43SC02E:: ; c (ä)  

-  goto neo_ä

-*VK56SC02F:: ; v (p)

-  goto neo_p

-*VK42SC030:: ; b (z)

-  goto neo_z

-*VK4ESC031:: ; n (b)

-  if !einHandNeo or !spacepressed

-    goto neo_b

-  else {

-    keypressed := 1

-    goto %gespiegelt_b%

-  }

-*VK4DSC032:: ; m (m)

-  if !einHandNeo or !spacepressed

-    goto neo_m

-  else {

-    keypressed := 1

-    goto %gespiegelt_m%

-  }

-*VKBCSC033:: ; , (,)

-  if !einHandNeo or !spacepressed

-    goto neo_komma

-  else {

-    keypressed := 1

-    goto %gespiegelt_komma%

-  }

-*VKBESC034:: ; . (.)

-  if !einHandNeo or !spacepressed

-    goto neo_punkt

-  else {

-    keypressed := 1

-    goto %gespiegelt_punkt%

-  }

-*VKBDSC035:: ; - (j)

-  if !einHandNeo or !spacepressed

-    goto neo_j

-  else {

-    keypressed := 1

-    goto %gespiegelt_j%

-  }

-

-; Numpad

-*VK90SC145::goto neo_NumLock

-*VK6FSC135::goto neo_NumpadDiv

-*VK6ASC037::goto neo_NumpadMult

-*VK6DSC04A::goto neo_NumpadSub

-*VK6BSC04E::goto neo_NumpadAdd

-*VK0DSC11C::goto neo_NumpadEnter

-*VK67SC047::                   ; NumPad7

-*VK24SC047::goto neo_Numpad7   ; NumPadHome

-*VK68SC048::                   ; NumPad8

-*VK26SC048::goto neo_Numpad8   ; NumPadUp

-*VK69SC049::                   ; NumPad9

-*VK21SC049::goto neo_Numpad9   ; NumPadPgUp

-*VK64SC04B::                   ; NumPad4

-*VK25SC04B::goto neo_Numpad4   ; NumPadLeft

-*VK65SC04C::                   ; NumPad5

-*VK0CSC04C::goto neo_Numpad5   ; NumPadClear

-*VK66SC04D::                   ; NumPad6

-*VK27SC04D::goto neo_Numpad6   ; NumPadRight

-*VK61SC04F::                   ; NumPad1

-*VK23SC04F::goto neo_Numpad1   ; NumPadEnd

-*VK62SC050::                   ; NumPad2

-*VK28SC050::goto neo_Numpad2   ; NumPadDown

-*VK63SC051::                   ; NumPad3

-*VK22SC051::goto neo_Numpad3   ; NumPadPgDn

-*VK60SC052::                   ; NumPad0

-*VK2DSC052::goto neo_Numpad0   ; NumPadIns

-*VK6ESC053::                   ; NumPadDot

-*VK2ESC053::goto neo_NumpadDot ; NumPadIns

-

-

diff --git a/windows/autohotkey/Source/Keys-Special.ahk b/windows/autohotkey/Source/Keys-Special.ahk
deleted file mode 100644
index 70c15cc..0000000
--- a/windows/autohotkey/Source/Keys-Special.ahk
+++ /dev/null
@@ -1,178 +0,0 @@
-neo_punkt:

-  noCaps = 1

-  EbeneAktualisieren()

-  if (Ebene = 1)

-    OutputChar(".", "period")

-  else if (Ebene = 2)

-    SendUnicodeChar(0x2023, "") ; Dreieckiges Aufzählungszeichen

-  else if (Ebene = 3)

-    OutputChar("'", "apostrophe")

-  else if ((Ebene = 4) and !(CheckDeadUni("c1",0x00B3)

-                          or CheckDeadUni("t4",0x2083)))

-    OutputChar("{Numpad3}", "KP_3")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03D1, "U03D1") ; theta symbol (vartheta)

-  else if (Ebene = 6)

-    SendUnicodeChar(0x0398, "Greek_THETA") ; Theta

-return

-

-neo_komma:

-  noCaps = 1

-  EbeneAktualisieren()

-  if (Ebene = 1)

-    OutputChar(",", "comma")

-  else if (Ebene = 2)

-    OutputChar("•", "enfilledcircbullet") ; Bullet

-  else if (Ebene = 3)

-    OutputChar(Chr(34), "quotedbl")

-  else if ((Ebene = 4) and !(CheckDeadUni("c1",0x00B2)

-                          or CheckDeadUni("c5",0x2082)))

-    OutputChar("{Numpad2}", "KP_2")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x03C1, "Greek_rho") ; rho

-  else if (Ebene = 6)

-    SendUnicodeChar(0x21D2, "implies") ; Doppelpfeil rechts

-return

-

-neo_strich:

-  noCaps = 1

-  EbeneAktualisieren()

-  if (Ebene = 1)

-    OutputChar("-", "minus") ; Bindestrich-Minus

-  else if (Ebene = 2)

-    SendUnicodeChar(0x2013, "endash") ; Gedankenstrich

-  else if (Ebene = 3)

-    SendUnicodeChar(0x2014, "emdash") ; Englischer Gedankenstrich (Geviertstrich)

-  else if (Ebene = 5)

-    SendUnicodeChar(0x2011, "U2011") ; geschützter Bindestrich (Bindestrich ohne Zeilenumbruch)

-  else if (Ebene = 6)

-    SendUnicodeChar(0x00AD, "hyphen") ; weicher Bindestrich

-return

-

-*space::

-  if einHandNeo

-    spacepressed := 1

-  else goto neo_SpaceUp

-return

-

-*space up::

-  if einHandNeo

-    if keypressed {

-     keypressed := 0

-     spacepressed := 0

-    } else goto neo_SpaceUp

-  return

-

-neo_SpaceUp:

-  EbeneAktualisieren()

-  if (Ebene = 1) and !CheckDeadUni("a3",0x2010)  ; Echter Bindestrich

-    OutputChar("{Space}", "Space")

-  else if (Ebene = 2) or (Ebene = 3)

-    Send {blind}{Space}

-  else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2070)

-                        or CheckDeadUni("a3",0x2080)))

-   OutputChar("{Numpad0}", "KP_0")

-  else if (Ebene = 5)

-    SendUnicodeChar(0x00A0, "U00A0") ; geschütztes Leerzeichen

-  else if (Ebene = 6)

-    SendUnicodeChar(0x202F, "U202F") ; schmales geschütztes Leerzeichen

-  DeadKey := ""

-  CompKey := ""

-  spacepressed := 0

-  keypressed := 0

-return

-

-*Enter::

-  EbeneAktualisieren()

-  if !lernModus or lernModus_std_Return {

-    if (Ebene = 4)

-      send {blind}{NumpadEnter}

-    else send {blind}{Enter}

-    DeadKey := ""

-    CompKey := ""

-  } return

-

-*Backspace::

-  if !lernModus or lernModus_std_Backspace {

-    send {Blind}{Backspace}

-    DeadKey := ""

-    CompKey := ""

-  } return

-

-*Del::

-  if !lernModus or lernModus_std_Entf

-    send {Blind}{Del}

-return

-

-*Ins::

-  if !lernModus or lernModus_std_Einf

-    send {Blind}{Ins}

-return

-

-neo_tab:

-  EbeneAktualisieren()

-  if IsMod3Pressed() { ; Compose!

-    DeadKey := "comp"

-    CompKey := ""

-  } else {

-    OutputChar("{Tab}", "Tab")

-    DeadKey := ""

-    CompKey := ""

-  } return

-

-*Home::

-  if !lernModus or lernModus_std_Pos1 {

-    send {Blind}{Home}

-    DeadKey := ""

-    CompKey := ""

-  } return

-

-*End::

-  if !lernModus or lernModus_std_Ende {

-    send {Blind}{End}

-    DeadKey := ""

-    CompKey := ""

-  } return

-

-*PgUp::

-  if !lernModus or lernModus_std_PgUp {

-    send {Blind}{PgUp}

-    DeadKey := ""

-    CompKey := ""

-  } return

-

-*PgDn::

-  if !lernModus or lernModus_std_PgDn {

-    send {Blind}{PgDn}

-    DeadKey := ""

-    CompKey := ""

-  } return

-

-*Up::

-  if !lernModus or lernModus_std_Hoch {

-    send {Blind}{Up}

-    DeadKey := ""

-    CompKey := ""

-  } return

-

-*Down::

-  if !lernModus or lernModus_std_Runter {

-    send {Blind}{Down}

-    DeadKey := ""

-    CompKey := ""

-  } return

-

-*Left::

-  if !lernModus or lernModus_std_Links {

-    send {Blind}{Left}

-    DeadKey := ""

-    CompKey := ""

-  } return

-

-*Right::

-  if !lernModus or lernModus_std_Rechts {

-    send {Blind}{Right}

-    DeadKey := ""

-    CompKey := ""

-  } return

-

diff --git a/windows/autohotkey/Source/Methods-Layers.ahk b/windows/autohotkey/Source/Methods-Layers.ahk
deleted file mode 100644
index c59ccb7..0000000
--- a/windows/autohotkey/Source/Methods-Layers.ahk
+++ /dev/null
@@ -1,131 +0,0 @@
-; LShift+RShift == CapsLock (simuliert)

-; Es werden nur die beiden Tastenkombinationen abgefragt,

-; daher kommen LShift und RShift ungehindert bis in die

-; Applikation. Dies ist aber merkwürdig, da beide Shift-

-; Tasten nun /modifier keys/ werden und, wie in der AHK-

-; Hilfe beschrieben, eigentlich nicht mehr bis zur App

-; durchkommen sollten.

-; KeyboardLED(4,"switch") hatte ich zuerst genommen, aber

-; das schaltet, oh Wunder, die LED nicht wieder aus.

-

-isMod2Locked = 0

-VKA1SC136 & VKA0SC02A:: ; RShift, dann LShift

-VKA0SC02A & VKA1SC136:: ; LShift, dann RShift

-  if GetKeyState("VKA1SC136", "P") and GetKeyState("VKA0SC02A", "P") {

-    if isMod2Locked {

-      isMod2Locked = 0

-      KeyboardLED(4, "off")

-    } else {

-      isMod2Locked = 1

-      KeyBoardLED(4, "on")

-    }

-  }

-return

-

-;Mod3-Tasten (Wichtig, sie werden sonst nicht verarbeitet!)

-;Auf Mod3+Mod3 liegt zusätzlich zu Mod3+Tab Compose

-*VKBFSC02B:: ; #

-*VK14SC03A:: ; CapsLock

-  if GetKeyState("VKBFSC02B", "P") and GetKeyState("VK14SC03A", "P") {

-    DeadKey := "comp"

-    CompKey := ""

-  }

-return

-

-;Mod4+Mod4 == Mod4-Lock

-; Im Gegensatz zu LShift+RShift werden die beiden Tasten

-; _nicht_ zur Applikation weitergeleitet, und nur bei

-; gleichzeitigem Drücken wird der Mod4-Lock aktiviert und

-; angezeigt.

-

-IsMod4Locked := 0

-*VKA5SC138::

-*VKE2SC056::

-  if GetKeyState("VKA5SC138", "P") and GetKeyState("VKE2SC056", "P") {

-    if IsMod4Locked {

-      if zeigeLockBox

-        MsgBox Mod4-Feststellung aufgebehoben!

-       IsMod4Locked = 0

-      if UseMod4Light

-        KeyboardLED(1, "off")

-    } else {

-      if zeigeLockBox

-        MsgBox Mod4 festgestellt: Um Mod4 wieder zu lösen, drücke beide Mod4-Tasten gleichzeitig!

-      IsMod4Locked = 1

-      if UseMod4Light

-        KeyboardLED(1, "on")

-    }

-  }

-return

-

-EbeneAktualisieren() {

-  global

-  PriorDeadKey := DeadKey

-  PriorCompKey := CompKey

-  DeadKey := ""

-  CompKey := ""

-  Modstate := IsMod4Pressed() . IsMod3Pressed() . IsShiftPressed()

-  Ebene7 := 0

-  Ebene8 := 0

-  if      (Modstate = "000") ; Ebene 1: Ohne Mod

-    Ebene = 1

-  else if (Modstate = "001") ; Ebene 2: Shift

-    Ebene = 2

-  else if (Modstate = "010") ; Ebene 3: Mod3

-    Ebene = 3

-  else if (Modstate = "100") ; Ebene 4: Mod4

-    Ebene = 4

-  else if (Modstate = "011") ; Ebene 5: Shift+Mod3

-    Ebene = 5

-  else if (Modstate = "110") ; Ebene 6: Mod3+Mod4

-    Ebene = 6

-  else if (Modstate = "101") { ; Ebene 7: Shift+Mod4 impliziert Ebene 4

-    Ebene = 4

-    Ebene7 = 1

-  } else if (Modstate = "111") { ; Ebene 8: Shift+Mod3+Mod4 impliziert Ebene 6

-    Ebene = 6

-    Ebene8 = 1

-  } Ebene12 := ((Ebene = 1) or (Ebene = 2))

-  NumLock := GetKeyState("NumLock", "T")

-  noCaps := 0

-}

-

-IsShiftPressed()

-{

-  global

-  if !(NoCaps and GetKeyState("Shift", "P") and (GetKeyState("Alt", "P") or GetKeyState("Strg", "P"))) {

-    if striktesMod2Lock

-      noCaps = 0

-    if GetKeyState("Shift","P")

-      if isMod2Locked and !noCaps

-        return 0

-      else return 1

-    else if isMod2Locked and !noCaps

-      return 1

-    else return 0

-  }

-}

-

-IsMod3Pressed()

-{

-  global

-  return (GetKeyState("VKBFSC02B","P") or GetKeyState("VK14SC03A","P"))

-}

-

-IsMod4Pressed()

-{

-  global

-  if !(einHandNeo) or !(spacepressed)

-    if IsMod4Locked

-      return !(GetKeyState("<","P") or GetKeyState("SC138","P"))

-    else

-      return (GetKeyState("<","P") or GetKeyState("SC138","P"))

-  else

-    if IsMod4Locked

-      return !(GetKeyState("<","P") or GetKeyState("SC138","P") or GetKeyState("ä","P"))

-    else

-      return (GetKeyState("<","P") or GetKeyState("SC138","P") or GetKeyState("ä","P"))

-}

-

-

-

diff --git a/windows/autohotkey/Source/Methods-Lights.ahk b/windows/autohotkey/Source/Methods-Lights.ahk
deleted file mode 100644
index 861f4ae..0000000
--- a/windows/autohotkey/Source/Methods-Lights.ahk
+++ /dev/null
@@ -1,108 +0,0 @@
-/* 

-   ------------------------------------------------------

-   Methode KeyboardLED zur Steuerung der Keyboard-LEDs

-   (NumLock/CapsLock/ScrollLock-Lichter)

-   

-   Benutzungshinweise: Man benutze

-   KeyboardLED(LEDvalue,"Cmd"), wobei

-   Cmd = on/off/switch,

-   LEDvalue: ScrollLock=1, NumLock=2, CapsLock=4,

-   bzw. eine beliebige Summe dieser Werte:

-   AlleAus=0, CapsLock+NumLock=6, etc.

-   

-   Der folgende Code wurde übernommen von:

-   http://www.autohotkey.com/forum/viewtopic.php?t=10532

-   

-   Um eventuelle Wechselwirkungen mit dem bestehenden

-   Code (insb. der Unicode-Konvertierung) auszuschließen,

-   sind auch alle (Hilfsmethoden) mit dem Postfix LED

-   versehen worden.

-   ------------------------------------------------------

-*/

-

-KeyboardLED(LEDvalue, Cmd) { ; LEDvalue: ScrollLock=1, NumLock=2, CapsLock=4 ; Cmd = on/off/switch

-  Static h_device

-  If !(h_device) { ; initialise

-    device=\Device\KeyBoardClass0

-    SetUnicodeStrLED(fn,device) 

-    h_device:=NtCreateFileLED(fn,0+0x00000100+0x00000080+0x00100000,1,1,0x00000040+0x00000020,0)

-  }

-  VarSetCapacity(output_actual,4,0)

-  input_size=4

-  VarSetCapacity(input,input_size,0)

-  If Cmd=switch ;switches every LED according to LEDvalue

-   KeyLED:=LEDvalue

-  If Cmd=on ;forces all choosen LED's to ON (LEDvalue= 0 ->LED's according to keystate)

-   KeyLED:=LEDvalue | (GetKeyState("ScrollLock", "T") + 2*GetKeyState("NumLock", "T") + 4*GetKeyState("CapsLock", "T"))

-  If (Cmd=off) { ;forces all choosen LED's to OFF (LEDvalue= 0 ->LED's according to keystate)

-    LEDvalue:=LEDvalue ^ 7

-    KeyLED:=LEDvalue & (GetKeyState("ScrollLock","T") + 2*GetKeyState("NumLock","T") + 4*GetKeyState("CapsLock","T"))

-  }

-  ; EncodeIntegerLED(KeyLED,1,&input,2) ;input bit pattern (KeyLED): bit 0 = scrolllock ;bit 1 = numlock ;bit 2 = capslock

-  input := Chr(1) Chr(1) Chr(KeyLED)

-  input := Chr(1)

-  input =

-  ; ???

-  success:=DllCall("DeviceIoControl"

-    , "uint", h_device

-    , "uint", CTL_CODE_LED( 0x0000000b     ; FILE_DEVICE_KEYBOARD

-              , 2

-              , 0             ; METHOD_BUFFERED

-              , 0  )          ; FILE_ANY_ACCESS

-    , "uint", &input

-    , "uint", input_size

-    , "uint", 0

-    , "uint", 0

-    , "uint", &output_actual

-    , "uint", 0 )

-}

-

-CTL_CODE_LED(p_device_type,p_function,p_method,p_access ) {

-  Return,( p_device_type << 16 ) | ( p_access << 14 ) | ( p_function << 2 ) | p_method

-}

-

-NtCreateFileLED(ByRef wfilename,desiredaccess,sharemode,createdist,flags,fattribs){ 

-  VarSetCapacity(fh,4,0) 

-  VarSetCapacity(objattrib,24,0) 

-  VarSetCapacity(io,8,0) 

-  VarSetCapacity(pus,8) 

-  uslen:=DllCall("lstrlenW","str",wfilename)*2 

-  InsertIntegerLED(uslen,pus,0,2) 

-  InsertIntegerLED(uslen,pus,2,2) 

-  InsertIntegerLED(&wfilename,pus,4) 

-  InsertIntegerLED(24,objattrib,0) 

-  InsertIntegerLED(&pus,objattrib,8) 

-  status:=DllCall("ntdll\ZwCreateFile","str",fh,"UInt",desiredaccess,"str",objattrib,"str",io,"UInt",0,"UInt",fattribs

-                  ,"UInt",sharemode,"UInt",createdist,"UInt",flags,"UInt",0,"UInt",0, "UInt") 

-  return ExtractIntegerLED(fh) 

-} 

-

-SetUnicodeStrLED(ByRef out, str_) { 

-  VarSetCapacity(st1, 8, 0) 

-  InsertIntegerLED(0x530025, st1) 

-  VarSetCapacity(out, (StrLen(str_)+1)*2, 0) 

-  DllCall("wsprintfW", "str", out, "str", st1, "str", str_, "Cdecl UInt") 

-} 

-

-ExtractIntegerLED(ByRef pSource, pOffset = 0, pIsSigned = false, pSize = 4) {

-; pSource is a string (buffer) whose memory area contains a raw/binary integer at pOffset. 

-; The caller should pass true for pSigned to interpret the result as signed vs. unsigned. 

-; pSize is the size of PSource's integer in bytes (e.g. 4 bytes for a DWORD or Int). 

-; pSource must be ByRef to avoid corruption during the formal-to-actual copying process 

-; (since pSource might contain valid data beyond its first binary zero). 

-  Loop %pSize%  ; Build the integer by adding up its bytes. 

-    result += *(&pSource + pOffset + A_Index-1) << 8*(A_Index-1) 

-  if (!pIsSigned OR pSize > 4 OR result < 0x80000000) 

-    return result  ; Signed vs. unsigned doesn't matter in these cases. 

-  ; Otherwise, convert the value (now known to be 32-bit) to its signed counterpart: 

-  return -(0xFFFFFFFF - result + 1) 

-} 

-

-InsertIntegerLED(pInteger, ByRef pDest, pOffset = 0, pSize = 4) { 

-; The caller must ensure that pDest has sufficient capacity.  To preserve any existing contents in pDest, 

-; only pSize number of bytes starting at pOffset are altered in it. 

-  Loop %pSize%  ; Copy each byte in the integer into the structure as raw binary data. 

-    DllCall("RtlFillMemory", "UInt", &pDest + pOffset + A_Index-1, "UInt", 1, "UChar", pInteger >> 8*(A_Index-1) & 0xFF) 

-}

-

-

diff --git a/windows/autohotkey/Source/Methods-Other.ahk b/windows/autohotkey/Source/Methods-Other.ahk
deleted file mode 100644
index ab1d86b..0000000
--- a/windows/autohotkey/Source/Methods-Other.ahk
+++ /dev/null
@@ -1,186 +0,0 @@
-deadAsc(val1, val2, a) {

-  global

-  if !DeadSilence

-    OutputChar(val1, val2)

-  else CheckComp(val2)

-  DeadKey := a

-}

-

-deadUni(val1, val2, a) {

-  global

-  if !DeadSilence

-    SendUnicodeChar(val1, val2)

-  else CheckComp(val2)

-  DeadKey := a

-}

-

-undeadAsc(val) {

-  global

-  if DeadSilence

-    send % val

-  else

-    send % "{bs}" . val

-}

-

-undeadUni(val){

-  global

-  if !DeadSilence

-    send {bs}

-  SendUnicodeChar(val, "")

-}

-

-CheckDeadAsc(d,val) {

-  global

-  if (PriorDeadKey == d) {

-    undeadAsc(val)

-    return 1

-  }

-}

-

-CheckDeadUni(d,val) {

-  global

-  if (PriorDeadKey == d) {

-    undeadUni(val)

-    return 1

-  }

-}

-

-CheckDeadAsc12(d,val1,val2) {

-  global

-  if (PriorDeadKey == d){

-    if (Ebene = 1) and (val1 != "") {

-      undeadAsc(val1)

-      return 1

-    } else if (Ebene = 2) and (val2 != "") {

-      undeadAsc(val2)

-      return 1

-    }

-  }

-}

-

-CheckDeadUni12(d,val1,val2) {

-  global

-  if(PriorDeadKey == d) {

-    if (Ebene = 1) and (val1 != "") {

-      undeadUni(val1)

-      return 1

-    } else if (Ebene = 2) and (val2 != "") {

-      undeadUni(val2)

-      return 1

-    }

-  }

-}

-

-CheckCompUni(d,val) {

-  global

-  if (CompKey == d) {

-    PriorCompKey =

-    CompKey =

-    if !DeadCompose

-      send {bs}

-    isFurtherCompkey = 0

-    SendUnicodeChar(val, "")

-    return 1

-  }

-}

-

-OutputChar(val1,val2) {

-  global

-  if (!CheckComp(val2))

-    send % "{blind}" . val1

-}

-

-OutputChar12(val1,val2,val3,val4) {

-  global

-  if (Ebene = 1)

-    c := val1

-  else c := val2

-  if (Ebene = 1)

-    d := val3

-  else d := val4

-  if (!CheckComp(d))

-    if GetKeyState("Shift","P") and isMod2Locked

-      send % "{blind}{Shift Up}" . c . "{Shift Down}"

-    else send % "{blind}" . c

-}

-

-;Folgende Funktion prüft, ob das eben geschriebene Zeichen eine gültige Coko 

-;fortsetzen KÖNNTE – falls ja, wird 1 zurückgegeben (die Eingabe soll blind erfolgen), 

-;andernfalls wird 0 zurückgegeben (das Zeichen soll ausgegeben werden).

-

-CheckComp(d) {

-  global

-  if (PriorDeadKey = "comp") {

-    CompKey := "<" . d . ">"

-    PriorDeadKey := DeadKey =

-    CheckCompose()

-    TryThirdCompKey = 0

-    return 1

-  } else if TryFourthCompKey {

-    TryFourthCompKey = 0

-    CompKey := ThreeCompKeys . " " . "<" . d . ">"

-    ThreeCompKeys =

-    CheckCompose()

-    if !(CompKey) {

-      send {left}{bs}{right}

-      return 1

-    } else CompKey =

-  } else if TryThirdCompKey {

-    TryThirdCompKey = 0

-    CompKey := PriorCompKey . " " . "<" . d . ">"

-    CheckCompose()

-    if CompKey {

-      TryFourthCompKey = 1

-      ThreeCompKeys := CompKey

-      CompKey =

-    } else return 1

-  } else if PriorCompKey {

-    CompKey := PriorCompKey . " " . "<" . d . ">"

-    CheckCompose()

-    if CompKey

-      TryThirdCompKey = 1

-    return 1

-  }

-}

-

-CumulateDeadKey(a) {

-  if DeadKey = a5

-  { if a = g1

-      DeadKey = a5g1

-    else if a = a1

-      DeadKey = a5a1

-    else if a = a2

-      DeadKey = a5a2

-    else if a = g1a2

-      DeadKey = a5g1a2

-    else if a = a1a2

-      DeadKey = a5a1a2

-    else if a = c1a2

-      DeadKey = a5c1a2

-  } else if DeadKey = g5

-  { if a = g1

-      DeadKey = g5g1

-    else if a = a1

-      DeadKey = g5a1

-    else if a = a2

-      DeadKey = g5a2

-    else if a = g1a2

-      DeadKey = g5g1a2

-    else if a = a1a2

-      DeadKey = g5a1a2

-    else if a = c1a2

-      DeadKey = g5c1a2

-  } else if DeadKey = g1

-  { if a = a5

-      DeadKey = a5g1

-    else if a = g5

-      DeadKey = g5g1

-    else if a = a2

-      DeadKey = g1a2

-    else if a = a5a2

-      DeadKey = a5g1a2

-    else if a = g5a2

-      DeadKey = g5g1a2

-  }

-}

-

diff --git a/windows/autohotkey/Source/Methods-ScreenKeyboard.ahk b/windows/autohotkey/Source/Methods-ScreenKeyboard.ahk
deleted file mode 100644
index 94c0cfc..0000000
--- a/windows/autohotkey/Source/Methods-ScreenKeyboard.ahk
+++ /dev/null
@@ -1,158 +0,0 @@
-/*

-   ------------------------------------------------------

-   BildschirmTastatur

-   ------------------------------------------------------

-*/

-

-guiErstellt = 0

-alwaysOnTop = 1

-

-*F1::

-  if (isMod4Pressed()&&zeigeBildschirmTastatur)

-    goto Switch1

-  else send {blind}{F1}

-return

-

-*F2::

-  if (isMod4Pressed()&&zeigeBildschirmTastatur)

-    goto Switch2

-  else send {blind}{F2}

-return

-

-*F3::

-  if (isMod4Pressed()&&zeigeBildschirmTastatur)

-    goto Switch3

-  else send {blind}{F3}

-return

-

-*F4::

-  if (isMod4Pressed()&&zeigeBildschirmTastatur)

-    goto Switch4

-  else send {blind}{F4}

-return

-

-*F5::

-  if (isMod4Pressed()&&zeigeBildschirmTastatur)

-    goto Switch5

-  else send {blind}{F5}

-return

-

-*F6::

-  if (isMod4Pressed()&&zeigeBildschirmTastatur)

-    goto Switch6

-  else send {blind}{F6}

-return

-

-*F7::

-  if (isMod4Pressed()&&zeigeBildschirmTastatur)

-    goto Show

-  else send {blind}{F7}

-return

-

-*F8::

-  if (isMod4Pressed()&&zeigeBildschirmTastatur)

-    goto ToggleAlwaysOnTop

-  else send {blind}{F8}

-return

-

-Switch1:

-  tImage := ResourceFolder . "\ebene1.png"

-  goto Switch

-Return

-

-Switch2:

-  tImage := ResourceFolder . "\ebene2.png"

-  goto Switch

-Return

-

-Switch3:

-  tImage := ResourceFolder . "\ebene3.png"

-  goto Switch

-Return

-

-Switch4:

-  tImage := ResourceFolder . "\ebene4.png"

-  goto Switch

-Return

-

-Switch5:

-  tImage := ResourceFolder . "\ebene5.png"

-  goto Switch

-Return

-

-Switch6:

-  tImage := ResourceFolder . "\ebene6.png"

-  goto Switch

-Return

-

-Switch:

-  if guiErstellt {

-    if (Image = tImage)

-       goto Close

-    else {

-      Image := tImage

-      SetTimer, Refresh

-    }

-  } else {

-    Image := tImage

-    goto Show    

-  }

-Return

-

-Show:

-  if guiErstellt {

-     goto Close

-  } else {

-    if (Image = "") {

-      Image := ResourceFolder . "\ebene1.png"

-    }     

-    yPosition := A_ScreenHeight -270

-    Gui,Color,FFFFFF

-    Gui,Add,Button,xm+5 gSwitch1,F1

-    Gui,Add,Text,x+5,kleine Buchstaben

-    Gui,Add,Button,xm+5 gSwitch2,F2

-    Gui,Add,Text,x+5,große Buchstaben

-    Gui,Add,Button,xm+5 gSwitch3,F3

-    Gui,Add,Text,x+5,Satz-/Sonderzeichen

-    Gui,Add,Button,xm+5 gSwitch4,F4

-    Gui,Add,Text,x+5,Zahlen / Steuerung

-    Gui,Add,Button,xm+5 gSwitch5,F5

-    Gui,Add,Text,x+5,Sprachen

-    Gui,Add,Button,xm+5 gSwitch6,F6

-    Gui,Add,Text,x+5,Mathesymbole

-    Gui,Add,Button,xm+5 gShow,F7

-    Gui,Add,Text,x+5,An /

-    Gui,Add,Text,y+3,Aus

-    Gui,Add,Button,x+10 y+-30 gShow,F8

-    Gui,Add,Text,x+5,OnTop

-    Gui,Add,Picture,AltSubmit ys w729 h200 vPicture,%Image%

-    Gui,+AlwaysOnTop

-    Gui,Show,y%yposition% Autosize

-;    SetTimer,Refresh

-    guiErstellt = 1

-  } 

-Return

-

-Close:

-  guiErstellt = 0

-  Gui,Destroy

-Return

-

-Refresh:

-  If (Image != OldImage) {

-    GuiControl,,Picture,%Image%

-    OldImage := Image

-  }

-Return

-

-ToggleAlwaysOnTop:

-  if alwaysOnTop {

-    Gui, -AlwaysOnTop

-    alwaysOnTop = 0    

-  } else {

-    Gui, +AlwaysOnTop

-    alwaysOnTop = 1

-  }

-Return

-

-

diff --git a/windows/autohotkey/Source/Methods-Unicode.ahk b/windows/autohotkey/Source/Methods-Unicode.ahk
deleted file mode 100644
index ac4ae79..0000000
--- a/windows/autohotkey/Source/Methods-Unicode.ahk
+++ /dev/null
@@ -1,34 +0,0 @@
-/*

-   ------------------------------------------------------

-   Methoden zum Senden von Unicode-Zeichen

-   ------------------------------------------------------

-

-Über den GTK-Workaround:

-Dieser basiert auf http://www.autohotkey.com/forum/topic32947.html

-Der Aufruf von »SubStr(charCode,3)« geht davon aus, dass alle charCodes in Hex mit führendem „0x“ angegeben sind. Die abenteuerliche „^+u“-Konstruktion benötigt im Übrigen den Hex-Wert in Kleinschrift, was derzeit nicht bei den Zeichendefinitionen umgesetzt ist, daher zentral und weniger fehlerträchtig an dieser Stelle. Außerdem ein abschließend gesendetes Space, sonst bleibt der „eingetippte“ Unicode-Wert noch kurz sichtbar stehen, bevor er sich GTK-sei-dank in das gewünschte Zeichen verwandelt.

-*/

-

-SendUnicodeChar(charCode1, charCode2) {

-  global

-  if !(CheckComp(charCode2) and DeadCompose)

-  IfWinActive,ahk_class gdkWindowToplevel

-  {

-    StringLower,charCode1,charCode1

-    send % "^+u" . SubStr(charCode1,3) . " "

-  } else {

-    VarSetCapacity(ki,28*2,0)

-    EncodeInteger(&ki+0,1)

-    EncodeInteger(&ki+6,charCode1)

-    EncodeInteger(&ki+8,4)

-    EncodeInteger(&ki+28,1)

-    EncodeInteger(&ki+34,charCode1)

-    EncodeInteger(&ki+36,4|2)

-    DllCall("SendInput","UInt",2,"UInt",&ki,"Int",28)

-  }

-}

-

-EncodeInteger(ref,val) {

-  DllCall("ntdll\RtlFillMemoryUlong","Uint",ref,"Uint",4,"Uint",val)

-}

-

-

diff --git a/windows/autohotkey/Source/README.txt b/windows/autohotkey/Source/README.txt
deleted file mode 100644
index 0e75707..0000000
--- a/windows/autohotkey/Source/README.txt
+++ /dev/null
@@ -1,52 +0,0 @@
-== Hinweise für Entwickler ==
-
-=== AutoHotkey herunter laden ===
-Man sollte als erstes das Programm namens »AutoHotkey« (http://www.autohotkey.com/download/AutoHotkeyInstall.exe) herunterlanden. Es wird empfohlen, dieses Programm möglichst in dem vorgeschlagenen Standardverzeichnis zu installieren.
-Wenn man jedoch über KEINE Administratorrechte verfügt, kann man das Programm beispielsweise auch in das Verzeichnis »Eigene Dateien/Neo«  (oder in ein anderes Verzeichnis, für das man Schreibrechte hat) installieren.
-In diesem Fall muss dann für eine Kompilierung des Skriptes noch die Datei Build-Update.bat lokal entsprechend angepasst werden (diese lokale Änderung der Build-Update.bat aber bitte nicht einchecken, da die allermeisten Entwickler Autohotkey im vorgeschlagenen Standardverzeichnis installiert haben!).
-
-=== Die ausführbare Datei aktualisieren ===
-Um die neo20.exe auf den neuesten Stand zu bringen, reicht (wenn Autohotkey im Standardverzeichnis installiert wurde) ein Doppelklick auf die Batch-Datei Build-Update.bat
-Es ist empfehlenswert, diese Batch-Datei stets vor einem Commit auszuführen, damit die .exe-Datei immer auf dem aktuellsten Stand ist.
-
-=== Den Sourcecode bearbeiten ===
-Die Datei neo20.ahk sollte auf keinen Fall mehr direkt bearbeitet werden, da sie inzwischen automatisch generiert und regelmäßig überschrieben wird.
-
-Stattdessen müssen die Dateien/Module im Source-Unterverzeichnis bearbeitet werden, etwa:
-Source\Keys-Neo.ahk
-Source\Keys-Qwert-to-Neo.ahk
-Source\Methods-Layers.ahk
-Source\Methods-Lights.ahk
-
-Um die gemachten Änderungen zu testen, sollte die Datei Source\All.ahk verwendet werden, die alle Module einbindet und regulär durch einen Doppelklick mit dem AHK-Interpreter gestartet werden kann.
-
-Der große Vorteil dieser Methode liegt darin, dass sich die Zeilennummern eventueller Fehlermeldungen nicht mehr auf die große »vereinigte« AHK-Datei, sondern auf die tatsächlich relevanten Module beziehen, z. B. :
-Error at line 64 in #include file "C:\...\autohotkey\Source\Methods-Lights.ahk"
-Line Text: CTL_CODE_LED(p_device_type, p_function, p_method, p_access)
-Error: Functions cannot contain functions.
-The programm will exit.
-
-=== Links zur AHK/Autohotkey-Skriptsprache ===
-Eine kurze Einführung (Installation und Beispielskript) findet man etwa auf
-http://www.kikizas.net/en/usbapps.ahk.html
-
-Eine alphabetische Liste aller erlaubten Kommandos findet man online unter
-http://www.autohotkey.com/docs/commands.htm
-
-=== Coding-Style ===
-Der Programmcode sollte möglichst einheitlich formatiert werden, um mögliche Fehlerquellen auszuschließen und um optimale Lesbarkeit zu erreichen:
-
-== Zuweisungen mit ":=" ==
-AHK erlaubt mehrere Arten der Zuweisung. Um Missverständnissen vorzubeugen, möge ausschließlich die Zuweisung mittels ":=" Verwendung finden. Die Zuweisung mit einem "=" funktioniert zwar auch und erspart bei Zuweisung konstanter Zeichenfolgen auch die Anführungszeichen, sorgt aber spätestens bei Berechnungen für Verwirrung.
-
-== Funktionale If-Abfrage ==
-Abfragen mittels "if" können in AHK auf zwei unterschiedliche Arten erfolgen, die sich durch die Klammerung des Ausdrucks unterscheiden. Um auch hier Missverständnissen vorzubeugen, mögen sämtliche Abfragen in eine gemeinsame Klammer gefasst werden.
-
-== Möglichst auf %-Variablen verzichten ==
-Gibt es von einer Funktion oder Methode zwei Varianten, so ist die Variante vorzuziehen, bei der Variablen nicht mit %varname% escaped werden müssen (analog zur Zuweisung mit ":="), um Missverständnissen vorzubeugen.
-
-== Einrückung ==
-Einrückung einheitlich 2 Zeichen vor dem Beginn der Zeile, dazwischen einheitlich 1 Zeichen. Dient es der Lesbarkeit, z.B. die Abfragen einer "if"-Abfrage mit der darunter liegenden "else if"-Abfrage auszurichten, darf dies stattfinden.
-
-== Geschwungene Klammern ==
-Geschwungene Klammern zum Zusammenhalten eines Funktionsblocks oder If-Zweiges mögen dem Funktionsnamen bzw. if-Zweig folgen. Bei If-Abfragen möge "else" mit einem Leerzeichen Abstand an die schließende Klammer angehängt werden, woran dann gegebenenfalls die nächste öffnende Klammer mit einem Leerzeichen angehängt wird.
\ No newline at end of file
diff --git a/windows/autohotkey/Source/Warning.ahk b/windows/autohotkey/Source/Warning.ahk
deleted file mode 100644
index 559ce26..0000000
--- a/windows/autohotkey/Source/Warning.ahk
+++ /dev/null
@@ -1,45 +0,0 @@
-/*

-*******************************************

-WICHTIGE WARNUNG:

-

-Dies ist inzwischen eine automatisch generierte

-Datei! Sie wird regelmäßig überschrieben und

-sollte deshalb nicht mehr direkt bearbeitet werden!

-

-Alle weiterführenden Informationen finden sich im Abschnitt 

-== Hinweise für Entwickler ==

-in der Datei README.txt!

-

-Versionshinweise (SVN Keywords) für diese Datei:

-$LastChangedRevision$

-$LastChangedDate$

-$LastChangedBy$

-$HeadURL$

-*******************************************

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-*******************************************

-Das war die letzte WARNUNG, ich hoffe nur, dass

-Sie wirklich wissen, was Sie hier tun wollen ...

-*******************************************

-*/

-

-