diff options
| author | martin_r <martin_r@b9310e46-f624-0410-8ea1-cfbb3a30dc96> | 2008-09-15 01:08:23 +0000 |
|---|---|---|
| committer | martin_r <martin_r@b9310e46-f624-0410-8ea1-cfbb3a30dc96> | 2008-09-15 01:08:23 +0000 |
| commit | 617adf85157eec87ff3fc4f177cb71af260539e7 (patch) | |
| tree | 267abc0692a28f2c24f48e55745cb8b62bafb515 /windows | |
| parent | 43433b3d799a0b7e89c0d856e47f8a6bf68049b8 (diff) | |
Compose-Automatisierung für den AHK
git-svn-id: https://svn.neo-layout.org@872 b9310e46-f624-0410-8ea1-cfbb3a30dc96
Diffstat (limited to 'windows')
| -rw-r--r-- | windows/autohotkey/Changelog-and-Todo.txt | 6 | ||||
| -rw-r--r-- | windows/autohotkey/Compose/AutoComp1.bas | 38 | ||||
| -rw-r--r-- | windows/autohotkey/Compose/AutoComp2.bas | 52 | ||||
| -rw-r--r-- | windows/autohotkey/Source/All.ahk | 3 | ||||
| -rw-r--r-- | windows/autohotkey/Source/Compose.ahk | 3079 | ||||
| -rw-r--r-- | windows/autohotkey/Source/Keys-Neo.ahk | 643 | ||||
| -rw-r--r-- | windows/autohotkey/Source/Methods-Layers.ahk | 1 | ||||
| -rw-r--r-- | windows/autohotkey/Source/Methods-Other.ahk | 45 | ||||
| -rw-r--r-- | windows/autohotkey/Source/Methods-Unicode.ahk | 12 | ||||
| -rw-r--r-- | windows/autohotkey/neo20.ahk | 3780 | ||||
| -rw-r--r-- | windows/autohotkey/neo20.exe | bin | 424927 -> 439617 bytes |
11 files changed, 6417 insertions, 1242 deletions
diff --git a/windows/autohotkey/Changelog-and-Todo.txt b/windows/autohotkey/Changelog-and-Todo.txt index 399c09e..769a8e6 100644 --- a/windows/autohotkey/Changelog-and-Todo.txt +++ b/windows/autohotkey/Changelog-and-Todo.txt @@ -16,13 +16,17 @@ Matthias Wächter <matthias (at) waechter.wiz. a t> ‐ Ausgiebig testen … (besonders Vollständigkeit bei Deadkeys).
‐ Compose vollständig implementieren (Welche Methode ist hierzu am besten geeignet?).
‐ Bessere Lösung für das Leeren von PriorDeadKey finden, damit die Sondertasten nicht mehr abgefangen werden müssen.
+‐ Bildschirmtastatur anpassen.
=== Ideen und Vorschläge ===
-‐ Die Compose‐Kombinationen sollen automatisch aus den Referenzdateien im Compose‐Verzeichnis erzeugt werden.
‐ Modi für vertauschte Ziffern in der Zahlenreihe und auf der 4. Ebene.
=== Änderungshistorie ===
+Revision 872 (von Martin Roppelt)
+‐ Alle Cokos automatisch eingefügt.
+‐ Compose-Playground gelöscht.
+‐ Anpassung an die Referenz.
Revision 864 (von Martin Roppelt)
‐ 253/2822 Cokos ≙ 9%.
Revision 849 (von Martin Roppelt)
diff --git a/windows/autohotkey/Compose/AutoComp1.bas b/windows/autohotkey/Compose/AutoComp1.bas new file mode 100644 index 0000000..ad740f6 --- /dev/null +++ b/windows/autohotkey/Compose/AutoComp1.bas @@ -0,0 +1,38 @@ +Rem Compose-AHK-Konverter
+Rem 2008 Martin Paul Roppelt (m.p.roppelt@web.de) GPL 2/3
+Rem
+Rem Basic-Datei fr OpenOffice (2.4):
+Rem Dateipfade an das Zielsystem anpassen!
+Rem
+Rem Anleitung:
+Rem OpenOffice-Basic aufrufen (Alt-x,m,v,m; Alt-n).
+Rem Strg-a; Symbolleisten-Schaltflche: BASIC-Quelltext einfgen, diese Datei auswhlen.
+Rem Skript ausfhren (Alt-x,m,a oder F5).
+
+
+Sub Main
+ Open "C:\Users\Martin_2\NEO\Compose\Compose.neo" For Input Lock Write As #1
+ Open "C:\Users\Martin_2\NEO\Compose\en_US.UTF-8" For Input Lock Write As #2
+ Open "C:\Users\Martin_2\Programmieren\NEO\ComposeList.txt" For Output Lock Read Write As #3
+
+ LeseDatei(1)
+ LeseDatei(2)
+
+ Close 1, 2, 3
+End Sub
+
+Sub LeseDatei(DateiNummer% as Integer)
+ While Not Eof(DateiNummer%)
+ Line Input #DateiNummer%, DateiZeile$
+ Dateizeile$ = LTrim(DateiZeile$)
+ If Left(DateiZeile$, 1) = "<" Then
+ DoppelpunktPosition% = InStr(DateiZeile$, ":")
+ Definition$ = RTrim( Left(DateiZeile$, DoppelpunktPosition% - 1) )
+ KlammerAufPosition1% = InStr(Definition$, "<")
+ KlammerZuPosition1% = InStr(Definition$, ">")
+ Taste1$ = Mid(Definition$, KlammerAufPosition1% + 1, KlammerZuPosition1% - KlammerAufPosition1% - 1)
+ If Taste1$ = "Multi_key" Then Print #3, DateiZeile$
+ End If
+ Wend
+End Sub
+
diff --git a/windows/autohotkey/Compose/AutoComp2.bas b/windows/autohotkey/Compose/AutoComp2.bas new file mode 100644 index 0000000..dde2bae --- /dev/null +++ b/windows/autohotkey/Compose/AutoComp2.bas @@ -0,0 +1,52 @@ +REM ***** BASIC *****
+
+'Programm zur Umwandlung einer ComposeList.txt-Datei in eine Compose.ahk-Datei.
+' 14. und 15. Sept. 2008 Martin Paul Roppelt (m.p.roppelt@web.de) GPL 2/3
+
+'Anleitung:
+'Pfade anpassen :-)
+'Alle Tabulatoren durch ein /einzelnes/ Leerzeichen ersetzen.
+'Skript ausfhren.
+'Korrektur von ein paar ungelsten kleinen Problemchen:
+'Letzte Zeile der Ausgabedatei durch "}" ersetzen.
+'Folgende Zeilen abndern (muss man in der Quelldatei suchen!):
+'CheckCompUni("<t> <z>", 0xE04A", 0x) ->
+'CheckCompUni("<???? <????", 0x????) ->
+'CheckCompUni("<t> <z>", 0xE04A)
+'CheckCompUni("<?> <?>", 0x????)
+'Compose unter Windows genieen!
+
+Sub Main
+ Open "C:\Users\Martin_2\Programmieren\NEO\ComposeList16.txt" For Binary Lock Write As #1
+ Open "C:\Users\Martin_2\NEO\windows\autohotkey\Source\Compose.ahk" For Output Lock Read Write As #2
+ Print #2, "CheckCompose() {"
+ Print #2, "CheckCompUni("; chr(34);
+ Position& = -2
+ For Position& = 1 To Lof(1) Step 2
+ Get #1, Position&, a%
+ If a% = 10 Then
+ Print #2, ")" : Klammer% = 0: Kommentar% = 0: Quotedbl% = 0
+ Print #2, "CheckCompUni("; chr(34);
+ ElseIf a%=asc(":") Then
+ Print #2, chr(34); ", 0x";
+ Zeichen% = 1
+ ElseIf a%=asc(" ") Then
+ ElseIf a%=asc("<") Then
+ Klammer% = Klammer% + 1
+ If Klammer% > 2 Then Print #2, " ";
+ If Klammer% <> 1 and Kommentar% <> 1 Then Print #2, "<";
+ ElseIf a% = 34 Then
+ Quotedbl% = Quotedbl% + 1
+ If Quotedbl% = 2 Then
+ Kommentar% = 1
+ Zeichen = 0
+ EndIf
+ ElseIf Klammer% <> 1 and a% < 255 and a% > 0 and Kommentar% <> 1 and Zeichen% <> 1 Then
+ Print #2, Chr(a%);
+ ElseIf Klammer% <> 1 and Kommentar% <> 1 Then
+ If a% <> -257 Then Print #2, Iif(Len(Hex(a%))>4, Right(Hex(a%),4),Hex(a%));
+ End If
+ Next
+ Print #2, "}"
+ Close 1, 2
+End Sub
diff --git a/windows/autohotkey/Source/All.ahk b/windows/autohotkey/Source/All.ahk index 9639f25..61eaedb 100644 --- a/windows/autohotkey/Source/All.ahk +++ b/windows/autohotkey/Source/All.ahk @@ -14,6 +14,3 @@ #Include %a_scriptdir%\Compose.ahk
#Include %a_scriptdir%\Methods-Unicode.ahk
#Include %a_scriptdir%\Methods-ScreenKeyboard.ahk
-; Eines schnen Tages sollten auch die Compose-Kombinationen automatisch aus der Referenz erzeugt werden.
-; Derzeitig gibt es nur den (hchst instabilen und experimentellen!) Compose-Playground:
-; #Include *i %a_scriptdir%\..\Compose\Compose-all-in-one.ahk
diff --git a/windows/autohotkey/Source/Compose.ahk b/windows/autohotkey/Source/Compose.ahk index 6097434..a298ac3 100644 --- a/windows/autohotkey/Source/Compose.ahk +++ b/windows/autohotkey/Source/Compose.ahk @@ -1,256 +1,2827 @@ CheckCompose() {
-CheckCompAsc("p_{!}","")
-CheckCompAsc("P_{!}","")
-CheckCompAsc("P_P","")
-CheckCompAsc("o_c","")
-CheckCompAsc("o_C","")
-CheckCompAsc("O_C","")
-CheckCompAsc("O_c","")
-CheckCompAsc("o_r","")
-CheckCompAsc("O_r","")
-CheckCompAsc("o_R","")
-CheckCompAsc("O_R","")
-CheckCompAsc("A_T","@")
-CheckCompAsc("a_e","")
-CheckCompAsc("A_E","")
-CheckCompAsc("o_e","")
-CheckCompAsc("O_E","")
-CheckCompAsc("t_h","")
-CheckCompAsc("T_H","")
-CheckCompUni("{Numpad1}_{Numpad4}",0x00BC)
-CheckCompUni("1_4",0x00BC)
-CheckCompUni("{Numpad1}_{Numpad2}",0x00BD)
-CheckCompUni("1_2",0x00BD)
-CheckCompUni("{Numpad3}_{Numpad4}",0x00BE)
-CheckCompUni("3_4",0x00BE)
-CheckCompUni("-_H",0x0126)
-CheckCompUni("-_h",0x0127)
-CheckCompUni("I_J",0x0132)
-CheckCompUni("i_j",0x0133)
-CheckCompUni("N_G",0x014A)
-CheckCompUni("n_g",0x014B)
-CheckCompUni("E_E",0x018F)
-CheckCompUni("D_z",0x01C4)
-CheckCompUni("D_z",0x01C5)
-CheckCompUni("d_z",0x01C6)
-CheckCompUni("L_J",0x01C7)
-CheckCompUni("L_j",0x01C8)
-CheckCompUni("l_j",0x01C9)
-CheckCompUni("N_J",0x01CA)
-CheckCompUni("N_j",0x01CB)
-CheckCompUni("n_j",0x01CC)
-CheckCompUni("G_A",0x0391)
-CheckCompUni("G_B",0x0392)
-CheckCompUni("G_E",0x0395)
-CheckCompUni("G_Z",0x0396)
-CheckCompUni("G_H",0x0397)
-CheckCompUni("G_I",0x0399)
-CheckCompUni("G_K",0x039A)
-CheckCompUni("G_M",0x039C)
-CheckCompUni("G_N",0x039D)
-CheckCompUni("G_X",0x039D)
-CheckCompUni("G_O",0x039F)
-CheckCompUni("G_P",0x03A1)
-CheckCompUni("G_T",0x03A4)
-CheckCompUni("G_Y",0x03A5)
-CheckCompUni("a_{Numpad0}",0x0660)
-CheckCompUni("a_0",0x0660)
-CheckCompUni("a_{Numpad1}",0x0661)
-CheckCompUni("a_1",0x0661)
-CheckCompUni("a_{Numpad2}",0x0662)
-CheckCompUni("a_2",0x0662)
-CheckCompUni("a_{Numpad3}",0x0663)
-CheckCompUni("a_3",0x0663)
-CheckCompUni("a_{Numpad4}",0x0664)
-CheckCompUni("a_4",0x0664)
-CheckCompUni("a_{Numpad5}",0x0665)
-CheckCompUni("a_5",0x0665)
-CheckCompUni("a_{Numpad6}",0x0666)
-CheckCompUni("a_6",0x0666)
-CheckCompUni("a_{Numpad7}",0x0667)
-CheckCompUni("a_7",0x0667)
-CheckCompUni("a_{Numpad8}",0x0668)
-CheckCompUni("a_8",0x0668)
-CheckCompUni("a_{Numpad9}",0x0669)
-CheckCompUni("a_9",0x0669)
-CheckCompUni("0x2020_0x2020",0x2021)
-CheckCompUni(":_:",0x2025)
-CheckCompUni("{!}_{Numpad2}",0x203C)
-CheckCompUni("{!}_2",0x203C)
-CheckCompUni("{Numpad2}_{!}",0x203C)
-CheckCompUni("2_{!}",0x203C)
-CheckCompUni("{Numpad1}_?_{!}",0x203D)
-CheckCompUni("{Numpad1}_{!}_?",0x203D)
-CheckCompUni("1_?_{!}",0x203D)
-CheckCompUni("1_{!}_?",0x203D)
-CheckCompUni("?_{Numpad2}",0x2047)
-CheckCompUni("?_2",0x2047)
-CheckCompUni("{Numpad2}_?",0x2047)
-CheckCompUni("2_?",0x2047)
-CheckCompUni("?_{!}",0x2048)
-CheckCompUni("{!}_?",0x2049)
-CheckCompUni("0x2192_0x2192",0x20D7)
-CheckCompUni("s_m",0x2120)
-CheckCompUni("t_m",0x2122)
-CheckCompUni("{Numpad1}_{Numpad3}",0x2153)
-CheckCompUni("1_3",0x2153)
-CheckCompUni("{Numpad5}_{Numpad3}",0x2154)
-CheckCompUni("5_3",0x2154)
-CheckCompUni("{Numpad1}_{Numpad5}",0x2155)
-CheckCompUni("1_5",0x2155)
-CheckCompUni("{Numpad2}_{Numpad5}",0x2156)
-CheckCompUni("2_5",0x2156)
-CheckCompUni("{Numpad3}_{Numpad5}",0x2157)
-CheckCompUni("3_5",0x2157)
-CheckCompUni("{Numpad4}_{Numpad5}",0x2158)
-CheckCompUni("4_5",0x2158)
-CheckCompUni("{Numpad1}_{Numpad6}",0x2159)
-CheckCompUni("1_6",0x2159)
-CheckCompUni("{Numpad5}_{Numpad6}",0x215A)
-CheckCompUni("5_6",0x215A)
-CheckCompUni("{Numpad1}_{Numpad8}",0x215B)
-CheckCompUni("1_8",0x215B)
-CheckCompUni("{Numpad3}_{Numpad8}",0x215C)
-CheckCompUni("3_8",0x215C)
-CheckCompUni("{Numpad5}_{Numpad8}",0x215D)
-CheckCompUni("5_8",0x215D)
-CheckCompUni("{Numpad7}_{Numpad8}",0x215E)
-CheckCompUni("7_8",0x215E)
-CheckCompUni("{Numpad1}_`/",0x215F)
-CheckCompUni("{Numpad1}_{NumpadDiv}",0x215F)
-CheckCompUni("1_`/",0x215F)
-CheckCompUni("1_{NumpadDiv}",0x215F)
-CheckCompUni("R_{Numpad1}_{Space}",0x2160)
-CheckCompUni("R_1_{Space}",0x2160)
-CheckCompUni("R_{Numpad2}",0x2161)
-CheckCompUni("R_2",0x2161)
-CheckCompUni("R_{Numpad3}",0x2162)
-CheckCompUni("R_3",0x2162)
-CheckCompUni("R_{Numpad4}",0x2163)
-CheckCompUni("R_4",0x2163)
-CheckCompUni("R_{Numpad5}",0x2164)
-CheckCompUni("R_5",0x2164)
-CheckCompUni("R_{Numpad6}",0x2165)
-CheckCompUni("R_6",0x2165)
-CheckCompUni("R_{Numpad7}",0x2166)
-CheckCompUni("R_7",0x2166)
-CheckCompUni("R_{Numpad8}",0x2167)
-CheckCompUni("R_8",0x2167)
-CheckCompUni("R_{Numpad9}",0x2168)
-CheckCompUni("R_9",0x2168)
-CheckCompUni("R_{Numpad1}_{Numpad0}",0x2169)
-CheckCompUni("R_1_0",0x2169)
-CheckCompUni("R_{Numpad1}_{Numpad1}",0x216A)
-CheckCompUni("R_1_1",0x216A)
-CheckCompUni("R_{Numpad1}_{Numpad2}",0x216B)
-CheckCompUni("R_1_2",0x216B)
-CheckCompUni("r_{Numpad1}_{Space}",0x2170)
-CheckCompUni("r_1_{Space}",0x2170)
-CheckCompUni("r_{Numpad2}",0x2171)
-CheckCompUni("r_2",0x2171)
-CheckCompUni("r_{Numpad3}",0x2172)
-CheckCompUni("r_3",0x2172)
-CheckCompUni("r_{Numpad4}",0x2173)
-CheckCompUni("r_4",0x2173)
-CheckCompUni("r_{Numpad5}",0x2174)
-CheckCompUni("r_5",0x2174)
-CheckCompUni("r_{Numpad6}",0x2175)
-CheckCompUni("r_6",0x2175)
-CheckCompUni("r_{Numpad7}",0x2176)
-CheckCompUni("r_7",0x2176)
-CheckCompUni("r_{Numpad8}",0x2177)
-CheckCompUni("r_8",0x2177)
-CheckCompUni("r_{Numpad9}",0x2178)
-CheckCompUni("r_9",0x2178)
-CheckCompUni("r_{Numpad1}_{Numpad0}",0x2179)
-CheckCompUni("r_1_0",0x2179)
-CheckCompUni("r_{Numpad1}_{Numpad1}",0x217A)
-CheckCompUni("r_1_1",0x217A)
-CheckCompUni("r_{Numpad1}_{Numpad2}",0x217B)
-CheckCompUni("r_1_2",0x217B)
-CheckCompUni("{Numpad3}_0x221A",0x221B)
-CheckCompUni("0x221A_{Numpad3}",0x221B)
-CheckCompUni("0x221A_3",0x221B)
-CheckCompUni("3_0x221A",0x221B)
-CheckCompUni("{Numpad4}_0x221A",0x221C)
-CheckCompUni("0x221A_{Numpad4}",0x221C)
-CheckCompUni("0x221A_4",0x221C)
-CheckCompUni("4_0x221A",0x221C)
-CheckCompUni("{Numpad2}_0x222B",0x222C)
-CheckCompUni("0x222B_{Numpad2}",0x222C)
-CheckCompUni("0x222B_0x222B",0x222C)
-CheckCompUni("0x222B_2",0x222C)
-CheckCompUni("2_0x222B",0x222C)
-CheckCompUni("{Numpad3}_0x222B",0x222D)
-CheckCompUni("0x222B_{Numpad3}",0x222D)
-CheckCompUni("0x222B_3",0x222D)
-CheckCompUni("3_0x222B",0x222D)
-CheckCompUni("{Numpad2}_0x222E",0x222F)
-CheckCompUni("0x222E_{Numpad2}",0x222F)
-CheckCompUni("0x222E_2",0x222F)
-CheckCompUni("2_0x222E",0x222F)
-CheckCompUni("{Numpad3}_0x222E",0x2230)
-CheckCompUni("0x222E_{Numpad3}",0x2230)
-CheckCompUni("0x222E_3",0x2230)
-CheckCompUni("3_0x222E",0x2230)
-CheckCompUni("0x005E_[",0x2308)
-CheckCompUni("0x005E_]",0x2309)
-CheckCompUni("__[",0x230A)
-CheckCompUni("__]",0x230B)
-CheckCompUni(":_(",0x2639)
-CheckCompUni(":_)",0x263A)
-CheckCompUni("{Numpad4}_0x222B",0x2A0C)
-CheckCompUni("0x222B_{Numpad4}",0x2A0C)
-CheckCompUni("0x222B_4",0x2A0C)
-CheckCompUni("4_0x222B",0x2A0C)
-CheckCompUni("{Numpad1}__",0x2E18)
-CheckCompUni("{Numpad1}__",0x2E18)
-CheckCompUni("1__",0x2E18)
-CheckCompUni("1__",0x2E18)
-CheckCompUni("2_m_m",0x339F)
-CheckCompUni("2_c_m",0x33A0)
-CheckCompUni("2_m_{Space}",0x33A1)
-CheckCompUni("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("l_n",0x33D1)
-CheckCompUni("l_o_g",0x33D2)
-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("c_k",0xE03A)
-CheckCompUni("c_h",0xE03B)
-CheckCompUni("t_t",0xE03C)
-CheckCompUni("c_t",0xE03D)
-CheckCompUni("0x017F_i",0xE03E)
-CheckCompUni("0x017F_0x017F",0xE03F)
-CheckCompUni("0x017F_l",0xE043)
-CheckCompUni("S_i",0xE044)
-CheckCompUni("0x017F_s",0xE045)
-CheckCompUni("Q_u",0xE048)
-CheckCompUni("T_h",0xE049)
-CheckCompUni("t_z",0xE04A)
-CheckCompUni("f_f",0xFB00)
-CheckCompUni("f_i",0xFB01)
-CheckCompUni("f_l",0xFB02)
-CheckCompUni("F_i",0xFB03)
-CheckCompUni("F_l",0xFB04)
-CheckCompUni("0x017F_t",0xFB05)
-CheckCompUni("s_t",0xFB06)
-CheckCompAsc("'_A","")
-CheckCompAsc("'_a","")
-CheckCompUni("U_A",0x0102)
-CheckCompUni("b_A",0x0102)
-CheckCompUni("U_a",0x0103)
-CheckCompUni("b_a",0x0103)
-
+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("<c> <k>", 0xE03A)
+CheckCompUni("<c> <h>", 0xE03B)
+CheckCompUni("<t> <t>", 0xE03C)
+CheckCompUni("<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("<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("<slash> <equal>", 0x2260)
+CheckCompUni("<KP_Divide> <KP_equal>", 0x2260)
+CheckCompUni("<notsign> <equal>", 0x2260)
+CheckCompUni("<less> <greater>", 0x2260)
+CheckCompUni("<KP_Add> <KP_Subtract>", 0xB1)
+CheckCompUni("<KP_Subtract> <KP_Add>", 0x2213)
+CheckCompUni("<minus> <plus>", 0x2213)
+CheckCompUni("<rightarrow> <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("<G> <H> <z>", 0x3393)
+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/Keys-Neo.ahk b/windows/autohotkey/Source/Keys-Neo.ahk index a23d709..f996dd3 100644 --- a/windows/autohotkey/Source/Keys-Neo.ahk +++ b/windows/autohotkey/Source/Keys-Neo.ahk @@ -8,18 +8,12 @@ neo_tot1: noCaps = 1
EbeneAktualisieren()
if (Ebene = 1) and !CheckDeadUni("c1",0x0302)
- deadUni(0x02C6, "c1") ; Zirkumflex, tot
+ deadUni(0x02C6, "dead_circumflex", "c1") ; Zirkumflex, tot
else if (Ebene = 2) and !CheckDeadUni("c2",0x030C)
- deadUni(0x02C7, "c2") ; Caron, tot
+ deadUni(0x02C7, "dead_caron", "c2") ; Caron, tot
else if (Ebene = 3) and !CheckDeadUni("c3",0x0306)
- deadUni(0x02D8, "c3") ; Brevis, tot
- else if (Ebene = 4)
- deadUni(0x00B7, "c4") ; Mittenpunkt, tot
- else if (Ebene = 5) and !CheckDeadUni("c5",0x0335)
- deadUni(0x002D, "c5") ; Querstrich, tot
- else if (Ebene = 6) and !CheckDeadUni("c6",0x0323)
- deadUni(0x002E, "c6") ; Punkt drunter (Colon), tot
- CompKey := PriorCompKey
+ deadUni(0x02D8, "dead_breve", "c3") ; Brevis, tot
+ ;CompKey := PriorCompKey
return
neo_1:
@@ -27,15 +21,15 @@ neo_1: EbeneAktualisieren()
if Ebene12 and !(CheckDeadUni("c1",0x00B9) ; Hochgestellte 1
or CheckDeadUni("c5",0x2081)) ; Tiefgestellte 1
- OutputChar12(1,"")
+ OutputChar12(1,"",1,"degree")
else if (Ebene = 3)
- SendUnicodeChar(0x00B9) ; Hochgestellte 1
+ SendUnicodeChar(0x00B9, "onesuperior") ; Hochgestellte 1
else if (Ebene = 4)
- SendUnicodeChar(0x2022) ; Bullet
+ SendUnicodeChar(0x2022, "enfilledcircbullet") ; Bullet
else if (Ebene = 5)
- SendUnicodeChar(0x2640) ; Piktogramm weiblich
+ SendUnicodeChar(0x2081, "U2081") ; Tiefgestellte 1
else if (Ebene = 6)
- SendUnicodeChar(0x00AC) ; Nicht-Symbol
+ SendUnicodeChar(0x00AC, "notsign") ; Nicht-Symbol
return
neo_2:
@@ -43,17 +37,17 @@ neo_2: EbeneAktualisieren()
if (Ebene = 1 and !(CheckDeadUni("c1",0x00B2) ; Hochgestellte 2
or CheckDeadUni("c5",0x2082))) ; Tiefgestellte 2
- OutputChar(2)
+ OutputChar(2,2)
else if (Ebene = 2)
- SendUnicodeChar(0x2116) ; Numero
+ SendUnicodeChar(0x2116, "numerosign") ; Numero
else if (Ebene = 3)
- SendUnicodeChar(0x00B2) ; Hochgestellte 2
+ SendUnicodeChar(0x00B2, "twosuperior") ; Hochgestellte 2
else if (Ebene = 4)
- SendUnicodeChar(0x2023) ; Aufzhlungspfeil
+ SendUnicodeChar(0x2023, "U2023") ; Aufzhlungspfeil
else if (Ebene = 5)
- SendUnicodeChar(0x26A5) ; Piktogramm Zwitter
+ SendUnicodeChar(0x2082, "U2082") ; Tiefgestellte 2
else if (Ebene = 6)
- SendUnicodeChar(0x2228) ; Logisches Oder
+ SendUnicodeChar(0x2228, "logicalor") ; Logisches Oder
return
neo_3:
@@ -61,15 +55,15 @@ neo_3: EbeneAktualisieren()
if Ebene12 and !(CheckDeadUni("c1",0x00B3) ; Hochgestellte 3
or CheckDeadUni("c5",0x2083)) ; Tiefgestellte 3
- OutputChar12(3,"")
+ OutputChar12(3,"",3,"section")
else if (Ebene = 3)
- SendUnicodeChar(0x00B3) ; Hochgestellte 3
+ SendUnicodeChar(0x00B3, "threesuperior") ; Hochgestellte 3
else if (Ebene = 4)
- SendUnicodeChar(0x266B) ; 2 Achtelnoten
+ SendUnicodeChar(0x266B, "U226B") ; 2 Achtelnoten
else if (Ebene = 5)
- SendUnicodeChar(0x2642) ; Piktogramm Mann
+ SendUnicodeChar(0x2083, "U2083") ; Tiefgestellte 3
else if (Ebene = 6)
- SendUnicodeChar(0x2227) ; Logisches Und
+ SendUnicodeChar(0x2227, "logicaland") ; Logisches Und
return
neo_4:
@@ -77,17 +71,17 @@ neo_4: EbeneAktualisieren()
if (Ebene = 1) and !(CheckDeadUni("c1",0x2074) ; Hochgestellte 4
or CheckDeadUni("c5",0x2084)) ; Tiefgestellte 4
- OutputChar(4)
+ OutputChar(4,4)
else if (Ebene = 2)
- SendUnicodeChar(0x00BB) ; Double guillemot right
+ SendUnicodeChar(0x00BB, "guillemotright") ; Double guillemot right
else if (Ebene = 3)
- Send {blind} ; Single guillemot right
+ OutputChar("", "U230A") ; Single guillemot right
else if (Ebene = 4)
- Send {blind}{PgUp}
+ OutputChar("{PgUp}", "Prior") ; Bild auf
else if (Ebene = 5)
- SendUnicodeChar(0x2113) ; Script small L
+ SendUnicodeChar(0x2113, "U2213") ; Script small L
else if (Ebene = 6)
- SendUnicodeChar(0x22A5) ; Senkrecht
+ SendUnicodeChar(0x22A5, "uptack") ; Senkrecht
return
neo_5:
@@ -95,15 +89,15 @@ neo_5: EbeneAktualisieren()
if (Ebene = 1) and !(CheckDeadUni("c1",0x2075) ; Hochgestellte 5
or CheckDeadUni("c5",0x2085)) ; Tiefgestellte 5
- OutputChar(5)
+ OutputChar(5,5)
else if (Ebene = 2)
- SendUnicodeChar(0x00AB) ; Double guillemot left
+ SendUnicodeChar(0x00AB, "guillemotleft") ; Double guillemot left
else if (Ebene = 3)
- Send {blind} ; Single guillemot left
+ OutputChar("", "U2039") ; Single guillemot left
else if (Ebene = 5)
- SendUnicodeChar(0x2020) ; Kreuz (Dagger)
+ SendUnicodeChar(0x0AF8, "femalesymbol") ; Kreuz (Dagger)
else if (Ebene = 6)
- SendUnicodeChar(0x2221) ; Winkel
+ SendUnicodeChar(0x2221, "U2221") ; Winkel
return
neo_6:
@@ -111,15 +105,17 @@ neo_6: EbeneAktualisieren()
if (Ebene = 1) and !(CheckDeadUni("c1",0x2076) ; Hochgestellte 6
or CheckDeadUni("c5",0x2086)) ; Tiefgestellte 6
- OutputChar(6)
+ OutputChar(6,6)
else if (Ebene = 2)
- SendUnicodeChar(0x20AC)
+ SendUnicodeChar(0x20AC, "EuroSign")
else if (Ebene = 3)
- send {blind}
+ OutputChar("", "cent")
else if (Ebene = 4)
- send {blind}
+ OutputChar("", "sterling")
+ else if (Ebene = 5)
+ SendUnicodeChar(0x0AF7, "malesymbol")
else if (Ebene = 6)
- SendUnicodeChar(0x2225) ; parallel
+ SendUnicodeChar(0x2225, "U2225") ; parallel
return
neo_7:
@@ -127,15 +123,15 @@ neo_7: EbeneAktualisieren()
if Ebene12 and !(CheckDeadUni("c1",0x2077) ; Hochgestellte 7
or CheckDeadUni("c5",0x2087)) ; Tiefgestellte 7
- OutputChar12(7,"$")
+ OutputChar12(7,"$",7,"dollar")
else if (Ebene = 3)
- send {blind}
+ OutputChar("", "yen")
else if (Ebene = 4)
- send {blind}
+ OutputChar("", "currency")
else if (Ebene = 5)
- SendUnicodeChar(0x03BA) ; greek small letter kappa
+ SendUnicodeChar(0x03BA, "Greek_kappa") ; greek small letter kappa
else if (Ebene = 6)
- SendUnicodeChar(0x2209) ; nicht Element von
+ SendUnicodeChar(0x2209, "notelementof") ; nicht Element von
return
neo_8:
@@ -143,15 +139,15 @@ neo_8: EbeneAktualisieren()
if Ebene12 and !(CheckDeadUni("c1",0x2078) ; Hochgestellte 8
or CheckDeadUni("c5",0x2088)) ; Tiefgestellte 8
- OutputChar12(8,"")
+ OutputChar12(8,"",8,"doublelowquotemark")
else if (Ebene = 3)
- send {blind}
+ OutputChar("", "singlelowquotemark")
else if (Ebene = 4)
- Send {blind}{NumpadDiv}
+ OutputChar("{NumpadDiv}", "KP_Divide")
else if (Ebene = 5)
- SendUnicodeChar(0x27E8) ; bra (ffnende spitze Klammer)
+ SendUnicodeChar(0x27E8, "U27E8") ; bra (ffnende spitze Klammer)
else if (Ebene = 6)
- SendUnicodeChar(0x2204) ; es existiert nicht
+ SendUnicodeChar(0x2204, "U2204") ; es existiert nicht
return
neo_9:
@@ -159,15 +155,15 @@ neo_9: EbeneAktualisieren()
if Ebene12 and !(CheckDeadUni("c1",0x2079) ; Hochgestellte 9
or CheckDeadUni("c5",0x2089)) ; Tiefgestellte 9
- OutputChar12(9,"")
+ OutputChar12(9,"",9,"leftdoublequotemark")
else if (Ebene = 3)
- send {blind}
+ OutputChar("", "leftsinglequotemark")
else if (Ebene = 4)
- Send {blind}{NumpadMult}
+ OutputChar("{NumpadMult}", "KP_Multiply")
else if (Ebene = 5)
- SendUnicodeChar(0x27E9) ; ket (schlieende spitze Klammer)
+ SendUnicodeChar(0x27E9, "U27E9") ; ket (schlieende spitze Klammer)
else if (Ebene = 6)
- SendUnicodeChar(0x2226) ; nicht parallel
+ SendUnicodeChar(0x2226, "U2226") ; nicht parallel
return
neo_0:
@@ -175,45 +171,45 @@ neo_0: EbeneAktualisieren()
if Ebene12 and !(CheckDeadUni("c1",0x2070) ; Hochgestellte 0
or CheckDeadUni("c5",0x2080)) ; Tiefgestellte 0
- OutputChar12(0,"")
+ OutputChar12(0,"",0,"rightdoublequotemark")
else if (Ebene = 3)
- send {blind}
+ OutputChar("", "rightsingleqoutemark")
else if (Ebene = 4)
- Send {blind}{NumpadSub}
+ OutputChar("{NumpadSub}", "minus") ; s. Mail vom Sun, 14 Sep 2008 00:33:47 +0200
else if (Ebene = 6)
- SendUnicodeChar(0x2205) ; leere Menge
+ SendUnicodeChar(0x2205, "emptyset") ; leere Menge
return
neo_strich:
noCaps = 1
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("-") ; Bindestrich-Minus
+ OutputChar("-", "minus") ; Bindestrich-Minus
else if (Ebene = 2)
- SendUnicodeChar(0x2013) ; Gedankenstrich
+ SendUnicodeChar(0x2013, "endash") ; Gedankenstrich
else if (Ebene = 3)
- SendUnicodeChar(0x2014) ; Englischer Gedankenstrich (Geviertstrich)
+ SendUnicodeChar(0x2014, "emdash") ; Englischer Gedankenstrich (Geviertstrich)
else if (Ebene = 5)
- SendUnicodeChar(0x2011) ; geschtzter Bindestrich (Bindestrich ohne Zeilenumbruch)
+ SendUnicodeChar(0x2011, "U2011") ; geschtzter Bindestrich (Bindestrich ohne Zeilenumbruch)
else if (Ebene = 6)
- SendUnicodeChar(0x00AD) ; weicher Bindestrich
+ SendUnicodeChar(0x00AD, "hyphen") ; weicher Bindestrich
return
neo_tot2:
noCaps = 1
EbeneAktualisieren()
if (Ebene = 1) and !CheckDeadUni("a1",0x0301)
- deadAsc("{}{space}", "a1") ; Akut, tot
+ deadAsc("{}{space}", "dead_acute", "a1") ; Akut, tot
else if (Ebene = 2) and !CheckDeadUni("a2",0x0300)
- deadAsc("``{space}", "a2") ; Gravis, tot
+ deadAsc("``{space}", "dead_grave", "a2") ; Gravis, tot
else if (Ebene = 3) and !CheckDeadUni("a3",0x0327)
- deadAsc("", "a3") ; Cedilla, tot
+ deadAsc("", "dead_cedilla", "a3") ; Cedilla, tot
else if (Ebene = 4) and !CheckDeadUni("a4",0x0307)
- deadUni(0x02D9, "a4") ; Punkt oben
+ deadUni(0x02D9, "dead_abovedot", "a4") ; Punkt oben
else if (Ebene = 5) and !CheckDeadUni("a5",0x0328)
- deadUni(0x02DB, "a5") ; Ogonek
+ deadUni(0x02DB, "dead_ogonek", "a5") ; Ogonek
else if (Ebene = 6) and !CheckDeadUni("a6",0x030A)
- deadUni(0x02DA, "a6") ; Ring oben
+ deadUni(0x02DA, "dead_abovering", "a6") ; Ring oben
CompKey := PriorCompKey
return
@@ -227,32 +223,29 @@ return neo_x:
EbeneAktualisieren()
if Ebene12
- OutputChar12("x","X")
+ OutputChar12("x","X","x","X")
else if (Ebene = 3)
- SendUnicodeChar(0x2026) ; Ellipse horizontal
+ SendUnicodeChar(0x2026, "ellipsis") ; Ellipse horizontal
else if (Ebene = 4)
- SendUnicodeChar(0x22EE) ; Ellipse vertikal
+ SendUnicodeChar(0x22EE, "U22EE") ; Ellipse vertikal
else if (Ebene = 5)
- SendUnicodeChar(0x03BE) ; xi
+ SendUnicodeChar(0x03BE, "Greek_xi") ; xi
else if (Ebene = 6)
- SendUnicodeChar(0x039E) ; Xi
+ SendUnicodeChar(0x039E, "Greek_XI") ; Xi
return
-
neo_v:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("c6",0x1E7F,0x1E7E)))
- OutputChar12("v","V")
+ OutputChar12("v","V","v","V")
else if (Ebene = 3)
- OutputChar("_")
+ OutputChar("_","underscore")
else if (Ebene = 4) and (!lernModus or lernModus_neo_Backspace)
- Send {blind}{Backspace}
+ OutputChar("{Backspace}", "BackSpace")
else if (Ebene = 6)
- SendUnicodeChar(0x2259) ; estimates/entspricht
+ SendUnicodeChar(0x2259, "U2259") ; estimates/entspricht
return
-
-
neo_l:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a1",0x013A,0x0139)
@@ -261,18 +254,17 @@ neo_l: or CheckDeadUni12("c4",0x0140,0x013F)
or CheckDeadUni12("c6",0x1E37,0x1E36)
or CheckDeadUni12("t4",0x0142,0x0141)))
- OutputChar12("l","L")
+ OutputChar12("l","L","l","L")
else if (Ebene = 3)
- OutputChar("[")
+ OutputChar("[", "bracketleft")
else if (Ebene = 4)
- Send {Blind}{Up}
+ OutputChar("{Up}", "Up")
else if (Ebene = 5)
- SendUnicodeChar(0x03BB) ; lambda
+ SendUnicodeChar(0x03BB, "Greek_lambda") ; lambda
else if (Ebene = 6)
- SendUnicodeChar(0x039B) ; Lambda
+ SendUnicodeChar(0x039B, "Greek_LAMBDA") ; Lambda
return
-
neo_c:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a1",0x0107,0x0106)
@@ -280,44 +272,44 @@ neo_c: or CheckDeadUni12("a4",0x010B,0x010A)
or CheckDeadUni12("c1",0x0109,0x0108)
or CheckDeadUni12("c2",0x010D,0x010C)))
- OutputChar12("c","C")
+ OutputChar12("c","C","c","C")
else if (Ebene = 3)
- OutputChar("]")
+ OutputChar("]", "bracketright")
else if (Ebene = 4) and (!lernModus or lernModus_neo_Entf)
- send {blind}{Del}
+ OutputChar("{Del}", "Delete")
else if (Ebene = 5)
- SendUnicodeChar(0x03C7) ; chi
+ SendUnicodeChar(0x03C7, "Greek_chi") ; chi
else if (Ebene = 6)
- SendUnicodeChar(0x2102) ; C (Komplexe Zahlen)]
+ SendUnicodeChar(0x2102, "U2102") ; C (Komplexe Zahlen)]
return
neo_w:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("c1",0x0175,0x0174)))
- OutputChar12("w","W")
+ OutputChar12("w","W","w","W")
else if (Ebene = 3)
- SendUnicodeChar(0x005E) ; Zirkumflex
+ SendUnicodeChar(0x005E, "asciicircum") ; Zirkumflex
else if (Ebene = 4)
- Send {blind}{Insert} ; Einfg
+ OutputChar("{Insert}", "Insert") ; Einfg
else if (Ebene = 5)
- SendUnicodeChar(0x03C9) ; omega
+ SendUnicodeChar(0x03C9, "Greek_omega") ; omega
else if (Ebene = 6)
- SendUnicodeChar(0x03A9) ; Omega
+ SendUnicodeChar(0x03A9, "Greek_OMEGA") ; Omega
return
neo_k:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a3",0x0137,0x0136)
or CheckDeadUni12("c6",0x1E33,0x1E32)))
- OutputChar12("k","K")
+ OutputChar12("k","K","k","K")
else if (Ebene = 3)
- OutputChar("{!}")
+ OutputChar("{!}", "exclam")
else if (Ebene = 4)
- OutputChar("")
+ OutputChar("", "exclamdown")
else if (Ebene = 5)
- SendUnicodeChar(0x03F0) ; kappa symbol (varkappa)
+ SendUnicodeChar(0x03F0, "U03F0") ; kappa symbol (varkappa)
else if (Ebene = 6)
- SendUnicodeChar(0x221A) ; Wurzel
+ SendUnicodeChar(0x221A, "radical") ; Wurzel
return
neo_h:
@@ -326,16 +318,16 @@ neo_h: or CheckDeadUni12("c1",0x0125,0x0124)
or CheckDeadUni12("c5",0x0127,0x0126)
or CheckDeadUni12("c6",0x1E25,0x1E24)))
- OutputChar12("h","H")
- else if ((Ebene = 3) and !(CheckDeadUni("c5",0x2264))) ; kleiner gleich
- send {blind}<
+ OutputChar12("h","H","h","H")
+ else if ((Ebene = 3) and !(CheckDeadUni("t4",0x2264))) ; kleiner gleich
+ OutputChar("<", "less")
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2077)
- or CheckDeadUni("c5",0x2087)))
- OutputChar("{Numpad7}")
+ or CheckDeadUni("t4",0x2087)))
+ OutputChar("{Numpad7}", "KP_7")
else if (Ebene = 5)
- SendUnicodeChar(0x03C8) ; psi
+ SendUnicodeChar(0x03C8, "Greek_psi") ; psi
else if (Ebene = 6)
- SendUnicodeChar(0x03A8) ; Psi
+ SendUnicodeChar(0x03A8, "Greek_PSI") ; Psi
return
neo_g:
@@ -344,71 +336,70 @@ neo_g: or CheckDeadUni12("a4",0x0121,0x0120)
or CheckDeadUni12("c1",0x011D,0x011C)
or CheckDeadUni12("c3",0x011F,0x011E)))
- OutputChar12("g","G")
- else if ((Ebene = 3) and !(CheckDeadUni("c5",0x2265))) ; grer gleich
- send {blind}>
+ OutputChar12("g","G","g","G")
+ else if ((Ebene = 3) and !(CheckDeadUni("t4",0x2265))) ; grer gleich
+ OutputChar(">", "greater")
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2078)
- or CheckDeadUni("c5",0x2088)))
- OutputChar("{Numpad8}")
+ or CheckDeadUni("t4",0x2088)))
+ OutputChar("{Numpad8}", "KP_8")
else if (Ebene = 5)
- SendUnicodeChar(0x03B3) ; gamma
+ SendUnicodeChar(0x03B3, "Greek_gamma") ; gamma
else if (Ebene = 6)
- SendUnicodeChar(0x0393) ; Gamma
+ SendUnicodeChar(0x0393, "Greek_GAMMA") ; Gamma
return
neo_f:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a4",0x1E1F,0x1E1E)
or CheckDeadUni12("t4",0x0192,0x0191)))
- OutputChar12("f","F")
+ OutputChar12("f","F","f","F")
else if ((Ebene = 3) and !(CheckDeadUni("a6",0x2257) ; ring equal to
or CheckDeadUni("c1",0x2259) ; entspricht
or CheckDeadUni("c2",0x225A) ; EQUIANGULAR TO
- or CheckDeadUni("c5",0x2261) ; identisch
+ or CheckDeadUni("t2",0x2261) ; identisch
or CheckDeadUni("t1",0x2245) ; ungefhr gleich
or CheckDeadUni("t4",0x2260))) ; ungleich
- send {blind}`=
+ OutputChar("`=", "equal")
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2079)
- or CheckDeadUni("c5",0x2089)))
- OutputChar("{Numpad9}")
+ or CheckDeadUni("t4",0x2089)))
+ OutputChar("{Numpad9}", "KP_9")
else if (Ebene = 5)
- SendUnicodeChar(0x03C6) ; phi
+ SendUnicodeChar(0x03C6, "Greek_phi") ; phi
else if (Ebene = 6)
- SendUnicodeChar(0x03A6) ; Phi
+ SendUnicodeChar(0x03A6, "Greek_PHI") ; Phi
return
neo_q:
EbeneAktualisieren()
if (Ebene12)
- OutputChar12("q","Q")
+ OutputChar12("q","Q","q","Q")
else if (Ebene = 3)
- send {blind}{&}
+ OutputChar("{&}", "ampersand")
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x207A)
or CheckDeadUni("c5",0x208A)))
- Send {blind}{NumPadAdd}
+ OutputChar("{NumPadAdd}", "plus") ; !!!
else if (Ebene = 5)
- SendUnicodeChar(0x03D5) ; phi symbol (varphi)
+ SendUnicodeChar(0x03D5, "U03D5") ; phi symbol (varphi)
else if (Ebene = 6)
- SendUnicodeChar(0x211A) ; Q (rationale Zahlen)
+ SendUnicodeChar(0x211A, "U211A") ; Q (rationale Zahlen)
return
neo_sz:
EbeneAktualisieren()
if (Ebene = 1)
if LangSTastatur
- OutputChar("s")
- else send
+ OutputChar("s", "s")
+ else OutputChar("", "ssharp")
else if (Ebene = 2)
- SendUnicodeChar(0x1E9E) ; versal-
+ SendUnicodeChar(0x1E9E, "U1E9E") ; versal-
else if (Ebene = 3)
if LangSTastatur
- send
- else
- SendUnicodeChar(0x017F) ; langes s
+ OutputChar("", "ssharp")
+ else SendUnicodeChar(0x017F, "17F") ; langes s
else if (Ebene = 5)
- SendUnicodeChar(0x03C2) ; varsigma
+ SendUnicodeChar(0x03C2, "Greek_finalsmallsigma") ; varsigma
else if (Ebene = 6)
- SendUnicodeChar(0x2218) ; Verknpfungsoperator
+ SendUnicodeChar(0x2218, "jot") ; Verknpfungsoperator
return
@@ -416,17 +407,17 @@ neo_tot3: noCaps = 1
EbeneAktualisieren()
if (Ebene = 1) and !CheckDeadUni("t1",0x0303)
- deadUni(0x02DC, "t1") ; Tilde, tot
+ deadUni(0x02DC, "dead_tilde", "t1") ; Tilde, tot
else if (Ebene = 2) and !CheckDeadUni("t2",0x0304)
- deadUni(0x00AF, "t2") ; Macron, tot
+ deadUni(0x00AF, "dead_macron", "t2") ; Macron, tot
else if (Ebene = 3) and !CheckDeadUni("t3",0x0308)
- deadUni(0x00A8, "t3") ; Direse
- else if (Ebene = 4) and !CheckDeadUni("t4",0x0337)
- deadUni(0x002F, "t4") ; Schrgstrich, tot
+ deadUni(0x00A8, "dead_diaeresis", "t3") ; Direse
+ else if (Ebene = 4) and !CheckDeadUni("t4",0x0338)
+ deadUni(0x002F, "", "t4") ; Schrgstrich, tot
else if (Ebene = 5) and !CheckDeadUni("t5",0x030B)
- deadUni(0x02DD, "t5") ; Doppelakut
+ deadUni(0x02DD, "dead_doubleacute", "t5") ; Doppelakut
else if (Ebene = 6) and !CheckDeadUni("t6",0x0326)
- deadUni(0x02CF, "t6") ; Komma drunter, tot
+ deadUni(0x02CF, "", "t6") ; Komma drunter, tot
return
@@ -449,13 +440,13 @@ neo_u: or CheckDeadUni12("t2",0x016B,0x016A)
or CheckDeadAsc12("t3","","")
or CheckDeadUni12("t5",0x0171,0x0170)))
- OutputChar12("u","U")
+ OutputChar12("u","U","u","U")
else if (Ebene = 3)
- send {blind}\
+ OutputChar("\", "backslash")
else if (Ebene = 4)
- Send {blind}{Home}
+ OutputChar("{Home}", "Home")
else if (Ebene = 6)
- SendUnicodeChar(0x222E) ; contour integral
+ SendUnicodeChar(0x222E, "U222E") ; contour integral
return
neo_i:
@@ -470,15 +461,15 @@ neo_i: or CheckDeadUni12("t1",0x0129,0x0128)
or CheckDeadUni12("t2",0x012B,0x012A)
or CheckDeadAsc12("t3","","")))
- OutputChar12("i","I")
+ OutputChar12("i","I","i","I")
else if (Ebene = 3)
- OutputChar("`/")
+ OutputChar("`/", "slash")
else if (Ebene = 4)
- Send {Blind}{Left}
+ OutputChar("{Left}", "Left")
else if (Ebene = 5)
- SendUnicodeChar(0x03B9) ; iota
+ SendUnicodeChar(0x03B9, "Greek_iota") ; iota
else if (Ebene = 6)
- SendUnicodeChar(0x222B) ; integral
+ SendUnicodeChar(0x222B, "integral") ; integral
return
neo_a:
@@ -493,15 +484,15 @@ neo_a: or CheckDeadUni12("t1",0x00E3,0x00C3)
or CheckDeadUni12("t2",0x0101,0x0100)
or CheckDeadAsc12("t3","","")))
- OutputChar12("a","A")
+ OutputChar12("a","A","a","A")
else if (Ebene = 3)
- send {blind}{{}
+ OutputChar("{{}", "braceleft")
else if (Ebene = 4)
- Send {Blind}{Down}
+ OutputChar("{Down}", "Down")
else if (Ebene = 5)
- SendUnicodeChar(0x03B1) ; alpha
+ SendUnicodeChar(0x03B1, "Greek_alpha") ; alpha
else if (Ebene = 6)
- SendUnicodeChar(0x2200) ; fr alle
+ SendUnicodeChar(0x2200, "U2200") ; fr alle
return
neo_e:
@@ -516,15 +507,15 @@ neo_e: or CheckDeadUni12("t1",0x1EBD,0x1EBC)
or CheckDeadUni12("t2",0x0113,0x0112)
or CheckDeadAsc12("t3","","")))
- OutputChar12("e","E")
+ OutputChar12("e","E","e","E")
else if (Ebene = 3)
- send {blind}{}}
+ OutputChar("{}}", "braceright")
else if (Ebene = 4)
- Send {Blind}{Right}
+ OutputChar("{Right}", "Right")
else if (Ebene = 5)
- SendUnicodeChar(0x03B5) ; epsilon
+ SendUnicodeChar(0x03B5, "Greek_epsilon") ; epsilon
else if (Ebene = 6)
- SendUnicodeChar(0x2203) ; es existiert
+ SendUnicodeChar(0x2203, "U2203") ; es existiert
return
neo_o:
@@ -540,15 +531,15 @@ neo_o: or CheckDeadAsc12("t3","","")
or CheckDeadUni12("t4",0x00F8,0x00D8)
or CheckDeadUni12("t5",0x0151,0x0150)))
- OutputChar12("o","O")
+ OutputChar12("o","O","o","O")
else if (Ebene = 3)
- send {blind}*
+ OutputChar("*", "asterisk")
else if (Ebene = 4)
- Send {blind}{End}
+ OutputChar("{End}", "End")
else if (Ebene = 5)
- SendUnicodeChar(0x03BF) ; omicron
+ SendUnicodeChar(0x03BF, "Greek_omicron") ; omicron
else if (Ebene = 6)
- SendUnicodeChar(0x2208) ; element of
+ SendUnicodeChar(0x2208, "elementof") ; element of
return
neo_s:
@@ -560,20 +551,20 @@ neo_s: or CheckDeadUni12("c2",0x0161,0x0160)
or CheckDeadUni12("c6",0x1E63,0x1A62))) {
if LangSTastatur and (Ebene = 1)
- SendUnicodeChar(0x017F) ; langes s
- else OutputChar12("s","S")
+ SendUnicodeChar(0x017F, "17F") ; langes s
+ else OutputChar12("s","S","s","S")
} else if (Ebene = 3)
- OutputChar("?")
+ OutputChar("?", "question")
else if Ebene7 {
if LangSTastatur
- OutputChar("s")
- else SendUnicodeChar(0x017F)
+ OutputChar("s", "s")
+ else SendUnicodeChar(0x017F, "17F")
} else if (Ebene = 4)
- OutputChar("")
+ OutputChar("", "questiondown")
else if (Ebene = 5)
- SendUnicodeChar(0x03C3) ;sigma
+ SendUnicodeChar(0x03C3, "Greek_sigma") ;sigma
else if (Ebene = 6)
- SendUnicodeChar(0x03A3) ;Sigma
+ SendUnicodeChar(0x03A3, "Greek_SIGMA") ;Sigma
return
neo_n:
@@ -583,16 +574,16 @@ neo_n: or CheckDeadUni12("a4",0x1E45,0x1E44)
or CheckDeadUni12("c2",0x0148,0x0147)
or CheckDeadUni12("t1",0x00F1,0x00D1)))
- OutputChar12("n","N")
+ OutputChar12("n","N","n","N")
else if (Ebene = 3)
- OutputChar("(")
+ OutputChar("(", "parenleft")
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2074)
- or CheckDeadUni("c5",0x2084)))
- OutputChar("{Numpad4}")
+ or CheckDeadUni("t4",0x2084)))
+ OutputChar("{Numpad4}", "KP_4")
else if (Ebene = 5)
- SendUnicodeChar(0x03BD) ; nu
+ SendUnicodeChar(0x03BD, "Greek_nu") ; nu
else if (Ebene = 6)
- SendUnicodeChar(0x2115) ; N (natrliche Zahlen)
+ SendUnicodeChar(0x2115, "U2115") ; N (natrliche Zahlen)
return
neo_r:
@@ -601,17 +592,17 @@ neo_r: or CheckDeadUni12("a3",0x0157,0x0156)
or CheckDeadUni12("a4",0x0E59,0x0E58)
or CheckDeadUni12("c2",0x0159,0x0158)
- or CheckDeadUni12("c6",0x1E5B,0x1E5A)))
- OutputChar12("r","R")
+ or CheckDeadUni12("t3",0x1E5B,0x1E5A)))
+ OutputChar12("r","R","r","R")
else if (Ebene = 3)
- OutputChar(")")
+ OutputChar(")", "parenright")
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2075)
- or CheckDeadUni("c5",0x2085)))
- OutputChar("{Numpad5}")
+ or CheckDeadUni("t4",0x2085)))
+ OutputChar("{Numpad5}", "KP_5")
else if (Ebene = 5)
- SendUnicodeChar(0x03F1) ; rho symbol (varrho)
+ SendUnicodeChar(0x03F1, "U03F1") ; rho symbol (varrho)
else if (Ebene = 6)
- SendUnicodeChar(0x211D) ; R (reelle Zahlen)
+ SendUnicodeChar(0x211D, "U221D") ; R (reelle Zahlen)
return
neo_t:
@@ -620,36 +611,36 @@ neo_t: or CheckDeadUni12("a4",0x1E6B,0x1E6A)
or CheckDeadUni12("c2",0x0165,0x0164)
or CheckDeadUni12("c5",0x0167,0x0166)
- or CheckDeadUni12("c6",0x1E6D,0x1E6C)
+ or CheckDeadUni12("t4",0x1E6D,0x1E6C)
or CheckDeadUni("t3",0x1E97)))
- OutputChar12("t","T")
+ OutputChar12("t","T","t","T")
else if (Ebene = 3)
- OutputChar("-") ; Bisstrich
+ OutputChar("-", "minus") ; Bisstrich
else if (Ebene = 4) and !(CheckDeadUni("c1",0x2076)
or CheckDeadUni("c5",0x2086))
- OutputChar("{Numpad6}")
+ OutputChar("{Numpad6}", "KP_6")
else if (Ebene = 5)
- SendUnicodeChar(0x03C4) ; tau
+ SendUnicodeChar(0x03C4, "Greek_tau") ; tau
else if (Ebene = 6)
- SendUnicodeChar(0x2202) ; partielle Ableitung
+ SendUnicodeChar(0x2202, "partialderivative") ; partielle Ableitung
return
neo_d:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a4",0x1E0B,0x1E0A)
or CheckDeadUni12("c2",0x010F,0x010E)
- or CheckDeadUni12("c5",0x0111,0x0110)
- or CheckDeadUni12("c6",0x1E0D,0x1E0C)
+ or CheckDeadUni12("t2",0x0111,0x0110)
+ or CheckDeadUni12("t3",0x1E0D,0x1E0C)
or CheckDeadUni12("t4",0x00F0,0x00D0)))
- OutputChar12("d","D")
+ OutputChar12("d","D","d","D")
else if (Ebene = 3)
- OutputChar(":")
+ OutputChar(":", "colon")
else if (Ebene = 4)
- send `,
+ OutputChar("`,", "comma")
else if (Ebene = 5)
- SendUnicodeChar(0x03B4) ; delta
+ SendUnicodeChar(0x03B4, "Greek_delta") ; delta
else if (Ebene = 6)
- SendUnicodeChar(0x0394) ; Delta
+ SendUnicodeChar(0x0394, "Greek_DELTA") ; Delta
return
neo_y:
@@ -657,15 +648,15 @@ neo_y: if (Ebene12 and !(CheckDeadUni12("a1",0x00FD,0x00DD)
or CheckDeadUni12("c1",0x0177,0x0176)
or CheckDeadAsc12("t3","","")))
- OutputChar12("y","Y")
+ OutputChar12("y","Y","y","Y")
else if (Ebene = 3)
- send {blind}@
+ OutputChar("@", "at")
else if (Ebene = 4)
- Send {blind}.
+ OutputChar(".", "period")
else if (Ebene = 5)
- SendUnicodeChar(0x03C5) ; upsilon
+ SendUnicodeChar(0x03C5, "Greek_upsilon") ; upsilon
else if (Ebene = 6)
- SendUnicodeChar(0x2207) ; nabla
+ SendUnicodeChar(0x2207, "nabla") ; nabla
return
/*
@@ -680,61 +671,55 @@ neo_: or CheckDeadUni12("a2",0x01DC,0x01DB)
or CheckDeadUni12("c2",0x01DA,0x01D9)
or CheckDeadUni12("t2",0x01D6,0x01D5)))
- OutputChar12("","")
+ OutputChar12("","","udiaeresis","Udiaeresis")
else if (Ebene = 3)
if isMod2Locked
- send {blind}{Shift Up}{#}
- else send {blind}{#}
+ OutputChar("{Shift Up}{#}", "numbersign")
+ else OutputChar("{blind}{#}", "numbersign")
else if (Ebene = 4)
- Send {blind}{Esc}
- else if (Ebene = 5) { ; leer
- DeadKey := PriorDeadKey
- CompKey := PriorCompKey
- } else if (Ebene = 6)
- SendUnicodeChar(0x221D) ; proportional
+ OutputChar("{Esc}", "Escape")
+ else if (Ebene = 6)
+ SendUnicodeChar(0x221D, "variation") ; proportional
return
neo_:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("t2",0x022B,0x022A)))
- OutputChar12("","")
+ OutputChar12("","","odiaeresis","Odiaeresis")
else if (Ebene = 3)
- send {blind}$
+ OutputChar("$", "dollar")
else if (Ebene = 4)
- send {blind}{Tab}
- else if (Ebene = 5) { ; leer
- DeadKey := PriorDeadKey
- CompKey := PriorCompKey
- } else if (Ebene = 6)
- SendUnicodeChar(0x2111) ; Fraktur I
+ OutputChar("{Tab}", "Tab")
+ else if (Ebene = 6)
+ SendUnicodeChar(0x2111, "U2221") ; Fraktur I
return
neo_:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("t2",0x01DF,0x01DE)))
- OutputChar12("","")
+ OutputChar12("","","adiaeresis","Adiaeresis")
else if (Ebene = 3)
- send {blind}|
+ OutputChar("|", "bar")
else if (Ebene = 4)
- Send {blind}{PgDn} ; Next
+ OutputChar("{PgDn}", "Next")
else if (Ebene = 5)
- SendUnicodeChar(0x03B7) ; eta
+ SendUnicodeChar(0x03B7, "Greek_eta") ; eta
else if (Ebene = 6)
- SendUnicodeChar(0x211C) ; Fraktur R
+ SendUnicodeChar(0x211C, "U221C") ; Fraktur R
return
neo_p:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a4",0x1E57,0x1E56)))
- OutputChar12("p","P")
+ OutputChar12("p","P","p","P")
else if ((Ebene = 3) and !(CheckDeadUni("t1",0x2248)))
- send {blind}~
+ OutputChar("~", "asciitilde")
else if (Ebene = 4)
- Send {blind}{Enter}
+ OutputChar("{Enter}", "Return")
else if (Ebene = 5)
- SendUnicodeChar(0x03C0) ; pi
+ SendUnicodeChar(0x03C0, "Greek_pi") ; pi
else if (Ebene = 6)
- SendUnicodeChar(0x03A0) ; Pi
+ SendUnicodeChar(0x03A0, "Greek_PI") ; Pi
return
neo_z:
@@ -743,97 +728,93 @@ neo_z: or CheckDeadUni12("a4",0x017C,0x017B)
or CheckDeadUni12("c2",0x017E,0x017D)
or CheckDeadUni12("c6",0x1E93,0x1E92)))
- OutputChar12("z","Z")
+ OutputChar12("z","Z","z","Z")
else if (Ebene = 3)
- send ``{space} ; untot
+ OutputChar("``{space}", "grave") ; untot
else if (Ebene = 5)
- SendUnicodeChar(0x03B6) ; zeta
+ SendUnicodeChar(0x03B6, "Greek_zeta") ; zeta
else if (Ebene = 6)
- SendUnicodeChar(0x2124) ; Z (ganze Zahlen)
+ SendUnicodeChar(0x2124, "U2124") ; Z (ganze Zahlen)
return
neo_b:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a4",0x1E03,0x1E02)))
- OutputChar12("b","B")
+ OutputChar12("b","B","b","B")
else if (Ebene = 3)
if isMod2Locked
- send {blind}{Shift Up}{+}
- else send {blind}{+}
+ OutputChar("{Shift Up}{+}", "plus")
+ else OutputChar("{blind}{+}", "plus")
else if (Ebene = 4)
- send {blind}:
+ OutputChar(":", "colon")
else if (Ebene = 5)
- SendUnicodeChar(0x03B2) ; beta
+ SendUnicodeChar(0x03B2, "Greek_beta") ; beta
else if (Ebene = 6)
- SendUnicodeChar(0x21D2) ; Doppel-Pfeil rechts
+ SendUnicodeChar(0x21D2, "implies") ; Doppel-Pfeil rechts
return
neo_m:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a4",0x1E41,0x1E40)
or CheckDeadUni12("c6",0x1E43,0x1E42)))
- OutputChar12("m","M")
+ OutputChar12("m","M","m","M")
else if (Ebene = 3)
- send {blind}`%
+ OutputChar("`%", "percent")
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x00B9)
- or CheckDeadUni("c5",0x2081)))
- OutputChar("{Numpad1}")
+ or CheckDeadUni("t4",0x2081)))
+ OutputChar("{Numpad1}", "KP_1")
else if (Ebene = 5)
- SendUnicodeChar(0x03BC) ; griechisch mu, micro wre 0x00B5
+ SendUnicodeChar(0x03BC, "Greek_mu") ; griechisch mu, micro wre 0x00B5
else if (Ebene = 6)
- SendUnicodeChar(0x21D4) ; doppelter Doppelpfeil (genau dann wenn)
+ SendUnicodeChar(0x21D4, "ifonlyif") ; doppelter Doppelpfeil (genau dann wenn)
return
neo_komma:
noCaps = 1
EbeneAktualisieren()
if (Ebene = 1)
- send {blind},
- else if (Ebene = 2)
- SendUnicodeChar(0x22EE) ; vertikale ellipse
+ OutputChar(",", "comma")
else if (Ebene = 3)
- OutputChar(Chr(34))
+ OutputChar(Chr(34), "quotedbl")
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x00B2)
or CheckDeadUni("c5",0x2082)))
- OutputChar("{Numpad2}")
+ OutputChar("{Numpad2}", "KP_2")
else if (Ebene = 5)
- SendUnicodeChar(0x03C1) ; rho
+ SendUnicodeChar(0x03C1, "Greek_rho") ; rho
else if (Ebene = 6)
- SendUnicodeChar(0x21D0) ; Doppelpfeil links
+ SendUnicodeChar(0x21D0, "U21D0") ; Doppelpfeil links
return
neo_punkt:
noCaps = 1
EbeneAktualisieren()
if (Ebene = 1)
- send {blind}.
- else if (Ebene = 2)
- SendUnicodeChar(0x2026) ; ellipse
+ OutputChar(".", "period")
else if (Ebene = 3)
- OutputChar("'")
+ OutputChar("'", "apostrophe")
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x00B3)
- or CheckDeadUni("c5",0x2083)))
- OutputChar("{Numpad3}")
+ or CheckDeadUni("t4",0x2083)))
+ OutputChar("{Numpad3}", "KP_3")
else if (Ebene = 5)
- SendUnicodeChar(0x03D1) ; theta symbol (vartheta)
+ SendUnicodeChar(0x03D1, "U03D1") ; theta symbol (vartheta)
else if (Ebene = 6)
- SendUnicodeChar(0x0398) ; Theta
+ SendUnicodeChar(0x0398, "Greek_THETA") ; Theta
return
neo_j:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("c1",0x0135,0x0134)
- or CheckDeadUni12("c2",0x01F0,"")))
- OutputChar12("j","J")
+ or CheckDeadUni("c2",0x01F0)))
+ OutputChar12("j","J","j","J")
else if (Ebene = 3)
- send {blind}`;
+ OutputChar("`;", "semicolon")
else if (Ebene = 4)
- Send {blind}`;
+ OutputChar("`;", "semicolon")
else if (Ebene = 5)
- SendUnicodeChar(0x03B8) ; theta
+ SendUnicodeChar(0x03B8, "Greek_theta") ; theta
else if (Ebene = 6)
- SendUnicodeChar(0x2261) ; identisch
+ SendUnicodeChar(0x2261, "identical") ; identisch
return
/*
@@ -844,52 +825,52 @@ return neo_NumLock:
EbeneAktualisieren()
- if (Ebene = 1)
- send `=
+ if (Ebene = 1) ;
+ OutputChar("`=", "equal")
if (Ebene = 3)
- SendUnicodeChar(0x2248) ; Fast gleich
- if (Ebene = 4)
- SendUnicodeChar(0x2260) ; Ungleich zu
+ SendUnicodeChar(0x2248, "U2248") ; Fast gleich
+ if (Ebene = 2)
+ SendUnicodeChar(0x2260, "U2260") ; Ungleich zu
return
neo_NumpadDiv:
EbeneAktualisieren()
- if Ebene14
- OutputChar("{NumpadDiv}")
- else if (Ebene = 2)
- SendUnicodeChar(0x2215) ; Slash
+ if Ebene12
+ OutputChar("{NumpadDiv}", "KP_Divide")
+ else if (Ebene = 4)
+ SendUnicodeChar(0x2215, "division") ; Slash
else if (Ebene = 3)
- send {blind}
+ OutputChar("", "U2044")
return
neo_NumpadMult:
EbeneAktualisieren()
- if Ebene14
+ if Ebene12
send {blind}{NumpadMult}
- else if (Ebene = 2)
- SendUnicodeChar(0x22C5) ; Cdot
else if (Ebene = 3)
- send {blind}
+ SendUnicodeChar(0x22C5, "multiply") ; Cdot
+ else if (Ebene = 4)
+ OutputChar("", "U2219")
return
neo_NumpadSub:
EbeneAktualisieren()
- if (Ebene14 and !(CheckDeadUni("c1",0x207B)
- or CheckDeadUni("c5",0x208B)))
+ if (Ebene12 and !(CheckDeadUni("c1",0x207B)
+ or CheckDeadUni("t4",0x208B)))
send {blind}{NumpadSub}
- else if (Ebene = 3)
- SendUnicodeChar(0x2212) ; Echtes Minus
+ else if (Ebene = 3) or (Ebene = 4)
+ SendUnicodeChar(0x2212, "U2212") ; Echtes Minus
return
neo_NumpadAdd:
EbeneAktualisieren()
- if (Ebene14 and !(CheckDeadUni("c1",0x207A)
+ if (Ebene12 and !(CheckDeadUni("c1",0x207A)
or CheckDeadUni("c5",0x208A)))
send {blind}{NumpadAdd}
else if (Ebene = 3)
- send {blind}
- else if (Ebene = 2)
- SendUnicodeChar(0x2213) ; Inverses
+ OutputChar("", "plusminus")
+ else if (Ebene = 4)
+ SendUnicodeChar(0x2213, "U2213") ; Inverses
return
neo_NumpadEnter:
@@ -899,11 +880,11 @@ return neo_Numpad7:
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("{Numpad7}")
+ OutputChar("{Numpad7}", "KP_7")
else if (Ebene = 2)
- SendUnicodeChar(0x2020) ; Kreuz
+ SendUnicodeChar(0x2020, "dagger") ; Kreuz
else if (Ebene = 3)
- SendUnicodeChar(0x2195) ; Hoch-Runter-Pfeil
+ SendUnicodeChar(0x2195, "U2195") ; Hoch-Runter-Pfeil
else if (Ebene = 4)
send {blind}{NumpadHome}
return
@@ -911,11 +892,11 @@ return neo_Numpad8:
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("{Numpad8}")
+ OutputChar("{Numpad8}", "KP_8")
else if (Ebene = 2)
- SendUnicodeChar(0x2229) ; Durchschnitt
+ SendUnicodeChar(0x2229, "intersection") ; Durchschnitt
else if (Ebene = 3)
- SendUnicodeChar(0x2191) ; Hochpfeil
+ SendUnicodeChar(0x2191, "uparrow") ; Hochpfeil
else if (Ebene = 4)
send {blind}{NumpadUp}
return
@@ -923,11 +904,11 @@ return neo_Numpad9:
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("{Numpad9}")
+ OutputChar("{Numpad9}", "KP_9")
else if (Ebene = 2)
- SendUnicodeChar(0x2297) ; Tensorprodukt / Vektor in die Ebene zeigend
+ SendUnicodeChar(0x2297, "U2297") ; Tensorprodukt / Vektor in die Ebene zeigend
else if (Ebene = 3)
- SendUnicodeChar(0x220D) ; Kleines umgekehrtes Elementzeichen
+ SendUnicodeChar(0x220D, "U220D") ; Kleines umgekehrtes Elementzeichen
else if (Ebene = 4)
send {blind}{NumpadPgUp}
return
@@ -935,11 +916,11 @@ return neo_Numpad4:
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("{Numpad4}")
+ OutputChar("{Numpad4}", "KP_4")
else if (Ebene = 2)
- SendUnicodeChar(0x2282) ; Teilmenge
+ SendUnicodeChar(0x2282, "includein") ; Teilmenge
else if (Ebene = 3)
- SendUnicodeChar(0x2190) ; Linkspfeil
+ SendUnicodeChar(0x2190, "leftarrow") ; Linkspfeil
else if (Ebene = 4)
send {blind}{NumpadLeft}
return
@@ -947,11 +928,11 @@ return neo_Numpad5:
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("{Numpad5}")
+ OutputChar("{Numpad5}", "KP_5")
else if (Ebene = 2)
- SendUnicodeChar(0x20AC) ; Euro
+ SendUnicodeChar(0x20AC, "EuroSign") ; Euro
else if (Ebene = 3)
- SendUnicodeChar(0x221E) ; Unendlich
+ SendUnicodeChar(0x221E, "infinity") ; Unendlich
else if (Ebene = 4) ; Beg
send {blind}{NumPadClear}
return
@@ -959,11 +940,11 @@ return neo_Numpad6:
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("{Numpad6}")
+ OutputChar("{Numpad6}", "KP_6")
else if (Ebene = 2)
- SendUnicodeChar(0x2283) ; Obermenge
+ SendUnicodeChar(0x2283, "includes") ; Obermenge
else if (Ebene = 3)
- SendUnicodeChar(0x2192) ; Rechtspfeil
+ SendUnicodeChar(0x2192, "rightarrow") ; Rechtspfeil
else if (Ebene = 4)
send {blind}{NumpadRight}
return
@@ -971,11 +952,11 @@ return neo_Numpad1:
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("{Numpad1}")
+ OutputChar("{Numpad1}", "KP_1")
else if (Ebene = 2)
- SendUnicodeChar(0x2714) ; Hkchen
+ SendUnicodeChar(0x2714, "U2714") ; Hkchen
else if (Ebene = 3)
- SendUnicodeChar(0x2194) ; Links-Rechts-Pfeil
+ SendUnicodeChar(0x2194, "U2194") ; Links-Rechts-Pfeil
else if (Ebene = 4)
send {blind}{NumpadEnd}
return
@@ -983,11 +964,11 @@ return neo_Numpad2:
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("{Numpad2}")
+ OutputChar("{Numpad2}", "KP_2")
else if (Ebene = 2)
- SendUnicodeChar(0x222A) ; Vereinigung
+ SendUnicodeChar(0x222A, "union") ; Vereinigung
else if (Ebene = 3)
- SendUnicodeChar(0x2192) ; Untenpfeil
+ SendUnicodeChar(0x2192, "downarrow") ; Untenpfeil
else if (Ebene = 4)
send {blind}{NumpadDown}
return
@@ -995,11 +976,11 @@ return neo_Numpad3:
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("{Numpad3}")
+ OutputChar("{Numpad3}", "KP_3")
else if (Ebene = 2)
- SendUnicodeChar(0x2718) ; Kreuzchen
+ SendUnicodeChar(0x2718, "U2718") ; Kreuzchen
else if (Ebene = 3)
- SendUnicodeChar(0x2192) ; Rechtspfeil
+ SendUnicodeChar(0x21CC, "U21CC") ; Harpune
else if (Ebene = 4)
send {blind}{NumpadPgDn}
return
@@ -1007,11 +988,11 @@ return neo_Numpad0:
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("{Numpad0}")
+ OutputChar("{Numpad0}", "KP_0")
else if (Ebene = 2)
- SendUnicodeChar(0x0025) ; Prozent
+ SendUnicodeChar(0x0025, "percent") ; Prozent
else if (Ebene = 3)
- SendUnicodeChar(0x2030) ; Promille
+ SendUnicodeChar(0x2030, "U2030") ; Promille
else if (Ebene = 4)
send {blind}{NumpadIns}
return
@@ -1050,17 +1031,17 @@ return neo_SpaceUp:
EbeneAktualisieren()
- if (Ebene = 1) and !CheckDeadUni("c5",0x2010) ; Echter Bindestrich
- OutputChar("{Space}")
+ if (Ebene = 1) and !CheckDeadUni("t4",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("c5",0x2080)))
- OutputChar("{Numpad0}")
+ OutputChar("{Numpad0}", "KP_0")
else if (Ebene = 5)
- SendUnicodeChar(0x00A0) ; geschtztes Leerzeichen
+ SendUnicodeChar(0x00A0, "U00A0") ; geschtztes Leerzeichen
else if (Ebene = 6)
- SendUnicodeChar(0x202F) ; schmales geschtztes Leerzeichen
+ SendUnicodeChar(0x202F, "U202F") ; schmales geschtztes Leerzeichen
DeadKey := ""
CompKey := ""
spacepressed := 0
@@ -1068,7 +1049,7 @@ neo_SpaceUp: return
/*
- Folgende Tasten sind nur aufgefhrt, um PriorDeadKey zu leeren.
+ Folgende Tasten sind nur aufgefhrt, um DeadKey zu leeren.
Irgendwie sieht das noch nicht schn aus. Vielleicht lsst sich dieses
Problem auch eleganter lsen...
*/
diff --git a/windows/autohotkey/Source/Methods-Layers.ahk b/windows/autohotkey/Source/Methods-Layers.ahk index 171fc8b..133be91 100644 --- a/windows/autohotkey/Source/Methods-Layers.ahk +++ b/windows/autohotkey/Source/Methods-Layers.ahk @@ -86,7 +86,6 @@ EbeneAktualisieren() { Ebene = 6
Ebene8 = 1
} Ebene12 := ((Ebene = 1) or (Ebene = 2))
- Ebene14 := ((Ebene = 1) or (Ebene = 4))
NumLock := GetKeyState("NumLock", "T")
noCaps := 0
}
diff --git a/windows/autohotkey/Source/Methods-Other.ahk b/windows/autohotkey/Source/Methods-Other.ahk index 0ef9d77..b57ba61 100644 --- a/windows/autohotkey/Source/Methods-Other.ahk +++ b/windows/autohotkey/Source/Methods-Other.ahk @@ -1,14 +1,14 @@ -deadAsc(val, a) {
+deadAsc(val1, val2, a) {
global
if !DeadSilence
- send % val
+ OutputChar(val1, val2)
DeadKey := a
}
-deadUni(val, a) {
+deadUni(val1, val2, a) {
global
if !DeadSilence
- SendUnicodeChar(val)
+ SendUnicodeChar(val1, val2)
DeadKey := a
}
@@ -24,7 +24,7 @@ undeadUni(val){ global
if !DeadSilence
send {bs}
- SendUnicodeChar(val)
+ SendUnicodeChar(val, "")
}
CheckDeadAsc(d,val) {
@@ -69,43 +69,34 @@ CheckDeadUni12(d,val1,val2) { }
}
-CheckCompAsc(d,val) {
- global
- if (PriorCompKey == d) {
- if !DeadCompose
- send {bs}
- send % val
- CompKey = 0
- isFurtherCompKey = 0
- return 1
- }
-}
-
CheckCompUni(d,val) {
global
- if (PriorCompKey == d) {
+ if (CompKey == d) {
PriorCompKey =
CompKey =
if !DeadCompose
send {bs}
isFurtherCompkey = 0
- SendUnicodeChar(val)
+ SendUnicodeChar(val, "")
return 1
}
}
-OutputChar(val) {
+OutputChar(val1,val2) {
global
- if !(CheckComp(val) and DeadCompose)
- send % "{blind}" . val
+ if !(CheckComp(val2) and DeadCompose)
+ send % "{blind}" . val1
}
-OutputChar12(val1,val2) {
+OutputChar12(val1,val2,val3,val4) {
global
if (Ebene = 1)
c := val1
else c := val2
- if !(CheckComp(c) and DeadCompose)
+ if (Ebene = 1)
+ d := val3
+ else d := val4
+ if !(CheckComp(d) and DeadCompose)
if GetKeyState("Shift","P") and isMod2Locked
send % "{blind}{Shift Up}" . c . "{Shift Down}"
else send % "{blind}" . c
@@ -114,20 +105,20 @@ OutputChar12(val1,val2) { CheckComp(d) {
global
if isFurtherCompkey {
- PriorCompKey := CompKey := PriorCompKey . "_" . d
+ CompKey := PriorCompKey . " " . "<" . d . ">"
isFurtherCompkey = 0
CheckCompose()
if (CompKey = "")
return 1
else CompKey =
} else if PriorCompKey {
- PriorCompKey := CompKey := PriorCompKey . "_" . d
+ CompKey := PriorCompKey . " " . "<" . d . ">"
CheckCompose()
if CompKey
isFurtherCompKey = 1
return 1
} else if (PriorDeadKey = "comp") {
- CompKey := d
+ CompKey := "<" . d . ">"
return 1
}
}
diff --git a/windows/autohotkey/Source/Methods-Unicode.ahk b/windows/autohotkey/Source/Methods-Unicode.ahk index a23da10..161e01c 100644 --- a/windows/autohotkey/Source/Methods-Unicode.ahk +++ b/windows/autohotkey/Source/Methods-Unicode.ahk @@ -8,21 +8,21 @@ 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 fhrendem 0x angegeben sind. Die abenteuerliche ^+u-Konstruktion bentigt im brigen den Hex-Wert in Kleinschrift, was derzeit nicht bei den Zeichendefinitionen umgesetzt ist, daher zentral und weniger fehlertrchtig an dieser Stelle. Auerdem ein abschlieend gesendetes Space, sonst bleibt der eingetippte Unicode-Wert noch kurz sichtbar stehen, bevor er sich GTK-sei-dank in das gewnschte Zeichen verwandelt.
*/
-SendUnicodeChar(charCode) { +SendUnicodeChar(charCode1, charCode2) { global
- if !(CheckComp(charCode) and DeadCompose)
+ if !(CheckComp(charCode2) and DeadCompose)
IfWinActive,ahk_class gdkWindowToplevel
{
- StringLower,charCode,charCode
- send % "^+u" . SubStr(charCode,3) . " "
+ StringLower,charCode1,charCode1
+ send % "^+u" . SubStr(charCode1,3) . " "
} else {
VarSetCapacity(ki,28*2,0)
EncodeInteger(&ki+0,1)
- EncodeInteger(&ki+6,charCode)
+ EncodeInteger(&ki+6,charCode1)
EncodeInteger(&ki+8,4)
EncodeInteger(&ki+28,1)
- EncodeInteger(&ki+34,charCode)
+ EncodeInteger(&ki+34,charCode1)
EncodeInteger(&ki+36,4|2)
DllCall("SendInput","UInt",2,"UInt",&ki,"Int",28)
}
diff --git a/windows/autohotkey/neo20.ahk b/windows/autohotkey/neo20.ahk index 336328c..a33eec0 100644 --- a/windows/autohotkey/neo20.ahk +++ b/windows/autohotkey/neo20.ahk @@ -466,7 +466,6 @@ EbeneAktualisieren() { Ebene = 6
Ebene8 = 1
} Ebene12 := ((Ebene = 1) or (Ebene = 2))
- Ebene14 := ((Ebene = 1) or (Ebene = 4))
NumLock := GetKeyState("NumLock", "T")
noCaps := 0
}
@@ -756,18 +755,12 @@ neo_tot1: noCaps = 1
EbeneAktualisieren()
if (Ebene = 1) and !CheckDeadUni("c1",0x0302)
- deadUni(0x02C6, "c1") ; Zirkumflex, tot
+ deadUni(0x02C6, "dead_circumflex", "c1") ; Zirkumflex, tot
else if (Ebene = 2) and !CheckDeadUni("c2",0x030C)
- deadUni(0x02C7, "c2") ; Caron, tot
+ deadUni(0x02C7, "dead_caron", "c2") ; Caron, tot
else if (Ebene = 3) and !CheckDeadUni("c3",0x0306)
- deadUni(0x02D8, "c3") ; Brevis, tot
- else if (Ebene = 4)
- deadUni(0x00B7, "c4") ; Mittenpunkt, tot
- else if (Ebene = 5) and !CheckDeadUni("c5",0x0335)
- deadUni(0x002D, "c5") ; Querstrich, tot
- else if (Ebene = 6) and !CheckDeadUni("c6",0x0323)
- deadUni(0x002E, "c6") ; Punkt drunter (Colon), tot
- CompKey := PriorCompKey
+ deadUni(0x02D8, "dead_breve", "c3") ; Brevis, tot
+ ;CompKey := PriorCompKey
return
neo_1:
@@ -775,15 +768,15 @@ neo_1: EbeneAktualisieren()
if Ebene12 and !(CheckDeadUni("c1",0x00B9) ; Hochgestellte 1
or CheckDeadUni("c5",0x2081)) ; Tiefgestellte 1
- OutputChar12(1,"")
+ OutputChar12(1,"",1,"degree")
else if (Ebene = 3)
- SendUnicodeChar(0x00B9) ; Hochgestellte 1
+ SendUnicodeChar(0x00B9, "onesuperior") ; Hochgestellte 1
else if (Ebene = 4)
- SendUnicodeChar(0x2022) ; Bullet
+ SendUnicodeChar(0x2022, "enfilledcircbullet") ; Bullet
else if (Ebene = 5)
- SendUnicodeChar(0x2640) ; Piktogramm weiblich
+ SendUnicodeChar(0x2081, "U2081") ; Tiefgestellte 1
else if (Ebene = 6)
- SendUnicodeChar(0x00AC) ; Nicht-Symbol
+ SendUnicodeChar(0x00AC, "notsign") ; Nicht-Symbol
return
neo_2:
@@ -791,17 +784,17 @@ neo_2: EbeneAktualisieren()
if (Ebene = 1 and !(CheckDeadUni("c1",0x00B2) ; Hochgestellte 2
or CheckDeadUni("c5",0x2082))) ; Tiefgestellte 2
- OutputChar(2)
+ OutputChar(2,2)
else if (Ebene = 2)
- SendUnicodeChar(0x2116) ; Numero
+ SendUnicodeChar(0x2116, "numerosign") ; Numero
else if (Ebene = 3)
- SendUnicodeChar(0x00B2) ; Hochgestellte 2
+ SendUnicodeChar(0x00B2, "twosuperior") ; Hochgestellte 2
else if (Ebene = 4)
- SendUnicodeChar(0x2023) ; Aufzhlungspfeil
+ SendUnicodeChar(0x2023, "U2023") ; Aufzhlungspfeil
else if (Ebene = 5)
- SendUnicodeChar(0x26A5) ; Piktogramm Zwitter
+ SendUnicodeChar(0x2082, "U2082") ; Tiefgestellte 2
else if (Ebene = 6)
- SendUnicodeChar(0x2228) ; Logisches Oder
+ SendUnicodeChar(0x2228, "logicalor") ; Logisches Oder
return
neo_3:
@@ -809,15 +802,15 @@ neo_3: EbeneAktualisieren()
if Ebene12 and !(CheckDeadUni("c1",0x00B3) ; Hochgestellte 3
or CheckDeadUni("c5",0x2083)) ; Tiefgestellte 3
- OutputChar12(3,"")
+ OutputChar12(3,"",3,"section")
else if (Ebene = 3)
- SendUnicodeChar(0x00B3) ; Hochgestellte 3
+ SendUnicodeChar(0x00B3, "threesuperior") ; Hochgestellte 3
else if (Ebene = 4)
- SendUnicodeChar(0x266B) ; 2 Achtelnoten
+ SendUnicodeChar(0x266B, "U226B") ; 2 Achtelnoten
else if (Ebene = 5)
- SendUnicodeChar(0x2642) ; Piktogramm Mann
+ SendUnicodeChar(0x2083, "U2083") ; Tiefgestellte 3
else if (Ebene = 6)
- SendUnicodeChar(0x2227) ; Logisches Und
+ SendUnicodeChar(0x2227, "logicaland") ; Logisches Und
return
neo_4:
@@ -825,17 +818,17 @@ neo_4: EbeneAktualisieren()
if (Ebene = 1) and !(CheckDeadUni("c1",0x2074) ; Hochgestellte 4
or CheckDeadUni("c5",0x2084)) ; Tiefgestellte 4
- OutputChar(4)
+ OutputChar(4,4)
else if (Ebene = 2)
- SendUnicodeChar(0x00BB) ; Double guillemot right
+ SendUnicodeChar(0x00BB, "guillemotright") ; Double guillemot right
else if (Ebene = 3)
- Send {blind} ; Single guillemot right
+ OutputChar("", "U230A") ; Single guillemot right
else if (Ebene = 4)
- Send {blind}{PgUp}
+ OutputChar("{PgUp}", "Prior") ; Bild auf
else if (Ebene = 5)
- SendUnicodeChar(0x2113) ; Script small L
+ SendUnicodeChar(0x2113, "U2213") ; Script small L
else if (Ebene = 6)
- SendUnicodeChar(0x22A5) ; Senkrecht
+ SendUnicodeChar(0x22A5, "uptack") ; Senkrecht
return
neo_5:
@@ -843,15 +836,15 @@ neo_5: EbeneAktualisieren()
if (Ebene = 1) and !(CheckDeadUni("c1",0x2075) ; Hochgestellte 5
or CheckDeadUni("c5",0x2085)) ; Tiefgestellte 5
- OutputChar(5)
+ OutputChar(5,5)
else if (Ebene = 2)
- SendUnicodeChar(0x00AB) ; Double guillemot left
+ SendUnicodeChar(0x00AB, "guillemotleft") ; Double guillemot left
else if (Ebene = 3)
- Send {blind} ; Single guillemot left
+ OutputChar("", "U2039") ; Single guillemot left
else if (Ebene = 5)
- SendUnicodeChar(0x2020) ; Kreuz (Dagger)
+ SendUnicodeChar(0x0AF8, "femalesymbol") ; Kreuz (Dagger)
else if (Ebene = 6)
- SendUnicodeChar(0x2221) ; Winkel
+ SendUnicodeChar(0x2221, "U2221") ; Winkel
return
neo_6:
@@ -859,15 +852,17 @@ neo_6: EbeneAktualisieren()
if (Ebene = 1) and !(CheckDeadUni("c1",0x2076) ; Hochgestellte 6
or CheckDeadUni("c5",0x2086)) ; Tiefgestellte 6
- OutputChar(6)
+ OutputChar(6,6)
else if (Ebene = 2)
- SendUnicodeChar(0x20AC)
+ SendUnicodeChar(0x20AC, "EuroSign")
else if (Ebene = 3)
- send {blind}
+ OutputChar("", "cent")
else if (Ebene = 4)
- send {blind}
+ OutputChar("", "sterling")
+ else if (Ebene = 5)
+ SendUnicodeChar(0x0AF7, "malesymbol")
else if (Ebene = 6)
- SendUnicodeChar(0x2225) ; parallel
+ SendUnicodeChar(0x2225, "U2225") ; parallel
return
neo_7:
@@ -875,15 +870,15 @@ neo_7: EbeneAktualisieren()
if Ebene12 and !(CheckDeadUni("c1",0x2077) ; Hochgestellte 7
or CheckDeadUni("c5",0x2087)) ; Tiefgestellte 7
- OutputChar12(7,"$")
+ OutputChar12(7,"$",7,"dollar")
else if (Ebene = 3)
- send {blind}
+ OutputChar("", "yen")
else if (Ebene = 4)
- send {blind}
+ OutputChar("", "currency")
else if (Ebene = 5)
- SendUnicodeChar(0x03BA) ; greek small letter kappa
+ SendUnicodeChar(0x03BA, "Greek_kappa") ; greek small letter kappa
else if (Ebene = 6)
- SendUnicodeChar(0x2209) ; nicht Element von
+ SendUnicodeChar(0x2209, "notelementof") ; nicht Element von
return
neo_8:
@@ -891,15 +886,15 @@ neo_8: EbeneAktualisieren()
if Ebene12 and !(CheckDeadUni("c1",0x2078) ; Hochgestellte 8
or CheckDeadUni("c5",0x2088)) ; Tiefgestellte 8
- OutputChar12(8,"")
+ OutputChar12(8,"",8,"doublelowquotemark")
else if (Ebene = 3)
- send {blind}
+ OutputChar("", "singlelowquotemark")
else if (Ebene = 4)
- Send {blind}{NumpadDiv}
+ OutputChar("{NumpadDiv}", "KP_Divide")
else if (Ebene = 5)
- SendUnicodeChar(0x27E8) ; bra (ffnende spitze Klammer)
+ SendUnicodeChar(0x27E8, "U27E8") ; bra (ffnende spitze Klammer)
else if (Ebene = 6)
- SendUnicodeChar(0x2204) ; es existiert nicht
+ SendUnicodeChar(0x2204, "U2204") ; es existiert nicht
return
neo_9:
@@ -907,15 +902,15 @@ neo_9: EbeneAktualisieren()
if Ebene12 and !(CheckDeadUni("c1",0x2079) ; Hochgestellte 9
or CheckDeadUni("c5",0x2089)) ; Tiefgestellte 9
- OutputChar12(9,"")
+ OutputChar12(9,"",9,"leftdoublequotemark")
else if (Ebene = 3)
- send {blind}
+ OutputChar("", "leftsinglequotemark")
else if (Ebene = 4)
- Send {blind}{NumpadMult}
+ OutputChar("{NumpadMult}", "KP_Multiply")
else if (Ebene = 5)
- SendUnicodeChar(0x27E9) ; ket (schlieende spitze Klammer)
+ SendUnicodeChar(0x27E9, "U27E9") ; ket (schlieende spitze Klammer)
else if (Ebene = 6)
- SendUnicodeChar(0x2226) ; nicht parallel
+ SendUnicodeChar(0x2226, "U2226") ; nicht parallel
return
neo_0:
@@ -923,45 +918,45 @@ neo_0: EbeneAktualisieren()
if Ebene12 and !(CheckDeadUni("c1",0x2070) ; Hochgestellte 0
or CheckDeadUni("c5",0x2080)) ; Tiefgestellte 0
- OutputChar12(0,"")
+ OutputChar12(0,"",0,"rightdoublequotemark")
else if (Ebene = 3)
- send {blind}
+ OutputChar("", "rightsingleqoutemark")
else if (Ebene = 4)
- Send {blind}{NumpadSub}
+ OutputChar("{NumpadSub}", "minus") ; s. Mail vom Sun, 14 Sep 2008 00:33:47 +0200
else if (Ebene = 6)
- SendUnicodeChar(0x2205) ; leere Menge
+ SendUnicodeChar(0x2205, "emptyset") ; leere Menge
return
neo_strich:
noCaps = 1
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("-") ; Bindestrich-Minus
+ OutputChar("-", "minus") ; Bindestrich-Minus
else if (Ebene = 2)
- SendUnicodeChar(0x2013) ; Gedankenstrich
+ SendUnicodeChar(0x2013, "endash") ; Gedankenstrich
else if (Ebene = 3)
- SendUnicodeChar(0x2014) ; Englischer Gedankenstrich (Geviertstrich)
+ SendUnicodeChar(0x2014, "emdash") ; Englischer Gedankenstrich (Geviertstrich)
else if (Ebene = 5)
- SendUnicodeChar(0x2011) ; geschtzter Bindestrich (Bindestrich ohne Zeilenumbruch)
+ SendUnicodeChar(0x2011, "U2011") ; geschtzter Bindestrich (Bindestrich ohne Zeilenumbruch)
else if (Ebene = 6)
- SendUnicodeChar(0x00AD) ; weicher Bindestrich
+ SendUnicodeChar(0x00AD, "hyphen") ; weicher Bindestrich
return
neo_tot2:
noCaps = 1
EbeneAktualisieren()
if (Ebene = 1) and !CheckDeadUni("a1",0x0301)
- deadAsc("{}{space}", "a1") ; Akut, tot
+ deadAsc("{}{space}", "dead_acute", "a1") ; Akut, tot
else if (Ebene = 2) and !CheckDeadUni("a2",0x0300)
- deadAsc("``{space}", "a2") ; Gravis, tot
+ deadAsc("``{space}", "dead_grave", "a2") ; Gravis, tot
else if (Ebene = 3) and !CheckDeadUni("a3",0x0327)
- deadAsc("", "a3") ; Cedilla, tot
+ deadAsc("", "dead_cedilla", "a3") ; Cedilla, tot
else if (Ebene = 4) and !CheckDeadUni("a4",0x0307)
- deadUni(0x02D9, "a4") ; Punkt oben
+ deadUni(0x02D9, "dead_abovedot", "a4") ; Punkt oben
else if (Ebene = 5) and !CheckDeadUni("a5",0x0328)
- deadUni(0x02DB, "a5") ; Ogonek
+ deadUni(0x02DB, "dead_ogonek", "a5") ; Ogonek
else if (Ebene = 6) and !CheckDeadUni("a6",0x030A)
- deadUni(0x02DA, "a6") ; Ring oben
+ deadUni(0x02DA, "dead_abovering", "a6") ; Ring oben
CompKey := PriorCompKey
return
@@ -975,32 +970,29 @@ return neo_x:
EbeneAktualisieren()
if Ebene12
- OutputChar12("x","X")
+ OutputChar12("x","X","x","X")
else if (Ebene = 3)
- SendUnicodeChar(0x2026) ; Ellipse horizontal
+ SendUnicodeChar(0x2026, "ellipsis") ; Ellipse horizontal
else if (Ebene = 4)
- SendUnicodeChar(0x22EE) ; Ellipse vertikal
+ SendUnicodeChar(0x22EE, "U22EE") ; Ellipse vertikal
else if (Ebene = 5)
- SendUnicodeChar(0x03BE) ; xi
+ SendUnicodeChar(0x03BE, "Greek_xi") ; xi
else if (Ebene = 6)
- SendUnicodeChar(0x039E) ; Xi
+ SendUnicodeChar(0x039E, "Greek_XI") ; Xi
return
-
neo_v:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("c6",0x1E7F,0x1E7E)))
- OutputChar12("v","V")
+ OutputChar12("v","V","v","V")
else if (Ebene = 3)
- OutputChar("_")
+ OutputChar("_","underscore")
else if (Ebene = 4) and (!lernModus or lernModus_neo_Backspace)
- Send {blind}{Backspace}
+ OutputChar("{Backspace}", "BackSpace")
else if (Ebene = 6)
- SendUnicodeChar(0x2259) ; estimates/entspricht
+ SendUnicodeChar(0x2259, "U2259") ; estimates/entspricht
return
-
-
neo_l:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a1",0x013A,0x0139)
@@ -1009,18 +1001,17 @@ neo_l: or CheckDeadUni12("c4",0x0140,0x013F)
or CheckDeadUni12("c6",0x1E37,0x1E36)
or CheckDeadUni12("t4",0x0142,0x0141)))
- OutputChar12("l","L")
+ OutputChar12("l","L","l","L")
else if (Ebene = 3)
- OutputChar("[")
+ OutputChar("[", "bracketleft")
else if (Ebene = 4)
- Send {Blind}{Up}
+ OutputChar("{Up}", "Up")
else if (Ebene = 5)
- SendUnicodeChar(0x03BB) ; lambda
+ SendUnicodeChar(0x03BB, "Greek_lambda") ; lambda
else if (Ebene = 6)
- SendUnicodeChar(0x039B) ; Lambda
+ SendUnicodeChar(0x039B, "Greek_LAMBDA") ; Lambda
return
-
neo_c:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a1",0x0107,0x0106)
@@ -1028,44 +1019,44 @@ neo_c: or CheckDeadUni12("a4",0x010B,0x010A)
or CheckDeadUni12("c1",0x0109,0x0108)
or CheckDeadUni12("c2",0x010D,0x010C)))
- OutputChar12("c","C")
+ OutputChar12("c","C","c","C")
else if (Ebene = 3)
- OutputChar("]")
+ OutputChar("]", "bracketright")
else if (Ebene = 4) and (!lernModus or lernModus_neo_Entf)
- send {blind}{Del}
+ OutputChar("{Del}", "Delete")
else if (Ebene = 5)
- SendUnicodeChar(0x03C7) ; chi
+ SendUnicodeChar(0x03C7, "Greek_chi") ; chi
else if (Ebene = 6)
- SendUnicodeChar(0x2102) ; C (Komplexe Zahlen)]
+ SendUnicodeChar(0x2102, "U2102") ; C (Komplexe Zahlen)]
return
neo_w:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("c1",0x0175,0x0174)))
- OutputChar12("w","W")
+ OutputChar12("w","W","w","W")
else if (Ebene = 3)
- SendUnicodeChar(0x005E) ; Zirkumflex
+ SendUnicodeChar(0x005E, "asciicircum") ; Zirkumflex
else if (Ebene = 4)
- Send {blind}{Insert} ; Einfg
+ OutputChar("{Insert}", "Insert") ; Einfg
else if (Ebene = 5)
- SendUnicodeChar(0x03C9) ; omega
+ SendUnicodeChar(0x03C9, "Greek_omega") ; omega
else if (Ebene = 6)
- SendUnicodeChar(0x03A9) ; Omega
+ SendUnicodeChar(0x03A9, "Greek_OMEGA") ; Omega
return
neo_k:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a3",0x0137,0x0136)
or CheckDeadUni12("c6",0x1E33,0x1E32)))
- OutputChar12("k","K")
+ OutputChar12("k","K","k","K")
else if (Ebene = 3)
- OutputChar("{!}")
+ OutputChar("{!}", "exclam")
else if (Ebene = 4)
- OutputChar("")
+ OutputChar("", "exclamdown")
else if (Ebene = 5)
- SendUnicodeChar(0x03F0) ; kappa symbol (varkappa)
+ SendUnicodeChar(0x03F0, "U03F0") ; kappa symbol (varkappa)
else if (Ebene = 6)
- SendUnicodeChar(0x221A) ; Wurzel
+ SendUnicodeChar(0x221A, "radical") ; Wurzel
return
neo_h:
@@ -1074,16 +1065,16 @@ neo_h: or CheckDeadUni12("c1",0x0125,0x0124)
or CheckDeadUni12("c5",0x0127,0x0126)
or CheckDeadUni12("c6",0x1E25,0x1E24)))
- OutputChar12("h","H")
- else if ((Ebene = 3) and !(CheckDeadUni("c5",0x2264))) ; kleiner gleich
- send {blind}<
+ OutputChar12("h","H","h","H")
+ else if ((Ebene = 3) and !(CheckDeadUni("t4",0x2264))) ; kleiner gleich
+ OutputChar("<", "less")
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2077)
- or CheckDeadUni("c5",0x2087)))
- OutputChar("{Numpad7}")
+ or CheckDeadUni("t4",0x2087)))
+ OutputChar("{Numpad7}", "KP_7")
else if (Ebene = 5)
- SendUnicodeChar(0x03C8) ; psi
+ SendUnicodeChar(0x03C8, "Greek_psi") ; psi
else if (Ebene = 6)
- SendUnicodeChar(0x03A8) ; Psi
+ SendUnicodeChar(0x03A8, "Greek_PSI") ; Psi
return
neo_g:
@@ -1092,71 +1083,70 @@ neo_g: or CheckDeadUni12("a4",0x0121,0x0120)
or CheckDeadUni12("c1",0x011D,0x011C)
or CheckDeadUni12("c3",0x011F,0x011E)))
- OutputChar12("g","G")
- else if ((Ebene = 3) and !(CheckDeadUni("c5",0x2265))) ; grer gleich
- send {blind}>
+ OutputChar12("g","G","g","G")
+ else if ((Ebene = 3) and !(CheckDeadUni("t4",0x2265))) ; grer gleich
+ OutputChar(">", "greater")
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2078)
- or CheckDeadUni("c5",0x2088)))
- OutputChar("{Numpad8}")
+ or CheckDeadUni("t4",0x2088)))
+ OutputChar("{Numpad8}", "KP_8")
else if (Ebene = 5)
- SendUnicodeChar(0x03B3) ; gamma
+ SendUnicodeChar(0x03B3, "Greek_gamma") ; gamma
else if (Ebene = 6)
- SendUnicodeChar(0x0393) ; Gamma
+ SendUnicodeChar(0x0393, "Greek_GAMMA") ; Gamma
return
neo_f:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a4",0x1E1F,0x1E1E)
or CheckDeadUni12("t4",0x0192,0x0191)))
- OutputChar12("f","F")
+ OutputChar12("f","F","f","F")
else if ((Ebene = 3) and !(CheckDeadUni("a6",0x2257) ; ring equal to
or CheckDeadUni("c1",0x2259) ; entspricht
or CheckDeadUni("c2",0x225A) ; EQUIANGULAR TO
- or CheckDeadUni("c5",0x2261) ; identisch
+ or CheckDeadUni("t2",0x2261) ; identisch
or CheckDeadUni("t1",0x2245) ; ungefhr gleich
or CheckDeadUni("t4",0x2260))) ; ungleich
- send {blind}`=
+ OutputChar("`=", "equal")
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2079)
- or CheckDeadUni("c5",0x2089)))
- OutputChar("{Numpad9}")
+ or CheckDeadUni("t4",0x2089)))
+ OutputChar("{Numpad9}", "KP_9")
else if (Ebene = 5)
- SendUnicodeChar(0x03C6) ; phi
+ SendUnicodeChar(0x03C6, "Greek_phi") ; phi
else if (Ebene = 6)
- SendUnicodeChar(0x03A6) ; Phi
+ SendUnicodeChar(0x03A6, "Greek_PHI") ; Phi
return
neo_q:
EbeneAktualisieren()
if (Ebene12)
- OutputChar12("q","Q")
+ OutputChar12("q","Q","q","Q")
else if (Ebene = 3)
- send {blind}{&}
+ OutputChar("{&}", "ampersand")
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x207A)
or CheckDeadUni("c5",0x208A)))
- Send {blind}{NumPadAdd}
+ OutputChar("{NumPadAdd}", "plus") ; !!!
else if (Ebene = 5)
- SendUnicodeChar(0x03D5) ; phi symbol (varphi)
+ SendUnicodeChar(0x03D5, "U03D5") ; phi symbol (varphi)
else if (Ebene = 6)
- SendUnicodeChar(0x211A) ; Q (rationale Zahlen)
+ SendUnicodeChar(0x211A, "U211A") ; Q (rationale Zahlen)
return
neo_sz:
EbeneAktualisieren()
if (Ebene = 1)
if LangSTastatur
- OutputChar("s")
- else send
+ OutputChar("s", "s")
+ else OutputChar("", "ssharp")
else if (Ebene = 2)
- SendUnicodeChar(0x1E9E) ; versal-
+ SendUnicodeChar(0x1E9E, "U1E9E") ; versal-
else if (Ebene = 3)
if LangSTastatur
- send
- else
- SendUnicodeChar(0x017F) ; langes s
+ OutputChar("", "ssharp")
+ else SendUnicodeChar(0x017F, "17F") ; langes s
else if (Ebene = 5)
- SendUnicodeChar(0x03C2) ; varsigma
+ SendUnicodeChar(0x03C2, "Greek_finalsmallsigma") ; varsigma
else if (Ebene = 6)
- SendUnicodeChar(0x2218) ; Verknpfungsoperator
+ SendUnicodeChar(0x2218, "jot") ; Verknpfungsoperator
return
@@ -1164,17 +1154,17 @@ neo_tot3: noCaps = 1
EbeneAktualisieren()
if (Ebene = 1) and !CheckDeadUni("t1",0x0303)
- deadUni(0x02DC, "t1") ; Tilde, tot
+ deadUni(0x02DC, "dead_tilde", "t1") ; Tilde, tot
else if (Ebene = 2) and !CheckDeadUni("t2",0x0304)
- deadUni(0x00AF, "t2") ; Macron, tot
+ deadUni(0x00AF, "dead_macron", "t2") ; Macron, tot
else if (Ebene = 3) and !CheckDeadUni("t3",0x0308)
- deadUni(0x00A8, "t3") ; Direse
- else if (Ebene = 4) and !CheckDeadUni("t4",0x0337)
- deadUni(0x002F, "t4") ; Schrgstrich, tot
+ deadUni(0x00A8, "dead_diaeresis", "t3") ; Direse
+ else if (Ebene = 4) and !CheckDeadUni("t4",0x0338)
+ deadUni(0x002F, "", "t4") ; Schrgstrich, tot
else if (Ebene = 5) and !CheckDeadUni("t5",0x030B)
- deadUni(0x02DD, "t5") ; Doppelakut
+ deadUni(0x02DD, "dead_doubleacute", "t5") ; Doppelakut
else if (Ebene = 6) and !CheckDeadUni("t6",0x0326)
- deadUni(0x02CF, "t6") ; Komma drunter, tot
+ deadUni(0x02CF, "", "t6") ; Komma drunter, tot
return
@@ -1197,13 +1187,13 @@ neo_u: or CheckDeadUni12("t2",0x016B,0x016A)
or CheckDeadAsc12("t3","","")
or CheckDeadUni12("t5",0x0171,0x0170)))
- OutputChar12("u","U")
+ OutputChar12("u","U","u","U")
else if (Ebene = 3)
- send {blind}\
+ OutputChar("\", "backslash")
else if (Ebene = 4)
- Send {blind}{Home}
+ OutputChar("{Home}", "Home")
else if (Ebene = 6)
- SendUnicodeChar(0x222E) ; contour integral
+ SendUnicodeChar(0x222E, "U222E") ; contour integral
return
neo_i:
@@ -1218,15 +1208,15 @@ neo_i: or CheckDeadUni12("t1",0x0129,0x0128)
or CheckDeadUni12("t2",0x012B,0x012A)
or CheckDeadAsc12("t3","","")))
- OutputChar12("i","I")
+ OutputChar12("i","I","i","I")
else if (Ebene = 3)
- OutputChar("`/")
+ OutputChar("`/", "slash")
else if (Ebene = 4)
- Send {Blind}{Left}
+ OutputChar("{Left}", "Left")
else if (Ebene = 5)
- SendUnicodeChar(0x03B9) ; iota
+ SendUnicodeChar(0x03B9, "Greek_iota") ; iota
else if (Ebene = 6)
- SendUnicodeChar(0x222B) ; integral
+ SendUnicodeChar(0x222B, "integral") ; integral
return
neo_a:
@@ -1241,15 +1231,15 @@ neo_a: or CheckDeadUni12("t1",0x00E3,0x00C3)
or CheckDeadUni12("t2",0x0101,0x0100)
or CheckDeadAsc12("t3","","")))
- OutputChar12("a","A")
+ OutputChar12("a","A","a","A")
else if (Ebene = 3)
- send {blind}{{}
+ OutputChar("{{}", "braceleft")
else if (Ebene = 4)
- Send {Blind}{Down}
+ OutputChar("{Down}", "Down")
else if (Ebene = 5)
- SendUnicodeChar(0x03B1) ; alpha
+ SendUnicodeChar(0x03B1, "Greek_alpha") ; alpha
else if (Ebene = 6)
- SendUnicodeChar(0x2200) ; fr alle
+ SendUnicodeChar(0x2200, "U2200") ; fr alle
return
neo_e:
@@ -1264,15 +1254,15 @@ neo_e: or CheckDeadUni12("t1",0x1EBD,0x1EBC)
or CheckDeadUni12("t2",0x0113,0x0112)
or CheckDeadAsc12("t3","","")))
- OutputChar12("e","E")
+ OutputChar12("e","E","e","E")
else if (Ebene = 3)
- send {blind}{}}
+ OutputChar("{}}", "braceright")
else if (Ebene = 4)
- Send {Blind}{Right}
+ OutputChar("{Right}", "Right")
else if (Ebene = 5)
- SendUnicodeChar(0x03B5) ; epsilon
+ SendUnicodeChar(0x03B5, "Greek_epsilon") ; epsilon
else if (Ebene = 6)
- SendUnicodeChar(0x2203) ; es existiert
+ SendUnicodeChar(0x2203, "U2203") ; es existiert
return
neo_o:
@@ -1288,15 +1278,15 @@ neo_o: or CheckDeadAsc12("t3","","")
or CheckDeadUni12("t4",0x00F8,0x00D8)
or CheckDeadUni12("t5",0x0151,0x0150)))
- OutputChar12("o","O")
+ OutputChar12("o","O","o","O")
else if (Ebene = 3)
- send {blind}*
+ OutputChar("*", "asterisk")
else if (Ebene = 4)
- Send {blind}{End}
+ OutputChar("{End}", "End")
else if (Ebene = 5)
- SendUnicodeChar(0x03BF) ; omicron
+ SendUnicodeChar(0x03BF, "Greek_omicron") ; omicron
else if (Ebene = 6)
- SendUnicodeChar(0x2208) ; element of
+ SendUnicodeChar(0x2208, "elementof") ; element of
return
neo_s:
@@ -1308,20 +1298,20 @@ neo_s: or CheckDeadUni12("c2",0x0161,0x0160)
or CheckDeadUni12("c6",0x1E63,0x1A62))) {
if LangSTastatur and (Ebene = 1)
- SendUnicodeChar(0x017F) ; langes s
- else OutputChar12("s","S")
+ SendUnicodeChar(0x017F, "17F") ; langes s
+ else OutputChar12("s","S","s","S")
} else if (Ebene = 3)
- OutputChar("?")
+ OutputChar("?", "question")
else if Ebene7 {
if LangSTastatur
- OutputChar("s")
- else SendUnicodeChar(0x017F)
+ OutputChar("s", "s")
+ else SendUnicodeChar(0x017F, "17F")
} else if (Ebene = 4)
- OutputChar("")
+ OutputChar("", "questiondown")
else if (Ebene = 5)
- SendUnicodeChar(0x03C3) ;sigma
+ SendUnicodeChar(0x03C3, "Greek_sigma") ;sigma
else if (Ebene = 6)
- SendUnicodeChar(0x03A3) ;Sigma
+ SendUnicodeChar(0x03A3, "Greek_SIGMA") ;Sigma
return
neo_n:
@@ -1331,16 +1321,16 @@ neo_n: or CheckDeadUni12("a4",0x1E45,0x1E44)
or CheckDeadUni12("c2",0x0148,0x0147)
or CheckDeadUni12("t1",0x00F1,0x00D1)))
- OutputChar12("n","N")
+ OutputChar12("n","N","n","N")
else if (Ebene = 3)
- OutputChar("(")
+ OutputChar("(", "parenleft")
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2074)
- or CheckDeadUni("c5",0x2084)))
- OutputChar("{Numpad4}")
+ or CheckDeadUni("t4",0x2084)))
+ OutputChar("{Numpad4}", "KP_4")
else if (Ebene = 5)
- SendUnicodeChar(0x03BD) ; nu
+ SendUnicodeChar(0x03BD, "Greek_nu") ; nu
else if (Ebene = 6)
- SendUnicodeChar(0x2115) ; N (natrliche Zahlen)
+ SendUnicodeChar(0x2115, "U2115") ; N (natrliche Zahlen)
return
neo_r:
@@ -1349,17 +1339,17 @@ neo_r: or CheckDeadUni12("a3",0x0157,0x0156)
or CheckDeadUni12("a4",0x0E59,0x0E58)
or CheckDeadUni12("c2",0x0159,0x0158)
- or CheckDeadUni12("c6",0x1E5B,0x1E5A)))
- OutputChar12("r","R")
+ or CheckDeadUni12("t3",0x1E5B,0x1E5A)))
+ OutputChar12("r","R","r","R")
else if (Ebene = 3)
- OutputChar(")")
+ OutputChar(")", "parenright")
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x2075)
- or CheckDeadUni("c5",0x2085)))
- OutputChar("{Numpad5}")
+ or CheckDeadUni("t4",0x2085)))
+ OutputChar("{Numpad5}", "KP_5")
else if (Ebene = 5)
- SendUnicodeChar(0x03F1) ; rho symbol (varrho)
+ SendUnicodeChar(0x03F1, "U03F1") ; rho symbol (varrho)
else if (Ebene = 6)
- SendUnicodeChar(0x211D) ; R (reelle Zahlen)
+ SendUnicodeChar(0x211D, "U221D") ; R (reelle Zahlen)
return
neo_t:
@@ -1368,36 +1358,36 @@ neo_t: or CheckDeadUni12("a4",0x1E6B,0x1E6A)
or CheckDeadUni12("c2",0x0165,0x0164)
or CheckDeadUni12("c5",0x0167,0x0166)
- or CheckDeadUni12("c6",0x1E6D,0x1E6C)
+ or CheckDeadUni12("t4",0x1E6D,0x1E6C)
or CheckDeadUni("t3",0x1E97)))
- OutputChar12("t","T")
+ OutputChar12("t","T","t","T")
else if (Ebene = 3)
- OutputChar("-") ; Bisstrich
+ OutputChar("-", "minus") ; Bisstrich
else if (Ebene = 4) and !(CheckDeadUni("c1",0x2076)
or CheckDeadUni("c5",0x2086))
- OutputChar("{Numpad6}")
+ OutputChar("{Numpad6}", "KP_6")
else if (Ebene = 5)
- SendUnicodeChar(0x03C4) ; tau
+ SendUnicodeChar(0x03C4, "Greek_tau") ; tau
else if (Ebene = 6)
- SendUnicodeChar(0x2202) ; partielle Ableitung
+ SendUnicodeChar(0x2202, "partialderivative") ; partielle Ableitung
return
neo_d:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a4",0x1E0B,0x1E0A)
or CheckDeadUni12("c2",0x010F,0x010E)
- or CheckDeadUni12("c5",0x0111,0x0110)
- or CheckDeadUni12("c6",0x1E0D,0x1E0C)
+ or CheckDeadUni12("t2",0x0111,0x0110)
+ or CheckDeadUni12("t3",0x1E0D,0x1E0C)
or CheckDeadUni12("t4",0x00F0,0x00D0)))
- OutputChar12("d","D")
+ OutputChar12("d","D","d","D")
else if (Ebene = 3)
- OutputChar(":")
+ OutputChar(":", "colon")
else if (Ebene = 4)
- send `,
+ OutputChar("`,", "comma")
else if (Ebene = 5)
- SendUnicodeChar(0x03B4) ; delta
+ SendUnicodeChar(0x03B4, "Greek_delta") ; delta
else if (Ebene = 6)
- SendUnicodeChar(0x0394) ; Delta
+ SendUnicodeChar(0x0394, "Greek_DELTA") ; Delta
return
neo_y:
@@ -1405,15 +1395,15 @@ neo_y: if (Ebene12 and !(CheckDeadUni12("a1",0x00FD,0x00DD)
or CheckDeadUni12("c1",0x0177,0x0176)
or CheckDeadAsc12("t3","","")))
- OutputChar12("y","Y")
+ OutputChar12("y","Y","y","Y")
else if (Ebene = 3)
- send {blind}@
+ OutputChar("@", "at")
else if (Ebene = 4)
- Send {blind}.
+ OutputChar(".", "period")
else if (Ebene = 5)
- SendUnicodeChar(0x03C5) ; upsilon
+ SendUnicodeChar(0x03C5, "Greek_upsilon") ; upsilon
else if (Ebene = 6)
- SendUnicodeChar(0x2207) ; nabla
+ SendUnicodeChar(0x2207, "nabla") ; nabla
return
/*
@@ -1428,61 +1418,55 @@ neo_: or CheckDeadUni12("a2",0x01DC,0x01DB)
or CheckDeadUni12("c2",0x01DA,0x01D9)
or CheckDeadUni12("t2",0x01D6,0x01D5)))
- OutputChar12("","")
+ OutputChar12("","","udiaeresis","Udiaeresis")
else if (Ebene = 3)
if isMod2Locked
- send {blind}{Shift Up}{#}
- else send {blind}{#}
+ OutputChar("{Shift Up}{#}", "numbersign")
+ else OutputChar("{blind}{#}", "numbersign")
else if (Ebene = 4)
- Send {blind}{Esc}
- else if (Ebene = 5) { ; leer
- DeadKey := PriorDeadKey
- CompKey := PriorCompKey
- } else if (Ebene = 6)
- SendUnicodeChar(0x221D) ; proportional
+ OutputChar("{Esc}", "Escape")
+ else if (Ebene = 6)
+ SendUnicodeChar(0x221D, "variation") ; proportional
return
neo_:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("t2",0x022B,0x022A)))
- OutputChar12("","")
+ OutputChar12("","","odiaeresis","Odiaeresis")
else if (Ebene = 3)
- send {blind}$
+ OutputChar("$", "dollar")
else if (Ebene = 4)
- send {blind}{Tab}
- else if (Ebene = 5) { ; leer
- DeadKey := PriorDeadKey
- CompKey := PriorCompKey
- } else if (Ebene = 6)
- SendUnicodeChar(0x2111) ; Fraktur I
+ OutputChar("{Tab}", "Tab")
+ else if (Ebene = 6)
+ SendUnicodeChar(0x2111, "U2221") ; Fraktur I
return
neo_:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("t2",0x01DF,0x01DE)))
- OutputChar12("","")
+ OutputChar12("","","adiaeresis","Adiaeresis")
else if (Ebene = 3)
- send {blind}|
+ OutputChar("|", "bar")
else if (Ebene = 4)
- Send {blind}{PgDn} ; Next
+ OutputChar("{PgDn}", "Next")
else if (Ebene = 5)
- SendUnicodeChar(0x03B7) ; eta
+ SendUnicodeChar(0x03B7, "Greek_eta") ; eta
else if (Ebene = 6)
- SendUnicodeChar(0x211C) ; Fraktur R
+ SendUnicodeChar(0x211C, "U221C") ; Fraktur R
return
neo_p:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a4",0x1E57,0x1E56)))
- OutputChar12("p","P")
+ OutputChar12("p","P","p","P")
else if ((Ebene = 3) and !(CheckDeadUni("t1",0x2248)))
- send {blind}~
+ OutputChar("~", "asciitilde")
else if (Ebene = 4)
- Send {blind}{Enter}
+ OutputChar("{Enter}", "Return")
else if (Ebene = 5)
- SendUnicodeChar(0x03C0) ; pi
+ SendUnicodeChar(0x03C0, "Greek_pi") ; pi
else if (Ebene = 6)
- SendUnicodeChar(0x03A0) ; Pi
+ SendUnicodeChar(0x03A0, "Greek_PI") ; Pi
return
neo_z:
@@ -1491,97 +1475,93 @@ neo_z: or CheckDeadUni12("a4",0x017C,0x017B)
or CheckDeadUni12("c2",0x017E,0x017D)
or CheckDeadUni12("c6",0x1E93,0x1E92)))
- OutputChar12("z","Z")
+ OutputChar12("z","Z","z","Z")
else if (Ebene = 3)
- send ``{space} ; untot
+ OutputChar("``{space}", "grave") ; untot
else if (Ebene = 5)
- SendUnicodeChar(0x03B6) ; zeta
+ SendUnicodeChar(0x03B6, "Greek_zeta") ; zeta
else if (Ebene = 6)
- SendUnicodeChar(0x2124) ; Z (ganze Zahlen)
+ SendUnicodeChar(0x2124, "U2124") ; Z (ganze Zahlen)
return
neo_b:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a4",0x1E03,0x1E02)))
- OutputChar12("b","B")
+ OutputChar12("b","B","b","B")
else if (Ebene = 3)
if isMod2Locked
- send {blind}{Shift Up}{+}
- else send {blind}{+}
+ OutputChar("{Shift Up}{+}", "plus")
+ else OutputChar("{blind}{+}", "plus")
else if (Ebene = 4)
- send {blind}:
+ OutputChar(":", "colon")
else if (Ebene = 5)
- SendUnicodeChar(0x03B2) ; beta
+ SendUnicodeChar(0x03B2, "Greek_beta") ; beta
else if (Ebene = 6)
- SendUnicodeChar(0x21D2) ; Doppel-Pfeil rechts
+ SendUnicodeChar(0x21D2, "implies") ; Doppel-Pfeil rechts
return
neo_m:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("a4",0x1E41,0x1E40)
or CheckDeadUni12("c6",0x1E43,0x1E42)))
- OutputChar12("m","M")
+ OutputChar12("m","M","m","M")
else if (Ebene = 3)
- send {blind}`%
+ OutputChar("`%", "percent")
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x00B9)
- or CheckDeadUni("c5",0x2081)))
- OutputChar("{Numpad1}")
+ or CheckDeadUni("t4",0x2081)))
+ OutputChar("{Numpad1}", "KP_1")
else if (Ebene = 5)
- SendUnicodeChar(0x03BC) ; griechisch mu, micro wre 0x00B5
+ SendUnicodeChar(0x03BC, "Greek_mu") ; griechisch mu, micro wre 0x00B5
else if (Ebene = 6)
- SendUnicodeChar(0x21D4) ; doppelter Doppelpfeil (genau dann wenn)
+ SendUnicodeChar(0x21D4, "ifonlyif") ; doppelter Doppelpfeil (genau dann wenn)
return
neo_komma:
noCaps = 1
EbeneAktualisieren()
if (Ebene = 1)
- send {blind},
- else if (Ebene = 2)
- SendUnicodeChar(0x22EE) ; vertikale ellipse
+ OutputChar(",", "comma")
else if (Ebene = 3)
- OutputChar(Chr(34))
+ OutputChar(Chr(34), "quotedbl")
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x00B2)
or CheckDeadUni("c5",0x2082)))
- OutputChar("{Numpad2}")
+ OutputChar("{Numpad2}", "KP_2")
else if (Ebene = 5)
- SendUnicodeChar(0x03C1) ; rho
+ SendUnicodeChar(0x03C1, "Greek_rho") ; rho
else if (Ebene = 6)
- SendUnicodeChar(0x21D0) ; Doppelpfeil links
+ SendUnicodeChar(0x21D0, "U21D0") ; Doppelpfeil links
return
neo_punkt:
noCaps = 1
EbeneAktualisieren()
if (Ebene = 1)
- send {blind}.
- else if (Ebene = 2)
- SendUnicodeChar(0x2026) ; ellipse
+ OutputChar(".", "period")
else if (Ebene = 3)
- OutputChar("'")
+ OutputChar("'", "apostrophe")
else if ((Ebene = 4) and !(CheckDeadUni("c1",0x00B3)
- or CheckDeadUni("c5",0x2083)))
- OutputChar("{Numpad3}")
+ or CheckDeadUni("t4",0x2083)))
+ OutputChar("{Numpad3}", "KP_3")
else if (Ebene = 5)
- SendUnicodeChar(0x03D1) ; theta symbol (vartheta)
+ SendUnicodeChar(0x03D1, "U03D1") ; theta symbol (vartheta)
else if (Ebene = 6)
- SendUnicodeChar(0x0398) ; Theta
+ SendUnicodeChar(0x0398, "Greek_THETA") ; Theta
return
neo_j:
EbeneAktualisieren()
if (Ebene12 and !(CheckDeadUni12("c1",0x0135,0x0134)
- or CheckDeadUni12("c2",0x01F0,"")))
- OutputChar12("j","J")
+ or CheckDeadUni("c2",0x01F0)))
+ OutputChar12("j","J","j","J")
else if (Ebene = 3)
- send {blind}`;
+ OutputChar("`;", "semicolon")
else if (Ebene = 4)
- Send {blind}`;
+ OutputChar("`;", "semicolon")
else if (Ebene = 5)
- SendUnicodeChar(0x03B8) ; theta
+ SendUnicodeChar(0x03B8, "Greek_theta") ; theta
else if (Ebene = 6)
- SendUnicodeChar(0x2261) ; identisch
+ SendUnicodeChar(0x2261, "identical") ; identisch
return
/*
@@ -1592,52 +1572,52 @@ return neo_NumLock:
EbeneAktualisieren()
- if (Ebene = 1)
- send `=
+ if (Ebene = 1) ;
+ OutputChar("`=", "equal")
if (Ebene = 3)
- SendUnicodeChar(0x2248) ; Fast gleich
- if (Ebene = 4)
- SendUnicodeChar(0x2260) ; Ungleich zu
+ SendUnicodeChar(0x2248, "U2248") ; Fast gleich
+ if (Ebene = 2)
+ SendUnicodeChar(0x2260, "U2260") ; Ungleich zu
return
neo_NumpadDiv:
EbeneAktualisieren()
- if Ebene14
- OutputChar("{NumpadDiv}")
- else if (Ebene = 2)
- SendUnicodeChar(0x2215) ; Slash
+ if Ebene12
+ OutputChar("{NumpadDiv}", "KP_Divide")
+ else if (Ebene = 4)
+ SendUnicodeChar(0x2215, "division") ; Slash
else if (Ebene = 3)
- send {blind}
+ OutputChar("", "U2044")
return
neo_NumpadMult:
EbeneAktualisieren()
- if Ebene14
+ if Ebene12
send {blind}{NumpadMult}
- else if (Ebene = 2)
- SendUnicodeChar(0x22C5) ; Cdot
else if (Ebene = 3)
- send {blind}
+ SendUnicodeChar(0x22C5, "multiply") ; Cdot
+ else if (Ebene = 4)
+ OutputChar("", "U2219")
return
neo_NumpadSub:
EbeneAktualisieren()
- if (Ebene14 and !(CheckDeadUni("c1",0x207B)
- or CheckDeadUni("c5",0x208B)))
+ if (Ebene12 and !(CheckDeadUni("c1",0x207B)
+ or CheckDeadUni("t4",0x208B)))
send {blind}{NumpadSub}
- else if (Ebene = 3)
- SendUnicodeChar(0x2212) ; Echtes Minus
+ else if (Ebene = 3) or (Ebene = 4)
+ SendUnicodeChar(0x2212, "U2212") ; Echtes Minus
return
neo_NumpadAdd:
EbeneAktualisieren()
- if (Ebene14 and !(CheckDeadUni("c1",0x207A)
+ if (Ebene12 and !(CheckDeadUni("c1",0x207A)
or CheckDeadUni("c5",0x208A)))
send {blind}{NumpadAdd}
else if (Ebene = 3)
- send {blind}
- else if (Ebene = 2)
- SendUnicodeChar(0x2213) ; Inverses
+ OutputChar("", "plusminus")
+ else if (Ebene = 4)
+ SendUnicodeChar(0x2213, "U2213") ; Inverses
return
neo_NumpadEnter:
@@ -1647,11 +1627,11 @@ return neo_Numpad7:
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("{Numpad7}")
+ OutputChar("{Numpad7}", "KP_7")
else if (Ebene = 2)
- SendUnicodeChar(0x2020) ; Kreuz
+ SendUnicodeChar(0x2020, "dagger") ; Kreuz
else if (Ebene = 3)
- SendUnicodeChar(0x2195) ; Hoch-Runter-Pfeil
+ SendUnicodeChar(0x2195, "U2195") ; Hoch-Runter-Pfeil
else if (Ebene = 4)
send {blind}{NumpadHome}
return
@@ -1659,11 +1639,11 @@ return neo_Numpad8:
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("{Numpad8}")
+ OutputChar("{Numpad8}", "KP_8")
else if (Ebene = 2)
- SendUnicodeChar(0x2229) ; Durchschnitt
+ SendUnicodeChar(0x2229, "intersection") ; Durchschnitt
else if (Ebene = 3)
- SendUnicodeChar(0x2191) ; Hochpfeil
+ SendUnicodeChar(0x2191, "uparrow") ; Hochpfeil
else if (Ebene = 4)
send {blind}{NumpadUp}
return
@@ -1671,11 +1651,11 @@ return neo_Numpad9:
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("{Numpad9}")
+ OutputChar("{Numpad9}", "KP_9")
else if (Ebene = 2)
- SendUnicodeChar(0x2297) ; Tensorprodukt / Vektor in die Ebene zeigend
+ SendUnicodeChar(0x2297, "U2297") ; Tensorprodukt / Vektor in die Ebene zeigend
else if (Ebene = 3)
- SendUnicodeChar(0x220D) ; Kleines umgekehrtes Elementzeichen
+ SendUnicodeChar(0x220D, "U220D") ; Kleines umgekehrtes Elementzeichen
else if (Ebene = 4)
send {blind}{NumpadPgUp}
return
@@ -1683,11 +1663,11 @@ return neo_Numpad4:
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("{Numpad4}")
+ OutputChar("{Numpad4}", "KP_4")
else if (Ebene = 2)
- SendUnicodeChar(0x2282) ; Teilmenge
+ SendUnicodeChar(0x2282, "includein") ; Teilmenge
else if (Ebene = 3)
- SendUnicodeChar(0x2190) ; Linkspfeil
+ SendUnicodeChar(0x2190, "leftarrow") ; Linkspfeil
else if (Ebene = 4)
send {blind}{NumpadLeft}
return
@@ -1695,11 +1675,11 @@ return neo_Numpad5:
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("{Numpad5}")
+ OutputChar("{Numpad5}", "KP_5")
else if (Ebene = 2)
- SendUnicodeChar(0x20AC) ; Euro
+ SendUnicodeChar(0x20AC, "EuroSign") ; Euro
else if (Ebene = 3)
- SendUnicodeChar(0x221E) ; Unendlich
+ SendUnicodeChar(0x221E, "infinity") ; Unendlich
else if (Ebene = 4) ; Beg
send {blind}{NumPadClear}
return
@@ -1707,11 +1687,11 @@ return neo_Numpad6:
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("{Numpad6}")
+ OutputChar("{Numpad6}", "KP_6")
else if (Ebene = 2)
- SendUnicodeChar(0x2283) ; Obermenge
+ SendUnicodeChar(0x2283, "includes") ; Obermenge
else if (Ebene = 3)
- SendUnicodeChar(0x2192) ; Rechtspfeil
+ SendUnicodeChar(0x2192, "rightarrow") ; Rechtspfeil
else if (Ebene = 4)
send {blind}{NumpadRight}
return
@@ -1719,11 +1699,11 @@ return neo_Numpad1:
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("{Numpad1}")
+ OutputChar("{Numpad1}", "KP_1")
else if (Ebene = 2)
- SendUnicodeChar(0x2714) ; Hkchen
+ SendUnicodeChar(0x2714, "U2714") ; Hkchen
else if (Ebene = 3)
- SendUnicodeChar(0x2194) ; Links-Rechts-Pfeil
+ SendUnicodeChar(0x2194, "U2194") ; Links-Rechts-Pfeil
else if (Ebene = 4)
send {blind}{NumpadEnd}
return
@@ -1731,11 +1711,11 @@ return neo_Numpad2:
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("{Numpad2}")
+ OutputChar("{Numpad2}", "KP_2")
else if (Ebene = 2)
- SendUnicodeChar(0x222A) ; Vereinigung
+ SendUnicodeChar(0x222A, "union") ; Vereinigung
else if (Ebene = 3)
- SendUnicodeChar(0x2192) ; Untenpfeil
+ SendUnicodeChar(0x2192, "downarrow") ; Untenpfeil
else if (Ebene = 4)
send {blind}{NumpadDown}
return
@@ -1743,11 +1723,11 @@ return neo_Numpad3:
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("{Numpad3}")
+ OutputChar("{Numpad3}", "KP_3")
else if (Ebene = 2)
- SendUnicodeChar(0x2718) ; Kreuzchen
+ SendUnicodeChar(0x2718, "U2718") ; Kreuzchen
else if (Ebene = 3)
- SendUnicodeChar(0x2192) ; Rechtspfeil
+ SendUnicodeChar(0x21CC, "U21CC") ; Harpune
else if (Ebene = 4)
send {blind}{NumpadPgDn}
return
@@ -1755,11 +1735,11 @@ return neo_Numpad0:
EbeneAktualisieren()
if (Ebene = 1)
- OutputChar("{Numpad0}")
+ OutputChar("{Numpad0}", "KP_0")
else if (Ebene = 2)
- SendUnicodeChar(0x0025) ; Prozent
+ SendUnicodeChar(0x0025, "percent") ; Prozent
else if (Ebene = 3)
- SendUnicodeChar(0x2030) ; Promille
+ SendUnicodeChar(0x2030, "U2030") ; Promille
else if (Ebene = 4)
send {blind}{NumpadIns}
return
@@ -1798,17 +1778,17 @@ return neo_SpaceUp:
EbeneAktualisieren()
- if (Ebene = 1) and !CheckDeadUni("c5",0x2010) ; Echter Bindestrich
- OutputChar("{Space}")
+ if (Ebene = 1) and !CheckDeadUni("t4",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("c5",0x2080)))
- OutputChar("{Numpad0}")
+ OutputChar("{Numpad0}", "KP_0")
else if (Ebene = 5)
- SendUnicodeChar(0x00A0) ; geschtztes Leerzeichen
+ SendUnicodeChar(0x00A0, "U00A0") ; geschtztes Leerzeichen
else if (Ebene = 6)
- SendUnicodeChar(0x202F) ; schmales geschtztes Leerzeichen
+ SendUnicodeChar(0x202F, "U202F") ; schmales geschtztes Leerzeichen
DeadKey := ""
CompKey := ""
spacepressed := 0
@@ -1816,7 +1796,7 @@ neo_SpaceUp: return
/*
- Folgende Tasten sind nur aufgefhrt, um PriorDeadKey zu leeren.
+ Folgende Tasten sind nur aufgefhrt, um DeadKey zu leeren.
Irgendwie sieht das noch nicht schn aus. Vielleicht lsst sich dieses
Problem auch eleganter lsen...
*/
@@ -2020,17 +2000,17 @@ InsertIntegerLED(pInteger, ByRef pDest, pOffset = 0, pSize = 4) { 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)
}
-deadAsc(val, a) {
+deadAsc(val1, val2, a) {
global
if !DeadSilence
- send % val
+ OutputChar(val1, val2)
DeadKey := a
}
-deadUni(val, a) {
+deadUni(val1, val2, a) {
global
if !DeadSilence
- SendUnicodeChar(val)
+ SendUnicodeChar(val1, val2)
DeadKey := a
}
@@ -2046,7 +2026,7 @@ undeadUni(val){ global
if !DeadSilence
send {bs}
- SendUnicodeChar(val)
+ SendUnicodeChar(val, "")
}
CheckDeadAsc(d,val) {
@@ -2091,43 +2071,34 @@ CheckDeadUni12(d,val1,val2) { }
}
-CheckCompAsc(d,val) {
- global
- if (PriorCompKey == d) {
- if !DeadCompose
- send {bs}
- send % val
- CompKey = 0
- isFurtherCompKey = 0
- return 1
- }
-}
-
CheckCompUni(d,val) {
global
- if (PriorCompKey == d) {
+ if (CompKey == d) {
PriorCompKey =
CompKey =
if !DeadCompose
send {bs}
isFurtherCompkey = 0
- SendUnicodeChar(val)
+ SendUnicodeChar(val, "")
return 1
}
}
-OutputChar(val) {
+OutputChar(val1,val2) {
global
- if !(CheckComp(val) and DeadCompose)
- send % "{blind}" . val
+ if !(CheckComp(val2) and DeadCompose)
+ send % "{blind}" . val1
}
-OutputChar12(val1,val2) {
+OutputChar12(val1,val2,val3,val4) {
global
if (Ebene = 1)
c := val1
else c := val2
- if !(CheckComp(c) and DeadCompose)
+ if (Ebene = 1)
+ d := val3
+ else d := val4
+ if !(CheckComp(d) and DeadCompose)
if GetKeyState("Shift","P") and isMod2Locked
send % "{blind}{Shift Up}" . c . "{Shift Down}"
else send % "{blind}" . c
@@ -2136,278 +2107,2849 @@ OutputChar12(val1,val2) { CheckComp(d) {
global
if isFurtherCompkey {
- PriorCompKey := CompKey := PriorCompKey . "_" . d
+ CompKey := PriorCompKey . " " . "<" . d . ">"
isFurtherCompkey = 0
CheckCompose()
if (CompKey = "")
return 1
else CompKey =
} else if PriorCompKey {
- PriorCompKey := CompKey := PriorCompKey . "_" . d
+ CompKey := PriorCompKey . " " . "<" . d . ">"
CheckCompose()
if CompKey
isFurtherCompKey = 1
return 1
} else if (PriorDeadKey = "comp") {
- CompKey := d
+ CompKey := "<" . d . ">"
return 1
}
}
CheckCompose() {
-CheckCompAsc("p_{!}","")
-CheckCompAsc("P_{!}","")
-CheckCompAsc("P_P","")
-CheckCompAsc("o_c","")
-CheckCompAsc("o_C","")
-CheckCompAsc("O_C","")
-CheckCompAsc("O_c","")
-CheckCompAsc("o_r","")
-CheckCompAsc("O_r","")
-CheckCompAsc("o_R","")
-CheckCompAsc("O_R","")
-CheckCompAsc("A_T","@")
-CheckCompAsc("a_e","")
-CheckCompAsc("A_E","")
-CheckCompAsc("o_e","")
-CheckCompAsc("O_E","")
-CheckCompAsc("t_h","")
-CheckCompAsc("T_H","")
-CheckCompUni("{Numpad1}_{Numpad4}",0x00BC)
-CheckCompUni("1_4",0x00BC)
-CheckCompUni("{Numpad1}_{Numpad2}",0x00BD)
-CheckCompUni("1_2",0x00BD)
-CheckCompUni("{Numpad3}_{Numpad4}",0x00BE)
-CheckCompUni("3_4",0x00BE)
-CheckCompUni("-_H",0x0126)
-CheckCompUni("-_h",0x0127)
-CheckCompUni("I_J",0x0132)
-CheckCompUni("i_j",0x0133)
-CheckCompUni("N_G",0x014A)
-CheckCompUni("n_g",0x014B)
-CheckCompUni("E_E",0x018F)
-CheckCompUni("D_z",0x01C4)
-CheckCompUni("D_z",0x01C5)
-CheckCompUni("d_z",0x01C6)
-CheckCompUni("L_J",0x01C7)
-CheckCompUni("L_j",0x01C8)
-CheckCompUni("l_j",0x01C9)
-CheckCompUni("N_J",0x01CA)
-CheckCompUni("N_j",0x01CB)
-CheckCompUni("n_j",0x01CC)
-CheckCompUni("G_A",0x0391)
-CheckCompUni("G_B",0x0392)
-CheckCompUni("G_E",0x0395)
-CheckCompUni("G_Z",0x0396)
-CheckCompUni("G_H",0x0397)
-CheckCompUni("G_I",0x0399)
-CheckCompUni("G_K",0x039A)
-CheckCompUni("G_M",0x039C)
-CheckCompUni("G_N",0x039D)
-CheckCompUni("G_X",0x039D)
-CheckCompUni("G_O",0x039F)
-CheckCompUni("G_P",0x03A1)
-CheckCompUni("G_T",0x03A4)
-CheckCompUni("G_Y",0x03A5)
-CheckCompUni("a_{Numpad0}",0x0660)
-CheckCompUni("a_0",0x0660)
-CheckCompUni("a_{Numpad1}",0x0661)
-CheckCompUni("a_1",0x0661)
-CheckCompUni("a_{Numpad2}",0x0662)
-CheckCompUni("a_2",0x0662)
-CheckCompUni("a_{Numpad3}",0x0663)
-CheckCompUni("a_3",0x0663)
-CheckCompUni("a_{Numpad4}",0x0664)
-CheckCompUni("a_4",0x0664)
-CheckCompUni("a_{Numpad5}",0x0665)
-CheckCompUni("a_5",0x0665)
-CheckCompUni("a_{Numpad6}",0x0666)
-CheckCompUni("a_6",0x0666)
-CheckCompUni("a_{Numpad7}",0x0667)
-CheckCompUni("a_7",0x0667)
-CheckCompUni("a_{Numpad8}",0x0668)
-CheckCompUni("a_8",0x0668)
-CheckCompUni("a_{Numpad9}",0x0669)
-CheckCompUni("a_9",0x0669)
-CheckCompUni("0x2020_0x2020",0x2021)
-CheckCompUni(":_:",0x2025)
-CheckCompUni("{!}_{Numpad2}",0x203C)
-CheckCompUni("{!}_2",0x203C)
-CheckCompUni("{Numpad2}_{!}",0x203C)
-CheckCompUni("2_{!}",0x203C)
-CheckCompUni("{Numpad1}_?_{!}",0x203D)
-CheckCompUni("{Numpad1}_{!}_?",0x203D)
-CheckCompUni("1_?_{!}",0x203D)
-CheckCompUni("1_{!}_?",0x203D)
-CheckCompUni("?_{Numpad2}",0x2047)
-CheckCompUni("?_2",0x2047)
-CheckCompUni("{Numpad2}_?",0x2047)
-CheckCompUni("2_?",0x2047)
-CheckCompUni("?_{!}",0x2048)
-CheckCompUni("{!}_?",0x2049)
-CheckCompUni("0x2192_0x2192",0x20D7)
-CheckCompUni("s_m",0x2120)
-CheckCompUni("t_m",0x2122)
-CheckCompUni("{Numpad1}_{Numpad3}",0x2153)
-CheckCompUni("1_3",0x2153)
-CheckCompUni("{Numpad5}_{Numpad3}",0x2154)
-CheckCompUni("5_3",0x2154)
-CheckCompUni("{Numpad1}_{Numpad5}",0x2155)
-CheckCompUni("1_5",0x2155)
-CheckCompUni("{Numpad2}_{Numpad5}",0x2156)
-CheckCompUni("2_5",0x2156)
-CheckCompUni("{Numpad3}_{Numpad5}",0x2157)
-CheckCompUni("3_5",0x2157)
-CheckCompUni("{Numpad4}_{Numpad5}",0x2158)
-CheckCompUni("4_5",0x2158)
-CheckCompUni("{Numpad1}_{Numpad6}",0x2159)
-CheckCompUni("1_6",0x2159)
-CheckCompUni("{Numpad5}_{Numpad6}",0x215A)
-CheckCompUni("5_6",0x215A)
-CheckCompUni("{Numpad1}_{Numpad8}",0x215B)
-CheckCompUni("1_8",0x215B)
-CheckCompUni("{Numpad3}_{Numpad8}",0x215C)
-CheckCompUni("3_8",0x215C)
-CheckCompUni("{Numpad5}_{Numpad8}",0x215D)
-CheckCompUni("5_8",0x215D)
-CheckCompUni("{Numpad7}_{Numpad8}",0x215E)
-CheckCompUni("7_8",0x215E)
-CheckCompUni("{Numpad1}_`/",0x215F)
-CheckCompUni("{Numpad1}_{NumpadDiv}",0x215F)
-CheckCompUni("1_`/",0x215F)
-CheckCompUni("1_{NumpadDiv}",0x215F)
-CheckCompUni("R_{Numpad1}_{Space}",0x2160)
-CheckCompUni("R_1_{Space}",0x2160)
-CheckCompUni("R_{Numpad2}",0x2161)
-CheckCompUni("R_2",0x2161)
-CheckCompUni("R_{Numpad3}",0x2162)
-CheckCompUni("R_3",0x2162)
-CheckCompUni("R_{Numpad4}",0x2163)
-CheckCompUni("R_4",0x2163)
-CheckCompUni("R_{Numpad5}",0x2164)
-CheckCompUni("R_5",0x2164)
-CheckCompUni("R_{Numpad6}",0x2165)
-CheckCompUni("R_6",0x2165)
-CheckCompUni("R_{Numpad7}",0x2166)
-CheckCompUni("R_7",0x2166)
-CheckCompUni("R_{Numpad8}",0x2167)
-CheckCompUni("R_8",0x2167)
-CheckCompUni("R_{Numpad9}",0x2168)
-CheckCompUni("R_9",0x2168)
-CheckCompUni("R_{Numpad1}_{Numpad0}",0x2169)
-CheckCompUni("R_1_0",0x2169)
-CheckCompUni("R_{Numpad1}_{Numpad1}",0x216A)
-CheckCompUni("R_1_1",0x216A)
-CheckCompUni("R_{Numpad1}_{Numpad2}",0x216B)
-CheckCompUni("R_1_2",0x216B)
-CheckCompUni("r_{Numpad1}_{Space}",0x2170)
-CheckCompUni("r_1_{Space}",0x2170)
-CheckCompUni("r_{Numpad2}",0x2171)
-CheckCompUni("r_2",0x2171)
-CheckCompUni("r_{Numpad3}",0x2172)
-CheckCompUni("r_3",0x2172)
-CheckCompUni("r_{Numpad4}",0x2173)
-CheckCompUni("r_4",0x2173)
-CheckCompUni("r_{Numpad5}",0x2174)
-CheckCompUni("r_5",0x2174)
-CheckCompUni("r_{Numpad6}",0x2175)
-CheckCompUni("r_6",0x2175)
-CheckCompUni("r_{Numpad7}",0x2176)
-CheckCompUni("r_7",0x2176)
-CheckCompUni("r_{Numpad8}",0x2177)
-CheckCompUni("r_8",0x2177)
-CheckCompUni("r_{Numpad9}",0x2178)
-CheckCompUni("r_9",0x2178)
-CheckCompUni("r_{Numpad1}_{Numpad0}",0x2179)
-CheckCompUni("r_1_0",0x2179)
-CheckCompUni("r_{Numpad1}_{Numpad1}",0x217A)
-CheckCompUni("r_1_1",0x217A)
-CheckCompUni("r_{Numpad1}_{Numpad2}",0x217B)
-CheckCompUni("r_1_2",0x217B)
-CheckCompUni("{Numpad3}_0x221A",0x221B)
-CheckCompUni("0x221A_{Numpad3}",0x221B)
-CheckCompUni("0x221A_3",0x221B)
-CheckCompUni("3_0x221A",0x221B)
-CheckCompUni("{Numpad4}_0x221A",0x221C)
-CheckCompUni("0x221A_{Numpad4}",0x221C)
-CheckCompUni("0x221A_4",0x221C)
-CheckCompUni("4_0x221A",0x221C)
-CheckCompUni("{Numpad2}_0x222B",0x222C)
-CheckCompUni("0x222B_{Numpad2}",0x222C)
-CheckCompUni("0x222B_0x222B",0x222C)
-CheckCompUni("0x222B_2",0x222C)
-CheckCompUni("2_0x222B",0x222C)
-CheckCompUni("{Numpad3}_0x222B",0x222D)
-CheckCompUni("0x222B_{Numpad3}",0x222D)
-CheckCompUni("0x222B_3",0x222D)
-CheckCompUni("3_0x222B",0x222D)
-CheckCompUni("{Numpad2}_0x222E",0x222F)
-CheckCompUni("0x222E_{Numpad2}",0x222F)
-CheckCompUni("0x222E_2",0x222F)
-CheckCompUni("2_0x222E",0x222F)
-CheckCompUni("{Numpad3}_0x222E",0x2230)
-CheckCompUni("0x222E_{Numpad3}",0x2230)
-CheckCompUni("0x222E_3",0x2230)
-CheckCompUni("3_0x222E",0x2230)
-CheckCompUni("0x005E_[",0x2308)
-CheckCompUni("0x005E_]",0x2309)
-CheckCompUni("__[",0x230A)
-CheckCompUni("__]",0x230B)
-CheckCompUni(":_(",0x2639)
-CheckCompUni(":_)",0x263A)
-CheckCompUni("{Numpad4}_0x222B",0x2A0C)
-CheckCompUni("0x222B_{Numpad4}",0x2A0C)
-CheckCompUni("0x222B_4",0x2A0C)
-CheckCompUni("4_0x222B",0x2A0C)
-CheckCompUni("{Numpad1}__",0x2E18)
-CheckCompUni("{Numpad1}__",0x2E18)
-CheckCompUni("1__",0x2E18)
-CheckCompUni("1__",0x2E18)
-CheckCompUni("2_m_m",0x339F)
-CheckCompUni("2_c_m",0x33A0)
-CheckCompUni("2_m_{Space}",0x33A1)
-CheckCompUni("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("l_n",0x33D1)
-CheckCompUni("l_o_g",0x33D2)
-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("c_k",0xE03A)
-CheckCompUni("c_h",0xE03B)
-CheckCompUni("t_t",0xE03C)
-CheckCompUni("c_t",0xE03D)
-CheckCompUni("0x017F_i",0xE03E)
-CheckCompUni("0x017F_0x017F",0xE03F)
-CheckCompUni("0x017F_l",0xE043)
-CheckCompUni("S_i",0xE044)
-CheckCompUni("0x017F_s",0xE045)
-CheckCompUni("Q_u",0xE048)
-CheckCompUni("T_h",0xE049)
-CheckCompUni("t_z",0xE04A)
-CheckCompUni("f_f",0xFB00)
-CheckCompUni("f_i",0xFB01)
-CheckCompUni("f_l",0xFB02)
-CheckCompUni("F_i",0xFB03)
-CheckCompUni("F_l",0xFB04)
-CheckCompUni("0x017F_t",0xFB05)
-CheckCompUni("s_t",0xFB06)
-CheckCompAsc("'_A","")
-CheckCompAsc("'_a","")
-CheckCompUni("U_A",0x0102)
-CheckCompUni("b_A",0x0102)
-CheckCompUni("U_a",0x0103)
-CheckCompUni("b_a",0x0103)
-
+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("<c> <k>", 0xE03A)
+CheckCompUni("<c> <h>", 0xE03B)
+CheckCompUni("<t> <t>", 0xE03C)
+CheckCompUni("<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("<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("<slash> <equal>", 0x2260)
+CheckCompUni("<KP_Divide> <KP_equal>", 0x2260)
+CheckCompUni("<notsign> <equal>", 0x2260)
+CheckCompUni("<less> <greater>", 0x2260)
+CheckCompUni("<KP_Add> <KP_Subtract>", 0xB1)
+CheckCompUni("<KP_Subtract> <KP_Add>", 0x2213)
+CheckCompUni("<minus> <plus>", 0x2213)
+CheckCompUni("<rightarrow> <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("<G> <H> <z>", 0x3393)
+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)
}
/*
------------------------------------------------------
@@ -2419,21 +4961,21 @@ 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 fhrendem 0x angegeben sind. Die abenteuerliche ^+u-Konstruktion bentigt im brigen den Hex-Wert in Kleinschrift, was derzeit nicht bei den Zeichendefinitionen umgesetzt ist, daher zentral und weniger fehlertrchtig an dieser Stelle. Auerdem ein abschlieend gesendetes Space, sonst bleibt der eingetippte Unicode-Wert noch kurz sichtbar stehen, bevor er sich GTK-sei-dank in das gewnschte Zeichen verwandelt.
*/
-SendUnicodeChar(charCode) { +SendUnicodeChar(charCode1, charCode2) { global
- if !(CheckComp(charCode) and DeadCompose)
+ if !(CheckComp(charCode2) and DeadCompose)
IfWinActive,ahk_class gdkWindowToplevel
{
- StringLower,charCode,charCode
- send % "^+u" . SubStr(charCode,3) . " "
+ StringLower,charCode1,charCode1
+ send % "^+u" . SubStr(charCode1,3) . " "
} else {
VarSetCapacity(ki,28*2,0)
EncodeInteger(&ki+0,1)
- EncodeInteger(&ki+6,charCode)
+ EncodeInteger(&ki+6,charCode1)
EncodeInteger(&ki+8,4)
EncodeInteger(&ki+28,1)
- EncodeInteger(&ki+34,charCode)
+ EncodeInteger(&ki+34,charCode1)
EncodeInteger(&ki+36,4|2)
DllCall("SendInput","UInt",2,"UInt",&ki,"Int",28)
}
diff --git a/windows/autohotkey/neo20.exe b/windows/autohotkey/neo20.exe Binary files differindex 066d484..c2b883d 100644 --- a/windows/autohotkey/neo20.exe +++ b/windows/autohotkey/neo20.exe |