This file is indexed.

/usr/include/libskk/libskk.h is in libskk-dev 1.0.2-3build1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

   1
   2
   3
   4
   5
   6
   7
   8
   9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85
  86
  87
  88
  89
  90
  91
  92
  93
  94
  95
  96
  97
  98
  99
 100
 101
 102
 103
 104
 105
 106
 107
 108
 109
 110
 111
 112
 113
 114
 115
 116
 117
 118
 119
 120
 121
 122
 123
 124
 125
 126
 127
 128
 129
 130
 131
 132
 133
 134
 135
 136
 137
 138
 139
 140
 141
 142
 143
 144
 145
 146
 147
 148
 149
 150
 151
 152
 153
 154
 155
 156
 157
 158
 159
 160
 161
 162
 163
 164
 165
 166
 167
 168
 169
 170
 171
 172
 173
 174
 175
 176
 177
 178
 179
 180
 181
 182
 183
 184
 185
 186
 187
 188
 189
 190
 191
 192
 193
 194
 195
 196
 197
 198
 199
 200
 201
 202
 203
 204
 205
 206
 207
 208
 209
 210
 211
 212
 213
 214
 215
 216
 217
 218
 219
 220
 221
 222
 223
 224
 225
 226
 227
 228
 229
 230
 231
 232
 233
 234
 235
 236
 237
 238
 239
 240
 241
 242
 243
 244
 245
 246
 247
 248
 249
 250
 251
 252
 253
 254
 255
 256
 257
 258
 259
 260
 261
 262
 263
 264
 265
 266
 267
 268
 269
 270
 271
 272
 273
 274
 275
 276
 277
 278
 279
 280
 281
 282
 283
 284
 285
 286
 287
 288
 289
 290
 291
 292
 293
 294
 295
 296
 297
 298
 299
 300
 301
 302
 303
 304
 305
 306
 307
 308
 309
 310
 311
 312
 313
 314
 315
 316
 317
 318
 319
 320
 321
 322
 323
 324
 325
 326
 327
 328
 329
 330
 331
 332
 333
 334
 335
 336
 337
 338
 339
 340
 341
 342
 343
 344
 345
 346
 347
 348
 349
 350
 351
 352
 353
 354
 355
 356
 357
 358
 359
 360
 361
 362
 363
 364
 365
 366
 367
 368
 369
 370
 371
 372
 373
 374
 375
 376
 377
 378
 379
 380
 381
 382
 383
 384
 385
 386
 387
 388
 389
 390
 391
 392
 393
 394
 395
 396
 397
 398
 399
 400
 401
 402
 403
 404
 405
 406
 407
 408
 409
 410
 411
 412
 413
 414
 415
 416
 417
 418
 419
 420
 421
 422
 423
 424
 425
 426
 427
 428
 429
 430
 431
 432
 433
 434
 435
 436
 437
 438
 439
 440
 441
 442
 443
 444
 445
 446
 447
 448
 449
 450
 451
 452
 453
 454
 455
 456
 457
 458
 459
 460
 461
 462
 463
 464
 465
 466
 467
 468
 469
 470
 471
 472
 473
 474
 475
 476
 477
 478
 479
 480
 481
 482
 483
 484
 485
 486
 487
 488
 489
 490
 491
 492
 493
 494
 495
 496
 497
 498
 499
 500
 501
 502
 503
 504
 505
 506
 507
 508
 509
 510
 511
 512
 513
 514
 515
 516
 517
 518
 519
 520
 521
 522
 523
 524
 525
 526
 527
 528
 529
 530
 531
 532
 533
 534
 535
 536
 537
 538
 539
 540
 541
 542
 543
 544
 545
 546
 547
 548
 549
 550
 551
 552
 553
 554
 555
 556
 557
 558
 559
 560
 561
 562
 563
 564
 565
 566
 567
 568
 569
 570
 571
 572
 573
 574
 575
 576
 577
 578
 579
 580
 581
 582
 583
 584
 585
 586
 587
 588
 589
 590
 591
 592
 593
 594
 595
 596
 597
 598
 599
 600
 601
 602
 603
 604
 605
 606
 607
 608
 609
 610
 611
 612
 613
 614
 615
 616
 617
 618
 619
 620
 621
 622
 623
 624
 625
 626
 627
 628
 629
 630
 631
 632
 633
 634
 635
 636
 637
 638
 639
 640
 641
 642
 643
 644
 645
 646
 647
 648
 649
 650
 651
 652
 653
 654
 655
 656
 657
 658
 659
 660
 661
 662
 663
 664
 665
 666
 667
 668
 669
 670
 671
 672
 673
 674
 675
 676
 677
 678
 679
 680
 681
 682
 683
 684
 685
 686
 687
 688
 689
 690
 691
 692
 693
 694
 695
 696
 697
 698
 699
 700
 701
 702
 703
 704
 705
 706
 707
 708
 709
 710
 711
 712
 713
 714
 715
 716
 717
 718
 719
 720
 721
 722
 723
 724
 725
 726
 727
 728
 729
 730
 731
 732
 733
 734
 735
 736
 737
 738
 739
 740
 741
 742
 743
 744
 745
 746
 747
 748
 749
 750
 751
 752
 753
 754
 755
 756
 757
 758
 759
 760
 761
 762
 763
 764
 765
 766
 767
 768
 769
 770
 771
 772
 773
 774
 775
 776
 777
 778
 779
 780
 781
 782
 783
 784
 785
 786
 787
 788
 789
 790
 791
 792
 793
 794
 795
 796
 797
 798
 799
 800
 801
 802
 803
 804
 805
 806
 807
 808
 809
 810
 811
 812
 813
 814
 815
 816
 817
 818
 819
 820
 821
 822
 823
 824
 825
 826
 827
 828
 829
 830
 831
 832
 833
 834
 835
 836
 837
 838
 839
 840
 841
 842
 843
 844
 845
 846
 847
 848
 849
 850
 851
 852
 853
 854
 855
 856
 857
 858
 859
 860
 861
 862
 863
 864
 865
 866
 867
 868
 869
 870
 871
 872
 873
 874
 875
 876
 877
 878
 879
 880
 881
 882
 883
 884
 885
 886
 887
 888
 889
 890
 891
 892
 893
 894
 895
 896
 897
 898
 899
 900
 901
 902
 903
 904
 905
 906
 907
 908
 909
 910
 911
 912
 913
 914
 915
 916
 917
 918
 919
 920
 921
 922
 923
 924
 925
 926
 927
 928
 929
 930
 931
 932
 933
 934
 935
 936
 937
 938
 939
 940
 941
 942
 943
 944
 945
 946
 947
 948
 949
 950
 951
 952
 953
 954
 955
 956
 957
 958
 959
 960
 961
 962
 963
 964
 965
 966
 967
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699
2700
2701
2702
2703
2704
2705
2706
2707
2708
2709
2710
2711
2712
2713
2714
2715
2716
2717
2718
2719
2720
2721
2722
2723
2724
2725
2726
2727
2728
2729
2730
2731
2732
2733
2734
2735
2736
2737
2738
2739
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
2756
2757
2758
2759
2760
2761
2762
2763
2764
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775
/* libskk.h generated by valac 0.40.2, the Vala compiler, do not modify */


#ifndef __LIBSKK_H__
#define __LIBSKK_H__

#include <glib.h>
#include <glib-object.h>
#include <stdlib.h>
#include <string.h>

G_BEGIN_DECLS


#define SKK_TYPE_KANA_MODE (skk_kana_mode_get_type ())

#define SKK_TYPE_PERIOD_STYLE (skk_period_style_get_type ())

#define SKK_TYPE_ROM_KANA_CONVERTER (skk_rom_kana_converter_get_type ())
#define SKK_ROM_KANA_CONVERTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SKK_TYPE_ROM_KANA_CONVERTER, SkkRomKanaConverter))
#define SKK_ROM_KANA_CONVERTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SKK_TYPE_ROM_KANA_CONVERTER, SkkRomKanaConverterClass))
#define SKK_IS_ROM_KANA_CONVERTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SKK_TYPE_ROM_KANA_CONVERTER))
#define SKK_IS_ROM_KANA_CONVERTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SKK_TYPE_ROM_KANA_CONVERTER))
#define SKK_ROM_KANA_CONVERTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SKK_TYPE_ROM_KANA_CONVERTER, SkkRomKanaConverterClass))

typedef struct _SkkRomKanaConverter SkkRomKanaConverter;
typedef struct _SkkRomKanaConverterClass SkkRomKanaConverterClass;
typedef struct _SkkRomKanaConverterPrivate SkkRomKanaConverterPrivate;

#define SKK_TYPE_DICT (skk_dict_get_type ())
#define SKK_DICT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SKK_TYPE_DICT, SkkDict))
#define SKK_DICT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SKK_TYPE_DICT, SkkDictClass))
#define SKK_IS_DICT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SKK_TYPE_DICT))
#define SKK_IS_DICT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SKK_TYPE_DICT))
#define SKK_DICT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SKK_TYPE_DICT, SkkDictClass))

typedef struct _SkkDict SkkDict;
typedef struct _SkkDictClass SkkDictClass;
typedef struct _SkkDictPrivate SkkDictPrivate;

#define SKK_TYPE_CANDIDATE (skk_candidate_get_type ())
#define SKK_CANDIDATE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SKK_TYPE_CANDIDATE, SkkCandidate))
#define SKK_CANDIDATE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SKK_TYPE_CANDIDATE, SkkCandidateClass))
#define SKK_IS_CANDIDATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SKK_TYPE_CANDIDATE))
#define SKK_IS_CANDIDATE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SKK_TYPE_CANDIDATE))
#define SKK_CANDIDATE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SKK_TYPE_CANDIDATE, SkkCandidateClass))

typedef struct _SkkCandidate SkkCandidate;
typedef struct _SkkCandidateClass SkkCandidateClass;

#define SKK_TYPE_EMPTY_DICT (skk_empty_dict_get_type ())
#define SKK_EMPTY_DICT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SKK_TYPE_EMPTY_DICT, SkkEmptyDict))
#define SKK_EMPTY_DICT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SKK_TYPE_EMPTY_DICT, SkkEmptyDictClass))
#define SKK_IS_EMPTY_DICT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SKK_TYPE_EMPTY_DICT))
#define SKK_IS_EMPTY_DICT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SKK_TYPE_EMPTY_DICT))
#define SKK_EMPTY_DICT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SKK_TYPE_EMPTY_DICT, SkkEmptyDictClass))

typedef struct _SkkEmptyDict SkkEmptyDict;
typedef struct _SkkEmptyDictClass SkkEmptyDictClass;
typedef struct _SkkEmptyDictPrivate SkkEmptyDictPrivate;

#define SKK_TYPE_FILE_DICT (skk_file_dict_get_type ())
#define SKK_FILE_DICT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SKK_TYPE_FILE_DICT, SkkFileDict))
#define SKK_FILE_DICT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SKK_TYPE_FILE_DICT, SkkFileDictClass))
#define SKK_IS_FILE_DICT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SKK_TYPE_FILE_DICT))
#define SKK_IS_FILE_DICT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SKK_TYPE_FILE_DICT))
#define SKK_FILE_DICT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SKK_TYPE_FILE_DICT, SkkFileDictClass))

typedef struct _SkkFileDict SkkFileDict;
typedef struct _SkkFileDictClass SkkFileDictClass;
typedef struct _SkkFileDictPrivate SkkFileDictPrivate;

#define SKK_TYPE_CDB_DICT (skk_cdb_dict_get_type ())
#define SKK_CDB_DICT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SKK_TYPE_CDB_DICT, SkkCdbDict))
#define SKK_CDB_DICT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SKK_TYPE_CDB_DICT, SkkCdbDictClass))
#define SKK_IS_CDB_DICT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SKK_TYPE_CDB_DICT))
#define SKK_IS_CDB_DICT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SKK_TYPE_CDB_DICT))
#define SKK_CDB_DICT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SKK_TYPE_CDB_DICT, SkkCdbDictClass))

typedef struct _SkkCdbDict SkkCdbDict;
typedef struct _SkkCdbDictClass SkkCdbDictClass;
typedef struct _SkkCdbDictPrivate SkkCdbDictPrivate;

#define SKK_TYPE_USER_DICT (skk_user_dict_get_type ())
#define SKK_USER_DICT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SKK_TYPE_USER_DICT, SkkUserDict))
#define SKK_USER_DICT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SKK_TYPE_USER_DICT, SkkUserDictClass))
#define SKK_IS_USER_DICT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SKK_TYPE_USER_DICT))
#define SKK_IS_USER_DICT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SKK_TYPE_USER_DICT))
#define SKK_USER_DICT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SKK_TYPE_USER_DICT, SkkUserDictClass))

typedef struct _SkkUserDict SkkUserDict;
typedef struct _SkkUserDictClass SkkUserDictClass;
typedef struct _SkkUserDictPrivate SkkUserDictPrivate;

#define SKK_TYPE_SKK_SERV (skk_skk_serv_get_type ())
#define SKK_SKK_SERV(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SKK_TYPE_SKK_SERV, SkkSkkServ))
#define SKK_SKK_SERV_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SKK_TYPE_SKK_SERV, SkkSkkServClass))
#define SKK_IS_SKK_SERV(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SKK_TYPE_SKK_SERV))
#define SKK_IS_SKK_SERV_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SKK_TYPE_SKK_SERV))
#define SKK_SKK_SERV_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SKK_TYPE_SKK_SERV, SkkSkkServClass))

typedef struct _SkkSkkServ SkkSkkServ;
typedef struct _SkkSkkServClass SkkSkkServClass;
typedef struct _SkkSkkServPrivate SkkSkkServPrivate;

#define SKK_TYPE_MODIFIER_TYPE (skk_modifier_type_get_type ())

#define SKK_TYPE_KEY_EVENT (skk_key_event_get_type ())
#define SKK_KEY_EVENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SKK_TYPE_KEY_EVENT, SkkKeyEvent))
#define SKK_KEY_EVENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SKK_TYPE_KEY_EVENT, SkkKeyEventClass))
#define SKK_IS_KEY_EVENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SKK_TYPE_KEY_EVENT))
#define SKK_IS_KEY_EVENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SKK_TYPE_KEY_EVENT))
#define SKK_KEY_EVENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SKK_TYPE_KEY_EVENT, SkkKeyEventClass))

typedef struct _SkkKeyEvent SkkKeyEvent;
typedef struct _SkkKeyEventClass SkkKeyEventClass;
typedef struct _SkkKeyEventPrivate SkkKeyEventPrivate;

#define SKK_TYPE_KEY_EVENT_FILTER (skk_key_event_filter_get_type ())
#define SKK_KEY_EVENT_FILTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SKK_TYPE_KEY_EVENT_FILTER, SkkKeyEventFilter))
#define SKK_KEY_EVENT_FILTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SKK_TYPE_KEY_EVENT_FILTER, SkkKeyEventFilterClass))
#define SKK_IS_KEY_EVENT_FILTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SKK_TYPE_KEY_EVENT_FILTER))
#define SKK_IS_KEY_EVENT_FILTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SKK_TYPE_KEY_EVENT_FILTER))
#define SKK_KEY_EVENT_FILTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SKK_TYPE_KEY_EVENT_FILTER, SkkKeyEventFilterClass))

typedef struct _SkkKeyEventFilter SkkKeyEventFilter;
typedef struct _SkkKeyEventFilterClass SkkKeyEventFilterClass;
typedef struct _SkkKeyEventFilterPrivate SkkKeyEventFilterPrivate;

#define SKK_TYPE_RULE_METADATA (skk_rule_metadata_get_type ())
typedef struct _SkkRuleMetadata SkkRuleMetadata;

#define SKK_TYPE_RULE (skk_rule_get_type ())
#define SKK_RULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SKK_TYPE_RULE, SkkRule))
#define SKK_RULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SKK_TYPE_RULE, SkkRuleClass))
#define SKK_IS_RULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SKK_TYPE_RULE))
#define SKK_IS_RULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SKK_TYPE_RULE))
#define SKK_RULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SKK_TYPE_RULE, SkkRuleClass))

typedef struct _SkkRule SkkRule;
typedef struct _SkkRuleClass SkkRuleClass;
typedef struct _SkkRulePrivate SkkRulePrivate;

#define SKK_TYPE_MAP_FILE (skk_map_file_get_type ())
#define SKK_MAP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SKK_TYPE_MAP_FILE, SkkMapFile))
#define SKK_MAP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SKK_TYPE_MAP_FILE, SkkMapFileClass))
#define SKK_IS_MAP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SKK_TYPE_MAP_FILE))
#define SKK_IS_MAP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SKK_TYPE_MAP_FILE))
#define SKK_MAP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SKK_TYPE_MAP_FILE, SkkMapFileClass))

typedef struct _SkkMapFile SkkMapFile;
typedef struct _SkkMapFileClass SkkMapFileClass;

#define SKK_TYPE_KEYMAP_MAP_FILE (skk_keymap_map_file_get_type ())
#define SKK_KEYMAP_MAP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SKK_TYPE_KEYMAP_MAP_FILE, SkkKeymapMapFile))
#define SKK_KEYMAP_MAP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SKK_TYPE_KEYMAP_MAP_FILE, SkkKeymapMapFileClass))
#define SKK_IS_KEYMAP_MAP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SKK_TYPE_KEYMAP_MAP_FILE))
#define SKK_IS_KEYMAP_MAP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SKK_TYPE_KEYMAP_MAP_FILE))
#define SKK_KEYMAP_MAP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SKK_TYPE_KEYMAP_MAP_FILE, SkkKeymapMapFileClass))

typedef struct _SkkKeymapMapFile SkkKeymapMapFile;
typedef struct _SkkKeymapMapFileClass SkkKeymapMapFileClass;

#define SKK_TYPE_ROM_KANA_MAP_FILE (skk_rom_kana_map_file_get_type ())
#define SKK_ROM_KANA_MAP_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SKK_TYPE_ROM_KANA_MAP_FILE, SkkRomKanaMapFile))
#define SKK_ROM_KANA_MAP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SKK_TYPE_ROM_KANA_MAP_FILE, SkkRomKanaMapFileClass))
#define SKK_IS_ROM_KANA_MAP_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SKK_TYPE_ROM_KANA_MAP_FILE))
#define SKK_IS_ROM_KANA_MAP_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SKK_TYPE_ROM_KANA_MAP_FILE))
#define SKK_ROM_KANA_MAP_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SKK_TYPE_ROM_KANA_MAP_FILE, SkkRomKanaMapFileClass))

typedef struct _SkkRomKanaMapFile SkkRomKanaMapFile;
typedef struct _SkkRomKanaMapFileClass SkkRomKanaMapFileClass;

#define SKK_TYPE_INPUT_MODE (skk_input_mode_get_type ())

#define SKK_TYPE_CONTEXT (skk_context_get_type ())
#define SKK_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SKK_TYPE_CONTEXT, SkkContext))
#define SKK_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SKK_TYPE_CONTEXT, SkkContextClass))
#define SKK_IS_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SKK_TYPE_CONTEXT))
#define SKK_IS_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SKK_TYPE_CONTEXT))
#define SKK_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SKK_TYPE_CONTEXT, SkkContextClass))

typedef struct _SkkContext SkkContext;
typedef struct _SkkContextClass SkkContextClass;
typedef struct _SkkContextPrivate SkkContextPrivate;

#define SKK_TYPE_CANDIDATE_LIST (skk_candidate_list_get_type ())
#define SKK_CANDIDATE_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SKK_TYPE_CANDIDATE_LIST, SkkCandidateList))
#define SKK_CANDIDATE_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SKK_TYPE_CANDIDATE_LIST, SkkCandidateListClass))
#define SKK_IS_CANDIDATE_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SKK_TYPE_CANDIDATE_LIST))
#define SKK_IS_CANDIDATE_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SKK_TYPE_CANDIDATE_LIST))
#define SKK_CANDIDATE_LIST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SKK_TYPE_CANDIDATE_LIST, SkkCandidateListClass))

typedef struct _SkkCandidateList SkkCandidateList;
typedef struct _SkkCandidateListClass SkkCandidateListClass;
typedef struct _SkkCandidatePrivate SkkCandidatePrivate;
typedef struct _SkkCandidateListPrivate SkkCandidateListPrivate;

#define SKK_TYPE_NICOLA_KEY_EVENT_FILTER (skk_nicola_key_event_filter_get_type ())
#define SKK_NICOLA_KEY_EVENT_FILTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SKK_TYPE_NICOLA_KEY_EVENT_FILTER, SkkNicolaKeyEventFilter))
#define SKK_NICOLA_KEY_EVENT_FILTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SKK_TYPE_NICOLA_KEY_EVENT_FILTER, SkkNicolaKeyEventFilterClass))
#define SKK_IS_NICOLA_KEY_EVENT_FILTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SKK_TYPE_NICOLA_KEY_EVENT_FILTER))
#define SKK_IS_NICOLA_KEY_EVENT_FILTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SKK_TYPE_NICOLA_KEY_EVENT_FILTER))
#define SKK_NICOLA_KEY_EVENT_FILTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SKK_TYPE_NICOLA_KEY_EVENT_FILTER, SkkNicolaKeyEventFilterClass))

typedef struct _SkkNicolaKeyEventFilter SkkNicolaKeyEventFilter;
typedef struct _SkkNicolaKeyEventFilterClass SkkNicolaKeyEventFilterClass;
typedef struct _SkkNicolaKeyEventFilterPrivate SkkNicolaKeyEventFilterPrivate;

typedef enum  {
	SKK_KANA_MODE_HIRAGANA,
	SKK_KANA_MODE_KATAKANA,
	SKK_KANA_MODE_HANKAKU_KATAKANA
} SkkKanaMode;

typedef enum  {
	SKK_PERIOD_STYLE_JA_JA,
	SKK_PERIOD_STYLE_EN_EN,
	SKK_PERIOD_STYLE_JA_EN,
	SKK_PERIOD_STYLE_EN_JA
} SkkPeriodStyle;

struct _SkkRomKanaConverter {
	GObject parent_instance;
	SkkRomKanaConverterPrivate * priv;
};

struct _SkkRomKanaConverterClass {
	GObjectClass parent_class;
};

struct _SkkDict {
	GObject parent_instance;
	SkkDictPrivate * priv;
};

struct _SkkDictClass {
	GObjectClass parent_class;
	void (*reload) (SkkDict* self, GError** error);
	SkkCandidate** (*lookup) (SkkDict* self, const gchar* midasi, gboolean okuri, int* result_length1);
	gchar** (*complete) (SkkDict* self, const gchar* midasi, int* result_length1);
	gboolean (*select_candidate) (SkkDict* self, SkkCandidate* candidate);
	gboolean (*purge_candidate) (SkkDict* self, SkkCandidate* candidate);
	void (*save) (SkkDict* self, GError** error);
	gboolean (*get_read_only) (SkkDict* self);
};

struct _SkkEmptyDict {
	SkkDict parent_instance;
	SkkEmptyDictPrivate * priv;
};

struct _SkkEmptyDictClass {
	SkkDictClass parent_class;
};

struct _SkkFileDict {
	SkkDict parent_instance;
	SkkFileDictPrivate * priv;
};

struct _SkkFileDictClass {
	SkkDictClass parent_class;
};

struct _SkkCdbDict {
	SkkDict parent_instance;
	SkkCdbDictPrivate * priv;
};

struct _SkkCdbDictClass {
	SkkDictClass parent_class;
};

struct _SkkUserDict {
	SkkDict parent_instance;
	SkkUserDictPrivate * priv;
};

struct _SkkUserDictClass {
	SkkDictClass parent_class;
};

struct _SkkSkkServ {
	SkkDict parent_instance;
	SkkSkkServPrivate * priv;
};

struct _SkkSkkServClass {
	SkkDictClass parent_class;
};

typedef enum  {
	SKK_KEY_EVENT_FORMAT_ERROR_PARSE_FAILED,
	SKK_KEY_EVENT_FORMAT_ERROR_KEYSYM_NOT_FOUND
} SkkKeyEventFormatError;
#define SKK_KEY_EVENT_FORMAT_ERROR skk_key_event_format_error_quark ()
typedef enum  {
	SKK_MODIFIER_TYPE_NONE = 0,
	SKK_MODIFIER_TYPE_SHIFT_MASK = 1 << 0,
	SKK_MODIFIER_TYPE_LOCK_MASK = 1 << 1,
	SKK_MODIFIER_TYPE_CONTROL_MASK = 1 << 2,
	SKK_MODIFIER_TYPE_MOD1_MASK = 1 << 3,
	SKK_MODIFIER_TYPE_MOD2_MASK = 1 << 4,
	SKK_MODIFIER_TYPE_MOD3_MASK = 1 << 5,
	SKK_MODIFIER_TYPE_MOD4_MASK = 1 << 6,
	SKK_MODIFIER_TYPE_MOD5_MASK = 1 << 7,
	SKK_MODIFIER_TYPE_LSHIFT_MASK = 1 << 22,
	SKK_MODIFIER_TYPE_RSHIFT_MASK = 1 << 23,
	SKK_MODIFIER_TYPE_USLEEP_MASK = 1 << 24,
	SKK_MODIFIER_TYPE_SUPER_MASK = 1 << 26,
	SKK_MODIFIER_TYPE_HYPER_MASK = 1 << 27,
	SKK_MODIFIER_TYPE_META_MASK = 1 << 28,
	SKK_MODIFIER_TYPE_RELEASE_MASK = 1 << 30
} SkkModifierType;

struct _SkkKeyEvent {
	GObject parent_instance;
	SkkKeyEventPrivate * priv;
};

struct _SkkKeyEventClass {
	GObjectClass parent_class;
};

struct _SkkKeyEventFilter {
	GObject parent_instance;
	SkkKeyEventFilterPrivate * priv;
};

struct _SkkKeyEventFilterClass {
	GObjectClass parent_class;
	SkkKeyEvent* (*filter_key_event) (SkkKeyEventFilter* self, SkkKeyEvent* key);
	void (*reset) (SkkKeyEventFilter* self);
};

typedef enum  {
	SKK_RULE_PARSE_ERROR_FAILED
} SkkRuleParseError;
#define SKK_RULE_PARSE_ERROR skk_rule_parse_error_quark ()
struct _SkkRuleMetadata {
	gchar* base_dir;
	gchar* name;
	gchar* label;
	gchar* description;
	gchar* filter;
};

struct _SkkRule {
	GObject parent_instance;
	SkkRulePrivate * priv;
	SkkKeymapMapFile** keymaps;
	gint keymaps_length1;
	gint _keymaps_size_;
	SkkRomKanaMapFile* rom_kana;
};

struct _SkkRuleClass {
	GObjectClass parent_class;
};

typedef enum  {
	SKK_INPUT_MODE_HIRAGANA = SKK_KANA_MODE_HIRAGANA,
	SKK_INPUT_MODE_KATAKANA = SKK_KANA_MODE_KATAKANA,
	SKK_INPUT_MODE_HANKAKU_KATAKANA = SKK_KANA_MODE_HANKAKU_KATAKANA,
	SKK_INPUT_MODE_LATIN,
	SKK_INPUT_MODE_WIDE_LATIN,
	SKK_INPUT_MODE_LAST,
	SKK_INPUT_MODE_DEFAULT = SKK_INPUT_MODE_HIRAGANA
} SkkInputMode;

struct _SkkContext {
	GObject parent_instance;
	SkkContextPrivate * priv;
};

struct _SkkContextClass {
	GObjectClass parent_class;
};

struct _SkkCandidate {
	GObject parent_instance;
	SkkCandidatePrivate * priv;
};

struct _SkkCandidateClass {
	GObjectClass parent_class;
};

struct _SkkCandidateList {
	GObject parent_instance;
	SkkCandidateListPrivate * priv;
};

struct _SkkCandidateListClass {
	GObjectClass parent_class;
	SkkCandidate* (*get) (SkkCandidateList* self, gint index);
	void (*clear) (SkkCandidateList* self);
	void (*add_candidates) (SkkCandidateList* self, SkkCandidate** array, int array_length1);
	void (*add_candidates_end) (SkkCandidateList* self);
	gboolean (*cursor_up) (SkkCandidateList* self);
	gboolean (*cursor_down) (SkkCandidateList* self);
	gboolean (*page_up) (SkkCandidateList* self);
	gboolean (*page_down) (SkkCandidateList* self);
	gboolean (*next) (SkkCandidateList* self);
	gboolean (*previous) (SkkCandidateList* self);
	gboolean (*select_at) (SkkCandidateList* self, guint index_in_page);
	void (*select) (SkkCandidateList* self);
	gint (*get_cursor_pos) (SkkCandidateList* self);
	gint (*get_size) (SkkCandidateList* self);
	guint (*get_page_start) (SkkCandidateList* self);
	void (*set_page_start) (SkkCandidateList* self, guint value);
	guint (*get_page_size) (SkkCandidateList* self);
	void (*set_page_size) (SkkCandidateList* self, guint value);
	gboolean (*get_page_visible) (SkkCandidateList* self);
};

typedef gint64 (*SkkGetTime) (void* user_data);
struct _SkkNicolaKeyEventFilter {
	SkkKeyEventFilter parent_instance;
	SkkNicolaKeyEventFilterPrivate * priv;
	SkkGetTime get_time_func;
	gpointer get_time_func_target;
	GDestroyNotify get_time_func_target_destroy_notify;
	gint64 timeout;
	gint64 overlap;
	gint64 maxwait;
	gchar** special_doubles;
	gint special_doubles_length1;
};

struct _SkkNicolaKeyEventFilterClass {
	SkkKeyEventFilterClass parent_class;
};


GType skk_kana_mode_get_type (void) G_GNUC_CONST;
GType skk_period_style_get_type (void) G_GNUC_CONST;
GType skk_rom_kana_converter_get_type (void) G_GNUC_CONST;
SkkRomKanaConverter* skk_rom_kana_converter_new (void);
SkkRomKanaConverter* skk_rom_kana_converter_construct (GType object_type);
gboolean skk_rom_kana_converter_is_valid (SkkRomKanaConverter* self,
                                          gunichar uc);
gboolean skk_rom_kana_converter_output_nn_if_any (SkkRomKanaConverter* self);
void skk_rom_kana_converter_append_text (SkkRomKanaConverter* self,
                                         const gchar* text);
gboolean skk_rom_kana_converter_append (SkkRomKanaConverter* self,
                                        gunichar uc);
gboolean skk_rom_kana_converter_can_consume (SkkRomKanaConverter* self,
                                             gunichar uc,
                                             gboolean preedit_only,
                                             gboolean no_carryover);
void skk_rom_kana_converter_reset (SkkRomKanaConverter* self);
gboolean skk_rom_kana_converter_delete (SkkRomKanaConverter* self);
SkkKanaMode skk_rom_kana_converter_get_kana_mode (SkkRomKanaConverter* self);
void skk_rom_kana_converter_set_kana_mode (SkkRomKanaConverter* self,
                                           SkkKanaMode value);
SkkPeriodStyle skk_rom_kana_converter_get_period_style (SkkRomKanaConverter* self);
void skk_rom_kana_converter_set_period_style (SkkRomKanaConverter* self,
                                              SkkPeriodStyle value);
const gchar* skk_rom_kana_converter_get_output (SkkRomKanaConverter* self);
const gchar* skk_rom_kana_converter_get_preedit (SkkRomKanaConverter* self);
GType skk_dict_get_type (void) G_GNUC_CONST;
GType skk_candidate_get_type (void) G_GNUC_CONST;
SkkCandidate** skk_dict_split_candidates (SkkDict* self,
                                          const gchar* midasi,
                                          gboolean okuri,
                                          const gchar* line,
                                          int* result_length1);
gchar* skk_dict_join_candidates (SkkDict* self,
                                 SkkCandidate** candidates,
                                 int candidates_length1);
void skk_dict_reload (SkkDict* self,
                      GError** error);
SkkCandidate** skk_dict_lookup (SkkDict* self,
                                const gchar* midasi,
                                gboolean okuri,
                                int* result_length1);
gchar** skk_dict_complete (SkkDict* self,
                           const gchar* midasi,
                           int* result_length1);
gboolean skk_dict_select_candidate (SkkDict* self,
                                    SkkCandidate* candidate);
gboolean skk_dict_purge_candidate (SkkDict* self,
                                   SkkCandidate* candidate);
void skk_dict_save (SkkDict* self,
                    GError** error);
SkkDict* skk_dict_construct (GType object_type);
gboolean skk_dict_get_read_only (SkkDict* self);
GType skk_empty_dict_get_type (void) G_GNUC_CONST;
SkkEmptyDict* skk_empty_dict_new (void);
SkkEmptyDict* skk_empty_dict_construct (GType object_type);
GType skk_file_dict_get_type (void) G_GNUC_CONST;
SkkFileDict* skk_file_dict_new (const gchar* path,
                                const gchar* encoding,
                                GError** error);
SkkFileDict* skk_file_dict_construct (GType object_type,
                                      const gchar* path,
                                      const gchar* encoding,
                                      GError** error);
GType skk_cdb_dict_get_type (void) G_GNUC_CONST;
SkkCdbDict* skk_cdb_dict_new (const gchar* path,
                              const gchar* encoding,
                              GError** error);
SkkCdbDict* skk_cdb_dict_construct (GType object_type,
                                    const gchar* path,
                                    const gchar* encoding,
                                    GError** error);
GType skk_user_dict_get_type (void) G_GNUC_CONST;
SkkUserDict* skk_user_dict_new (const gchar* path,
                                const gchar* encoding,
                                GError** error);
SkkUserDict* skk_user_dict_construct (GType object_type,
                                      const gchar* path,
                                      const gchar* encoding,
                                      GError** error);
GType skk_skk_serv_get_type (void) G_GNUC_CONST;
SkkSkkServ* skk_skk_serv_new (const gchar* host,
                              guint16 port,
                              const gchar* encoding,
                              GError** error);
SkkSkkServ* skk_skk_serv_construct (GType object_type,
                                    const gchar* host,
                                    guint16 port,
                                    const gchar* encoding,
                                    GError** error);
GQuark skk_key_event_format_error_quark (void);
GType skk_modifier_type_get_type (void) G_GNUC_CONST;
GType skk_key_event_get_type (void) G_GNUC_CONST;
SkkKeyEvent* skk_key_event_new (const gchar* name,
                                gunichar code,
                                SkkModifierType modifiers);
SkkKeyEvent* skk_key_event_construct (GType object_type,
                                      const gchar* name,
                                      gunichar code,
                                      SkkModifierType modifiers);
SkkKeyEvent* skk_key_event_copy (SkkKeyEvent* self);
SkkKeyEvent* skk_key_event_new_from_string (const gchar* key,
                                            GError** error);
SkkKeyEvent* skk_key_event_construct_from_string (GType object_type,
                                                  const gchar* key,
                                                  GError** error);
gchar* skk_key_event_to_string (SkkKeyEvent* self);
SkkKeyEvent* skk_key_event_new_from_x_keysym (guint keyval,
                                              SkkModifierType modifiers,
                                              GError** error);
SkkKeyEvent* skk_key_event_construct_from_x_keysym (GType object_type,
                                                    guint keyval,
                                                    SkkModifierType modifiers,
                                                    GError** error);
gboolean skk_key_event_base_equal (SkkKeyEvent* self,
                                   SkkKeyEvent* key);
const gchar* skk_key_event_get_name (SkkKeyEvent* self);
gunichar skk_key_event_get_code (SkkKeyEvent* self);
SkkModifierType skk_key_event_get_modifiers (SkkKeyEvent* self);
void skk_key_event_set_modifiers (SkkKeyEvent* self,
                                  SkkModifierType value);
GType skk_key_event_filter_get_type (void) G_GNUC_CONST;
SkkKeyEvent* skk_key_event_filter_filter_key_event (SkkKeyEventFilter* self,
                                                    SkkKeyEvent* key);
void skk_key_event_filter_reset (SkkKeyEventFilter* self);
SkkKeyEventFilter* skk_key_event_filter_construct (GType object_type);
GQuark skk_rule_parse_error_quark (void);
GType skk_rule_metadata_get_type (void) G_GNUC_CONST;
SkkRuleMetadata* skk_rule_metadata_dup (const SkkRuleMetadata* self);
void skk_rule_metadata_free (SkkRuleMetadata* self);
void skk_rule_metadata_copy (const SkkRuleMetadata* self,
                             SkkRuleMetadata* dest);
void skk_rule_metadata_destroy (SkkRuleMetadata* self);
gchar* skk_rule_metadata_locate_map_file (SkkRuleMetadata *self,
                                          const gchar* type,
                                          const gchar* name);
GType skk_rule_get_type (void) G_GNUC_CONST;
GType skk_map_file_get_type (void) G_GNUC_CONST;
GType skk_keymap_map_file_get_type (void) G_GNUC_CONST;
GType skk_rom_kana_map_file_get_type (void) G_GNUC_CONST;
SkkRule* skk_rule_new (const gchar* name,
                       GError** error);
SkkRule* skk_rule_construct (GType object_type,
                             const gchar* name,
                             GError** error);
SkkRuleMetadata* skk_rule_find_rule (const gchar* name);
SkkRuleMetadata* skk_rule_list (int* result_length1);
void skk_rule_get_metadata (SkkRule* self,
                            SkkRuleMetadata * result);
void skk_init (void);
GType skk_input_mode_get_type (void) G_GNUC_CONST;
GType skk_context_get_type (void) G_GNUC_CONST;
void skk_context_add_dictionary (SkkContext* self,
                                 SkkDict* dict);
void skk_context_remove_dictionary (SkkContext* self,
                                    SkkDict* dict);
SkkContext* skk_context_new (SkkDict** dictionaries,
                             int dictionaries_length1);
SkkContext* skk_context_construct (GType object_type,
                                   SkkDict** dictionaries,
                                   int dictionaries_length1);
gboolean skk_context_process_key_events (SkkContext* self,
                                         const gchar* keyseq);
gboolean skk_context_process_key_event (SkkContext* self,
                                        SkkKeyEvent* key);
void skk_context_reset (SkkContext* self);
gchar* skk_context_get_output (SkkContext* self);
gchar* skk_context_peek_output (SkkContext* self);
gchar* skk_context_poll_output (SkkContext* self);
void skk_context_clear_output (SkkContext* self);
void skk_context_get_preedit_underline (SkkContext* self,
                                        guint* offset,
                                        guint* nchars);
void skk_context_save_dictionaries (SkkContext* self,
                                    GError** error);
SkkDict** skk_context_get_dictionaries (SkkContext* self,
                                        int* result_length1);
void skk_context_set_dictionaries (SkkContext* self,
                                   SkkDict** value,
                                   int value_length1);
GType skk_candidate_list_get_type (void) G_GNUC_CONST;
SkkCandidateList* skk_context_get_candidates (SkkContext* self);
SkkInputMode skk_context_get_input_mode (SkkContext* self);
void skk_context_set_input_mode (SkkContext* self,
                                 SkkInputMode value);
gchar** skk_context_get_auto_start_henkan_keywords (SkkContext* self,
                                                    int* result_length1);
void skk_context_set_auto_start_henkan_keywords (SkkContext* self,
                                                 gchar** value,
                                                 int value_length1);
gboolean skk_context_get_egg_like_newline (SkkContext* self);
void skk_context_set_egg_like_newline (SkkContext* self,
                                       gboolean value);
SkkPeriodStyle skk_context_get_period_style (SkkContext* self);
void skk_context_set_period_style (SkkContext* self,
                                   SkkPeriodStyle value);
SkkRule* skk_context_get_typing_rule (SkkContext* self);
void skk_context_set_typing_rule (SkkContext* self,
                                  SkkRule* value);
SkkKeyEventFilter* skk_context_get_key_event_filter (SkkContext* self);
const gchar* skk_context_get_preedit (SkkContext* self);
gchar* skk_candidate_to_string (SkkCandidate* self);
SkkCandidate* skk_candidate_new (const gchar* midasi,
                                 gboolean okuri,
                                 const gchar* text,
                                 const gchar* annotation,
                                 const gchar* output);
SkkCandidate* skk_candidate_construct (GType object_type,
                                       const gchar* midasi,
                                       gboolean okuri,
                                       const gchar* text,
                                       const gchar* annotation,
                                       const gchar* output);
const gchar* skk_candidate_get_midasi (SkkCandidate* self);
gboolean skk_candidate_get_okuri (SkkCandidate* self);
const gchar* skk_candidate_get_text (SkkCandidate* self);
void skk_candidate_set_text (SkkCandidate* self,
                             const gchar* value);
const gchar* skk_candidate_get_annotation (SkkCandidate* self);
void skk_candidate_set_annotation (SkkCandidate* self,
                                   const gchar* value);
const gchar* skk_candidate_get_output (SkkCandidate* self);
void skk_candidate_set_output (SkkCandidate* self,
                               const gchar* value);
SkkCandidate* skk_candidate_list_get (SkkCandidateList* self,
                                      gint index);
gboolean skk_candidate_list_cursor_up (SkkCandidateList* self);
gboolean skk_candidate_list_cursor_down (SkkCandidateList* self);
gboolean skk_candidate_list_page_up (SkkCandidateList* self);
gboolean skk_candidate_list_page_down (SkkCandidateList* self);
gboolean skk_candidate_list_next (SkkCandidateList* self);
gboolean skk_candidate_list_previous (SkkCandidateList* self);
guint skk_candidate_list_get_page_start_cursor_pos (SkkCandidateList* self);
gboolean skk_candidate_list_select_at (SkkCandidateList* self,
                                       guint index_in_page);
void skk_candidate_list_select (SkkCandidateList* self);
SkkCandidateList* skk_candidate_list_construct (GType object_type);
gint skk_candidate_list_get_cursor_pos (SkkCandidateList* self);
gint skk_candidate_list_get_size (SkkCandidateList* self);
guint skk_candidate_list_get_page_start (SkkCandidateList* self);
void skk_candidate_list_set_page_start (SkkCandidateList* self,
                                        guint value);
guint skk_candidate_list_get_page_size (SkkCandidateList* self);
void skk_candidate_list_set_page_size (SkkCandidateList* self,
                                       guint value);
gboolean skk_candidate_list_get_page_visible (SkkCandidateList* self);
GType skk_nicola_key_event_filter_get_type (void) G_GNUC_CONST;
SkkNicolaKeyEventFilter* skk_nicola_key_event_filter_new (void);
SkkNicolaKeyEventFilter* skk_nicola_key_event_filter_construct (GType object_type);
#define SKK_KEYSYMS_VoidSymbol ((guint) 0xffffff)
#define SKK_KEYSYMS_BackSpace ((guint) 0xff08)
#define SKK_KEYSYMS_Tab ((guint) 0xff09)
#define SKK_KEYSYMS_Linefeed ((guint) 0xff0a)
#define SKK_KEYSYMS_Clear ((guint) 0xff0b)
#define SKK_KEYSYMS_Return ((guint) 0xff0d)
#define SKK_KEYSYMS_Pause ((guint) 0xff13)
#define SKK_KEYSYMS_Scroll_Lock ((guint) 0xff14)
#define SKK_KEYSYMS_Sys_Req ((guint) 0xff15)
#define SKK_KEYSYMS_Escape ((guint) 0xff1b)
#define SKK_KEYSYMS_Delete ((guint) 0xffff)
#define SKK_KEYSYMS_Multi_key ((guint) 0xff20)
#define SKK_KEYSYMS_Codeinput ((guint) 0xff37)
#define SKK_KEYSYMS_SingleCandidate ((guint) 0xff3c)
#define SKK_KEYSYMS_MultipleCandidate ((guint) 0xff3d)
#define SKK_KEYSYMS_PreviousCandidate ((guint) 0xff3e)
#define SKK_KEYSYMS_Kanji ((guint) 0xff21)
#define SKK_KEYSYMS_Muhenkan ((guint) 0xff22)
#define SKK_KEYSYMS_Henkan_Mode ((guint) 0xff23)
#define SKK_KEYSYMS_Henkan ((guint) 0xff23)
#define SKK_KEYSYMS_Romaji ((guint) 0xff24)
#define SKK_KEYSYMS_Hiragana ((guint) 0xff25)
#define SKK_KEYSYMS_Katakana ((guint) 0xff26)
#define SKK_KEYSYMS_Hiragana_Katakana ((guint) 0xff27)
#define SKK_KEYSYMS_Zenkaku ((guint) 0xff28)
#define SKK_KEYSYMS_Hankaku ((guint) 0xff29)
#define SKK_KEYSYMS_Zenkaku_Hankaku ((guint) 0xff2a)
#define SKK_KEYSYMS_Touroku ((guint) 0xff2b)
#define SKK_KEYSYMS_Massyo ((guint) 0xff2c)
#define SKK_KEYSYMS_Kana_Lock ((guint) 0xff2d)
#define SKK_KEYSYMS_Kana_Shift ((guint) 0xff2e)
#define SKK_KEYSYMS_Eisu_Shift ((guint) 0xff2f)
#define SKK_KEYSYMS_Eisu_toggle ((guint) 0xff30)
#define SKK_KEYSYMS_Kanji_Bangou ((guint) 0xff37)
#define SKK_KEYSYMS_Zen_Koho ((guint) 0xff3d)
#define SKK_KEYSYMS_Mae_Koho ((guint) 0xff3e)
#define SKK_KEYSYMS_Home ((guint) 0xff50)
#define SKK_KEYSYMS_Left ((guint) 0xff51)
#define SKK_KEYSYMS_Up ((guint) 0xff52)
#define SKK_KEYSYMS_Right ((guint) 0xff53)
#define SKK_KEYSYMS_Down ((guint) 0xff54)
#define SKK_KEYSYMS_Prior ((guint) 0xff55)
#define SKK_KEYSYMS_Page_Up ((guint) 0xff55)
#define SKK_KEYSYMS_Next ((guint) 0xff56)
#define SKK_KEYSYMS_Page_Down ((guint) 0xff56)
#define SKK_KEYSYMS_End ((guint) 0xff57)
#define SKK_KEYSYMS_Begin ((guint) 0xff58)
#define SKK_KEYSYMS_Select ((guint) 0xff60)
#define SKK_KEYSYMS_Print ((guint) 0xff61)
#define SKK_KEYSYMS_Execute ((guint) 0xff62)
#define SKK_KEYSYMS_Insert ((guint) 0xff63)
#define SKK_KEYSYMS_Undo ((guint) 0xff65)
#define SKK_KEYSYMS_Redo ((guint) 0xff66)
#define SKK_KEYSYMS_Menu ((guint) 0xff67)
#define SKK_KEYSYMS_Find ((guint) 0xff68)
#define SKK_KEYSYMS_Cancel ((guint) 0xff69)
#define SKK_KEYSYMS_Help ((guint) 0xff6a)
#define SKK_KEYSYMS_Break ((guint) 0xff6b)
#define SKK_KEYSYMS_Mode_switch ((guint) 0xff7e)
#define SKK_KEYSYMS_script_switch ((guint) 0xff7e)
#define SKK_KEYSYMS_Num_Lock ((guint) 0xff7f)
#define SKK_KEYSYMS_KP_Space ((guint) 0xff80)
#define SKK_KEYSYMS_KP_Tab ((guint) 0xff89)
#define SKK_KEYSYMS_KP_Enter ((guint) 0xff8d)
#define SKK_KEYSYMS_KP_F1 ((guint) 0xff91)
#define SKK_KEYSYMS_KP_F2 ((guint) 0xff92)
#define SKK_KEYSYMS_KP_F3 ((guint) 0xff93)
#define SKK_KEYSYMS_KP_F4 ((guint) 0xff94)
#define SKK_KEYSYMS_KP_Home ((guint) 0xff95)
#define SKK_KEYSYMS_KP_Left ((guint) 0xff96)
#define SKK_KEYSYMS_KP_Up ((guint) 0xff97)
#define SKK_KEYSYMS_KP_Right ((guint) 0xff98)
#define SKK_KEYSYMS_KP_Down ((guint) 0xff99)
#define SKK_KEYSYMS_KP_Prior ((guint) 0xff9a)
#define SKK_KEYSYMS_KP_Page_Up ((guint) 0xff9a)
#define SKK_KEYSYMS_KP_Next ((guint) 0xff9b)
#define SKK_KEYSYMS_KP_Page_Down ((guint) 0xff9b)
#define SKK_KEYSYMS_KP_End ((guint) 0xff9c)
#define SKK_KEYSYMS_KP_Begin ((guint) 0xff9d)
#define SKK_KEYSYMS_KP_Insert ((guint) 0xff9e)
#define SKK_KEYSYMS_KP_Delete ((guint) 0xff9f)
#define SKK_KEYSYMS_KP_Equal ((guint) 0xffbd)
#define SKK_KEYSYMS_KP_Multiply ((guint) 0xffaa)
#define SKK_KEYSYMS_KP_Add ((guint) 0xffab)
#define SKK_KEYSYMS_KP_Separator ((guint) 0xffac)
#define SKK_KEYSYMS_KP_Subtract ((guint) 0xffad)
#define SKK_KEYSYMS_KP_Decimal ((guint) 0xffae)
#define SKK_KEYSYMS_KP_Divide ((guint) 0xffaf)
#define SKK_KEYSYMS_KP_0 ((guint) 0xffb0)
#define SKK_KEYSYMS_KP_1 ((guint) 0xffb1)
#define SKK_KEYSYMS_KP_2 ((guint) 0xffb2)
#define SKK_KEYSYMS_KP_3 ((guint) 0xffb3)
#define SKK_KEYSYMS_KP_4 ((guint) 0xffb4)
#define SKK_KEYSYMS_KP_5 ((guint) 0xffb5)
#define SKK_KEYSYMS_KP_6 ((guint) 0xffb6)
#define SKK_KEYSYMS_KP_7 ((guint) 0xffb7)
#define SKK_KEYSYMS_KP_8 ((guint) 0xffb8)
#define SKK_KEYSYMS_KP_9 ((guint) 0xffb9)
#define SKK_KEYSYMS_F1 ((guint) 0xffbe)
#define SKK_KEYSYMS_F2 ((guint) 0xffbf)
#define SKK_KEYSYMS_F3 ((guint) 0xffc0)
#define SKK_KEYSYMS_F4 ((guint) 0xffc1)
#define SKK_KEYSYMS_F5 ((guint) 0xffc2)
#define SKK_KEYSYMS_F6 ((guint) 0xffc3)
#define SKK_KEYSYMS_F7 ((guint) 0xffc4)
#define SKK_KEYSYMS_F8 ((guint) 0xffc5)
#define SKK_KEYSYMS_F9 ((guint) 0xffc6)
#define SKK_KEYSYMS_F10 ((guint) 0xffc7)
#define SKK_KEYSYMS_F11 ((guint) 0xffc8)
#define SKK_KEYSYMS_L1 ((guint) 0xffc8)
#define SKK_KEYSYMS_F12 ((guint) 0xffc9)
#define SKK_KEYSYMS_L2 ((guint) 0xffc9)
#define SKK_KEYSYMS_F13 ((guint) 0xffca)
#define SKK_KEYSYMS_L3 ((guint) 0xffca)
#define SKK_KEYSYMS_F14 ((guint) 0xffcb)
#define SKK_KEYSYMS_L4 ((guint) 0xffcb)
#define SKK_KEYSYMS_F15 ((guint) 0xffcc)
#define SKK_KEYSYMS_L5 ((guint) 0xffcc)
#define SKK_KEYSYMS_F16 ((guint) 0xffcd)
#define SKK_KEYSYMS_L6 ((guint) 0xffcd)
#define SKK_KEYSYMS_F17 ((guint) 0xffce)
#define SKK_KEYSYMS_L7 ((guint) 0xffce)
#define SKK_KEYSYMS_F18 ((guint) 0xffcf)
#define SKK_KEYSYMS_L8 ((guint) 0xffcf)
#define SKK_KEYSYMS_F19 ((guint) 0xffd0)
#define SKK_KEYSYMS_L9 ((guint) 0xffd0)
#define SKK_KEYSYMS_F20 ((guint) 0xffd1)
#define SKK_KEYSYMS_L10 ((guint) 0xffd1)
#define SKK_KEYSYMS_F21 ((guint) 0xffd2)
#define SKK_KEYSYMS_R1 ((guint) 0xffd2)
#define SKK_KEYSYMS_F22 ((guint) 0xffd3)
#define SKK_KEYSYMS_R2 ((guint) 0xffd3)
#define SKK_KEYSYMS_F23 ((guint) 0xffd4)
#define SKK_KEYSYMS_R3 ((guint) 0xffd4)
#define SKK_KEYSYMS_F24 ((guint) 0xffd5)
#define SKK_KEYSYMS_R4 ((guint) 0xffd5)
#define SKK_KEYSYMS_F25 ((guint) 0xffd6)
#define SKK_KEYSYMS_R5 ((guint) 0xffd6)
#define SKK_KEYSYMS_F26 ((guint) 0xffd7)
#define SKK_KEYSYMS_R6 ((guint) 0xffd7)
#define SKK_KEYSYMS_F27 ((guint) 0xffd8)
#define SKK_KEYSYMS_R7 ((guint) 0xffd8)
#define SKK_KEYSYMS_F28 ((guint) 0xffd9)
#define SKK_KEYSYMS_R8 ((guint) 0xffd9)
#define SKK_KEYSYMS_F29 ((guint) 0xffda)
#define SKK_KEYSYMS_R9 ((guint) 0xffda)
#define SKK_KEYSYMS_F30 ((guint) 0xffdb)
#define SKK_KEYSYMS_R10 ((guint) 0xffdb)
#define SKK_KEYSYMS_F31 ((guint) 0xffdc)
#define SKK_KEYSYMS_R11 ((guint) 0xffdc)
#define SKK_KEYSYMS_F32 ((guint) 0xffdd)
#define SKK_KEYSYMS_R12 ((guint) 0xffdd)
#define SKK_KEYSYMS_F33 ((guint) 0xffde)
#define SKK_KEYSYMS_R13 ((guint) 0xffde)
#define SKK_KEYSYMS_F34 ((guint) 0xffdf)
#define SKK_KEYSYMS_R14 ((guint) 0xffdf)
#define SKK_KEYSYMS_F35 ((guint) 0xffe0)
#define SKK_KEYSYMS_R15 ((guint) 0xffe0)
#define SKK_KEYSYMS_Shift_L ((guint) 0xffe1)
#define SKK_KEYSYMS_Shift_R ((guint) 0xffe2)
#define SKK_KEYSYMS_Control_L ((guint) 0xffe3)
#define SKK_KEYSYMS_Control_R ((guint) 0xffe4)
#define SKK_KEYSYMS_Caps_Lock ((guint) 0xffe5)
#define SKK_KEYSYMS_Shift_Lock ((guint) 0xffe6)
#define SKK_KEYSYMS_Meta_L ((guint) 0xffe7)
#define SKK_KEYSYMS_Meta_R ((guint) 0xffe8)
#define SKK_KEYSYMS_Alt_L ((guint) 0xffe9)
#define SKK_KEYSYMS_Alt_R ((guint) 0xffea)
#define SKK_KEYSYMS_Super_L ((guint) 0xffeb)
#define SKK_KEYSYMS_Super_R ((guint) 0xffec)
#define SKK_KEYSYMS_Hyper_L ((guint) 0xffed)
#define SKK_KEYSYMS_Hyper_R ((guint) 0xffee)
#define SKK_KEYSYMS_ISO_Lock ((guint) 0xfe01)
#define SKK_KEYSYMS_ISO_Level2_Latch ((guint) 0xfe02)
#define SKK_KEYSYMS_ISO_Level3_Shift ((guint) 0xfe03)
#define SKK_KEYSYMS_ISO_Level3_Latch ((guint) 0xfe04)
#define SKK_KEYSYMS_ISO_Level3_Lock ((guint) 0xfe05)
#define SKK_KEYSYMS_ISO_Level5_Shift ((guint) 0xfe11)
#define SKK_KEYSYMS_ISO_Level5_Latch ((guint) 0xfe12)
#define SKK_KEYSYMS_ISO_Level5_Lock ((guint) 0xfe13)
#define SKK_KEYSYMS_ISO_Group_Shift ((guint) 0xff7e)
#define SKK_KEYSYMS_ISO_Group_Latch ((guint) 0xfe06)
#define SKK_KEYSYMS_ISO_Group_Lock ((guint) 0xfe07)
#define SKK_KEYSYMS_ISO_Next_Group ((guint) 0xfe08)
#define SKK_KEYSYMS_ISO_Next_Group_Lock ((guint) 0xfe09)
#define SKK_KEYSYMS_ISO_Prev_Group ((guint) 0xfe0a)
#define SKK_KEYSYMS_ISO_Prev_Group_Lock ((guint) 0xfe0b)
#define SKK_KEYSYMS_ISO_First_Group ((guint) 0xfe0c)
#define SKK_KEYSYMS_ISO_First_Group_Lock ((guint) 0xfe0d)
#define SKK_KEYSYMS_ISO_Last_Group ((guint) 0xfe0e)
#define SKK_KEYSYMS_ISO_Last_Group_Lock ((guint) 0xfe0f)
#define SKK_KEYSYMS_ISO_Left_Tab ((guint) 0xfe20)
#define SKK_KEYSYMS_ISO_Move_Line_Up ((guint) 0xfe21)
#define SKK_KEYSYMS_ISO_Move_Line_Down ((guint) 0xfe22)
#define SKK_KEYSYMS_ISO_Partial_Line_Up ((guint) 0xfe23)
#define SKK_KEYSYMS_ISO_Partial_Line_Down ((guint) 0xfe24)
#define SKK_KEYSYMS_ISO_Partial_Space_Left ((guint) 0xfe25)
#define SKK_KEYSYMS_ISO_Partial_Space_Right ((guint) 0xfe26)
#define SKK_KEYSYMS_ISO_Set_Margin_Left ((guint) 0xfe27)
#define SKK_KEYSYMS_ISO_Set_Margin_Right ((guint) 0xfe28)
#define SKK_KEYSYMS_ISO_Release_Margin_Left ((guint) 0xfe29)
#define SKK_KEYSYMS_ISO_Release_Margin_Right ((guint) 0xfe2a)
#define SKK_KEYSYMS_ISO_Release_Both_Margins ((guint) 0xfe2b)
#define SKK_KEYSYMS_ISO_Fast_Cursor_Left ((guint) 0xfe2c)
#define SKK_KEYSYMS_ISO_Fast_Cursor_Right ((guint) 0xfe2d)
#define SKK_KEYSYMS_ISO_Fast_Cursor_Up ((guint) 0xfe2e)
#define SKK_KEYSYMS_ISO_Fast_Cursor_Down ((guint) 0xfe2f)
#define SKK_KEYSYMS_ISO_Continuous_Underline ((guint) 0xfe30)
#define SKK_KEYSYMS_ISO_Discontinuous_Underline ((guint) 0xfe31)
#define SKK_KEYSYMS_ISO_Emphasize ((guint) 0xfe32)
#define SKK_KEYSYMS_ISO_Center_Object ((guint) 0xfe33)
#define SKK_KEYSYMS_ISO_Enter ((guint) 0xfe34)
#define SKK_KEYSYMS_dead_grave ((guint) 0xfe50)
#define SKK_KEYSYMS_dead_acute ((guint) 0xfe51)
#define SKK_KEYSYMS_dead_circumflex ((guint) 0xfe52)
#define SKK_KEYSYMS_dead_tilde ((guint) 0xfe53)
#define SKK_KEYSYMS_dead_perispomeni ((guint) 0xfe53)
#define SKK_KEYSYMS_dead_macron ((guint) 0xfe54)
#define SKK_KEYSYMS_dead_breve ((guint) 0xfe55)
#define SKK_KEYSYMS_dead_abovedot ((guint) 0xfe56)
#define SKK_KEYSYMS_dead_diaeresis ((guint) 0xfe57)
#define SKK_KEYSYMS_dead_abovering ((guint) 0xfe58)
#define SKK_KEYSYMS_dead_doubleacute ((guint) 0xfe59)
#define SKK_KEYSYMS_dead_caron ((guint) 0xfe5a)
#define SKK_KEYSYMS_dead_cedilla ((guint) 0xfe5b)
#define SKK_KEYSYMS_dead_ogonek ((guint) 0xfe5c)
#define SKK_KEYSYMS_dead_iota ((guint) 0xfe5d)
#define SKK_KEYSYMS_dead_voiced_sound ((guint) 0xfe5e)
#define SKK_KEYSYMS_dead_semivoiced_sound ((guint) 0xfe5f)
#define SKK_KEYSYMS_dead_belowdot ((guint) 0xfe60)
#define SKK_KEYSYMS_dead_hook ((guint) 0xfe61)
#define SKK_KEYSYMS_dead_horn ((guint) 0xfe62)
#define SKK_KEYSYMS_dead_stroke ((guint) 0xfe63)
#define SKK_KEYSYMS_dead_abovecomma ((guint) 0xfe64)
#define SKK_KEYSYMS_dead_psili ((guint) 0xfe64)
#define SKK_KEYSYMS_dead_abovereversedcomma ((guint) 0xfe65)
#define SKK_KEYSYMS_dead_dasia ((guint) 0xfe65)
#define SKK_KEYSYMS_dead_doublegrave ((guint) 0xfe66)
#define SKK_KEYSYMS_dead_belowring ((guint) 0xfe67)
#define SKK_KEYSYMS_dead_belowmacron ((guint) 0xfe68)
#define SKK_KEYSYMS_dead_belowcircumflex ((guint) 0xfe69)
#define SKK_KEYSYMS_dead_belowtilde ((guint) 0xfe6a)
#define SKK_KEYSYMS_dead_belowbreve ((guint) 0xfe6b)
#define SKK_KEYSYMS_dead_belowdiaeresis ((guint) 0xfe6c)
#define SKK_KEYSYMS_dead_invertedbreve ((guint) 0xfe6d)
#define SKK_KEYSYMS_dead_belowcomma ((guint) 0xfe6e)
#define SKK_KEYSYMS_dead_currency ((guint) 0xfe6f)
#define SKK_KEYSYMS_dead_a ((guint) 0xfe80)
#define SKK_KEYSYMS_dead_A ((guint) 0xfe81)
#define SKK_KEYSYMS_dead_e ((guint) 0xfe82)
#define SKK_KEYSYMS_dead_E ((guint) 0xfe83)
#define SKK_KEYSYMS_dead_i ((guint) 0xfe84)
#define SKK_KEYSYMS_dead_I ((guint) 0xfe85)
#define SKK_KEYSYMS_dead_o ((guint) 0xfe86)
#define SKK_KEYSYMS_dead_O ((guint) 0xfe87)
#define SKK_KEYSYMS_dead_u ((guint) 0xfe88)
#define SKK_KEYSYMS_dead_U ((guint) 0xfe89)
#define SKK_KEYSYMS_dead_small_schwa ((guint) 0xfe8a)
#define SKK_KEYSYMS_dead_capital_schwa ((guint) 0xfe8b)
#define SKK_KEYSYMS_First_Virtual_Screen ((guint) 0xfed0)
#define SKK_KEYSYMS_Prev_Virtual_Screen ((guint) 0xfed1)
#define SKK_KEYSYMS_Next_Virtual_Screen ((guint) 0xfed2)
#define SKK_KEYSYMS_Last_Virtual_Screen ((guint) 0xfed4)
#define SKK_KEYSYMS_Terminate_Server ((guint) 0xfed5)
#define SKK_KEYSYMS_AccessX_Enable ((guint) 0xfe70)
#define SKK_KEYSYMS_AccessX_Feedback_Enable ((guint) 0xfe71)
#define SKK_KEYSYMS_RepeatKeys_Enable ((guint) 0xfe72)
#define SKK_KEYSYMS_SlowKeys_Enable ((guint) 0xfe73)
#define SKK_KEYSYMS_BounceKeys_Enable ((guint) 0xfe74)
#define SKK_KEYSYMS_StickyKeys_Enable ((guint) 0xfe75)
#define SKK_KEYSYMS_MouseKeys_Enable ((guint) 0xfe76)
#define SKK_KEYSYMS_MouseKeys_Accel_Enable ((guint) 0xfe77)
#define SKK_KEYSYMS_Overlay1_Enable ((guint) 0xfe78)
#define SKK_KEYSYMS_Overlay2_Enable ((guint) 0xfe79)
#define SKK_KEYSYMS_AudibleBell_Enable ((guint) 0xfe7a)
#define SKK_KEYSYMS_Pointer_Left ((guint) 0xfee0)
#define SKK_KEYSYMS_Pointer_Right ((guint) 0xfee1)
#define SKK_KEYSYMS_Pointer_Up ((guint) 0xfee2)
#define SKK_KEYSYMS_Pointer_Down ((guint) 0xfee3)
#define SKK_KEYSYMS_Pointer_UpLeft ((guint) 0xfee4)
#define SKK_KEYSYMS_Pointer_UpRight ((guint) 0xfee5)
#define SKK_KEYSYMS_Pointer_DownLeft ((guint) 0xfee6)
#define SKK_KEYSYMS_Pointer_DownRight ((guint) 0xfee7)
#define SKK_KEYSYMS_Pointer_Button_Dflt ((guint) 0xfee8)
#define SKK_KEYSYMS_Pointer_Button1 ((guint) 0xfee9)
#define SKK_KEYSYMS_Pointer_Button2 ((guint) 0xfeea)
#define SKK_KEYSYMS_Pointer_Button3 ((guint) 0xfeeb)
#define SKK_KEYSYMS_Pointer_Button4 ((guint) 0xfeec)
#define SKK_KEYSYMS_Pointer_Button5 ((guint) 0xfeed)
#define SKK_KEYSYMS_Pointer_DblClick_Dflt ((guint) 0xfeee)
#define SKK_KEYSYMS_Pointer_DblClick1 ((guint) 0xfeef)
#define SKK_KEYSYMS_Pointer_DblClick2 ((guint) 0xfef0)
#define SKK_KEYSYMS_Pointer_DblClick3 ((guint) 0xfef1)
#define SKK_KEYSYMS_Pointer_DblClick4 ((guint) 0xfef2)
#define SKK_KEYSYMS_Pointer_DblClick5 ((guint) 0xfef3)
#define SKK_KEYSYMS_Pointer_Drag_Dflt ((guint) 0xfef4)
#define SKK_KEYSYMS_Pointer_Drag1 ((guint) 0xfef5)
#define SKK_KEYSYMS_Pointer_Drag2 ((guint) 0xfef6)
#define SKK_KEYSYMS_Pointer_Drag3 ((guint) 0xfef7)
#define SKK_KEYSYMS_Pointer_Drag4 ((guint) 0xfef8)
#define SKK_KEYSYMS_Pointer_Drag5 ((guint) 0xfefd)
#define SKK_KEYSYMS_Pointer_EnableKeys ((guint) 0xfef9)
#define SKK_KEYSYMS_Pointer_Accelerate ((guint) 0xfefa)
#define SKK_KEYSYMS_Pointer_DfltBtnNext ((guint) 0xfefb)
#define SKK_KEYSYMS_Pointer_DfltBtnPrev ((guint) 0xfefc)
#define SKK_KEYSYMS_3270_Duplicate ((guint) 0xfd01)
#define SKK_KEYSYMS_3270_FieldMark ((guint) 0xfd02)
#define SKK_KEYSYMS_3270_Right2 ((guint) 0xfd03)
#define SKK_KEYSYMS_3270_Left2 ((guint) 0xfd04)
#define SKK_KEYSYMS_3270_BackTab ((guint) 0xfd05)
#define SKK_KEYSYMS_3270_EraseEOF ((guint) 0xfd06)
#define SKK_KEYSYMS_3270_EraseInput ((guint) 0xfd07)
#define SKK_KEYSYMS_3270_Reset ((guint) 0xfd08)
#define SKK_KEYSYMS_3270_Quit ((guint) 0xfd09)
#define SKK_KEYSYMS_3270_PA1 ((guint) 0xfd0a)
#define SKK_KEYSYMS_3270_PA2 ((guint) 0xfd0b)
#define SKK_KEYSYMS_3270_PA3 ((guint) 0xfd0c)
#define SKK_KEYSYMS_3270_Test ((guint) 0xfd0d)
#define SKK_KEYSYMS_3270_Attn ((guint) 0xfd0e)
#define SKK_KEYSYMS_3270_CursorBlink ((guint) 0xfd0f)
#define SKK_KEYSYMS_3270_AltCursor ((guint) 0xfd10)
#define SKK_KEYSYMS_3270_KeyClick ((guint) 0xfd11)
#define SKK_KEYSYMS_3270_Jump ((guint) 0xfd12)
#define SKK_KEYSYMS_3270_Ident ((guint) 0xfd13)
#define SKK_KEYSYMS_3270_Rule ((guint) 0xfd14)
#define SKK_KEYSYMS_3270_Copy ((guint) 0xfd15)
#define SKK_KEYSYMS_3270_Play ((guint) 0xfd16)
#define SKK_KEYSYMS_3270_Setup ((guint) 0xfd17)
#define SKK_KEYSYMS_3270_Record ((guint) 0xfd18)
#define SKK_KEYSYMS_3270_ChangeScreen ((guint) 0xfd19)
#define SKK_KEYSYMS_3270_DeleteWord ((guint) 0xfd1a)
#define SKK_KEYSYMS_3270_ExSelect ((guint) 0xfd1b)
#define SKK_KEYSYMS_3270_CursorSelect ((guint) 0xfd1c)
#define SKK_KEYSYMS_3270_PrintScreen ((guint) 0xfd1d)
#define SKK_KEYSYMS_3270_Enter ((guint) 0xfd1e)
#define SKK_KEYSYMS_space ((guint) 0x0020)
#define SKK_KEYSYMS_exclam ((guint) 0x0021)
#define SKK_KEYSYMS_quotedbl ((guint) 0x0022)
#define SKK_KEYSYMS_numbersign ((guint) 0x0023)
#define SKK_KEYSYMS_dollar ((guint) 0x0024)
#define SKK_KEYSYMS_percent ((guint) 0x0025)
#define SKK_KEYSYMS_ampersand ((guint) 0x0026)
#define SKK_KEYSYMS_apostrophe ((guint) 0x0027)
#define SKK_KEYSYMS_quoteright ((guint) 0x0027)
#define SKK_KEYSYMS_parenleft ((guint) 0x0028)
#define SKK_KEYSYMS_parenright ((guint) 0x0029)
#define SKK_KEYSYMS_asterisk ((guint) 0x002a)
#define SKK_KEYSYMS_plus ((guint) 0x002b)
#define SKK_KEYSYMS_comma ((guint) 0x002c)
#define SKK_KEYSYMS_minus ((guint) 0x002d)
#define SKK_KEYSYMS_period ((guint) 0x002e)
#define SKK_KEYSYMS_slash ((guint) 0x002f)
#define SKK_KEYSYMS_0 ((guint) 0x0030)
#define SKK_KEYSYMS_1 ((guint) 0x0031)
#define SKK_KEYSYMS_2 ((guint) 0x0032)
#define SKK_KEYSYMS_3 ((guint) 0x0033)
#define SKK_KEYSYMS_4 ((guint) 0x0034)
#define SKK_KEYSYMS_5 ((guint) 0x0035)
#define SKK_KEYSYMS_6 ((guint) 0x0036)
#define SKK_KEYSYMS_7 ((guint) 0x0037)
#define SKK_KEYSYMS_8 ((guint) 0x0038)
#define SKK_KEYSYMS_9 ((guint) 0x0039)
#define SKK_KEYSYMS_colon ((guint) 0x003a)
#define SKK_KEYSYMS_semicolon ((guint) 0x003b)
#define SKK_KEYSYMS_less ((guint) 0x003c)
#define SKK_KEYSYMS_equal ((guint) 0x003d)
#define SKK_KEYSYMS_greater ((guint) 0x003e)
#define SKK_KEYSYMS_question ((guint) 0x003f)
#define SKK_KEYSYMS_at ((guint) 0x0040)
#define SKK_KEYSYMS_A ((guint) 0x0041)
#define SKK_KEYSYMS_B ((guint) 0x0042)
#define SKK_KEYSYMS_C ((guint) 0x0043)
#define SKK_KEYSYMS_D ((guint) 0x0044)
#define SKK_KEYSYMS_E ((guint) 0x0045)
#define SKK_KEYSYMS_F ((guint) 0x0046)
#define SKK_KEYSYMS_G ((guint) 0x0047)
#define SKK_KEYSYMS_H ((guint) 0x0048)
#define SKK_KEYSYMS_I ((guint) 0x0049)
#define SKK_KEYSYMS_J ((guint) 0x004a)
#define SKK_KEYSYMS_K ((guint) 0x004b)
#define SKK_KEYSYMS_L ((guint) 0x004c)
#define SKK_KEYSYMS_M ((guint) 0x004d)
#define SKK_KEYSYMS_N ((guint) 0x004e)
#define SKK_KEYSYMS_O ((guint) 0x004f)
#define SKK_KEYSYMS_P ((guint) 0x0050)
#define SKK_KEYSYMS_Q ((guint) 0x0051)
#define SKK_KEYSYMS_R ((guint) 0x0052)
#define SKK_KEYSYMS_S ((guint) 0x0053)
#define SKK_KEYSYMS_T ((guint) 0x0054)
#define SKK_KEYSYMS_U ((guint) 0x0055)
#define SKK_KEYSYMS_V ((guint) 0x0056)
#define SKK_KEYSYMS_W ((guint) 0x0057)
#define SKK_KEYSYMS_X ((guint) 0x0058)
#define SKK_KEYSYMS_Y ((guint) 0x0059)
#define SKK_KEYSYMS_Z ((guint) 0x005a)
#define SKK_KEYSYMS_bracketleft ((guint) 0x005b)
#define SKK_KEYSYMS_backslash ((guint) 0x005c)
#define SKK_KEYSYMS_bracketright ((guint) 0x005d)
#define SKK_KEYSYMS_asciicircum ((guint) 0x005e)
#define SKK_KEYSYMS_underscore ((guint) 0x005f)
#define SKK_KEYSYMS_grave ((guint) 0x0060)
#define SKK_KEYSYMS_quoteleft ((guint) 0x0060)
#define SKK_KEYSYMS_a ((guint) 0x0061)
#define SKK_KEYSYMS_b ((guint) 0x0062)
#define SKK_KEYSYMS_c ((guint) 0x0063)
#define SKK_KEYSYMS_d ((guint) 0x0064)
#define SKK_KEYSYMS_e ((guint) 0x0065)
#define SKK_KEYSYMS_f ((guint) 0x0066)
#define SKK_KEYSYMS_g ((guint) 0x0067)
#define SKK_KEYSYMS_h ((guint) 0x0068)
#define SKK_KEYSYMS_i ((guint) 0x0069)
#define SKK_KEYSYMS_j ((guint) 0x006a)
#define SKK_KEYSYMS_k ((guint) 0x006b)
#define SKK_KEYSYMS_l ((guint) 0x006c)
#define SKK_KEYSYMS_m ((guint) 0x006d)
#define SKK_KEYSYMS_n ((guint) 0x006e)
#define SKK_KEYSYMS_o ((guint) 0x006f)
#define SKK_KEYSYMS_p ((guint) 0x0070)
#define SKK_KEYSYMS_q ((guint) 0x0071)
#define SKK_KEYSYMS_r ((guint) 0x0072)
#define SKK_KEYSYMS_s ((guint) 0x0073)
#define SKK_KEYSYMS_t ((guint) 0x0074)
#define SKK_KEYSYMS_u ((guint) 0x0075)
#define SKK_KEYSYMS_v ((guint) 0x0076)
#define SKK_KEYSYMS_w ((guint) 0x0077)
#define SKK_KEYSYMS_x ((guint) 0x0078)
#define SKK_KEYSYMS_y ((guint) 0x0079)
#define SKK_KEYSYMS_z ((guint) 0x007a)
#define SKK_KEYSYMS_braceleft ((guint) 0x007b)
#define SKK_KEYSYMS_bar ((guint) 0x007c)
#define SKK_KEYSYMS_braceright ((guint) 0x007d)
#define SKK_KEYSYMS_asciitilde ((guint) 0x007e)
#define SKK_KEYSYMS_nobreakspace ((guint) 0x00a0)
#define SKK_KEYSYMS_exclamdown ((guint) 0x00a1)
#define SKK_KEYSYMS_cent ((guint) 0x00a2)
#define SKK_KEYSYMS_sterling ((guint) 0x00a3)
#define SKK_KEYSYMS_currency ((guint) 0x00a4)
#define SKK_KEYSYMS_yen ((guint) 0x00a5)
#define SKK_KEYSYMS_brokenbar ((guint) 0x00a6)
#define SKK_KEYSYMS_section ((guint) 0x00a7)
#define SKK_KEYSYMS_diaeresis ((guint) 0x00a8)
#define SKK_KEYSYMS_copyright ((guint) 0x00a9)
#define SKK_KEYSYMS_ordfeminine ((guint) 0x00aa)
#define SKK_KEYSYMS_guillemotleft ((guint) 0x00ab)
#define SKK_KEYSYMS_notsign ((guint) 0x00ac)
#define SKK_KEYSYMS_hyphen ((guint) 0x00ad)
#define SKK_KEYSYMS_registered ((guint) 0x00ae)
#define SKK_KEYSYMS_macron ((guint) 0x00af)
#define SKK_KEYSYMS_degree ((guint) 0x00b0)
#define SKK_KEYSYMS_plusminus ((guint) 0x00b1)
#define SKK_KEYSYMS_twosuperior ((guint) 0x00b2)
#define SKK_KEYSYMS_threesuperior ((guint) 0x00b3)
#define SKK_KEYSYMS_acute ((guint) 0x00b4)
#define SKK_KEYSYMS_mu ((guint) 0x00b5)
#define SKK_KEYSYMS_paragraph ((guint) 0x00b6)
#define SKK_KEYSYMS_periodcentered ((guint) 0x00b7)
#define SKK_KEYSYMS_cedilla ((guint) 0x00b8)
#define SKK_KEYSYMS_onesuperior ((guint) 0x00b9)
#define SKK_KEYSYMS_masculine ((guint) 0x00ba)
#define SKK_KEYSYMS_guillemotright ((guint) 0x00bb)
#define SKK_KEYSYMS_onequarter ((guint) 0x00bc)
#define SKK_KEYSYMS_onehalf ((guint) 0x00bd)
#define SKK_KEYSYMS_threequarters ((guint) 0x00be)
#define SKK_KEYSYMS_questiondown ((guint) 0x00bf)
#define SKK_KEYSYMS_Agrave ((guint) 0x00c0)
#define SKK_KEYSYMS_Aacute ((guint) 0x00c1)
#define SKK_KEYSYMS_Acircumflex ((guint) 0x00c2)
#define SKK_KEYSYMS_Atilde ((guint) 0x00c3)
#define SKK_KEYSYMS_Adiaeresis ((guint) 0x00c4)
#define SKK_KEYSYMS_Aring ((guint) 0x00c5)
#define SKK_KEYSYMS_AE ((guint) 0x00c6)
#define SKK_KEYSYMS_Ccedilla ((guint) 0x00c7)
#define SKK_KEYSYMS_Egrave ((guint) 0x00c8)
#define SKK_KEYSYMS_Eacute ((guint) 0x00c9)
#define SKK_KEYSYMS_Ecircumflex ((guint) 0x00ca)
#define SKK_KEYSYMS_Ediaeresis ((guint) 0x00cb)
#define SKK_KEYSYMS_Igrave ((guint) 0x00cc)
#define SKK_KEYSYMS_Iacute ((guint) 0x00cd)
#define SKK_KEYSYMS_Icircumflex ((guint) 0x00ce)
#define SKK_KEYSYMS_Idiaeresis ((guint) 0x00cf)
#define SKK_KEYSYMS_ETH ((guint) 0x00d0)
#define SKK_KEYSYMS_Eth ((guint) 0x00d0)
#define SKK_KEYSYMS_Ntilde ((guint) 0x00d1)
#define SKK_KEYSYMS_Ograve ((guint) 0x00d2)
#define SKK_KEYSYMS_Oacute ((guint) 0x00d3)
#define SKK_KEYSYMS_Ocircumflex ((guint) 0x00d4)
#define SKK_KEYSYMS_Otilde ((guint) 0x00d5)
#define SKK_KEYSYMS_Odiaeresis ((guint) 0x00d6)
#define SKK_KEYSYMS_multiply ((guint) 0x00d7)
#define SKK_KEYSYMS_Oslash ((guint) 0x00d8)
#define SKK_KEYSYMS_Ooblique ((guint) 0x00d8)
#define SKK_KEYSYMS_Ugrave ((guint) 0x00d9)
#define SKK_KEYSYMS_Uacute ((guint) 0x00da)
#define SKK_KEYSYMS_Ucircumflex ((guint) 0x00db)
#define SKK_KEYSYMS_Udiaeresis ((guint) 0x00dc)
#define SKK_KEYSYMS_Yacute ((guint) 0x00dd)
#define SKK_KEYSYMS_THORN ((guint) 0x00de)
#define SKK_KEYSYMS_Thorn ((guint) 0x00de)
#define SKK_KEYSYMS_ssharp ((guint) 0x00df)
#define SKK_KEYSYMS_agrave ((guint) 0x00e0)
#define SKK_KEYSYMS_aacute ((guint) 0x00e1)
#define SKK_KEYSYMS_acircumflex ((guint) 0x00e2)
#define SKK_KEYSYMS_atilde ((guint) 0x00e3)
#define SKK_KEYSYMS_adiaeresis ((guint) 0x00e4)
#define SKK_KEYSYMS_aring ((guint) 0x00e5)
#define SKK_KEYSYMS_ae ((guint) 0x00e6)
#define SKK_KEYSYMS_ccedilla ((guint) 0x00e7)
#define SKK_KEYSYMS_egrave ((guint) 0x00e8)
#define SKK_KEYSYMS_eacute ((guint) 0x00e9)
#define SKK_KEYSYMS_ecircumflex ((guint) 0x00ea)
#define SKK_KEYSYMS_ediaeresis ((guint) 0x00eb)
#define SKK_KEYSYMS_igrave ((guint) 0x00ec)
#define SKK_KEYSYMS_iacute ((guint) 0x00ed)
#define SKK_KEYSYMS_icircumflex ((guint) 0x00ee)
#define SKK_KEYSYMS_idiaeresis ((guint) 0x00ef)
#define SKK_KEYSYMS_eth ((guint) 0x00f0)
#define SKK_KEYSYMS_ntilde ((guint) 0x00f1)
#define SKK_KEYSYMS_ograve ((guint) 0x00f2)
#define SKK_KEYSYMS_oacute ((guint) 0x00f3)
#define SKK_KEYSYMS_ocircumflex ((guint) 0x00f4)
#define SKK_KEYSYMS_otilde ((guint) 0x00f5)
#define SKK_KEYSYMS_odiaeresis ((guint) 0x00f6)
#define SKK_KEYSYMS_division ((guint) 0x00f7)
#define SKK_KEYSYMS_oslash ((guint) 0x00f8)
#define SKK_KEYSYMS_ooblique ((guint) 0x00f8)
#define SKK_KEYSYMS_ugrave ((guint) 0x00f9)
#define SKK_KEYSYMS_uacute ((guint) 0x00fa)
#define SKK_KEYSYMS_ucircumflex ((guint) 0x00fb)
#define SKK_KEYSYMS_udiaeresis ((guint) 0x00fc)
#define SKK_KEYSYMS_yacute ((guint) 0x00fd)
#define SKK_KEYSYMS_thorn ((guint) 0x00fe)
#define SKK_KEYSYMS_ydiaeresis ((guint) 0x00ff)
#define SKK_KEYSYMS_Aogonek ((guint) 0x01a1)
#define SKK_KEYSYMS_breve ((guint) 0x01a2)
#define SKK_KEYSYMS_Lstroke ((guint) 0x01a3)
#define SKK_KEYSYMS_Lcaron ((guint) 0x01a5)
#define SKK_KEYSYMS_Sacute ((guint) 0x01a6)
#define SKK_KEYSYMS_Scaron ((guint) 0x01a9)
#define SKK_KEYSYMS_Scedilla ((guint) 0x01aa)
#define SKK_KEYSYMS_Tcaron ((guint) 0x01ab)
#define SKK_KEYSYMS_Zacute ((guint) 0x01ac)
#define SKK_KEYSYMS_Zcaron ((guint) 0x01ae)
#define SKK_KEYSYMS_Zabovedot ((guint) 0x01af)
#define SKK_KEYSYMS_aogonek ((guint) 0x01b1)
#define SKK_KEYSYMS_ogonek ((guint) 0x01b2)
#define SKK_KEYSYMS_lstroke ((guint) 0x01b3)
#define SKK_KEYSYMS_lcaron ((guint) 0x01b5)
#define SKK_KEYSYMS_sacute ((guint) 0x01b6)
#define SKK_KEYSYMS_caron ((guint) 0x01b7)
#define SKK_KEYSYMS_scaron ((guint) 0x01b9)
#define SKK_KEYSYMS_scedilla ((guint) 0x01ba)
#define SKK_KEYSYMS_tcaron ((guint) 0x01bb)
#define SKK_KEYSYMS_zacute ((guint) 0x01bc)
#define SKK_KEYSYMS_doubleacute ((guint) 0x01bd)
#define SKK_KEYSYMS_zcaron ((guint) 0x01be)
#define SKK_KEYSYMS_zabovedot ((guint) 0x01bf)
#define SKK_KEYSYMS_Racute ((guint) 0x01c0)
#define SKK_KEYSYMS_Abreve ((guint) 0x01c3)
#define SKK_KEYSYMS_Lacute ((guint) 0x01c5)
#define SKK_KEYSYMS_Cacute ((guint) 0x01c6)
#define SKK_KEYSYMS_Ccaron ((guint) 0x01c8)
#define SKK_KEYSYMS_Eogonek ((guint) 0x01ca)
#define SKK_KEYSYMS_Ecaron ((guint) 0x01cc)
#define SKK_KEYSYMS_Dcaron ((guint) 0x01cf)
#define SKK_KEYSYMS_Dstroke ((guint) 0x01d0)
#define SKK_KEYSYMS_Nacute ((guint) 0x01d1)
#define SKK_KEYSYMS_Ncaron ((guint) 0x01d2)
#define SKK_KEYSYMS_Odoubleacute ((guint) 0x01d5)
#define SKK_KEYSYMS_Rcaron ((guint) 0x01d8)
#define SKK_KEYSYMS_Uring ((guint) 0x01d9)
#define SKK_KEYSYMS_Udoubleacute ((guint) 0x01db)
#define SKK_KEYSYMS_Tcedilla ((guint) 0x01de)
#define SKK_KEYSYMS_racute ((guint) 0x01e0)
#define SKK_KEYSYMS_abreve ((guint) 0x01e3)
#define SKK_KEYSYMS_lacute ((guint) 0x01e5)
#define SKK_KEYSYMS_cacute ((guint) 0x01e6)
#define SKK_KEYSYMS_ccaron ((guint) 0x01e8)
#define SKK_KEYSYMS_eogonek ((guint) 0x01ea)
#define SKK_KEYSYMS_ecaron ((guint) 0x01ec)
#define SKK_KEYSYMS_dcaron ((guint) 0x01ef)
#define SKK_KEYSYMS_dstroke ((guint) 0x01f0)
#define SKK_KEYSYMS_nacute ((guint) 0x01f1)
#define SKK_KEYSYMS_ncaron ((guint) 0x01f2)
#define SKK_KEYSYMS_odoubleacute ((guint) 0x01f5)
#define SKK_KEYSYMS_rcaron ((guint) 0x01f8)
#define SKK_KEYSYMS_uring ((guint) 0x01f9)
#define SKK_KEYSYMS_udoubleacute ((guint) 0x01fb)
#define SKK_KEYSYMS_tcedilla ((guint) 0x01fe)
#define SKK_KEYSYMS_abovedot ((guint) 0x01ff)
#define SKK_KEYSYMS_Hstroke ((guint) 0x02a1)
#define SKK_KEYSYMS_Hcircumflex ((guint) 0x02a6)
#define SKK_KEYSYMS_Iabovedot ((guint) 0x02a9)
#define SKK_KEYSYMS_Gbreve ((guint) 0x02ab)
#define SKK_KEYSYMS_Jcircumflex ((guint) 0x02ac)
#define SKK_KEYSYMS_hstroke ((guint) 0x02b1)
#define SKK_KEYSYMS_hcircumflex ((guint) 0x02b6)
#define SKK_KEYSYMS_idotless ((guint) 0x02b9)
#define SKK_KEYSYMS_gbreve ((guint) 0x02bb)
#define SKK_KEYSYMS_jcircumflex ((guint) 0x02bc)
#define SKK_KEYSYMS_Cabovedot ((guint) 0x02c5)
#define SKK_KEYSYMS_Ccircumflex ((guint) 0x02c6)
#define SKK_KEYSYMS_Gabovedot ((guint) 0x02d5)
#define SKK_KEYSYMS_Gcircumflex ((guint) 0x02d8)
#define SKK_KEYSYMS_Ubreve ((guint) 0x02dd)
#define SKK_KEYSYMS_Scircumflex ((guint) 0x02de)
#define SKK_KEYSYMS_cabovedot ((guint) 0x02e5)
#define SKK_KEYSYMS_ccircumflex ((guint) 0x02e6)
#define SKK_KEYSYMS_gabovedot ((guint) 0x02f5)
#define SKK_KEYSYMS_gcircumflex ((guint) 0x02f8)
#define SKK_KEYSYMS_ubreve ((guint) 0x02fd)
#define SKK_KEYSYMS_scircumflex ((guint) 0x02fe)
#define SKK_KEYSYMS_kra ((guint) 0x03a2)
#define SKK_KEYSYMS_kappa ((guint) 0x03a2)
#define SKK_KEYSYMS_Rcedilla ((guint) 0x03a3)
#define SKK_KEYSYMS_Itilde ((guint) 0x03a5)
#define SKK_KEYSYMS_Lcedilla ((guint) 0x03a6)
#define SKK_KEYSYMS_Emacron ((guint) 0x03aa)
#define SKK_KEYSYMS_Gcedilla ((guint) 0x03ab)
#define SKK_KEYSYMS_Tslash ((guint) 0x03ac)
#define SKK_KEYSYMS_rcedilla ((guint) 0x03b3)
#define SKK_KEYSYMS_itilde ((guint) 0x03b5)
#define SKK_KEYSYMS_lcedilla ((guint) 0x03b6)
#define SKK_KEYSYMS_emacron ((guint) 0x03ba)
#define SKK_KEYSYMS_gcedilla ((guint) 0x03bb)
#define SKK_KEYSYMS_tslash ((guint) 0x03bc)
#define SKK_KEYSYMS_ENG ((guint) 0x03bd)
#define SKK_KEYSYMS_eng ((guint) 0x03bf)
#define SKK_KEYSYMS_Amacron ((guint) 0x03c0)
#define SKK_KEYSYMS_Iogonek ((guint) 0x03c7)
#define SKK_KEYSYMS_Eabovedot ((guint) 0x03cc)
#define SKK_KEYSYMS_Imacron ((guint) 0x03cf)
#define SKK_KEYSYMS_Ncedilla ((guint) 0x03d1)
#define SKK_KEYSYMS_Omacron ((guint) 0x03d2)
#define SKK_KEYSYMS_Kcedilla ((guint) 0x03d3)
#define SKK_KEYSYMS_Uogonek ((guint) 0x03d9)
#define SKK_KEYSYMS_Utilde ((guint) 0x03dd)
#define SKK_KEYSYMS_Umacron ((guint) 0x03de)
#define SKK_KEYSYMS_amacron ((guint) 0x03e0)
#define SKK_KEYSYMS_iogonek ((guint) 0x03e7)
#define SKK_KEYSYMS_eabovedot ((guint) 0x03ec)
#define SKK_KEYSYMS_imacron ((guint) 0x03ef)
#define SKK_KEYSYMS_ncedilla ((guint) 0x03f1)
#define SKK_KEYSYMS_omacron ((guint) 0x03f2)
#define SKK_KEYSYMS_kcedilla ((guint) 0x03f3)
#define SKK_KEYSYMS_uogonek ((guint) 0x03f9)
#define SKK_KEYSYMS_utilde ((guint) 0x03fd)
#define SKK_KEYSYMS_umacron ((guint) 0x03fe)
#define SKK_KEYSYMS_Wcircumflex ((guint) 0x1000174)
#define SKK_KEYSYMS_wcircumflex ((guint) 0x1000175)
#define SKK_KEYSYMS_Ycircumflex ((guint) 0x1000176)
#define SKK_KEYSYMS_ycircumflex ((guint) 0x1000177)
#define SKK_KEYSYMS_Babovedot ((guint) 0x1001e02)
#define SKK_KEYSYMS_babovedot ((guint) 0x1001e03)
#define SKK_KEYSYMS_Dabovedot ((guint) 0x1001e0a)
#define SKK_KEYSYMS_dabovedot ((guint) 0x1001e0b)
#define SKK_KEYSYMS_Fabovedot ((guint) 0x1001e1e)
#define SKK_KEYSYMS_fabovedot ((guint) 0x1001e1f)
#define SKK_KEYSYMS_Mabovedot ((guint) 0x1001e40)
#define SKK_KEYSYMS_mabovedot ((guint) 0x1001e41)
#define SKK_KEYSYMS_Pabovedot ((guint) 0x1001e56)
#define SKK_KEYSYMS_pabovedot ((guint) 0x1001e57)
#define SKK_KEYSYMS_Sabovedot ((guint) 0x1001e60)
#define SKK_KEYSYMS_sabovedot ((guint) 0x1001e61)
#define SKK_KEYSYMS_Tabovedot ((guint) 0x1001e6a)
#define SKK_KEYSYMS_tabovedot ((guint) 0x1001e6b)
#define SKK_KEYSYMS_Wgrave ((guint) 0x1001e80)
#define SKK_KEYSYMS_wgrave ((guint) 0x1001e81)
#define SKK_KEYSYMS_Wacute ((guint) 0x1001e82)
#define SKK_KEYSYMS_wacute ((guint) 0x1001e83)
#define SKK_KEYSYMS_Wdiaeresis ((guint) 0x1001e84)
#define SKK_KEYSYMS_wdiaeresis ((guint) 0x1001e85)
#define SKK_KEYSYMS_Ygrave ((guint) 0x1001ef2)
#define SKK_KEYSYMS_ygrave ((guint) 0x1001ef3)
#define SKK_KEYSYMS_OE ((guint) 0x13bc)
#define SKK_KEYSYMS_oe ((guint) 0x13bd)
#define SKK_KEYSYMS_Ydiaeresis ((guint) 0x13be)
#define SKK_KEYSYMS_overline ((guint) 0x047e)
#define SKK_KEYSYMS_kana_fullstop ((guint) 0x04a1)
#define SKK_KEYSYMS_kana_openingbracket ((guint) 0x04a2)
#define SKK_KEYSYMS_kana_closingbracket ((guint) 0x04a3)
#define SKK_KEYSYMS_kana_comma ((guint) 0x04a4)
#define SKK_KEYSYMS_kana_conjunctive ((guint) 0x04a5)
#define SKK_KEYSYMS_kana_middledot ((guint) 0x04a5)
#define SKK_KEYSYMS_kana_WO ((guint) 0x04a6)
#define SKK_KEYSYMS_kana_a ((guint) 0x04a7)
#define SKK_KEYSYMS_kana_i ((guint) 0x04a8)
#define SKK_KEYSYMS_kana_u ((guint) 0x04a9)
#define SKK_KEYSYMS_kana_e ((guint) 0x04aa)
#define SKK_KEYSYMS_kana_o ((guint) 0x04ab)
#define SKK_KEYSYMS_kana_ya ((guint) 0x04ac)
#define SKK_KEYSYMS_kana_yu ((guint) 0x04ad)
#define SKK_KEYSYMS_kana_yo ((guint) 0x04ae)
#define SKK_KEYSYMS_kana_tsu ((guint) 0x04af)
#define SKK_KEYSYMS_kana_tu ((guint) 0x04af)
#define SKK_KEYSYMS_prolongedsound ((guint) 0x04b0)
#define SKK_KEYSYMS_kana_A ((guint) 0x04b1)
#define SKK_KEYSYMS_kana_I ((guint) 0x04b2)
#define SKK_KEYSYMS_kana_U ((guint) 0x04b3)
#define SKK_KEYSYMS_kana_E ((guint) 0x04b4)
#define SKK_KEYSYMS_kana_O ((guint) 0x04b5)
#define SKK_KEYSYMS_kana_KA ((guint) 0x04b6)
#define SKK_KEYSYMS_kana_KI ((guint) 0x04b7)
#define SKK_KEYSYMS_kana_KU ((guint) 0x04b8)
#define SKK_KEYSYMS_kana_KE ((guint) 0x04b9)
#define SKK_KEYSYMS_kana_KO ((guint) 0x04ba)
#define SKK_KEYSYMS_kana_SA ((guint) 0x04bb)
#define SKK_KEYSYMS_kana_SHI ((guint) 0x04bc)
#define SKK_KEYSYMS_kana_SU ((guint) 0x04bd)
#define SKK_KEYSYMS_kana_SE ((guint) 0x04be)
#define SKK_KEYSYMS_kana_SO ((guint) 0x04bf)
#define SKK_KEYSYMS_kana_TA ((guint) 0x04c0)
#define SKK_KEYSYMS_kana_CHI ((guint) 0x04c1)
#define SKK_KEYSYMS_kana_TI ((guint) 0x04c1)
#define SKK_KEYSYMS_kana_TSU ((guint) 0x04c2)
#define SKK_KEYSYMS_kana_TU ((guint) 0x04c2)
#define SKK_KEYSYMS_kana_TE ((guint) 0x04c3)
#define SKK_KEYSYMS_kana_TO ((guint) 0x04c4)
#define SKK_KEYSYMS_kana_NA ((guint) 0x04c5)
#define SKK_KEYSYMS_kana_NI ((guint) 0x04c6)
#define SKK_KEYSYMS_kana_NU ((guint) 0x04c7)
#define SKK_KEYSYMS_kana_NE ((guint) 0x04c8)
#define SKK_KEYSYMS_kana_NO ((guint) 0x04c9)
#define SKK_KEYSYMS_kana_HA ((guint) 0x04ca)
#define SKK_KEYSYMS_kana_HI ((guint) 0x04cb)
#define SKK_KEYSYMS_kana_FU ((guint) 0x04cc)
#define SKK_KEYSYMS_kana_HU ((guint) 0x04cc)
#define SKK_KEYSYMS_kana_HE ((guint) 0x04cd)
#define SKK_KEYSYMS_kana_HO ((guint) 0x04ce)
#define SKK_KEYSYMS_kana_MA ((guint) 0x04cf)
#define SKK_KEYSYMS_kana_MI ((guint) 0x04d0)
#define SKK_KEYSYMS_kana_MU ((guint) 0x04d1)
#define SKK_KEYSYMS_kana_ME ((guint) 0x04d2)
#define SKK_KEYSYMS_kana_MO ((guint) 0x04d3)
#define SKK_KEYSYMS_kana_YA ((guint) 0x04d4)
#define SKK_KEYSYMS_kana_YU ((guint) 0x04d5)
#define SKK_KEYSYMS_kana_YO ((guint) 0x04d6)
#define SKK_KEYSYMS_kana_RA ((guint) 0x04d7)
#define SKK_KEYSYMS_kana_RI ((guint) 0x04d8)
#define SKK_KEYSYMS_kana_RU ((guint) 0x04d9)
#define SKK_KEYSYMS_kana_RE ((guint) 0x04da)
#define SKK_KEYSYMS_kana_RO ((guint) 0x04db)
#define SKK_KEYSYMS_kana_WA ((guint) 0x04dc)
#define SKK_KEYSYMS_kana_N ((guint) 0x04dd)
#define SKK_KEYSYMS_voicedsound ((guint) 0x04de)
#define SKK_KEYSYMS_semivoicedsound ((guint) 0x04df)
#define SKK_KEYSYMS_kana_switch ((guint) 0xff7e)
#define SKK_KEYSYMS_Farsi_0 ((guint) 0x10006f0)
#define SKK_KEYSYMS_Farsi_1 ((guint) 0x10006f1)
#define SKK_KEYSYMS_Farsi_2 ((guint) 0x10006f2)
#define SKK_KEYSYMS_Farsi_3 ((guint) 0x10006f3)
#define SKK_KEYSYMS_Farsi_4 ((guint) 0x10006f4)
#define SKK_KEYSYMS_Farsi_5 ((guint) 0x10006f5)
#define SKK_KEYSYMS_Farsi_6 ((guint) 0x10006f6)
#define SKK_KEYSYMS_Farsi_7 ((guint) 0x10006f7)
#define SKK_KEYSYMS_Farsi_8 ((guint) 0x10006f8)
#define SKK_KEYSYMS_Farsi_9 ((guint) 0x10006f9)
#define SKK_KEYSYMS_Arabic_percent ((guint) 0x100066a)
#define SKK_KEYSYMS_Arabic_superscript_alef ((guint) 0x1000670)
#define SKK_KEYSYMS_Arabic_tteh ((guint) 0x1000679)
#define SKK_KEYSYMS_Arabic_peh ((guint) 0x100067e)
#define SKK_KEYSYMS_Arabic_tcheh ((guint) 0x1000686)
#define SKK_KEYSYMS_Arabic_ddal ((guint) 0x1000688)
#define SKK_KEYSYMS_Arabic_rreh ((guint) 0x1000691)
#define SKK_KEYSYMS_Arabic_comma ((guint) 0x05ac)
#define SKK_KEYSYMS_Arabic_fullstop ((guint) 0x10006d4)
#define SKK_KEYSYMS_Arabic_0 ((guint) 0x1000660)
#define SKK_KEYSYMS_Arabic_1 ((guint) 0x1000661)
#define SKK_KEYSYMS_Arabic_2 ((guint) 0x1000662)
#define SKK_KEYSYMS_Arabic_3 ((guint) 0x1000663)
#define SKK_KEYSYMS_Arabic_4 ((guint) 0x1000664)
#define SKK_KEYSYMS_Arabic_5 ((guint) 0x1000665)
#define SKK_KEYSYMS_Arabic_6 ((guint) 0x1000666)
#define SKK_KEYSYMS_Arabic_7 ((guint) 0x1000667)
#define SKK_KEYSYMS_Arabic_8 ((guint) 0x1000668)
#define SKK_KEYSYMS_Arabic_9 ((guint) 0x1000669)
#define SKK_KEYSYMS_Arabic_semicolon ((guint) 0x05bb)
#define SKK_KEYSYMS_Arabic_question_mark ((guint) 0x05bf)
#define SKK_KEYSYMS_Arabic_hamza ((guint) 0x05c1)
#define SKK_KEYSYMS_Arabic_maddaonalef ((guint) 0x05c2)
#define SKK_KEYSYMS_Arabic_hamzaonalef ((guint) 0x05c3)
#define SKK_KEYSYMS_Arabic_hamzaonwaw ((guint) 0x05c4)
#define SKK_KEYSYMS_Arabic_hamzaunderalef ((guint) 0x05c5)
#define SKK_KEYSYMS_Arabic_hamzaonyeh ((guint) 0x05c6)
#define SKK_KEYSYMS_Arabic_alef ((guint) 0x05c7)
#define SKK_KEYSYMS_Arabic_beh ((guint) 0x05c8)
#define SKK_KEYSYMS_Arabic_tehmarbuta ((guint) 0x05c9)
#define SKK_KEYSYMS_Arabic_teh ((guint) 0x05ca)
#define SKK_KEYSYMS_Arabic_theh ((guint) 0x05cb)
#define SKK_KEYSYMS_Arabic_jeem ((guint) 0x05cc)
#define SKK_KEYSYMS_Arabic_hah ((guint) 0x05cd)
#define SKK_KEYSYMS_Arabic_khah ((guint) 0x05ce)
#define SKK_KEYSYMS_Arabic_dal ((guint) 0x05cf)
#define SKK_KEYSYMS_Arabic_thal ((guint) 0x05d0)
#define SKK_KEYSYMS_Arabic_ra ((guint) 0x05d1)
#define SKK_KEYSYMS_Arabic_zain ((guint) 0x05d2)
#define SKK_KEYSYMS_Arabic_seen ((guint) 0x05d3)
#define SKK_KEYSYMS_Arabic_sheen ((guint) 0x05d4)
#define SKK_KEYSYMS_Arabic_sad ((guint) 0x05d5)
#define SKK_KEYSYMS_Arabic_dad ((guint) 0x05d6)
#define SKK_KEYSYMS_Arabic_tah ((guint) 0x05d7)
#define SKK_KEYSYMS_Arabic_zah ((guint) 0x05d8)
#define SKK_KEYSYMS_Arabic_ain ((guint) 0x05d9)
#define SKK_KEYSYMS_Arabic_ghain ((guint) 0x05da)
#define SKK_KEYSYMS_Arabic_tatweel ((guint) 0x05e0)
#define SKK_KEYSYMS_Arabic_feh ((guint) 0x05e1)
#define SKK_KEYSYMS_Arabic_qaf ((guint) 0x05e2)
#define SKK_KEYSYMS_Arabic_kaf ((guint) 0x05e3)
#define SKK_KEYSYMS_Arabic_lam ((guint) 0x05e4)
#define SKK_KEYSYMS_Arabic_meem ((guint) 0x05e5)
#define SKK_KEYSYMS_Arabic_noon ((guint) 0x05e6)
#define SKK_KEYSYMS_Arabic_ha ((guint) 0x05e7)
#define SKK_KEYSYMS_Arabic_heh ((guint) 0x05e7)
#define SKK_KEYSYMS_Arabic_waw ((guint) 0x05e8)
#define SKK_KEYSYMS_Arabic_alefmaksura ((guint) 0x05e9)
#define SKK_KEYSYMS_Arabic_yeh ((guint) 0x05ea)
#define SKK_KEYSYMS_Arabic_fathatan ((guint) 0x05eb)
#define SKK_KEYSYMS_Arabic_dammatan ((guint) 0x05ec)
#define SKK_KEYSYMS_Arabic_kasratan ((guint) 0x05ed)
#define SKK_KEYSYMS_Arabic_fatha ((guint) 0x05ee)
#define SKK_KEYSYMS_Arabic_damma ((guint) 0x05ef)
#define SKK_KEYSYMS_Arabic_kasra ((guint) 0x05f0)
#define SKK_KEYSYMS_Arabic_shadda ((guint) 0x05f1)
#define SKK_KEYSYMS_Arabic_sukun ((guint) 0x05f2)
#define SKK_KEYSYMS_Arabic_madda_above ((guint) 0x1000653)
#define SKK_KEYSYMS_Arabic_hamza_above ((guint) 0x1000654)
#define SKK_KEYSYMS_Arabic_hamza_below ((guint) 0x1000655)
#define SKK_KEYSYMS_Arabic_jeh ((guint) 0x1000698)
#define SKK_KEYSYMS_Arabic_veh ((guint) 0x10006a4)
#define SKK_KEYSYMS_Arabic_keheh ((guint) 0x10006a9)
#define SKK_KEYSYMS_Arabic_gaf ((guint) 0x10006af)
#define SKK_KEYSYMS_Arabic_noon_ghunna ((guint) 0x10006ba)
#define SKK_KEYSYMS_Arabic_heh_doachashmee ((guint) 0x10006be)
#define SKK_KEYSYMS_Farsi_yeh ((guint) 0x10006cc)
#define SKK_KEYSYMS_Arabic_farsi_yeh ((guint) 0x10006cc)
#define SKK_KEYSYMS_Arabic_yeh_baree ((guint) 0x10006d2)
#define SKK_KEYSYMS_Arabic_heh_goal ((guint) 0x10006c1)
#define SKK_KEYSYMS_Arabic_switch ((guint) 0xff7e)
#define SKK_KEYSYMS_Cyrillic_GHE_bar ((guint) 0x1000492)
#define SKK_KEYSYMS_Cyrillic_ghe_bar ((guint) 0x1000493)
#define SKK_KEYSYMS_Cyrillic_ZHE_descender ((guint) 0x1000496)
#define SKK_KEYSYMS_Cyrillic_zhe_descender ((guint) 0x1000497)
#define SKK_KEYSYMS_Cyrillic_KA_descender ((guint) 0x100049a)
#define SKK_KEYSYMS_Cyrillic_ka_descender ((guint) 0x100049b)
#define SKK_KEYSYMS_Cyrillic_KA_vertstroke ((guint) 0x100049c)
#define SKK_KEYSYMS_Cyrillic_ka_vertstroke ((guint) 0x100049d)
#define SKK_KEYSYMS_Cyrillic_EN_descender ((guint) 0x10004a2)
#define SKK_KEYSYMS_Cyrillic_en_descender ((guint) 0x10004a3)
#define SKK_KEYSYMS_Cyrillic_U_straight ((guint) 0x10004ae)
#define SKK_KEYSYMS_Cyrillic_u_straight ((guint) 0x10004af)
#define SKK_KEYSYMS_Cyrillic_U_straight_bar ((guint) 0x10004b0)
#define SKK_KEYSYMS_Cyrillic_u_straight_bar ((guint) 0x10004b1)
#define SKK_KEYSYMS_Cyrillic_HA_descender ((guint) 0x10004b2)
#define SKK_KEYSYMS_Cyrillic_ha_descender ((guint) 0x10004b3)
#define SKK_KEYSYMS_Cyrillic_CHE_descender ((guint) 0x10004b6)
#define SKK_KEYSYMS_Cyrillic_che_descender ((guint) 0x10004b7)
#define SKK_KEYSYMS_Cyrillic_CHE_vertstroke ((guint) 0x10004b8)
#define SKK_KEYSYMS_Cyrillic_che_vertstroke ((guint) 0x10004b9)
#define SKK_KEYSYMS_Cyrillic_SHHA ((guint) 0x10004ba)
#define SKK_KEYSYMS_Cyrillic_shha ((guint) 0x10004bb)
#define SKK_KEYSYMS_Cyrillic_SCHWA ((guint) 0x10004d8)
#define SKK_KEYSYMS_Cyrillic_schwa ((guint) 0x10004d9)
#define SKK_KEYSYMS_Cyrillic_I_macron ((guint) 0x10004e2)
#define SKK_KEYSYMS_Cyrillic_i_macron ((guint) 0x10004e3)
#define SKK_KEYSYMS_Cyrillic_O_bar ((guint) 0x10004e8)
#define SKK_KEYSYMS_Cyrillic_o_bar ((guint) 0x10004e9)
#define SKK_KEYSYMS_Cyrillic_U_macron ((guint) 0x10004ee)
#define SKK_KEYSYMS_Cyrillic_u_macron ((guint) 0x10004ef)
#define SKK_KEYSYMS_Serbian_dje ((guint) 0x06a1)
#define SKK_KEYSYMS_Macedonia_gje ((guint) 0x06a2)
#define SKK_KEYSYMS_Cyrillic_io ((guint) 0x06a3)
#define SKK_KEYSYMS_Ukrainian_ie ((guint) 0x06a4)
#define SKK_KEYSYMS_Ukranian_je ((guint) 0x06a4)
#define SKK_KEYSYMS_Macedonia_dse ((guint) 0x06a5)
#define SKK_KEYSYMS_Ukrainian_i ((guint) 0x06a6)
#define SKK_KEYSYMS_Ukranian_i ((guint) 0x06a6)
#define SKK_KEYSYMS_Ukrainian_yi ((guint) 0x06a7)
#define SKK_KEYSYMS_Ukranian_yi ((guint) 0x06a7)
#define SKK_KEYSYMS_Cyrillic_je ((guint) 0x06a8)
#define SKK_KEYSYMS_Serbian_je ((guint) 0x06a8)
#define SKK_KEYSYMS_Cyrillic_lje ((guint) 0x06a9)
#define SKK_KEYSYMS_Serbian_lje ((guint) 0x06a9)
#define SKK_KEYSYMS_Cyrillic_nje ((guint) 0x06aa)
#define SKK_KEYSYMS_Serbian_nje ((guint) 0x06aa)
#define SKK_KEYSYMS_Serbian_tshe ((guint) 0x06ab)
#define SKK_KEYSYMS_Macedonia_kje ((guint) 0x06ac)
#define SKK_KEYSYMS_Ukrainian_ghe_with_upturn ((guint) 0x06ad)
#define SKK_KEYSYMS_Byelorussian_shortu ((guint) 0x06ae)
#define SKK_KEYSYMS_Cyrillic_dzhe ((guint) 0x06af)
#define SKK_KEYSYMS_Serbian_dze ((guint) 0x06af)
#define SKK_KEYSYMS_numerosign ((guint) 0x06b0)
#define SKK_KEYSYMS_Serbian_DJE ((guint) 0x06b1)
#define SKK_KEYSYMS_Macedonia_GJE ((guint) 0x06b2)
#define SKK_KEYSYMS_Cyrillic_IO ((guint) 0x06b3)
#define SKK_KEYSYMS_Ukrainian_IE ((guint) 0x06b4)
#define SKK_KEYSYMS_Ukranian_JE ((guint) 0x06b4)
#define SKK_KEYSYMS_Macedonia_DSE ((guint) 0x06b5)
#define SKK_KEYSYMS_Ukrainian_I ((guint) 0x06b6)
#define SKK_KEYSYMS_Ukranian_I ((guint) 0x06b6)
#define SKK_KEYSYMS_Ukrainian_YI ((guint) 0x06b7)
#define SKK_KEYSYMS_Ukranian_YI ((guint) 0x06b7)
#define SKK_KEYSYMS_Cyrillic_JE ((guint) 0x06b8)
#define SKK_KEYSYMS_Serbian_JE ((guint) 0x06b8)
#define SKK_KEYSYMS_Cyrillic_LJE ((guint) 0x06b9)
#define SKK_KEYSYMS_Serbian_LJE ((guint) 0x06b9)
#define SKK_KEYSYMS_Cyrillic_NJE ((guint) 0x06ba)
#define SKK_KEYSYMS_Serbian_NJE ((guint) 0x06ba)
#define SKK_KEYSYMS_Serbian_TSHE ((guint) 0x06bb)
#define SKK_KEYSYMS_Macedonia_KJE ((guint) 0x06bc)
#define SKK_KEYSYMS_Ukrainian_GHE_WITH_UPTURN ((guint) 0x06bd)
#define SKK_KEYSYMS_Byelorussian_SHORTU ((guint) 0x06be)
#define SKK_KEYSYMS_Cyrillic_DZHE ((guint) 0x06bf)
#define SKK_KEYSYMS_Serbian_DZE ((guint) 0x06bf)
#define SKK_KEYSYMS_Cyrillic_yu ((guint) 0x06c0)
#define SKK_KEYSYMS_Cyrillic_a ((guint) 0x06c1)
#define SKK_KEYSYMS_Cyrillic_be ((guint) 0x06c2)
#define SKK_KEYSYMS_Cyrillic_tse ((guint) 0x06c3)
#define SKK_KEYSYMS_Cyrillic_de ((guint) 0x06c4)
#define SKK_KEYSYMS_Cyrillic_ie ((guint) 0x06c5)
#define SKK_KEYSYMS_Cyrillic_ef ((guint) 0x06c6)
#define SKK_KEYSYMS_Cyrillic_ghe ((guint) 0x06c7)
#define SKK_KEYSYMS_Cyrillic_ha ((guint) 0x06c8)
#define SKK_KEYSYMS_Cyrillic_i ((guint) 0x06c9)
#define SKK_KEYSYMS_Cyrillic_shorti ((guint) 0x06ca)
#define SKK_KEYSYMS_Cyrillic_ka ((guint) 0x06cb)
#define SKK_KEYSYMS_Cyrillic_el ((guint) 0x06cc)
#define SKK_KEYSYMS_Cyrillic_em ((guint) 0x06cd)
#define SKK_KEYSYMS_Cyrillic_en ((guint) 0x06ce)
#define SKK_KEYSYMS_Cyrillic_o ((guint) 0x06cf)
#define SKK_KEYSYMS_Cyrillic_pe ((guint) 0x06d0)
#define SKK_KEYSYMS_Cyrillic_ya ((guint) 0x06d1)
#define SKK_KEYSYMS_Cyrillic_er ((guint) 0x06d2)
#define SKK_KEYSYMS_Cyrillic_es ((guint) 0x06d3)
#define SKK_KEYSYMS_Cyrillic_te ((guint) 0x06d4)
#define SKK_KEYSYMS_Cyrillic_u ((guint) 0x06d5)
#define SKK_KEYSYMS_Cyrillic_zhe ((guint) 0x06d6)
#define SKK_KEYSYMS_Cyrillic_ve ((guint) 0x06d7)
#define SKK_KEYSYMS_Cyrillic_softsign ((guint) 0x06d8)
#define SKK_KEYSYMS_Cyrillic_yeru ((guint) 0x06d9)
#define SKK_KEYSYMS_Cyrillic_ze ((guint) 0x06da)
#define SKK_KEYSYMS_Cyrillic_sha ((guint) 0x06db)
#define SKK_KEYSYMS_Cyrillic_e ((guint) 0x06dc)
#define SKK_KEYSYMS_Cyrillic_shcha ((guint) 0x06dd)
#define SKK_KEYSYMS_Cyrillic_che ((guint) 0x06de)
#define SKK_KEYSYMS_Cyrillic_hardsign ((guint) 0x06df)
#define SKK_KEYSYMS_Cyrillic_YU ((guint) 0x06e0)
#define SKK_KEYSYMS_Cyrillic_A ((guint) 0x06e1)
#define SKK_KEYSYMS_Cyrillic_BE ((guint) 0x06e2)
#define SKK_KEYSYMS_Cyrillic_TSE ((guint) 0x06e3)
#define SKK_KEYSYMS_Cyrillic_DE ((guint) 0x06e4)
#define SKK_KEYSYMS_Cyrillic_IE ((guint) 0x06e5)
#define SKK_KEYSYMS_Cyrillic_EF ((guint) 0x06e6)
#define SKK_KEYSYMS_Cyrillic_GHE ((guint) 0x06e7)
#define SKK_KEYSYMS_Cyrillic_HA ((guint) 0x06e8)
#define SKK_KEYSYMS_Cyrillic_I ((guint) 0x06e9)
#define SKK_KEYSYMS_Cyrillic_SHORTI ((guint) 0x06ea)
#define SKK_KEYSYMS_Cyrillic_KA ((guint) 0x06eb)
#define SKK_KEYSYMS_Cyrillic_EL ((guint) 0x06ec)
#define SKK_KEYSYMS_Cyrillic_EM ((guint) 0x06ed)
#define SKK_KEYSYMS_Cyrillic_EN ((guint) 0x06ee)
#define SKK_KEYSYMS_Cyrillic_O ((guint) 0x06ef)
#define SKK_KEYSYMS_Cyrillic_PE ((guint) 0x06f0)
#define SKK_KEYSYMS_Cyrillic_YA ((guint) 0x06f1)
#define SKK_KEYSYMS_Cyrillic_ER ((guint) 0x06f2)
#define SKK_KEYSYMS_Cyrillic_ES ((guint) 0x06f3)
#define SKK_KEYSYMS_Cyrillic_TE ((guint) 0x06f4)
#define SKK_KEYSYMS_Cyrillic_U ((guint) 0x06f5)
#define SKK_KEYSYMS_Cyrillic_ZHE ((guint) 0x06f6)
#define SKK_KEYSYMS_Cyrillic_VE ((guint) 0x06f7)
#define SKK_KEYSYMS_Cyrillic_SOFTSIGN ((guint) 0x06f8)
#define SKK_KEYSYMS_Cyrillic_YERU ((guint) 0x06f9)
#define SKK_KEYSYMS_Cyrillic_ZE ((guint) 0x06fa)
#define SKK_KEYSYMS_Cyrillic_SHA ((guint) 0x06fb)
#define SKK_KEYSYMS_Cyrillic_E ((guint) 0x06fc)
#define SKK_KEYSYMS_Cyrillic_SHCHA ((guint) 0x06fd)
#define SKK_KEYSYMS_Cyrillic_CHE ((guint) 0x06fe)
#define SKK_KEYSYMS_Cyrillic_HARDSIGN ((guint) 0x06ff)
#define SKK_KEYSYMS_Greek_ALPHAaccent ((guint) 0x07a1)
#define SKK_KEYSYMS_Greek_EPSILONaccent ((guint) 0x07a2)
#define SKK_KEYSYMS_Greek_ETAaccent ((guint) 0x07a3)
#define SKK_KEYSYMS_Greek_IOTAaccent ((guint) 0x07a4)
#define SKK_KEYSYMS_Greek_IOTAdieresis ((guint) 0x07a5)
#define SKK_KEYSYMS_Greek_IOTAdiaeresis ((guint) 0x07a5)
#define SKK_KEYSYMS_Greek_OMICRONaccent ((guint) 0x07a7)
#define SKK_KEYSYMS_Greek_UPSILONaccent ((guint) 0x07a8)
#define SKK_KEYSYMS_Greek_UPSILONdieresis ((guint) 0x07a9)
#define SKK_KEYSYMS_Greek_OMEGAaccent ((guint) 0x07ab)
#define SKK_KEYSYMS_Greek_accentdieresis ((guint) 0x07ae)
#define SKK_KEYSYMS_Greek_horizbar ((guint) 0x07af)
#define SKK_KEYSYMS_Greek_alphaaccent ((guint) 0x07b1)
#define SKK_KEYSYMS_Greek_epsilonaccent ((guint) 0x07b2)
#define SKK_KEYSYMS_Greek_etaaccent ((guint) 0x07b3)
#define SKK_KEYSYMS_Greek_iotaaccent ((guint) 0x07b4)
#define SKK_KEYSYMS_Greek_iotadieresis ((guint) 0x07b5)
#define SKK_KEYSYMS_Greek_iotaaccentdieresis ((guint) 0x07b6)
#define SKK_KEYSYMS_Greek_omicronaccent ((guint) 0x07b7)
#define SKK_KEYSYMS_Greek_upsilonaccent ((guint) 0x07b8)
#define SKK_KEYSYMS_Greek_upsilondieresis ((guint) 0x07b9)
#define SKK_KEYSYMS_Greek_upsilonaccentdieresis ((guint) 0x07ba)
#define SKK_KEYSYMS_Greek_omegaaccent ((guint) 0x07bb)
#define SKK_KEYSYMS_Greek_ALPHA ((guint) 0x07c1)
#define SKK_KEYSYMS_Greek_BETA ((guint) 0x07c2)
#define SKK_KEYSYMS_Greek_GAMMA ((guint) 0x07c3)
#define SKK_KEYSYMS_Greek_DELTA ((guint) 0x07c4)
#define SKK_KEYSYMS_Greek_EPSILON ((guint) 0x07c5)
#define SKK_KEYSYMS_Greek_ZETA ((guint) 0x07c6)
#define SKK_KEYSYMS_Greek_ETA ((guint) 0x07c7)
#define SKK_KEYSYMS_Greek_THETA ((guint) 0x07c8)
#define SKK_KEYSYMS_Greek_IOTA ((guint) 0x07c9)
#define SKK_KEYSYMS_Greek_KAPPA ((guint) 0x07ca)
#define SKK_KEYSYMS_Greek_LAMDA ((guint) 0x07cb)
#define SKK_KEYSYMS_Greek_LAMBDA ((guint) 0x07cb)
#define SKK_KEYSYMS_Greek_MU ((guint) 0x07cc)
#define SKK_KEYSYMS_Greek_NU ((guint) 0x07cd)
#define SKK_KEYSYMS_Greek_XI ((guint) 0x07ce)
#define SKK_KEYSYMS_Greek_OMICRON ((guint) 0x07cf)
#define SKK_KEYSYMS_Greek_PI ((guint) 0x07d0)
#define SKK_KEYSYMS_Greek_RHO ((guint) 0x07d1)
#define SKK_KEYSYMS_Greek_SIGMA ((guint) 0x07d2)
#define SKK_KEYSYMS_Greek_TAU ((guint) 0x07d4)
#define SKK_KEYSYMS_Greek_UPSILON ((guint) 0x07d5)
#define SKK_KEYSYMS_Greek_PHI ((guint) 0x07d6)
#define SKK_KEYSYMS_Greek_CHI ((guint) 0x07d7)
#define SKK_KEYSYMS_Greek_PSI ((guint) 0x07d8)
#define SKK_KEYSYMS_Greek_OMEGA ((guint) 0x07d9)
#define SKK_KEYSYMS_Greek_alpha ((guint) 0x07e1)
#define SKK_KEYSYMS_Greek_beta ((guint) 0x07e2)
#define SKK_KEYSYMS_Greek_gamma ((guint) 0x07e3)
#define SKK_KEYSYMS_Greek_delta ((guint) 0x07e4)
#define SKK_KEYSYMS_Greek_epsilon ((guint) 0x07e5)
#define SKK_KEYSYMS_Greek_zeta ((guint) 0x07e6)
#define SKK_KEYSYMS_Greek_eta ((guint) 0x07e7)
#define SKK_KEYSYMS_Greek_theta ((guint) 0x07e8)
#define SKK_KEYSYMS_Greek_iota ((guint) 0x07e9)
#define SKK_KEYSYMS_Greek_kappa ((guint) 0x07ea)
#define SKK_KEYSYMS_Greek_lamda ((guint) 0x07eb)
#define SKK_KEYSYMS_Greek_lambda ((guint) 0x07eb)
#define SKK_KEYSYMS_Greek_mu ((guint) 0x07ec)
#define SKK_KEYSYMS_Greek_nu ((guint) 0x07ed)
#define SKK_KEYSYMS_Greek_xi ((guint) 0x07ee)
#define SKK_KEYSYMS_Greek_omicron ((guint) 0x07ef)
#define SKK_KEYSYMS_Greek_pi ((guint) 0x07f0)
#define SKK_KEYSYMS_Greek_rho ((guint) 0x07f1)
#define SKK_KEYSYMS_Greek_sigma ((guint) 0x07f2)
#define SKK_KEYSYMS_Greek_finalsmallsigma ((guint) 0x07f3)
#define SKK_KEYSYMS_Greek_tau ((guint) 0x07f4)
#define SKK_KEYSYMS_Greek_upsilon ((guint) 0x07f5)
#define SKK_KEYSYMS_Greek_phi ((guint) 0x07f6)
#define SKK_KEYSYMS_Greek_chi ((guint) 0x07f7)
#define SKK_KEYSYMS_Greek_psi ((guint) 0x07f8)
#define SKK_KEYSYMS_Greek_omega ((guint) 0x07f9)
#define SKK_KEYSYMS_Greek_switch ((guint) 0xff7e)
#define SKK_KEYSYMS_leftradical ((guint) 0x08a1)
#define SKK_KEYSYMS_topleftradical ((guint) 0x08a2)
#define SKK_KEYSYMS_horizconnector ((guint) 0x08a3)
#define SKK_KEYSYMS_topintegral ((guint) 0x08a4)
#define SKK_KEYSYMS_botintegral ((guint) 0x08a5)
#define SKK_KEYSYMS_vertconnector ((guint) 0x08a6)
#define SKK_KEYSYMS_topleftsqbracket ((guint) 0x08a7)
#define SKK_KEYSYMS_botleftsqbracket ((guint) 0x08a8)
#define SKK_KEYSYMS_toprightsqbracket ((guint) 0x08a9)
#define SKK_KEYSYMS_botrightsqbracket ((guint) 0x08aa)
#define SKK_KEYSYMS_topleftparens ((guint) 0x08ab)
#define SKK_KEYSYMS_botleftparens ((guint) 0x08ac)
#define SKK_KEYSYMS_toprightparens ((guint) 0x08ad)
#define SKK_KEYSYMS_botrightparens ((guint) 0x08ae)
#define SKK_KEYSYMS_leftmiddlecurlybrace ((guint) 0x08af)
#define SKK_KEYSYMS_rightmiddlecurlybrace ((guint) 0x08b0)
#define SKK_KEYSYMS_topleftsummation ((guint) 0x08b1)
#define SKK_KEYSYMS_botleftsummation ((guint) 0x08b2)
#define SKK_KEYSYMS_topvertsummationconnector ((guint) 0x08b3)
#define SKK_KEYSYMS_botvertsummationconnector ((guint) 0x08b4)
#define SKK_KEYSYMS_toprightsummation ((guint) 0x08b5)
#define SKK_KEYSYMS_botrightsummation ((guint) 0x08b6)
#define SKK_KEYSYMS_rightmiddlesummation ((guint) 0x08b7)
#define SKK_KEYSYMS_lessthanequal ((guint) 0x08bc)
#define SKK_KEYSYMS_notequal ((guint) 0x08bd)
#define SKK_KEYSYMS_greaterthanequal ((guint) 0x08be)
#define SKK_KEYSYMS_integral ((guint) 0x08bf)
#define SKK_KEYSYMS_therefore ((guint) 0x08c0)
#define SKK_KEYSYMS_variation ((guint) 0x08c1)
#define SKK_KEYSYMS_infinity ((guint) 0x08c2)
#define SKK_KEYSYMS_nabla ((guint) 0x08c5)
#define SKK_KEYSYMS_approximate ((guint) 0x08c8)
#define SKK_KEYSYMS_similarequal ((guint) 0x08c9)
#define SKK_KEYSYMS_ifonlyif ((guint) 0x08cd)
#define SKK_KEYSYMS_implies ((guint) 0x08ce)
#define SKK_KEYSYMS_identical ((guint) 0x08cf)
#define SKK_KEYSYMS_radical ((guint) 0x08d6)
#define SKK_KEYSYMS_includedin ((guint) 0x08da)
#define SKK_KEYSYMS_includes ((guint) 0x08db)
#define SKK_KEYSYMS_intersection ((guint) 0x08dc)
#define SKK_KEYSYMS_union ((guint) 0x08dd)
#define SKK_KEYSYMS_logicaland ((guint) 0x08de)
#define SKK_KEYSYMS_logicalor ((guint) 0x08df)
#define SKK_KEYSYMS_partialderivative ((guint) 0x08ef)
#define SKK_KEYSYMS_function ((guint) 0x08f6)
#define SKK_KEYSYMS_leftarrow ((guint) 0x08fb)
#define SKK_KEYSYMS_uparrow ((guint) 0x08fc)
#define SKK_KEYSYMS_rightarrow ((guint) 0x08fd)
#define SKK_KEYSYMS_downarrow ((guint) 0x08fe)
#define SKK_KEYSYMS_blank ((guint) 0x09df)
#define SKK_KEYSYMS_soliddiamond ((guint) 0x09e0)
#define SKK_KEYSYMS_checkerboard ((guint) 0x09e1)
#define SKK_KEYSYMS_ht ((guint) 0x09e2)
#define SKK_KEYSYMS_ff ((guint) 0x09e3)
#define SKK_KEYSYMS_cr ((guint) 0x09e4)
#define SKK_KEYSYMS_lf ((guint) 0x09e5)
#define SKK_KEYSYMS_nl ((guint) 0x09e8)
#define SKK_KEYSYMS_vt ((guint) 0x09e9)
#define SKK_KEYSYMS_lowrightcorner ((guint) 0x09ea)
#define SKK_KEYSYMS_uprightcorner ((guint) 0x09eb)
#define SKK_KEYSYMS_upleftcorner ((guint) 0x09ec)
#define SKK_KEYSYMS_lowleftcorner ((guint) 0x09ed)
#define SKK_KEYSYMS_crossinglines ((guint) 0x09ee)
#define SKK_KEYSYMS_horizlinescan1 ((guint) 0x09ef)
#define SKK_KEYSYMS_horizlinescan3 ((guint) 0x09f0)
#define SKK_KEYSYMS_horizlinescan5 ((guint) 0x09f1)
#define SKK_KEYSYMS_horizlinescan7 ((guint) 0x09f2)
#define SKK_KEYSYMS_horizlinescan9 ((guint) 0x09f3)
#define SKK_KEYSYMS_leftt ((guint) 0x09f4)
#define SKK_KEYSYMS_rightt ((guint) 0x09f5)
#define SKK_KEYSYMS_bott ((guint) 0x09f6)
#define SKK_KEYSYMS_topt ((guint) 0x09f7)
#define SKK_KEYSYMS_vertbar ((guint) 0x09f8)
#define SKK_KEYSYMS_emspace ((guint) 0x0aa1)
#define SKK_KEYSYMS_enspace ((guint) 0x0aa2)
#define SKK_KEYSYMS_em3space ((guint) 0x0aa3)
#define SKK_KEYSYMS_em4space ((guint) 0x0aa4)
#define SKK_KEYSYMS_digitspace ((guint) 0x0aa5)
#define SKK_KEYSYMS_punctspace ((guint) 0x0aa6)
#define SKK_KEYSYMS_thinspace ((guint) 0x0aa7)
#define SKK_KEYSYMS_hairspace ((guint) 0x0aa8)
#define SKK_KEYSYMS_emdash ((guint) 0x0aa9)
#define SKK_KEYSYMS_endash ((guint) 0x0aaa)
#define SKK_KEYSYMS_signifblank ((guint) 0x0aac)
#define SKK_KEYSYMS_ellipsis ((guint) 0x0aae)
#define SKK_KEYSYMS_doubbaselinedot ((guint) 0x0aaf)
#define SKK_KEYSYMS_onethird ((guint) 0x0ab0)
#define SKK_KEYSYMS_twothirds ((guint) 0x0ab1)
#define SKK_KEYSYMS_onefifth ((guint) 0x0ab2)
#define SKK_KEYSYMS_twofifths ((guint) 0x0ab3)
#define SKK_KEYSYMS_threefifths ((guint) 0x0ab4)
#define SKK_KEYSYMS_fourfifths ((guint) 0x0ab5)
#define SKK_KEYSYMS_onesixth ((guint) 0x0ab6)
#define SKK_KEYSYMS_fivesixths ((guint) 0x0ab7)
#define SKK_KEYSYMS_careof ((guint) 0x0ab8)
#define SKK_KEYSYMS_figdash ((guint) 0x0abb)
#define SKK_KEYSYMS_leftanglebracket ((guint) 0x0abc)
#define SKK_KEYSYMS_decimalpoint ((guint) 0x0abd)
#define SKK_KEYSYMS_rightanglebracket ((guint) 0x0abe)
#define SKK_KEYSYMS_marker ((guint) 0x0abf)
#define SKK_KEYSYMS_oneeighth ((guint) 0x0ac3)
#define SKK_KEYSYMS_threeeighths ((guint) 0x0ac4)
#define SKK_KEYSYMS_fiveeighths ((guint) 0x0ac5)
#define SKK_KEYSYMS_seveneighths ((guint) 0x0ac6)
#define SKK_KEYSYMS_trademark ((guint) 0x0ac9)
#define SKK_KEYSYMS_signaturemark ((guint) 0x0aca)
#define SKK_KEYSYMS_trademarkincircle ((guint) 0x0acb)
#define SKK_KEYSYMS_leftopentriangle ((guint) 0x0acc)
#define SKK_KEYSYMS_rightopentriangle ((guint) 0x0acd)
#define SKK_KEYSYMS_emopencircle ((guint) 0x0ace)
#define SKK_KEYSYMS_emopenrectangle ((guint) 0x0acf)
#define SKK_KEYSYMS_leftsinglequotemark ((guint) 0x0ad0)
#define SKK_KEYSYMS_rightsinglequotemark ((guint) 0x0ad1)
#define SKK_KEYSYMS_leftdoublequotemark ((guint) 0x0ad2)
#define SKK_KEYSYMS_rightdoublequotemark ((guint) 0x0ad3)
#define SKK_KEYSYMS_prescription ((guint) 0x0ad4)
#define SKK_KEYSYMS_minutes ((guint) 0x0ad6)
#define SKK_KEYSYMS_seconds ((guint) 0x0ad7)
#define SKK_KEYSYMS_latincross ((guint) 0x0ad9)
#define SKK_KEYSYMS_hexagram ((guint) 0x0ada)
#define SKK_KEYSYMS_filledrectbullet ((guint) 0x0adb)
#define SKK_KEYSYMS_filledlefttribullet ((guint) 0x0adc)
#define SKK_KEYSYMS_filledrighttribullet ((guint) 0x0add)
#define SKK_KEYSYMS_emfilledcircle ((guint) 0x0ade)
#define SKK_KEYSYMS_emfilledrect ((guint) 0x0adf)
#define SKK_KEYSYMS_enopencircbullet ((guint) 0x0ae0)
#define SKK_KEYSYMS_enopensquarebullet ((guint) 0x0ae1)
#define SKK_KEYSYMS_openrectbullet ((guint) 0x0ae2)
#define SKK_KEYSYMS_opentribulletup ((guint) 0x0ae3)
#define SKK_KEYSYMS_opentribulletdown ((guint) 0x0ae4)
#define SKK_KEYSYMS_openstar ((guint) 0x0ae5)
#define SKK_KEYSYMS_enfilledcircbullet ((guint) 0x0ae6)
#define SKK_KEYSYMS_enfilledsqbullet ((guint) 0x0ae7)
#define SKK_KEYSYMS_filledtribulletup ((guint) 0x0ae8)
#define SKK_KEYSYMS_filledtribulletdown ((guint) 0x0ae9)
#define SKK_KEYSYMS_leftpointer ((guint) 0x0aea)
#define SKK_KEYSYMS_rightpointer ((guint) 0x0aeb)
#define SKK_KEYSYMS_club ((guint) 0x0aec)
#define SKK_KEYSYMS_diamond ((guint) 0x0aed)
#define SKK_KEYSYMS_heart ((guint) 0x0aee)
#define SKK_KEYSYMS_maltesecross ((guint) 0x0af0)
#define SKK_KEYSYMS_dagger ((guint) 0x0af1)
#define SKK_KEYSYMS_doubledagger ((guint) 0x0af2)
#define SKK_KEYSYMS_checkmark ((guint) 0x0af3)
#define SKK_KEYSYMS_ballotcross ((guint) 0x0af4)
#define SKK_KEYSYMS_musicalsharp ((guint) 0x0af5)
#define SKK_KEYSYMS_musicalflat ((guint) 0x0af6)
#define SKK_KEYSYMS_malesymbol ((guint) 0x0af7)
#define SKK_KEYSYMS_femalesymbol ((guint) 0x0af8)
#define SKK_KEYSYMS_telephone ((guint) 0x0af9)
#define SKK_KEYSYMS_telephonerecorder ((guint) 0x0afa)
#define SKK_KEYSYMS_phonographcopyright ((guint) 0x0afb)
#define SKK_KEYSYMS_caret ((guint) 0x0afc)
#define SKK_KEYSYMS_singlelowquotemark ((guint) 0x0afd)
#define SKK_KEYSYMS_doublelowquotemark ((guint) 0x0afe)
#define SKK_KEYSYMS_cursor ((guint) 0x0aff)
#define SKK_KEYSYMS_leftcaret ((guint) 0x0ba3)
#define SKK_KEYSYMS_rightcaret ((guint) 0x0ba6)
#define SKK_KEYSYMS_downcaret ((guint) 0x0ba8)
#define SKK_KEYSYMS_upcaret ((guint) 0x0ba9)
#define SKK_KEYSYMS_overbar ((guint) 0x0bc0)
#define SKK_KEYSYMS_downtack ((guint) 0x0bc2)
#define SKK_KEYSYMS_upshoe ((guint) 0x0bc3)
#define SKK_KEYSYMS_downstile ((guint) 0x0bc4)
#define SKK_KEYSYMS_underbar ((guint) 0x0bc6)
#define SKK_KEYSYMS_jot ((guint) 0x0bca)
#define SKK_KEYSYMS_quad ((guint) 0x0bcc)
#define SKK_KEYSYMS_uptack ((guint) 0x0bce)
#define SKK_KEYSYMS_circle ((guint) 0x0bcf)
#define SKK_KEYSYMS_upstile ((guint) 0x0bd3)
#define SKK_KEYSYMS_downshoe ((guint) 0x0bd6)
#define SKK_KEYSYMS_rightshoe ((guint) 0x0bd8)
#define SKK_KEYSYMS_leftshoe ((guint) 0x0bda)
#define SKK_KEYSYMS_lefttack ((guint) 0x0bdc)
#define SKK_KEYSYMS_righttack ((guint) 0x0bfc)
#define SKK_KEYSYMS_hebrew_doublelowline ((guint) 0x0cdf)
#define SKK_KEYSYMS_hebrew_aleph ((guint) 0x0ce0)
#define SKK_KEYSYMS_hebrew_bet ((guint) 0x0ce1)
#define SKK_KEYSYMS_hebrew_beth ((guint) 0x0ce1)
#define SKK_KEYSYMS_hebrew_gimel ((guint) 0x0ce2)
#define SKK_KEYSYMS_hebrew_gimmel ((guint) 0x0ce2)
#define SKK_KEYSYMS_hebrew_dalet ((guint) 0x0ce3)
#define SKK_KEYSYMS_hebrew_daleth ((guint) 0x0ce3)
#define SKK_KEYSYMS_hebrew_he ((guint) 0x0ce4)
#define SKK_KEYSYMS_hebrew_waw ((guint) 0x0ce5)
#define SKK_KEYSYMS_hebrew_zain ((guint) 0x0ce6)
#define SKK_KEYSYMS_hebrew_zayin ((guint) 0x0ce6)
#define SKK_KEYSYMS_hebrew_chet ((guint) 0x0ce7)
#define SKK_KEYSYMS_hebrew_het ((guint) 0x0ce7)
#define SKK_KEYSYMS_hebrew_tet ((guint) 0x0ce8)
#define SKK_KEYSYMS_hebrew_teth ((guint) 0x0ce8)
#define SKK_KEYSYMS_hebrew_yod ((guint) 0x0ce9)
#define SKK_KEYSYMS_hebrew_finalkaph ((guint) 0x0cea)
#define SKK_KEYSYMS_hebrew_kaph ((guint) 0x0ceb)
#define SKK_KEYSYMS_hebrew_lamed ((guint) 0x0cec)
#define SKK_KEYSYMS_hebrew_finalmem ((guint) 0x0ced)
#define SKK_KEYSYMS_hebrew_mem ((guint) 0x0cee)
#define SKK_KEYSYMS_hebrew_finalnun ((guint) 0x0cef)
#define SKK_KEYSYMS_hebrew_nun ((guint) 0x0cf0)
#define SKK_KEYSYMS_hebrew_samech ((guint) 0x0cf1)
#define SKK_KEYSYMS_hebrew_samekh ((guint) 0x0cf1)
#define SKK_KEYSYMS_hebrew_ayin ((guint) 0x0cf2)
#define SKK_KEYSYMS_hebrew_finalpe ((guint) 0x0cf3)
#define SKK_KEYSYMS_hebrew_pe ((guint) 0x0cf4)
#define SKK_KEYSYMS_hebrew_finalzade ((guint) 0x0cf5)
#define SKK_KEYSYMS_hebrew_finalzadi ((guint) 0x0cf5)
#define SKK_KEYSYMS_hebrew_zade ((guint) 0x0cf6)
#define SKK_KEYSYMS_hebrew_zadi ((guint) 0x0cf6)
#define SKK_KEYSYMS_hebrew_qoph ((guint) 0x0cf7)
#define SKK_KEYSYMS_hebrew_kuf ((guint) 0x0cf7)
#define SKK_KEYSYMS_hebrew_resh ((guint) 0x0cf8)
#define SKK_KEYSYMS_hebrew_shin ((guint) 0x0cf9)
#define SKK_KEYSYMS_hebrew_taw ((guint) 0x0cfa)
#define SKK_KEYSYMS_hebrew_taf ((guint) 0x0cfa)
#define SKK_KEYSYMS_Hebrew_switch ((guint) 0xff7e)
#define SKK_KEYSYMS_Thai_kokai ((guint) 0x0da1)
#define SKK_KEYSYMS_Thai_khokhai ((guint) 0x0da2)
#define SKK_KEYSYMS_Thai_khokhuat ((guint) 0x0da3)
#define SKK_KEYSYMS_Thai_khokhwai ((guint) 0x0da4)
#define SKK_KEYSYMS_Thai_khokhon ((guint) 0x0da5)
#define SKK_KEYSYMS_Thai_khorakhang ((guint) 0x0da6)
#define SKK_KEYSYMS_Thai_ngongu ((guint) 0x0da7)
#define SKK_KEYSYMS_Thai_chochan ((guint) 0x0da8)
#define SKK_KEYSYMS_Thai_choching ((guint) 0x0da9)
#define SKK_KEYSYMS_Thai_chochang ((guint) 0x0daa)
#define SKK_KEYSYMS_Thai_soso ((guint) 0x0dab)
#define SKK_KEYSYMS_Thai_chochoe ((guint) 0x0dac)
#define SKK_KEYSYMS_Thai_yoying ((guint) 0x0dad)
#define SKK_KEYSYMS_Thai_dochada ((guint) 0x0dae)
#define SKK_KEYSYMS_Thai_topatak ((guint) 0x0daf)
#define SKK_KEYSYMS_Thai_thothan ((guint) 0x0db0)
#define SKK_KEYSYMS_Thai_thonangmontho ((guint) 0x0db1)
#define SKK_KEYSYMS_Thai_thophuthao ((guint) 0x0db2)
#define SKK_KEYSYMS_Thai_nonen ((guint) 0x0db3)
#define SKK_KEYSYMS_Thai_dodek ((guint) 0x0db4)
#define SKK_KEYSYMS_Thai_totao ((guint) 0x0db5)
#define SKK_KEYSYMS_Thai_thothung ((guint) 0x0db6)
#define SKK_KEYSYMS_Thai_thothahan ((guint) 0x0db7)
#define SKK_KEYSYMS_Thai_thothong ((guint) 0x0db8)
#define SKK_KEYSYMS_Thai_nonu ((guint) 0x0db9)
#define SKK_KEYSYMS_Thai_bobaimai ((guint) 0x0dba)
#define SKK_KEYSYMS_Thai_popla ((guint) 0x0dbb)
#define SKK_KEYSYMS_Thai_phophung ((guint) 0x0dbc)
#define SKK_KEYSYMS_Thai_fofa ((guint) 0x0dbd)
#define SKK_KEYSYMS_Thai_phophan ((guint) 0x0dbe)
#define SKK_KEYSYMS_Thai_fofan ((guint) 0x0dbf)
#define SKK_KEYSYMS_Thai_phosamphao ((guint) 0x0dc0)
#define SKK_KEYSYMS_Thai_moma ((guint) 0x0dc1)
#define SKK_KEYSYMS_Thai_yoyak ((guint) 0x0dc2)
#define SKK_KEYSYMS_Thai_rorua ((guint) 0x0dc3)
#define SKK_KEYSYMS_Thai_ru ((guint) 0x0dc4)
#define SKK_KEYSYMS_Thai_loling ((guint) 0x0dc5)
#define SKK_KEYSYMS_Thai_lu ((guint) 0x0dc6)
#define SKK_KEYSYMS_Thai_wowaen ((guint) 0x0dc7)
#define SKK_KEYSYMS_Thai_sosala ((guint) 0x0dc8)
#define SKK_KEYSYMS_Thai_sorusi ((guint) 0x0dc9)
#define SKK_KEYSYMS_Thai_sosua ((guint) 0x0dca)
#define SKK_KEYSYMS_Thai_hohip ((guint) 0x0dcb)
#define SKK_KEYSYMS_Thai_lochula ((guint) 0x0dcc)
#define SKK_KEYSYMS_Thai_oang ((guint) 0x0dcd)
#define SKK_KEYSYMS_Thai_honokhuk ((guint) 0x0dce)
#define SKK_KEYSYMS_Thai_paiyannoi ((guint) 0x0dcf)
#define SKK_KEYSYMS_Thai_saraa ((guint) 0x0dd0)
#define SKK_KEYSYMS_Thai_maihanakat ((guint) 0x0dd1)
#define SKK_KEYSYMS_Thai_saraaa ((guint) 0x0dd2)
#define SKK_KEYSYMS_Thai_saraam ((guint) 0x0dd3)
#define SKK_KEYSYMS_Thai_sarai ((guint) 0x0dd4)
#define SKK_KEYSYMS_Thai_saraii ((guint) 0x0dd5)
#define SKK_KEYSYMS_Thai_saraue ((guint) 0x0dd6)
#define SKK_KEYSYMS_Thai_sarauee ((guint) 0x0dd7)
#define SKK_KEYSYMS_Thai_sarau ((guint) 0x0dd8)
#define SKK_KEYSYMS_Thai_sarauu ((guint) 0x0dd9)
#define SKK_KEYSYMS_Thai_phinthu ((guint) 0x0dda)
#define SKK_KEYSYMS_Thai_maihanakat_maitho ((guint) 0x0dde)
#define SKK_KEYSYMS_Thai_baht ((guint) 0x0ddf)
#define SKK_KEYSYMS_Thai_sarae ((guint) 0x0de0)
#define SKK_KEYSYMS_Thai_saraae ((guint) 0x0de1)
#define SKK_KEYSYMS_Thai_sarao ((guint) 0x0de2)
#define SKK_KEYSYMS_Thai_saraaimaimuan ((guint) 0x0de3)
#define SKK_KEYSYMS_Thai_saraaimaimalai ((guint) 0x0de4)
#define SKK_KEYSYMS_Thai_lakkhangyao ((guint) 0x0de5)
#define SKK_KEYSYMS_Thai_maiyamok ((guint) 0x0de6)
#define SKK_KEYSYMS_Thai_maitaikhu ((guint) 0x0de7)
#define SKK_KEYSYMS_Thai_maiek ((guint) 0x0de8)
#define SKK_KEYSYMS_Thai_maitho ((guint) 0x0de9)
#define SKK_KEYSYMS_Thai_maitri ((guint) 0x0dea)
#define SKK_KEYSYMS_Thai_maichattawa ((guint) 0x0deb)
#define SKK_KEYSYMS_Thai_thanthakhat ((guint) 0x0dec)
#define SKK_KEYSYMS_Thai_nikhahit ((guint) 0x0ded)
#define SKK_KEYSYMS_Thai_leksun ((guint) 0x0df0)
#define SKK_KEYSYMS_Thai_leknung ((guint) 0x0df1)
#define SKK_KEYSYMS_Thai_leksong ((guint) 0x0df2)
#define SKK_KEYSYMS_Thai_leksam ((guint) 0x0df3)
#define SKK_KEYSYMS_Thai_leksi ((guint) 0x0df4)
#define SKK_KEYSYMS_Thai_lekha ((guint) 0x0df5)
#define SKK_KEYSYMS_Thai_lekhok ((guint) 0x0df6)
#define SKK_KEYSYMS_Thai_lekchet ((guint) 0x0df7)
#define SKK_KEYSYMS_Thai_lekpaet ((guint) 0x0df8)
#define SKK_KEYSYMS_Thai_lekkao ((guint) 0x0df9)
#define SKK_KEYSYMS_Hangul ((guint) 0xff31)
#define SKK_KEYSYMS_Hangul_Start ((guint) 0xff32)
#define SKK_KEYSYMS_Hangul_End ((guint) 0xff33)
#define SKK_KEYSYMS_Hangul_Hanja ((guint) 0xff34)
#define SKK_KEYSYMS_Hangul_Jamo ((guint) 0xff35)
#define SKK_KEYSYMS_Hangul_Romaja ((guint) 0xff36)
#define SKK_KEYSYMS_Hangul_Codeinput ((guint) 0xff37)
#define SKK_KEYSYMS_Hangul_Jeonja ((guint) 0xff38)
#define SKK_KEYSYMS_Hangul_Banja ((guint) 0xff39)
#define SKK_KEYSYMS_Hangul_PreHanja ((guint) 0xff3a)
#define SKK_KEYSYMS_Hangul_PostHanja ((guint) 0xff3b)
#define SKK_KEYSYMS_Hangul_SingleCandidate ((guint) 0xff3c)
#define SKK_KEYSYMS_Hangul_MultipleCandidate ((guint) 0xff3d)
#define SKK_KEYSYMS_Hangul_PreviousCandidate ((guint) 0xff3e)
#define SKK_KEYSYMS_Hangul_Special ((guint) 0xff3f)
#define SKK_KEYSYMS_Hangul_switch ((guint) 0xff7e)
#define SKK_KEYSYMS_Hangul_Kiyeog ((guint) 0x0ea1)
#define SKK_KEYSYMS_Hangul_SsangKiyeog ((guint) 0x0ea2)
#define SKK_KEYSYMS_Hangul_KiyeogSios ((guint) 0x0ea3)
#define SKK_KEYSYMS_Hangul_Nieun ((guint) 0x0ea4)
#define SKK_KEYSYMS_Hangul_NieunJieuj ((guint) 0x0ea5)
#define SKK_KEYSYMS_Hangul_NieunHieuh ((guint) 0x0ea6)
#define SKK_KEYSYMS_Hangul_Dikeud ((guint) 0x0ea7)
#define SKK_KEYSYMS_Hangul_SsangDikeud ((guint) 0x0ea8)
#define SKK_KEYSYMS_Hangul_Rieul ((guint) 0x0ea9)
#define SKK_KEYSYMS_Hangul_RieulKiyeog ((guint) 0x0eaa)
#define SKK_KEYSYMS_Hangul_RieulMieum ((guint) 0x0eab)
#define SKK_KEYSYMS_Hangul_RieulPieub ((guint) 0x0eac)
#define SKK_KEYSYMS_Hangul_RieulSios ((guint) 0x0ead)
#define SKK_KEYSYMS_Hangul_RieulTieut ((guint) 0x0eae)
#define SKK_KEYSYMS_Hangul_RieulPhieuf ((guint) 0x0eaf)
#define SKK_KEYSYMS_Hangul_RieulHieuh ((guint) 0x0eb0)
#define SKK_KEYSYMS_Hangul_Mieum ((guint) 0x0eb1)
#define SKK_KEYSYMS_Hangul_Pieub ((guint) 0x0eb2)
#define SKK_KEYSYMS_Hangul_SsangPieub ((guint) 0x0eb3)
#define SKK_KEYSYMS_Hangul_PieubSios ((guint) 0x0eb4)
#define SKK_KEYSYMS_Hangul_Sios ((guint) 0x0eb5)
#define SKK_KEYSYMS_Hangul_SsangSios ((guint) 0x0eb6)
#define SKK_KEYSYMS_Hangul_Ieung ((guint) 0x0eb7)
#define SKK_KEYSYMS_Hangul_Jieuj ((guint) 0x0eb8)
#define SKK_KEYSYMS_Hangul_SsangJieuj ((guint) 0x0eb9)
#define SKK_KEYSYMS_Hangul_Cieuc ((guint) 0x0eba)
#define SKK_KEYSYMS_Hangul_Khieuq ((guint) 0x0ebb)
#define SKK_KEYSYMS_Hangul_Tieut ((guint) 0x0ebc)
#define SKK_KEYSYMS_Hangul_Phieuf ((guint) 0x0ebd)
#define SKK_KEYSYMS_Hangul_Hieuh ((guint) 0x0ebe)
#define SKK_KEYSYMS_Hangul_A ((guint) 0x0ebf)
#define SKK_KEYSYMS_Hangul_AE ((guint) 0x0ec0)
#define SKK_KEYSYMS_Hangul_YA ((guint) 0x0ec1)
#define SKK_KEYSYMS_Hangul_YAE ((guint) 0x0ec2)
#define SKK_KEYSYMS_Hangul_EO ((guint) 0x0ec3)
#define SKK_KEYSYMS_Hangul_E ((guint) 0x0ec4)
#define SKK_KEYSYMS_Hangul_YEO ((guint) 0x0ec5)
#define SKK_KEYSYMS_Hangul_YE ((guint) 0x0ec6)
#define SKK_KEYSYMS_Hangul_O ((guint) 0x0ec7)
#define SKK_KEYSYMS_Hangul_WA ((guint) 0x0ec8)
#define SKK_KEYSYMS_Hangul_WAE ((guint) 0x0ec9)
#define SKK_KEYSYMS_Hangul_OE ((guint) 0x0eca)
#define SKK_KEYSYMS_Hangul_YO ((guint) 0x0ecb)
#define SKK_KEYSYMS_Hangul_U ((guint) 0x0ecc)
#define SKK_KEYSYMS_Hangul_WEO ((guint) 0x0ecd)
#define SKK_KEYSYMS_Hangul_WE ((guint) 0x0ece)
#define SKK_KEYSYMS_Hangul_WI ((guint) 0x0ecf)
#define SKK_KEYSYMS_Hangul_YU ((guint) 0x0ed0)
#define SKK_KEYSYMS_Hangul_EU ((guint) 0x0ed1)
#define SKK_KEYSYMS_Hangul_YI ((guint) 0x0ed2)
#define SKK_KEYSYMS_Hangul_I ((guint) 0x0ed3)
#define SKK_KEYSYMS_Hangul_J_Kiyeog ((guint) 0x0ed4)
#define SKK_KEYSYMS_Hangul_J_SsangKiyeog ((guint) 0x0ed5)
#define SKK_KEYSYMS_Hangul_J_KiyeogSios ((guint) 0x0ed6)
#define SKK_KEYSYMS_Hangul_J_Nieun ((guint) 0x0ed7)
#define SKK_KEYSYMS_Hangul_J_NieunJieuj ((guint) 0x0ed8)
#define SKK_KEYSYMS_Hangul_J_NieunHieuh ((guint) 0x0ed9)
#define SKK_KEYSYMS_Hangul_J_Dikeud ((guint) 0x0eda)
#define SKK_KEYSYMS_Hangul_J_Rieul ((guint) 0x0edb)
#define SKK_KEYSYMS_Hangul_J_RieulKiyeog ((guint) 0x0edc)
#define SKK_KEYSYMS_Hangul_J_RieulMieum ((guint) 0x0edd)
#define SKK_KEYSYMS_Hangul_J_RieulPieub ((guint) 0x0ede)
#define SKK_KEYSYMS_Hangul_J_RieulSios ((guint) 0x0edf)
#define SKK_KEYSYMS_Hangul_J_RieulTieut ((guint) 0x0ee0)
#define SKK_KEYSYMS_Hangul_J_RieulPhieuf ((guint) 0x0ee1)
#define SKK_KEYSYMS_Hangul_J_RieulHieuh ((guint) 0x0ee2)
#define SKK_KEYSYMS_Hangul_J_Mieum ((guint) 0x0ee3)
#define SKK_KEYSYMS_Hangul_J_Pieub ((guint) 0x0ee4)
#define SKK_KEYSYMS_Hangul_J_PieubSios ((guint) 0x0ee5)
#define SKK_KEYSYMS_Hangul_J_Sios ((guint) 0x0ee6)
#define SKK_KEYSYMS_Hangul_J_SsangSios ((guint) 0x0ee7)
#define SKK_KEYSYMS_Hangul_J_Ieung ((guint) 0x0ee8)
#define SKK_KEYSYMS_Hangul_J_Jieuj ((guint) 0x0ee9)
#define SKK_KEYSYMS_Hangul_J_Cieuc ((guint) 0x0eea)
#define SKK_KEYSYMS_Hangul_J_Khieuq ((guint) 0x0eeb)
#define SKK_KEYSYMS_Hangul_J_Tieut ((guint) 0x0eec)
#define SKK_KEYSYMS_Hangul_J_Phieuf ((guint) 0x0eed)
#define SKK_KEYSYMS_Hangul_J_Hieuh ((guint) 0x0eee)
#define SKK_KEYSYMS_Hangul_RieulYeorinHieuh ((guint) 0x0eef)
#define SKK_KEYSYMS_Hangul_SunkyeongeumMieum ((guint) 0x0ef0)
#define SKK_KEYSYMS_Hangul_SunkyeongeumPieub ((guint) 0x0ef1)
#define SKK_KEYSYMS_Hangul_PanSios ((guint) 0x0ef2)
#define SKK_KEYSYMS_Hangul_KkogjiDalrinIeung ((guint) 0x0ef3)
#define SKK_KEYSYMS_Hangul_SunkyeongeumPhieuf ((guint) 0x0ef4)
#define SKK_KEYSYMS_Hangul_YeorinHieuh ((guint) 0x0ef5)
#define SKK_KEYSYMS_Hangul_AraeA ((guint) 0x0ef6)
#define SKK_KEYSYMS_Hangul_AraeAE ((guint) 0x0ef7)
#define SKK_KEYSYMS_Hangul_J_PanSios ((guint) 0x0ef8)
#define SKK_KEYSYMS_Hangul_J_KkogjiDalrinIeung ((guint) 0x0ef9)
#define SKK_KEYSYMS_Hangul_J_YeorinHieuh ((guint) 0x0efa)
#define SKK_KEYSYMS_Korean_Won ((guint) 0x0eff)
#define SKK_KEYSYMS_Armenian_ligature_ew ((guint) 0x1000587)
#define SKK_KEYSYMS_Armenian_full_stop ((guint) 0x1000589)
#define SKK_KEYSYMS_Armenian_verjaket ((guint) 0x1000589)
#define SKK_KEYSYMS_Armenian_separation_mark ((guint) 0x100055d)
#define SKK_KEYSYMS_Armenian_but ((guint) 0x100055d)
#define SKK_KEYSYMS_Armenian_hyphen ((guint) 0x100058a)
#define SKK_KEYSYMS_Armenian_yentamna ((guint) 0x100058a)
#define SKK_KEYSYMS_Armenian_exclam ((guint) 0x100055c)
#define SKK_KEYSYMS_Armenian_amanak ((guint) 0x100055c)
#define SKK_KEYSYMS_Armenian_accent ((guint) 0x100055b)
#define SKK_KEYSYMS_Armenian_shesht ((guint) 0x100055b)
#define SKK_KEYSYMS_Armenian_question ((guint) 0x100055e)
#define SKK_KEYSYMS_Armenian_paruyk ((guint) 0x100055e)
#define SKK_KEYSYMS_Armenian_AYB ((guint) 0x1000531)
#define SKK_KEYSYMS_Armenian_ayb ((guint) 0x1000561)
#define SKK_KEYSYMS_Armenian_BEN ((guint) 0x1000532)
#define SKK_KEYSYMS_Armenian_ben ((guint) 0x1000562)
#define SKK_KEYSYMS_Armenian_GIM ((guint) 0x1000533)
#define SKK_KEYSYMS_Armenian_gim ((guint) 0x1000563)
#define SKK_KEYSYMS_Armenian_DA ((guint) 0x1000534)
#define SKK_KEYSYMS_Armenian_da ((guint) 0x1000564)
#define SKK_KEYSYMS_Armenian_YECH ((guint) 0x1000535)
#define SKK_KEYSYMS_Armenian_yech ((guint) 0x1000565)
#define SKK_KEYSYMS_Armenian_ZA ((guint) 0x1000536)
#define SKK_KEYSYMS_Armenian_za ((guint) 0x1000566)
#define SKK_KEYSYMS_Armenian_E ((guint) 0x1000537)
#define SKK_KEYSYMS_Armenian_e ((guint) 0x1000567)
#define SKK_KEYSYMS_Armenian_AT ((guint) 0x1000538)
#define SKK_KEYSYMS_Armenian_at ((guint) 0x1000568)
#define SKK_KEYSYMS_Armenian_TO ((guint) 0x1000539)
#define SKK_KEYSYMS_Armenian_to ((guint) 0x1000569)
#define SKK_KEYSYMS_Armenian_ZHE ((guint) 0x100053a)
#define SKK_KEYSYMS_Armenian_zhe ((guint) 0x100056a)
#define SKK_KEYSYMS_Armenian_INI ((guint) 0x100053b)
#define SKK_KEYSYMS_Armenian_ini ((guint) 0x100056b)
#define SKK_KEYSYMS_Armenian_LYUN ((guint) 0x100053c)
#define SKK_KEYSYMS_Armenian_lyun ((guint) 0x100056c)
#define SKK_KEYSYMS_Armenian_KHE ((guint) 0x100053d)
#define SKK_KEYSYMS_Armenian_khe ((guint) 0x100056d)
#define SKK_KEYSYMS_Armenian_TSA ((guint) 0x100053e)
#define SKK_KEYSYMS_Armenian_tsa ((guint) 0x100056e)
#define SKK_KEYSYMS_Armenian_KEN ((guint) 0x100053f)
#define SKK_KEYSYMS_Armenian_ken ((guint) 0x100056f)
#define SKK_KEYSYMS_Armenian_HO ((guint) 0x1000540)
#define SKK_KEYSYMS_Armenian_ho ((guint) 0x1000570)
#define SKK_KEYSYMS_Armenian_DZA ((guint) 0x1000541)
#define SKK_KEYSYMS_Armenian_dza ((guint) 0x1000571)
#define SKK_KEYSYMS_Armenian_GHAT ((guint) 0x1000542)
#define SKK_KEYSYMS_Armenian_ghat ((guint) 0x1000572)
#define SKK_KEYSYMS_Armenian_TCHE ((guint) 0x1000543)
#define SKK_KEYSYMS_Armenian_tche ((guint) 0x1000573)
#define SKK_KEYSYMS_Armenian_MEN ((guint) 0x1000544)
#define SKK_KEYSYMS_Armenian_men ((guint) 0x1000574)
#define SKK_KEYSYMS_Armenian_HI ((guint) 0x1000545)
#define SKK_KEYSYMS_Armenian_hi ((guint) 0x1000575)
#define SKK_KEYSYMS_Armenian_NU ((guint) 0x1000546)
#define SKK_KEYSYMS_Armenian_nu ((guint) 0x1000576)
#define SKK_KEYSYMS_Armenian_SHA ((guint) 0x1000547)
#define SKK_KEYSYMS_Armenian_sha ((guint) 0x1000577)
#define SKK_KEYSYMS_Armenian_VO ((guint) 0x1000548)
#define SKK_KEYSYMS_Armenian_vo ((guint) 0x1000578)
#define SKK_KEYSYMS_Armenian_CHA ((guint) 0x1000549)
#define SKK_KEYSYMS_Armenian_cha ((guint) 0x1000579)
#define SKK_KEYSYMS_Armenian_PE ((guint) 0x100054a)
#define SKK_KEYSYMS_Armenian_pe ((guint) 0x100057a)
#define SKK_KEYSYMS_Armenian_JE ((guint) 0x100054b)
#define SKK_KEYSYMS_Armenian_je ((guint) 0x100057b)
#define SKK_KEYSYMS_Armenian_RA ((guint) 0x100054c)
#define SKK_KEYSYMS_Armenian_ra ((guint) 0x100057c)
#define SKK_KEYSYMS_Armenian_SE ((guint) 0x100054d)
#define SKK_KEYSYMS_Armenian_se ((guint) 0x100057d)
#define SKK_KEYSYMS_Armenian_VEV ((guint) 0x100054e)
#define SKK_KEYSYMS_Armenian_vev ((guint) 0x100057e)
#define SKK_KEYSYMS_Armenian_TYUN ((guint) 0x100054f)
#define SKK_KEYSYMS_Armenian_tyun ((guint) 0x100057f)
#define SKK_KEYSYMS_Armenian_RE ((guint) 0x1000550)
#define SKK_KEYSYMS_Armenian_re ((guint) 0x1000580)
#define SKK_KEYSYMS_Armenian_TSO ((guint) 0x1000551)
#define SKK_KEYSYMS_Armenian_tso ((guint) 0x1000581)
#define SKK_KEYSYMS_Armenian_VYUN ((guint) 0x1000552)
#define SKK_KEYSYMS_Armenian_vyun ((guint) 0x1000582)
#define SKK_KEYSYMS_Armenian_PYUR ((guint) 0x1000553)
#define SKK_KEYSYMS_Armenian_pyur ((guint) 0x1000583)
#define SKK_KEYSYMS_Armenian_KE ((guint) 0x1000554)
#define SKK_KEYSYMS_Armenian_ke ((guint) 0x1000584)
#define SKK_KEYSYMS_Armenian_O ((guint) 0x1000555)
#define SKK_KEYSYMS_Armenian_o ((guint) 0x1000585)
#define SKK_KEYSYMS_Armenian_FE ((guint) 0x1000556)
#define SKK_KEYSYMS_Armenian_fe ((guint) 0x1000586)
#define SKK_KEYSYMS_Armenian_apostrophe ((guint) 0x100055a)
#define SKK_KEYSYMS_Georgian_an ((guint) 0x10010d0)
#define SKK_KEYSYMS_Georgian_ban ((guint) 0x10010d1)
#define SKK_KEYSYMS_Georgian_gan ((guint) 0x10010d2)
#define SKK_KEYSYMS_Georgian_don ((guint) 0x10010d3)
#define SKK_KEYSYMS_Georgian_en ((guint) 0x10010d4)
#define SKK_KEYSYMS_Georgian_vin ((guint) 0x10010d5)
#define SKK_KEYSYMS_Georgian_zen ((guint) 0x10010d6)
#define SKK_KEYSYMS_Georgian_tan ((guint) 0x10010d7)
#define SKK_KEYSYMS_Georgian_in ((guint) 0x10010d8)
#define SKK_KEYSYMS_Georgian_kan ((guint) 0x10010d9)
#define SKK_KEYSYMS_Georgian_las ((guint) 0x10010da)
#define SKK_KEYSYMS_Georgian_man ((guint) 0x10010db)
#define SKK_KEYSYMS_Georgian_nar ((guint) 0x10010dc)
#define SKK_KEYSYMS_Georgian_on ((guint) 0x10010dd)
#define SKK_KEYSYMS_Georgian_par ((guint) 0x10010de)
#define SKK_KEYSYMS_Georgian_zhar ((guint) 0x10010df)
#define SKK_KEYSYMS_Georgian_rae ((guint) 0x10010e0)
#define SKK_KEYSYMS_Georgian_san ((guint) 0x10010e1)
#define SKK_KEYSYMS_Georgian_tar ((guint) 0x10010e2)
#define SKK_KEYSYMS_Georgian_un ((guint) 0x10010e3)
#define SKK_KEYSYMS_Georgian_phar ((guint) 0x10010e4)
#define SKK_KEYSYMS_Georgian_khar ((guint) 0x10010e5)
#define SKK_KEYSYMS_Georgian_ghan ((guint) 0x10010e6)
#define SKK_KEYSYMS_Georgian_qar ((guint) 0x10010e7)
#define SKK_KEYSYMS_Georgian_shin ((guint) 0x10010e8)
#define SKK_KEYSYMS_Georgian_chin ((guint) 0x10010e9)
#define SKK_KEYSYMS_Georgian_can ((guint) 0x10010ea)
#define SKK_KEYSYMS_Georgian_jil ((guint) 0x10010eb)
#define SKK_KEYSYMS_Georgian_cil ((guint) 0x10010ec)
#define SKK_KEYSYMS_Georgian_char ((guint) 0x10010ed)
#define SKK_KEYSYMS_Georgian_xan ((guint) 0x10010ee)
#define SKK_KEYSYMS_Georgian_jhan ((guint) 0x10010ef)
#define SKK_KEYSYMS_Georgian_hae ((guint) 0x10010f0)
#define SKK_KEYSYMS_Georgian_he ((guint) 0x10010f1)
#define SKK_KEYSYMS_Georgian_hie ((guint) 0x10010f2)
#define SKK_KEYSYMS_Georgian_we ((guint) 0x10010f3)
#define SKK_KEYSYMS_Georgian_har ((guint) 0x10010f4)
#define SKK_KEYSYMS_Georgian_hoe ((guint) 0x10010f5)
#define SKK_KEYSYMS_Georgian_fi ((guint) 0x10010f6)
#define SKK_KEYSYMS_Xabovedot ((guint) 0x1001e8a)
#define SKK_KEYSYMS_Ibreve ((guint) 0x100012c)
#define SKK_KEYSYMS_Zstroke ((guint) 0x10001b5)
#define SKK_KEYSYMS_Gcaron ((guint) 0x10001e6)
#define SKK_KEYSYMS_Ocaron ((guint) 0x10001d1)
#define SKK_KEYSYMS_Obarred ((guint) 0x100019f)
#define SKK_KEYSYMS_xabovedot ((guint) 0x1001e8b)
#define SKK_KEYSYMS_ibreve ((guint) 0x100012d)
#define SKK_KEYSYMS_zstroke ((guint) 0x10001b6)
#define SKK_KEYSYMS_gcaron ((guint) 0x10001e7)
#define SKK_KEYSYMS_ocaron ((guint) 0x10001d2)
#define SKK_KEYSYMS_obarred ((guint) 0x1000275)
#define SKK_KEYSYMS_SCHWA ((guint) 0x100018f)
#define SKK_KEYSYMS_schwa ((guint) 0x1000259)
#define SKK_KEYSYMS_Lbelowdot ((guint) 0x1001e36)
#define SKK_KEYSYMS_lbelowdot ((guint) 0x1001e37)
#define SKK_KEYSYMS_Abelowdot ((guint) 0x1001ea0)
#define SKK_KEYSYMS_abelowdot ((guint) 0x1001ea1)
#define SKK_KEYSYMS_Ahook ((guint) 0x1001ea2)
#define SKK_KEYSYMS_ahook ((guint) 0x1001ea3)
#define SKK_KEYSYMS_Acircumflexacute ((guint) 0x1001ea4)
#define SKK_KEYSYMS_acircumflexacute ((guint) 0x1001ea5)
#define SKK_KEYSYMS_Acircumflexgrave ((guint) 0x1001ea6)
#define SKK_KEYSYMS_acircumflexgrave ((guint) 0x1001ea7)
#define SKK_KEYSYMS_Acircumflexhook ((guint) 0x1001ea8)
#define SKK_KEYSYMS_acircumflexhook ((guint) 0x1001ea9)
#define SKK_KEYSYMS_Acircumflextilde ((guint) 0x1001eaa)
#define SKK_KEYSYMS_acircumflextilde ((guint) 0x1001eab)
#define SKK_KEYSYMS_Acircumflexbelowdot ((guint) 0x1001eac)
#define SKK_KEYSYMS_acircumflexbelowdot ((guint) 0x1001ead)
#define SKK_KEYSYMS_Abreveacute ((guint) 0x1001eae)
#define SKK_KEYSYMS_abreveacute ((guint) 0x1001eaf)
#define SKK_KEYSYMS_Abrevegrave ((guint) 0x1001eb0)
#define SKK_KEYSYMS_abrevegrave ((guint) 0x1001eb1)
#define SKK_KEYSYMS_Abrevehook ((guint) 0x1001eb2)
#define SKK_KEYSYMS_abrevehook ((guint) 0x1001eb3)
#define SKK_KEYSYMS_Abrevetilde ((guint) 0x1001eb4)
#define SKK_KEYSYMS_abrevetilde ((guint) 0x1001eb5)
#define SKK_KEYSYMS_Abrevebelowdot ((guint) 0x1001eb6)
#define SKK_KEYSYMS_abrevebelowdot ((guint) 0x1001eb7)
#define SKK_KEYSYMS_Ebelowdot ((guint) 0x1001eb8)
#define SKK_KEYSYMS_ebelowdot ((guint) 0x1001eb9)
#define SKK_KEYSYMS_Ehook ((guint) 0x1001eba)
#define SKK_KEYSYMS_ehook ((guint) 0x1001ebb)
#define SKK_KEYSYMS_Etilde ((guint) 0x1001ebc)
#define SKK_KEYSYMS_etilde ((guint) 0x1001ebd)
#define SKK_KEYSYMS_Ecircumflexacute ((guint) 0x1001ebe)
#define SKK_KEYSYMS_ecircumflexacute ((guint) 0x1001ebf)
#define SKK_KEYSYMS_Ecircumflexgrave ((guint) 0x1001ec0)
#define SKK_KEYSYMS_ecircumflexgrave ((guint) 0x1001ec1)
#define SKK_KEYSYMS_Ecircumflexhook ((guint) 0x1001ec2)
#define SKK_KEYSYMS_ecircumflexhook ((guint) 0x1001ec3)
#define SKK_KEYSYMS_Ecircumflextilde ((guint) 0x1001ec4)
#define SKK_KEYSYMS_ecircumflextilde ((guint) 0x1001ec5)
#define SKK_KEYSYMS_Ecircumflexbelowdot ((guint) 0x1001ec6)
#define SKK_KEYSYMS_ecircumflexbelowdot ((guint) 0x1001ec7)
#define SKK_KEYSYMS_Ihook ((guint) 0x1001ec8)
#define SKK_KEYSYMS_ihook ((guint) 0x1001ec9)
#define SKK_KEYSYMS_Ibelowdot ((guint) 0x1001eca)
#define SKK_KEYSYMS_ibelowdot ((guint) 0x1001ecb)
#define SKK_KEYSYMS_Obelowdot ((guint) 0x1001ecc)
#define SKK_KEYSYMS_obelowdot ((guint) 0x1001ecd)
#define SKK_KEYSYMS_Ohook ((guint) 0x1001ece)
#define SKK_KEYSYMS_ohook ((guint) 0x1001ecf)
#define SKK_KEYSYMS_Ocircumflexacute ((guint) 0x1001ed0)
#define SKK_KEYSYMS_ocircumflexacute ((guint) 0x1001ed1)
#define SKK_KEYSYMS_Ocircumflexgrave ((guint) 0x1001ed2)
#define SKK_KEYSYMS_ocircumflexgrave ((guint) 0x1001ed3)
#define SKK_KEYSYMS_Ocircumflexhook ((guint) 0x1001ed4)
#define SKK_KEYSYMS_ocircumflexhook ((guint) 0x1001ed5)
#define SKK_KEYSYMS_Ocircumflextilde ((guint) 0x1001ed6)
#define SKK_KEYSYMS_ocircumflextilde ((guint) 0x1001ed7)
#define SKK_KEYSYMS_Ocircumflexbelowdot ((guint) 0x1001ed8)
#define SKK_KEYSYMS_ocircumflexbelowdot ((guint) 0x1001ed9)
#define SKK_KEYSYMS_Ohornacute ((guint) 0x1001eda)
#define SKK_KEYSYMS_ohornacute ((guint) 0x1001edb)
#define SKK_KEYSYMS_Ohorngrave ((guint) 0x1001edc)
#define SKK_KEYSYMS_ohorngrave ((guint) 0x1001edd)
#define SKK_KEYSYMS_Ohornhook ((guint) 0x1001ede)
#define SKK_KEYSYMS_ohornhook ((guint) 0x1001edf)
#define SKK_KEYSYMS_Ohorntilde ((guint) 0x1001ee0)
#define SKK_KEYSYMS_ohorntilde ((guint) 0x1001ee1)
#define SKK_KEYSYMS_Ohornbelowdot ((guint) 0x1001ee2)
#define SKK_KEYSYMS_ohornbelowdot ((guint) 0x1001ee3)
#define SKK_KEYSYMS_Ubelowdot ((guint) 0x1001ee4)
#define SKK_KEYSYMS_ubelowdot ((guint) 0x1001ee5)
#define SKK_KEYSYMS_Uhook ((guint) 0x1001ee6)
#define SKK_KEYSYMS_uhook ((guint) 0x1001ee7)
#define SKK_KEYSYMS_Uhornacute ((guint) 0x1001ee8)
#define SKK_KEYSYMS_uhornacute ((guint) 0x1001ee9)
#define SKK_KEYSYMS_Uhorngrave ((guint) 0x1001eea)
#define SKK_KEYSYMS_uhorngrave ((guint) 0x1001eeb)
#define SKK_KEYSYMS_Uhornhook ((guint) 0x1001eec)
#define SKK_KEYSYMS_uhornhook ((guint) 0x1001eed)
#define SKK_KEYSYMS_Uhorntilde ((guint) 0x1001eee)
#define SKK_KEYSYMS_uhorntilde ((guint) 0x1001eef)
#define SKK_KEYSYMS_Uhornbelowdot ((guint) 0x1001ef0)
#define SKK_KEYSYMS_uhornbelowdot ((guint) 0x1001ef1)
#define SKK_KEYSYMS_Ybelowdot ((guint) 0x1001ef4)
#define SKK_KEYSYMS_ybelowdot ((guint) 0x1001ef5)
#define SKK_KEYSYMS_Yhook ((guint) 0x1001ef6)
#define SKK_KEYSYMS_yhook ((guint) 0x1001ef7)
#define SKK_KEYSYMS_Ytilde ((guint) 0x1001ef8)
#define SKK_KEYSYMS_ytilde ((guint) 0x1001ef9)
#define SKK_KEYSYMS_Ohorn ((guint) 0x10001a0)
#define SKK_KEYSYMS_ohorn ((guint) 0x10001a1)
#define SKK_KEYSYMS_Uhorn ((guint) 0x10001af)
#define SKK_KEYSYMS_uhorn ((guint) 0x10001b0)
#define SKK_KEYSYMS_EcuSign ((guint) 0x10020a0)
#define SKK_KEYSYMS_ColonSign ((guint) 0x10020a1)
#define SKK_KEYSYMS_CruzeiroSign ((guint) 0x10020a2)
#define SKK_KEYSYMS_FFrancSign ((guint) 0x10020a3)
#define SKK_KEYSYMS_LiraSign ((guint) 0x10020a4)
#define SKK_KEYSYMS_MillSign ((guint) 0x10020a5)
#define SKK_KEYSYMS_NairaSign ((guint) 0x10020a6)
#define SKK_KEYSYMS_PesetaSign ((guint) 0x10020a7)
#define SKK_KEYSYMS_RupeeSign ((guint) 0x10020a8)
#define SKK_KEYSYMS_WonSign ((guint) 0x10020a9)
#define SKK_KEYSYMS_NewSheqelSign ((guint) 0x10020aa)
#define SKK_KEYSYMS_DongSign ((guint) 0x10020ab)
#define SKK_KEYSYMS_EuroSign ((guint) 0x20ac)
#define SKK_KEYSYMS_zerosuperior ((guint) 0x1002070)
#define SKK_KEYSYMS_foursuperior ((guint) 0x1002074)
#define SKK_KEYSYMS_fivesuperior ((guint) 0x1002075)
#define SKK_KEYSYMS_sixsuperior ((guint) 0x1002076)
#define SKK_KEYSYMS_sevensuperior ((guint) 0x1002077)
#define SKK_KEYSYMS_eightsuperior ((guint) 0x1002078)
#define SKK_KEYSYMS_ninesuperior ((guint) 0x1002079)
#define SKK_KEYSYMS_zerosubscript ((guint) 0x1002080)
#define SKK_KEYSYMS_onesubscript ((guint) 0x1002081)
#define SKK_KEYSYMS_twosubscript ((guint) 0x1002082)
#define SKK_KEYSYMS_threesubscript ((guint) 0x1002083)
#define SKK_KEYSYMS_foursubscript ((guint) 0x1002084)
#define SKK_KEYSYMS_fivesubscript ((guint) 0x1002085)
#define SKK_KEYSYMS_sixsubscript ((guint) 0x1002086)
#define SKK_KEYSYMS_sevensubscript ((guint) 0x1002087)
#define SKK_KEYSYMS_eightsubscript ((guint) 0x1002088)
#define SKK_KEYSYMS_ninesubscript ((guint) 0x1002089)
#define SKK_KEYSYMS_partdifferential ((guint) 0x1002202)
#define SKK_KEYSYMS_emptyset ((guint) 0x1002205)
#define SKK_KEYSYMS_elementof ((guint) 0x1002208)
#define SKK_KEYSYMS_notelementof ((guint) 0x1002209)
#define SKK_KEYSYMS_containsas ((guint) 0x100220B)
#define SKK_KEYSYMS_squareroot ((guint) 0x100221A)
#define SKK_KEYSYMS_cuberoot ((guint) 0x100221B)
#define SKK_KEYSYMS_fourthroot ((guint) 0x100221C)
#define SKK_KEYSYMS_dintegral ((guint) 0x100222C)
#define SKK_KEYSYMS_tintegral ((guint) 0x100222D)
#define SKK_KEYSYMS_because ((guint) 0x1002235)
#define SKK_KEYSYMS_approxeq ((guint) 0x1002248)
#define SKK_KEYSYMS_notapproxeq ((guint) 0x1002247)
#define SKK_KEYSYMS_notidentical ((guint) 0x1002262)
#define SKK_KEYSYMS_stricteq ((guint) 0x1002263)
#define SKK_KEYSYMS_braille_dot_1 ((guint) 0xfff1)
#define SKK_KEYSYMS_braille_dot_2 ((guint) 0xfff2)
#define SKK_KEYSYMS_braille_dot_3 ((guint) 0xfff3)
#define SKK_KEYSYMS_braille_dot_4 ((guint) 0xfff4)
#define SKK_KEYSYMS_braille_dot_5 ((guint) 0xfff5)
#define SKK_KEYSYMS_braille_dot_6 ((guint) 0xfff6)
#define SKK_KEYSYMS_braille_dot_7 ((guint) 0xfff7)
#define SKK_KEYSYMS_braille_dot_8 ((guint) 0xfff8)
#define SKK_KEYSYMS_braille_dot_9 ((guint) 0xfff9)
#define SKK_KEYSYMS_braille_dot_10 ((guint) 0xfffa)
#define SKK_KEYSYMS_braille_blank ((guint) 0x1002800)
#define SKK_KEYSYMS_braille_dots_1 ((guint) 0x1002801)
#define SKK_KEYSYMS_braille_dots_2 ((guint) 0x1002802)
#define SKK_KEYSYMS_braille_dots_12 ((guint) 0x1002803)
#define SKK_KEYSYMS_braille_dots_3 ((guint) 0x1002804)
#define SKK_KEYSYMS_braille_dots_13 ((guint) 0x1002805)
#define SKK_KEYSYMS_braille_dots_23 ((guint) 0x1002806)
#define SKK_KEYSYMS_braille_dots_123 ((guint) 0x1002807)
#define SKK_KEYSYMS_braille_dots_4 ((guint) 0x1002808)
#define SKK_KEYSYMS_braille_dots_14 ((guint) 0x1002809)
#define SKK_KEYSYMS_braille_dots_24 ((guint) 0x100280a)
#define SKK_KEYSYMS_braille_dots_124 ((guint) 0x100280b)
#define SKK_KEYSYMS_braille_dots_34 ((guint) 0x100280c)
#define SKK_KEYSYMS_braille_dots_134 ((guint) 0x100280d)
#define SKK_KEYSYMS_braille_dots_234 ((guint) 0x100280e)
#define SKK_KEYSYMS_braille_dots_1234 ((guint) 0x100280f)
#define SKK_KEYSYMS_braille_dots_5 ((guint) 0x1002810)
#define SKK_KEYSYMS_braille_dots_15 ((guint) 0x1002811)
#define SKK_KEYSYMS_braille_dots_25 ((guint) 0x1002812)
#define SKK_KEYSYMS_braille_dots_125 ((guint) 0x1002813)
#define SKK_KEYSYMS_braille_dots_35 ((guint) 0x1002814)
#define SKK_KEYSYMS_braille_dots_135 ((guint) 0x1002815)
#define SKK_KEYSYMS_braille_dots_235 ((guint) 0x1002816)
#define SKK_KEYSYMS_braille_dots_1235 ((guint) 0x1002817)
#define SKK_KEYSYMS_braille_dots_45 ((guint) 0x1002818)
#define SKK_KEYSYMS_braille_dots_145 ((guint) 0x1002819)
#define SKK_KEYSYMS_braille_dots_245 ((guint) 0x100281a)
#define SKK_KEYSYMS_braille_dots_1245 ((guint) 0x100281b)
#define SKK_KEYSYMS_braille_dots_345 ((guint) 0x100281c)
#define SKK_KEYSYMS_braille_dots_1345 ((guint) 0x100281d)
#define SKK_KEYSYMS_braille_dots_2345 ((guint) 0x100281e)
#define SKK_KEYSYMS_braille_dots_12345 ((guint) 0x100281f)
#define SKK_KEYSYMS_braille_dots_6 ((guint) 0x1002820)
#define SKK_KEYSYMS_braille_dots_16 ((guint) 0x1002821)
#define SKK_KEYSYMS_braille_dots_26 ((guint) 0x1002822)
#define SKK_KEYSYMS_braille_dots_126 ((guint) 0x1002823)
#define SKK_KEYSYMS_braille_dots_36 ((guint) 0x1002824)
#define SKK_KEYSYMS_braille_dots_136 ((guint) 0x1002825)
#define SKK_KEYSYMS_braille_dots_236 ((guint) 0x1002826)
#define SKK_KEYSYMS_braille_dots_1236 ((guint) 0x1002827)
#define SKK_KEYSYMS_braille_dots_46 ((guint) 0x1002828)
#define SKK_KEYSYMS_braille_dots_146 ((guint) 0x1002829)
#define SKK_KEYSYMS_braille_dots_246 ((guint) 0x100282a)
#define SKK_KEYSYMS_braille_dots_1246 ((guint) 0x100282b)
#define SKK_KEYSYMS_braille_dots_346 ((guint) 0x100282c)
#define SKK_KEYSYMS_braille_dots_1346 ((guint) 0x100282d)
#define SKK_KEYSYMS_braille_dots_2346 ((guint) 0x100282e)
#define SKK_KEYSYMS_braille_dots_12346 ((guint) 0x100282f)
#define SKK_KEYSYMS_braille_dots_56 ((guint) 0x1002830)
#define SKK_KEYSYMS_braille_dots_156 ((guint) 0x1002831)
#define SKK_KEYSYMS_braille_dots_256 ((guint) 0x1002832)
#define SKK_KEYSYMS_braille_dots_1256 ((guint) 0x1002833)
#define SKK_KEYSYMS_braille_dots_356 ((guint) 0x1002834)
#define SKK_KEYSYMS_braille_dots_1356 ((guint) 0x1002835)
#define SKK_KEYSYMS_braille_dots_2356 ((guint) 0x1002836)
#define SKK_KEYSYMS_braille_dots_12356 ((guint) 0x1002837)
#define SKK_KEYSYMS_braille_dots_456 ((guint) 0x1002838)
#define SKK_KEYSYMS_braille_dots_1456 ((guint) 0x1002839)
#define SKK_KEYSYMS_braille_dots_2456 ((guint) 0x100283a)
#define SKK_KEYSYMS_braille_dots_12456 ((guint) 0x100283b)
#define SKK_KEYSYMS_braille_dots_3456 ((guint) 0x100283c)
#define SKK_KEYSYMS_braille_dots_13456 ((guint) 0x100283d)
#define SKK_KEYSYMS_braille_dots_23456 ((guint) 0x100283e)
#define SKK_KEYSYMS_braille_dots_123456 ((guint) 0x100283f)
#define SKK_KEYSYMS_braille_dots_7 ((guint) 0x1002840)
#define SKK_KEYSYMS_braille_dots_17 ((guint) 0x1002841)
#define SKK_KEYSYMS_braille_dots_27 ((guint) 0x1002842)
#define SKK_KEYSYMS_braille_dots_127 ((guint) 0x1002843)
#define SKK_KEYSYMS_braille_dots_37 ((guint) 0x1002844)
#define SKK_KEYSYMS_braille_dots_137 ((guint) 0x1002845)
#define SKK_KEYSYMS_braille_dots_237 ((guint) 0x1002846)
#define SKK_KEYSYMS_braille_dots_1237 ((guint) 0x1002847)
#define SKK_KEYSYMS_braille_dots_47 ((guint) 0x1002848)
#define SKK_KEYSYMS_braille_dots_147 ((guint) 0x1002849)
#define SKK_KEYSYMS_braille_dots_247 ((guint) 0x100284a)
#define SKK_KEYSYMS_braille_dots_1247 ((guint) 0x100284b)
#define SKK_KEYSYMS_braille_dots_347 ((guint) 0x100284c)
#define SKK_KEYSYMS_braille_dots_1347 ((guint) 0x100284d)
#define SKK_KEYSYMS_braille_dots_2347 ((guint) 0x100284e)
#define SKK_KEYSYMS_braille_dots_12347 ((guint) 0x100284f)
#define SKK_KEYSYMS_braille_dots_57 ((guint) 0x1002850)
#define SKK_KEYSYMS_braille_dots_157 ((guint) 0x1002851)
#define SKK_KEYSYMS_braille_dots_257 ((guint) 0x1002852)
#define SKK_KEYSYMS_braille_dots_1257 ((guint) 0x1002853)
#define SKK_KEYSYMS_braille_dots_357 ((guint) 0x1002854)
#define SKK_KEYSYMS_braille_dots_1357 ((guint) 0x1002855)
#define SKK_KEYSYMS_braille_dots_2357 ((guint) 0x1002856)
#define SKK_KEYSYMS_braille_dots_12357 ((guint) 0x1002857)
#define SKK_KEYSYMS_braille_dots_457 ((guint) 0x1002858)
#define SKK_KEYSYMS_braille_dots_1457 ((guint) 0x1002859)
#define SKK_KEYSYMS_braille_dots_2457 ((guint) 0x100285a)
#define SKK_KEYSYMS_braille_dots_12457 ((guint) 0x100285b)
#define SKK_KEYSYMS_braille_dots_3457 ((guint) 0x100285c)
#define SKK_KEYSYMS_braille_dots_13457 ((guint) 0x100285d)
#define SKK_KEYSYMS_braille_dots_23457 ((guint) 0x100285e)
#define SKK_KEYSYMS_braille_dots_123457 ((guint) 0x100285f)
#define SKK_KEYSYMS_braille_dots_67 ((guint) 0x1002860)
#define SKK_KEYSYMS_braille_dots_167 ((guint) 0x1002861)
#define SKK_KEYSYMS_braille_dots_267 ((guint) 0x1002862)
#define SKK_KEYSYMS_braille_dots_1267 ((guint) 0x1002863)
#define SKK_KEYSYMS_braille_dots_367 ((guint) 0x1002864)
#define SKK_KEYSYMS_braille_dots_1367 ((guint) 0x1002865)
#define SKK_KEYSYMS_braille_dots_2367 ((guint) 0x1002866)
#define SKK_KEYSYMS_braille_dots_12367 ((guint) 0x1002867)
#define SKK_KEYSYMS_braille_dots_467 ((guint) 0x1002868)
#define SKK_KEYSYMS_braille_dots_1467 ((guint) 0x1002869)
#define SKK_KEYSYMS_braille_dots_2467 ((guint) 0x100286a)
#define SKK_KEYSYMS_braille_dots_12467 ((guint) 0x100286b)
#define SKK_KEYSYMS_braille_dots_3467 ((guint) 0x100286c)
#define SKK_KEYSYMS_braille_dots_13467 ((guint) 0x100286d)
#define SKK_KEYSYMS_braille_dots_23467 ((guint) 0x100286e)
#define SKK_KEYSYMS_braille_dots_123467 ((guint) 0x100286f)
#define SKK_KEYSYMS_braille_dots_567 ((guint) 0x1002870)
#define SKK_KEYSYMS_braille_dots_1567 ((guint) 0x1002871)
#define SKK_KEYSYMS_braille_dots_2567 ((guint) 0x1002872)
#define SKK_KEYSYMS_braille_dots_12567 ((guint) 0x1002873)
#define SKK_KEYSYMS_braille_dots_3567 ((guint) 0x1002874)
#define SKK_KEYSYMS_braille_dots_13567 ((guint) 0x1002875)
#define SKK_KEYSYMS_braille_dots_23567 ((guint) 0x1002876)
#define SKK_KEYSYMS_braille_dots_123567 ((guint) 0x1002877)
#define SKK_KEYSYMS_braille_dots_4567 ((guint) 0x1002878)
#define SKK_KEYSYMS_braille_dots_14567 ((guint) 0x1002879)
#define SKK_KEYSYMS_braille_dots_24567 ((guint) 0x100287a)
#define SKK_KEYSYMS_braille_dots_124567 ((guint) 0x100287b)
#define SKK_KEYSYMS_braille_dots_34567 ((guint) 0x100287c)
#define SKK_KEYSYMS_braille_dots_134567 ((guint) 0x100287d)
#define SKK_KEYSYMS_braille_dots_234567 ((guint) 0x100287e)
#define SKK_KEYSYMS_braille_dots_1234567 ((guint) 0x100287f)
#define SKK_KEYSYMS_braille_dots_8 ((guint) 0x1002880)
#define SKK_KEYSYMS_braille_dots_18 ((guint) 0x1002881)
#define SKK_KEYSYMS_braille_dots_28 ((guint) 0x1002882)
#define SKK_KEYSYMS_braille_dots_128 ((guint) 0x1002883)
#define SKK_KEYSYMS_braille_dots_38 ((guint) 0x1002884)
#define SKK_KEYSYMS_braille_dots_138 ((guint) 0x1002885)
#define SKK_KEYSYMS_braille_dots_238 ((guint) 0x1002886)
#define SKK_KEYSYMS_braille_dots_1238 ((guint) 0x1002887)
#define SKK_KEYSYMS_braille_dots_48 ((guint) 0x1002888)
#define SKK_KEYSYMS_braille_dots_148 ((guint) 0x1002889)
#define SKK_KEYSYMS_braille_dots_248 ((guint) 0x100288a)
#define SKK_KEYSYMS_braille_dots_1248 ((guint) 0x100288b)
#define SKK_KEYSYMS_braille_dots_348 ((guint) 0x100288c)
#define SKK_KEYSYMS_braille_dots_1348 ((guint) 0x100288d)
#define SKK_KEYSYMS_braille_dots_2348 ((guint) 0x100288e)
#define SKK_KEYSYMS_braille_dots_12348 ((guint) 0x100288f)
#define SKK_KEYSYMS_braille_dots_58 ((guint) 0x1002890)
#define SKK_KEYSYMS_braille_dots_158 ((guint) 0x1002891)
#define SKK_KEYSYMS_braille_dots_258 ((guint) 0x1002892)
#define SKK_KEYSYMS_braille_dots_1258 ((guint) 0x1002893)
#define SKK_KEYSYMS_braille_dots_358 ((guint) 0x1002894)
#define SKK_KEYSYMS_braille_dots_1358 ((guint) 0x1002895)
#define SKK_KEYSYMS_braille_dots_2358 ((guint) 0x1002896)
#define SKK_KEYSYMS_braille_dots_12358 ((guint) 0x1002897)
#define SKK_KEYSYMS_braille_dots_458 ((guint) 0x1002898)
#define SKK_KEYSYMS_braille_dots_1458 ((guint) 0x1002899)
#define SKK_KEYSYMS_braille_dots_2458 ((guint) 0x100289a)
#define SKK_KEYSYMS_braille_dots_12458 ((guint) 0x100289b)
#define SKK_KEYSYMS_braille_dots_3458 ((guint) 0x100289c)
#define SKK_KEYSYMS_braille_dots_13458 ((guint) 0x100289d)
#define SKK_KEYSYMS_braille_dots_23458 ((guint) 0x100289e)
#define SKK_KEYSYMS_braille_dots_123458 ((guint) 0x100289f)
#define SKK_KEYSYMS_braille_dots_68 ((guint) 0x10028a0)
#define SKK_KEYSYMS_braille_dots_168 ((guint) 0x10028a1)
#define SKK_KEYSYMS_braille_dots_268 ((guint) 0x10028a2)
#define SKK_KEYSYMS_braille_dots_1268 ((guint) 0x10028a3)
#define SKK_KEYSYMS_braille_dots_368 ((guint) 0x10028a4)
#define SKK_KEYSYMS_braille_dots_1368 ((guint) 0x10028a5)
#define SKK_KEYSYMS_braille_dots_2368 ((guint) 0x10028a6)
#define SKK_KEYSYMS_braille_dots_12368 ((guint) 0x10028a7)
#define SKK_KEYSYMS_braille_dots_468 ((guint) 0x10028a8)
#define SKK_KEYSYMS_braille_dots_1468 ((guint) 0x10028a9)
#define SKK_KEYSYMS_braille_dots_2468 ((guint) 0x10028aa)
#define SKK_KEYSYMS_braille_dots_12468 ((guint) 0x10028ab)
#define SKK_KEYSYMS_braille_dots_3468 ((guint) 0x10028ac)
#define SKK_KEYSYMS_braille_dots_13468 ((guint) 0x10028ad)
#define SKK_KEYSYMS_braille_dots_23468 ((guint) 0x10028ae)
#define SKK_KEYSYMS_braille_dots_123468 ((guint) 0x10028af)
#define SKK_KEYSYMS_braille_dots_568 ((guint) 0x10028b0)
#define SKK_KEYSYMS_braille_dots_1568 ((guint) 0x10028b1)
#define SKK_KEYSYMS_braille_dots_2568 ((guint) 0x10028b2)
#define SKK_KEYSYMS_braille_dots_12568 ((guint) 0x10028b3)
#define SKK_KEYSYMS_braille_dots_3568 ((guint) 0x10028b4)
#define SKK_KEYSYMS_braille_dots_13568 ((guint) 0x10028b5)
#define SKK_KEYSYMS_braille_dots_23568 ((guint) 0x10028b6)
#define SKK_KEYSYMS_braille_dots_123568 ((guint) 0x10028b7)
#define SKK_KEYSYMS_braille_dots_4568 ((guint) 0x10028b8)
#define SKK_KEYSYMS_braille_dots_14568 ((guint) 0x10028b9)
#define SKK_KEYSYMS_braille_dots_24568 ((guint) 0x10028ba)
#define SKK_KEYSYMS_braille_dots_124568 ((guint) 0x10028bb)
#define SKK_KEYSYMS_braille_dots_34568 ((guint) 0x10028bc)
#define SKK_KEYSYMS_braille_dots_134568 ((guint) 0x10028bd)
#define SKK_KEYSYMS_braille_dots_234568 ((guint) 0x10028be)
#define SKK_KEYSYMS_braille_dots_1234568 ((guint) 0x10028bf)
#define SKK_KEYSYMS_braille_dots_78 ((guint) 0x10028c0)
#define SKK_KEYSYMS_braille_dots_178 ((guint) 0x10028c1)
#define SKK_KEYSYMS_braille_dots_278 ((guint) 0x10028c2)
#define SKK_KEYSYMS_braille_dots_1278 ((guint) 0x10028c3)
#define SKK_KEYSYMS_braille_dots_378 ((guint) 0x10028c4)
#define SKK_KEYSYMS_braille_dots_1378 ((guint) 0x10028c5)
#define SKK_KEYSYMS_braille_dots_2378 ((guint) 0x10028c6)
#define SKK_KEYSYMS_braille_dots_12378 ((guint) 0x10028c7)
#define SKK_KEYSYMS_braille_dots_478 ((guint) 0x10028c8)
#define SKK_KEYSYMS_braille_dots_1478 ((guint) 0x10028c9)
#define SKK_KEYSYMS_braille_dots_2478 ((guint) 0x10028ca)
#define SKK_KEYSYMS_braille_dots_12478 ((guint) 0x10028cb)
#define SKK_KEYSYMS_braille_dots_3478 ((guint) 0x10028cc)
#define SKK_KEYSYMS_braille_dots_13478 ((guint) 0x10028cd)
#define SKK_KEYSYMS_braille_dots_23478 ((guint) 0x10028ce)
#define SKK_KEYSYMS_braille_dots_123478 ((guint) 0x10028cf)
#define SKK_KEYSYMS_braille_dots_578 ((guint) 0x10028d0)
#define SKK_KEYSYMS_braille_dots_1578 ((guint) 0x10028d1)
#define SKK_KEYSYMS_braille_dots_2578 ((guint) 0x10028d2)
#define SKK_KEYSYMS_braille_dots_12578 ((guint) 0x10028d3)
#define SKK_KEYSYMS_braille_dots_3578 ((guint) 0x10028d4)
#define SKK_KEYSYMS_braille_dots_13578 ((guint) 0x10028d5)
#define SKK_KEYSYMS_braille_dots_23578 ((guint) 0x10028d6)
#define SKK_KEYSYMS_braille_dots_123578 ((guint) 0x10028d7)
#define SKK_KEYSYMS_braille_dots_4578 ((guint) 0x10028d8)
#define SKK_KEYSYMS_braille_dots_14578 ((guint) 0x10028d9)
#define SKK_KEYSYMS_braille_dots_24578 ((guint) 0x10028da)
#define SKK_KEYSYMS_braille_dots_124578 ((guint) 0x10028db)
#define SKK_KEYSYMS_braille_dots_34578 ((guint) 0x10028dc)
#define SKK_KEYSYMS_braille_dots_134578 ((guint) 0x10028dd)
#define SKK_KEYSYMS_braille_dots_234578 ((guint) 0x10028de)
#define SKK_KEYSYMS_braille_dots_1234578 ((guint) 0x10028df)
#define SKK_KEYSYMS_braille_dots_678 ((guint) 0x10028e0)
#define SKK_KEYSYMS_braille_dots_1678 ((guint) 0x10028e1)
#define SKK_KEYSYMS_braille_dots_2678 ((guint) 0x10028e2)
#define SKK_KEYSYMS_braille_dots_12678 ((guint) 0x10028e3)
#define SKK_KEYSYMS_braille_dots_3678 ((guint) 0x10028e4)
#define SKK_KEYSYMS_braille_dots_13678 ((guint) 0x10028e5)
#define SKK_KEYSYMS_braille_dots_23678 ((guint) 0x10028e6)
#define SKK_KEYSYMS_braille_dots_123678 ((guint) 0x10028e7)
#define SKK_KEYSYMS_braille_dots_4678 ((guint) 0x10028e8)
#define SKK_KEYSYMS_braille_dots_14678 ((guint) 0x10028e9)
#define SKK_KEYSYMS_braille_dots_24678 ((guint) 0x10028ea)
#define SKK_KEYSYMS_braille_dots_124678 ((guint) 0x10028eb)
#define SKK_KEYSYMS_braille_dots_34678 ((guint) 0x10028ec)
#define SKK_KEYSYMS_braille_dots_134678 ((guint) 0x10028ed)
#define SKK_KEYSYMS_braille_dots_234678 ((guint) 0x10028ee)
#define SKK_KEYSYMS_braille_dots_1234678 ((guint) 0x10028ef)
#define SKK_KEYSYMS_braille_dots_5678 ((guint) 0x10028f0)
#define SKK_KEYSYMS_braille_dots_15678 ((guint) 0x10028f1)
#define SKK_KEYSYMS_braille_dots_25678 ((guint) 0x10028f2)
#define SKK_KEYSYMS_braille_dots_125678 ((guint) 0x10028f3)
#define SKK_KEYSYMS_braille_dots_35678 ((guint) 0x10028f4)
#define SKK_KEYSYMS_braille_dots_135678 ((guint) 0x10028f5)
#define SKK_KEYSYMS_braille_dots_235678 ((guint) 0x10028f6)
#define SKK_KEYSYMS_braille_dots_1235678 ((guint) 0x10028f7)
#define SKK_KEYSYMS_braille_dots_45678 ((guint) 0x10028f8)
#define SKK_KEYSYMS_braille_dots_145678 ((guint) 0x10028f9)
#define SKK_KEYSYMS_braille_dots_245678 ((guint) 0x10028fa)
#define SKK_KEYSYMS_braille_dots_1245678 ((guint) 0x10028fb)
#define SKK_KEYSYMS_braille_dots_345678 ((guint) 0x10028fc)
#define SKK_KEYSYMS_braille_dots_1345678 ((guint) 0x10028fd)
#define SKK_KEYSYMS_braille_dots_2345678 ((guint) 0x10028fe)
#define SKK_KEYSYMS_braille_dots_12345678 ((guint) 0x10028ff)
#define SKK_KEYSYMS_Sinh_ng ((guint) 0x1000d82)
#define SKK_KEYSYMS_Sinh_h2 ((guint) 0x1000d83)
#define SKK_KEYSYMS_Sinh_a ((guint) 0x1000d85)
#define SKK_KEYSYMS_Sinh_aa ((guint) 0x1000d86)
#define SKK_KEYSYMS_Sinh_ae ((guint) 0x1000d87)
#define SKK_KEYSYMS_Sinh_aee ((guint) 0x1000d88)
#define SKK_KEYSYMS_Sinh_i ((guint) 0x1000d89)
#define SKK_KEYSYMS_Sinh_ii ((guint) 0x1000d8a)
#define SKK_KEYSYMS_Sinh_u ((guint) 0x1000d8b)
#define SKK_KEYSYMS_Sinh_uu ((guint) 0x1000d8c)
#define SKK_KEYSYMS_Sinh_ri ((guint) 0x1000d8d)
#define SKK_KEYSYMS_Sinh_rii ((guint) 0x1000d8e)
#define SKK_KEYSYMS_Sinh_lu ((guint) 0x1000d8f)
#define SKK_KEYSYMS_Sinh_luu ((guint) 0x1000d90)
#define SKK_KEYSYMS_Sinh_e ((guint) 0x1000d91)
#define SKK_KEYSYMS_Sinh_ee ((guint) 0x1000d92)
#define SKK_KEYSYMS_Sinh_ai ((guint) 0x1000d93)
#define SKK_KEYSYMS_Sinh_o ((guint) 0x1000d94)
#define SKK_KEYSYMS_Sinh_oo ((guint) 0x1000d95)
#define SKK_KEYSYMS_Sinh_au ((guint) 0x1000d96)
#define SKK_KEYSYMS_Sinh_ka ((guint) 0x1000d9a)
#define SKK_KEYSYMS_Sinh_kha ((guint) 0x1000d9b)
#define SKK_KEYSYMS_Sinh_ga ((guint) 0x1000d9c)
#define SKK_KEYSYMS_Sinh_gha ((guint) 0x1000d9d)
#define SKK_KEYSYMS_Sinh_ng2 ((guint) 0x1000d9e)
#define SKK_KEYSYMS_Sinh_nga ((guint) 0x1000d9f)
#define SKK_KEYSYMS_Sinh_ca ((guint) 0x1000da0)
#define SKK_KEYSYMS_Sinh_cha ((guint) 0x1000da1)
#define SKK_KEYSYMS_Sinh_ja ((guint) 0x1000da2)
#define SKK_KEYSYMS_Sinh_jha ((guint) 0x1000da3)
#define SKK_KEYSYMS_Sinh_nya ((guint) 0x1000da4)
#define SKK_KEYSYMS_Sinh_jnya ((guint) 0x1000da5)
#define SKK_KEYSYMS_Sinh_nja ((guint) 0x1000da6)
#define SKK_KEYSYMS_Sinh_tta ((guint) 0x1000da7)
#define SKK_KEYSYMS_Sinh_ttha ((guint) 0x1000da8)
#define SKK_KEYSYMS_Sinh_dda ((guint) 0x1000da9)
#define SKK_KEYSYMS_Sinh_ddha ((guint) 0x1000daa)
#define SKK_KEYSYMS_Sinh_nna ((guint) 0x1000dab)
#define SKK_KEYSYMS_Sinh_ndda ((guint) 0x1000dac)
#define SKK_KEYSYMS_Sinh_tha ((guint) 0x1000dad)
#define SKK_KEYSYMS_Sinh_thha ((guint) 0x1000dae)
#define SKK_KEYSYMS_Sinh_dha ((guint) 0x1000daf)
#define SKK_KEYSYMS_Sinh_dhha ((guint) 0x1000db0)
#define SKK_KEYSYMS_Sinh_na ((guint) 0x1000db1)
#define SKK_KEYSYMS_Sinh_ndha ((guint) 0x1000db3)
#define SKK_KEYSYMS_Sinh_pa ((guint) 0x1000db4)
#define SKK_KEYSYMS_Sinh_pha ((guint) 0x1000db5)
#define SKK_KEYSYMS_Sinh_ba ((guint) 0x1000db6)
#define SKK_KEYSYMS_Sinh_bha ((guint) 0x1000db7)
#define SKK_KEYSYMS_Sinh_ma ((guint) 0x1000db8)
#define SKK_KEYSYMS_Sinh_mba ((guint) 0x1000db9)
#define SKK_KEYSYMS_Sinh_ya ((guint) 0x1000dba)
#define SKK_KEYSYMS_Sinh_ra ((guint) 0x1000dbb)
#define SKK_KEYSYMS_Sinh_la ((guint) 0x1000dbd)
#define SKK_KEYSYMS_Sinh_va ((guint) 0x1000dc0)
#define SKK_KEYSYMS_Sinh_sha ((guint) 0x1000dc1)
#define SKK_KEYSYMS_Sinh_ssha ((guint) 0x1000dc2)
#define SKK_KEYSYMS_Sinh_sa ((guint) 0x1000dc3)
#define SKK_KEYSYMS_Sinh_ha ((guint) 0x1000dc4)
#define SKK_KEYSYMS_Sinh_lla ((guint) 0x1000dc5)
#define SKK_KEYSYMS_Sinh_fa ((guint) 0x1000dc6)
#define SKK_KEYSYMS_Sinh_al ((guint) 0x1000dca)
#define SKK_KEYSYMS_Sinh_aa2 ((guint) 0x1000dcf)
#define SKK_KEYSYMS_Sinh_ae2 ((guint) 0x1000dd0)
#define SKK_KEYSYMS_Sinh_aee2 ((guint) 0x1000dd1)
#define SKK_KEYSYMS_Sinh_i2 ((guint) 0x1000dd2)
#define SKK_KEYSYMS_Sinh_ii2 ((guint) 0x1000dd3)
#define SKK_KEYSYMS_Sinh_u2 ((guint) 0x1000dd4)
#define SKK_KEYSYMS_Sinh_uu2 ((guint) 0x1000dd6)
#define SKK_KEYSYMS_Sinh_ru2 ((guint) 0x1000dd8)
#define SKK_KEYSYMS_Sinh_e2 ((guint) 0x1000dd9)
#define SKK_KEYSYMS_Sinh_ee2 ((guint) 0x1000dda)
#define SKK_KEYSYMS_Sinh_ai2 ((guint) 0x1000ddb)
#define SKK_KEYSYMS_Sinh_o2 ((guint) 0x1000ddc)
#define SKK_KEYSYMS_Sinh_oo2 ((guint) 0x1000ddd)
#define SKK_KEYSYMS_Sinh_au2 ((guint) 0x1000dde)
#define SKK_KEYSYMS_Sinh_lu2 ((guint) 0x1000ddf)
#define SKK_KEYSYMS_Sinh_ruu2 ((guint) 0x1000df2)
#define SKK_KEYSYMS_Sinh_luu2 ((guint) 0x1000df3)
#define SKK_KEYSYMS_Sinh_kunddaliya ((guint) 0x1000df4)


G_END_DECLS

#endif