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
2776
2777
2778
2779
2780
2781
2782
2783
2784
2785
2786
2787
2788
2789
2790
2791
2792
2793
2794
2795
2796
2797
2798
2799
2800
2801
2802
2803
2804
2805
2806
2807
2808
2809
2810
2811
2812
2813
2814
2815
2816
2817
2818
2819
2820
2821
2822
2823
2824
2825
2826
2827
2828
2829
2830
2831
2832
2833
2834
2835
2836
2837
2838
2839
2840
2841
2842
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854
2855
2856
2857
2858
2859
2860
2861
2862
2863
2864
2865
2866
2867
2868
2869
2870
2871
2872
2873
2874
2875
2876
2877
2878
2879
2880
2881
2882
2883
2884
2885
2886
2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899
2900
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924
2925
2926
2927
2928
2929
2930
2931
2932
2933
2934
2935
2936
2937
2938
2939
2940
2941
2942
2943
2944
2945
2946
2947
2948
2949
2950
2951
2952
2953
2954
2955
2956
2957
2958
2959
2960
2961
2962
2963
2964
2965
2966
2967
2968
2969
2970
2971
2972
2973
2974
2975
2976
2977
2978
2979
2980
2981
2982
2983
2984
2985
2986
2987
2988
2989
2990
2991
2992
2993
2994
2995
2996
2997
2998
2999
3000
3001
3002
3003
3004
3005
3006
3007
3008
3009
3010
3011
3012
3013
3014
3015
3016
3017
3018
3019
3020
3021
3022
3023
3024
3025
3026
3027
3028
3029
3030
3031
3032
3033
3034
3035
3036
3037
3038
3039
3040
3041
3042
3043
3044
3045
3046
3047
3048
3049
3050
3051
3052
3053
3054
3055
3056
3057
3058
3059
3060
3061
3062
3063
3064
3065
3066
3067
3068
3069
3070
3071
3072
3073
3074
3075
3076
3077
3078
3079
3080
3081
3082
3083
3084
3085
3086
3087
3088
3089
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099
3100
3101
3102
3103
3104
3105
3106
3107
3108
3109
3110
3111
3112
3113
3114
3115
3116
3117
3118
3119
3120
3121
3122
3123
3124
3125
3126
3127
3128
3129
3130
3131
3132
3133
3134
3135
3136
3137
3138
3139
3140
3141
3142
3143
3144
3145
3146
3147
3148
3149
3150
3151
3152
3153
3154
3155
3156
3157
3158
3159
3160
3161
3162
3163
3164
3165
3166
3167
3168
3169
3170
3171
3172
3173
3174
3175
3176
3177
3178
3179
3180
3181
3182
3183
3184
3185
3186
3187
3188
3189
3190
3191
3192
3193
3194
3195
3196
3197
3198
3199
3200
3201
3202
3203
3204
3205
3206
3207
3208
3209
3210
3211
3212
3213
3214
3215
3216
3217
3218
3219
3220
3221
3222
3223
3224
3225
3226
3227
3228
3229
3230
3231
3232
3233
3234
3235
3236
3237
3238
3239
3240
3241
3242
3243
3244
3245
3246
3247
3248
3249
3250
3251
3252
3253
3254
3255
3256
3257
3258
3259
3260
3261
3262
3263
3264
3265
3266
3267
3268
3269
3270
3271
3272
3273
3274
3275
3276
3277
3278
3279
3280
3281
3282
3283
3284
3285
3286
3287
3288
3289
3290
3291
3292
3293
3294
3295
3296
3297
3298
3299
3300
3301
3302
3303
3304
3305
3306
3307
3308
3309
3310
3311
3312
3313
3314
3315
3316
3317
3318
3319
3320
3321
3322
3323
3324
3325
3326
3327
3328
3329
3330
3331
3332
3333
3334
3335
3336
3337
3338
3339
3340
3341
3342
3343
3344
3345
3346
3347
3348
3349
3350
3351
3352
3353
3354
3355
3356
3357
3358
3359
3360
3361
3362
3363
3364
3365
3366
3367
3368
3369
3370
3371
3372
3373
3374
3375
3376
3377
3378
3379
3380
3381
3382
3383
3384
3385
3386
3387
3388
3389
3390
3391
3392
3393
3394
3395
3396
3397
3398
3399
3400
3401
3402
3403
3404
3405
3406
3407
3408
3409
3410
3411
3412
3413
3414
3415
3416
3417
3418
3419
3420
3421
3422
3423
3424
3425
3426
3427
3428
3429
3430
3431
3432
3433
3434
3435
3436
3437
3438
3439
3440
3441
3442
3443
3444
3445
3446
3447
3448
3449
3450
3451
3452
3453
3454
3455
3456
3457
3458
3459
3460
3461
3462
3463
3464
3465
3466
3467
3468
3469
3470
3471
3472
3473
3474
3475
3476
3477
3478
3479
3480
3481
3482
3483
3484
3485
3486
3487
3488
3489
3490
3491
3492
3493
3494
3495
3496
3497
3498
3499
3500
3501
3502
3503
3504
3505
3506
3507
3508
3509
3510
3511
3512
3513
3514
3515
3516
3517
3518
3519
3520
3521
3522
3523
3524
3525
3526
3527
3528
3529
3530
3531
3532
3533
3534
3535
3536
3537
3538
3539
3540
3541
3542
3543
3544
3545
3546
3547
3548
3549
3550
3551
3552
3553
3554
3555
3556
3557
3558
3559
3560
3561
3562
3563
3564
3565
3566
3567
3568
3569
3570
3571
3572
3573
3574
3575
3576
3577
3578
3579
3580
3581
3582
3583
3584
3585
3586
3587
3588
3589
3590
3591
3592
3593
3594
3595
3596
3597
3598
3599
3600
3601
3602
3603
3604
3605
3606
3607
3608
3609
3610
3611
3612
3613
3614
3615
3616
3617
3618
3619
3620
3621
3622
3623
3624
3625
3626
3627
3628
3629
3630
3631
3632
3633
3634
3635
3636
3637
3638
3639
3640
3641
3642
3643
3644
3645
3646
3647
3648
3649
3650
3651
3652
3653
3654
3655
3656
3657
3658
3659
3660
3661
3662
3663
3664
3665
3666
3667
3668
3669
3670
3671
3672
3673
3674
3675
3676
3677
3678
3679
3680
3681
3682
3683
3684
3685
3686
3687
3688
3689
3690
3691
3692
3693
3694
3695
3696
3697
3698
3699
3700
3701
3702
3703
3704
3705
3706
3707
3708
3709
3710
3711
3712
3713
3714
3715
3716
3717
3718
3719
3720
3721
3722
3723
3724
3725
3726
3727
3728
3729
3730
3731
3732
3733
3734
3735
3736
3737
3738
3739
3740
3741
3742
3743
3744
3745
3746
3747
3748
3749
3750
3751
3752
3753
3754
3755
3756
3757
3758
3759
3760
3761
3762
3763
3764
3765
3766
3767
3768
3769
3770
3771
3772
3773
3774
3775
3776
3777
3778
3779
3780
3781
3782
3783
3784
3785
3786
3787
3788
3789
3790
3791
3792
3793
3794
3795
3796
3797
3798
3799
3800
3801
3802
3803
3804
3805
3806
3807
3808
3809
3810
3811
3812
3813
3814
3815
3816
3817
3818
3819
3820
3821
3822
3823
3824
3825
3826
3827
3828
3829
3830
3831
3832
3833
3834
3835
3836
3837
3838
3839
3840
3841
3842
3843
3844
3845
3846
3847
3848
3849
3850
3851
3852
3853
3854
3855
3856
3857
3858
3859
3860
3861
3862
3863
3864
3865
3866
3867
3868
3869
3870
3871
3872
3873
3874
3875
3876
3877
3878
3879
3880
3881
3882
3883
3884
3885
3886
3887
3888
3889
3890
3891
3892
3893
3894
3895
3896
3897
3898
3899
3900
3901
3902
3903
3904
3905
3906
3907
3908
3909
3910
3911
3912
3913
3914
3915
3916
3917
3918
3919
3920
3921
3922
3923
3924
3925
3926
3927
3928
3929
3930
3931
3932
3933
3934
3935
3936
3937
3938
3939
3940
3941
3942
3943
3944
3945
3946
3947
3948
3949
3950
3951
3952
3953
3954
3955
3956
3957
3958
3959
3960
3961
3962
3963
3964
3965
3966
3967
3968
3969
3970
3971
3972
3973
3974
3975
3976
3977
3978
3979
3980
3981
3982
3983
3984
3985
3986
3987
3988
3989
3990
3991
3992
3993
3994
3995
3996
3997
3998
3999
4000
4001
4002
4003
4004
4005
4006
4007
4008
4009
4010
4011
4012
4013
4014
4015
4016
4017
4018
4019
4020
4021
4022
4023
4024
4025
4026
4027
4028
4029
4030
4031
4032
4033
4034
4035
4036
4037
4038
4039
4040
4041
4042
// This file was generated by gir (89daf8f) from gir-files (71d73f0)
// DO NOT EDIT

#![allow(non_camel_case_types, non_upper_case_globals)]

extern crate libc;
#[macro_use] extern crate bitflags;

#[allow(unused_imports)]
use libc::{c_int, c_char, c_uchar, c_float, c_uint, c_double,
    c_short, c_ushort, c_long, c_ulong,
    c_void, size_t, ssize_t, intptr_t, uintptr_t, time_t, FILE};

pub type gboolean = c_int;
pub const GFALSE:  c_int = 0;
pub const GTRUE:   c_int = 1;

pub type gconstpointer = *const c_void;
pub type gpointer = *mut c_void;

#[repr(C)]
pub struct Volatile<T>(T);


// Aliases
pub type GDateDay = u8;
pub type GDateYear = u16;
pub type GMutexLocker = gpointer;
pub type GPid = c_int;
pub type GQuark = u32;
pub type GStrv = gpointer;
pub type GTime = i32;
pub type GTimeSpan = i64;
pub type GType = size_t;

// Enums
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GBookmarkFileError {
    InvalidUri = 0,
    InvalidValue = 1,
    AppNotRegistered = 2,
    UriNotFound = 3,
    Read = 4,
    UnknownEncoding = 5,
    Write = 6,
    FileNotFound = 7,
}
pub const G_BOOKMARK_FILE_ERROR_INVALID_URI: GBookmarkFileError = GBookmarkFileError::InvalidUri;
pub const G_BOOKMARK_FILE_ERROR_INVALID_VALUE: GBookmarkFileError = GBookmarkFileError::InvalidValue;
pub const G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED: GBookmarkFileError = GBookmarkFileError::AppNotRegistered;
pub const G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND: GBookmarkFileError = GBookmarkFileError::UriNotFound;
pub const G_BOOKMARK_FILE_ERROR_READ: GBookmarkFileError = GBookmarkFileError::Read;
pub const G_BOOKMARK_FILE_ERROR_UNKNOWN_ENCODING: GBookmarkFileError = GBookmarkFileError::UnknownEncoding;
pub const G_BOOKMARK_FILE_ERROR_WRITE: GBookmarkFileError = GBookmarkFileError::Write;
pub const G_BOOKMARK_FILE_ERROR_FILE_NOT_FOUND: GBookmarkFileError = GBookmarkFileError::FileNotFound;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GChecksumType {
    Md5 = 0,
    Sha1 = 1,
    Sha256 = 2,
    Sha512 = 3,
}
pub const G_CHECKSUM_MD5: GChecksumType = GChecksumType::Md5;
pub const G_CHECKSUM_SHA1: GChecksumType = GChecksumType::Sha1;
pub const G_CHECKSUM_SHA256: GChecksumType = GChecksumType::Sha256;
pub const G_CHECKSUM_SHA512: GChecksumType = GChecksumType::Sha512;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GConvertError {
    NoConversion = 0,
    IllegalSequence = 1,
    Failed = 2,
    PartialInput = 3,
    BadUri = 4,
    NotAbsolutePath = 5,
    NoMemory = 6,
}
pub const G_CONVERT_ERROR_NO_CONVERSION: GConvertError = GConvertError::NoConversion;
pub const G_CONVERT_ERROR_ILLEGAL_SEQUENCE: GConvertError = GConvertError::IllegalSequence;
pub const G_CONVERT_ERROR_FAILED: GConvertError = GConvertError::Failed;
pub const G_CONVERT_ERROR_PARTIAL_INPUT: GConvertError = GConvertError::PartialInput;
pub const G_CONVERT_ERROR_BAD_URI: GConvertError = GConvertError::BadUri;
pub const G_CONVERT_ERROR_NOT_ABSOLUTE_PATH: GConvertError = GConvertError::NotAbsolutePath;
pub const G_CONVERT_ERROR_NO_MEMORY: GConvertError = GConvertError::NoMemory;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GDateDMY {
    Day = 0,
    Month = 1,
    Year = 2,
}
pub const G_DATE_DAY: GDateDMY = GDateDMY::Day;
pub const G_DATE_MONTH: GDateDMY = GDateDMY::Month;
pub const G_DATE_YEAR: GDateDMY = GDateDMY::Year;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GDateMonth {
    BadMonth = 0,
    January = 1,
    February = 2,
    March = 3,
    April = 4,
    May = 5,
    June = 6,
    July = 7,
    August = 8,
    September = 9,
    October = 10,
    November = 11,
    December = 12,
}
pub const G_DATE_BAD_MONTH: GDateMonth = GDateMonth::BadMonth;
pub const G_DATE_JANUARY: GDateMonth = GDateMonth::January;
pub const G_DATE_FEBRUARY: GDateMonth = GDateMonth::February;
pub const G_DATE_MARCH: GDateMonth = GDateMonth::March;
pub const G_DATE_APRIL: GDateMonth = GDateMonth::April;
pub const G_DATE_MAY: GDateMonth = GDateMonth::May;
pub const G_DATE_JUNE: GDateMonth = GDateMonth::June;
pub const G_DATE_JULY: GDateMonth = GDateMonth::July;
pub const G_DATE_AUGUST: GDateMonth = GDateMonth::August;
pub const G_DATE_SEPTEMBER: GDateMonth = GDateMonth::September;
pub const G_DATE_OCTOBER: GDateMonth = GDateMonth::October;
pub const G_DATE_NOVEMBER: GDateMonth = GDateMonth::November;
pub const G_DATE_DECEMBER: GDateMonth = GDateMonth::December;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GDateWeekday {
    BadWeekday = 0,
    Monday = 1,
    Tuesday = 2,
    Wednesday = 3,
    Thursday = 4,
    Friday = 5,
    Saturday = 6,
    Sunday = 7,
}
pub const G_DATE_BAD_WEEKDAY: GDateWeekday = GDateWeekday::BadWeekday;
pub const G_DATE_MONDAY: GDateWeekday = GDateWeekday::Monday;
pub const G_DATE_TUESDAY: GDateWeekday = GDateWeekday::Tuesday;
pub const G_DATE_WEDNESDAY: GDateWeekday = GDateWeekday::Wednesday;
pub const G_DATE_THURSDAY: GDateWeekday = GDateWeekday::Thursday;
pub const G_DATE_FRIDAY: GDateWeekday = GDateWeekday::Friday;
pub const G_DATE_SATURDAY: GDateWeekday = GDateWeekday::Saturday;
pub const G_DATE_SUNDAY: GDateWeekday = GDateWeekday::Sunday;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GErrorType {
    Unknown = 0,
    UnexpEof = 1,
    UnexpEofInString = 2,
    UnexpEofInComment = 3,
    NonDigitInConst = 4,
    DigitRadix = 5,
    FloatRadix = 6,
    FloatMalformed = 7,
}
pub const G_ERR_UNKNOWN: GErrorType = GErrorType::Unknown;
pub const G_ERR_UNEXP_EOF: GErrorType = GErrorType::UnexpEof;
pub const G_ERR_UNEXP_EOF_IN_STRING: GErrorType = GErrorType::UnexpEofInString;
pub const G_ERR_UNEXP_EOF_IN_COMMENT: GErrorType = GErrorType::UnexpEofInComment;
pub const G_ERR_NON_DIGIT_IN_CONST: GErrorType = GErrorType::NonDigitInConst;
pub const G_ERR_DIGIT_RADIX: GErrorType = GErrorType::DigitRadix;
pub const G_ERR_FLOAT_RADIX: GErrorType = GErrorType::FloatRadix;
pub const G_ERR_FLOAT_MALFORMED: GErrorType = GErrorType::FloatMalformed;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GFileError {
    Exist = 0,
    Isdir = 1,
    Acces = 2,
    Nametoolong = 3,
    Noent = 4,
    Notdir = 5,
    Nxio = 6,
    Nodev = 7,
    Rofs = 8,
    Txtbsy = 9,
    Fault = 10,
    Loop = 11,
    Nospc = 12,
    Nomem = 13,
    Mfile = 14,
    Nfile = 15,
    Badf = 16,
    Inval = 17,
    Pipe = 18,
    Again = 19,
    Intr = 20,
    Io = 21,
    Perm = 22,
    Nosys = 23,
    Failed = 24,
}
pub const G_FILE_ERROR_EXIST: GFileError = GFileError::Exist;
pub const G_FILE_ERROR_ISDIR: GFileError = GFileError::Isdir;
pub const G_FILE_ERROR_ACCES: GFileError = GFileError::Acces;
pub const G_FILE_ERROR_NAMETOOLONG: GFileError = GFileError::Nametoolong;
pub const G_FILE_ERROR_NOENT: GFileError = GFileError::Noent;
pub const G_FILE_ERROR_NOTDIR: GFileError = GFileError::Notdir;
pub const G_FILE_ERROR_NXIO: GFileError = GFileError::Nxio;
pub const G_FILE_ERROR_NODEV: GFileError = GFileError::Nodev;
pub const G_FILE_ERROR_ROFS: GFileError = GFileError::Rofs;
pub const G_FILE_ERROR_TXTBSY: GFileError = GFileError::Txtbsy;
pub const G_FILE_ERROR_FAULT: GFileError = GFileError::Fault;
pub const G_FILE_ERROR_LOOP: GFileError = GFileError::Loop;
pub const G_FILE_ERROR_NOSPC: GFileError = GFileError::Nospc;
pub const G_FILE_ERROR_NOMEM: GFileError = GFileError::Nomem;
pub const G_FILE_ERROR_MFILE: GFileError = GFileError::Mfile;
pub const G_FILE_ERROR_NFILE: GFileError = GFileError::Nfile;
pub const G_FILE_ERROR_BADF: GFileError = GFileError::Badf;
pub const G_FILE_ERROR_INVAL: GFileError = GFileError::Inval;
pub const G_FILE_ERROR_PIPE: GFileError = GFileError::Pipe;
pub const G_FILE_ERROR_AGAIN: GFileError = GFileError::Again;
pub const G_FILE_ERROR_INTR: GFileError = GFileError::Intr;
pub const G_FILE_ERROR_IO: GFileError = GFileError::Io;
pub const G_FILE_ERROR_PERM: GFileError = GFileError::Perm;
pub const G_FILE_ERROR_NOSYS: GFileError = GFileError::Nosys;
pub const G_FILE_ERROR_FAILED: GFileError = GFileError::Failed;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GIOChannelError {
    Fbig = 0,
    Inval = 1,
    Io = 2,
    Isdir = 3,
    Nospc = 4,
    Nxio = 5,
    Overflow = 6,
    Pipe = 7,
    Failed = 8,
}
pub const G_IO_CHANNEL_ERROR_FBIG: GIOChannelError = GIOChannelError::Fbig;
pub const G_IO_CHANNEL_ERROR_INVAL: GIOChannelError = GIOChannelError::Inval;
pub const G_IO_CHANNEL_ERROR_IO: GIOChannelError = GIOChannelError::Io;
pub const G_IO_CHANNEL_ERROR_ISDIR: GIOChannelError = GIOChannelError::Isdir;
pub const G_IO_CHANNEL_ERROR_NOSPC: GIOChannelError = GIOChannelError::Nospc;
pub const G_IO_CHANNEL_ERROR_NXIO: GIOChannelError = GIOChannelError::Nxio;
pub const G_IO_CHANNEL_ERROR_OVERFLOW: GIOChannelError = GIOChannelError::Overflow;
pub const G_IO_CHANNEL_ERROR_PIPE: GIOChannelError = GIOChannelError::Pipe;
pub const G_IO_CHANNEL_ERROR_FAILED: GIOChannelError = GIOChannelError::Failed;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GIOError {
    None = 0,
    Again = 1,
    Inval = 2,
    Unknown = 3,
}
pub const G_IO_ERROR_NONE: GIOError = GIOError::None;
pub const G_IO_ERROR_AGAIN: GIOError = GIOError::Again;
pub const G_IO_ERROR_INVAL: GIOError = GIOError::Inval;
pub const G_IO_ERROR_UNKNOWN: GIOError = GIOError::Unknown;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GIOStatus {
    Error = 0,
    Normal = 1,
    Eof = 2,
    Again = 3,
}
pub const G_IO_STATUS_ERROR: GIOStatus = GIOStatus::Error;
pub const G_IO_STATUS_NORMAL: GIOStatus = GIOStatus::Normal;
pub const G_IO_STATUS_EOF: GIOStatus = GIOStatus::Eof;
pub const G_IO_STATUS_AGAIN: GIOStatus = GIOStatus::Again;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GKeyFileError {
    UnknownEncoding = 0,
    Parse = 1,
    NotFound = 2,
    KeyNotFound = 3,
    GroupNotFound = 4,
    InvalidValue = 5,
}
pub const G_KEY_FILE_ERROR_UNKNOWN_ENCODING: GKeyFileError = GKeyFileError::UnknownEncoding;
pub const G_KEY_FILE_ERROR_PARSE: GKeyFileError = GKeyFileError::Parse;
pub const G_KEY_FILE_ERROR_NOT_FOUND: GKeyFileError = GKeyFileError::NotFound;
pub const G_KEY_FILE_ERROR_KEY_NOT_FOUND: GKeyFileError = GKeyFileError::KeyNotFound;
pub const G_KEY_FILE_ERROR_GROUP_NOT_FOUND: GKeyFileError = GKeyFileError::GroupNotFound;
pub const G_KEY_FILE_ERROR_INVALID_VALUE: GKeyFileError = GKeyFileError::InvalidValue;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GLogWriterOutput {
    Handled = 1,
    Unhandled = 0,
}
pub const G_LOG_WRITER_HANDLED: GLogWriterOutput = GLogWriterOutput::Handled;
pub const G_LOG_WRITER_UNHANDLED: GLogWriterOutput = GLogWriterOutput::Unhandled;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GMarkupError {
    BadUtf8 = 0,
    Empty = 1,
    Parse = 2,
    UnknownElement = 3,
    UnknownAttribute = 4,
    InvalidContent = 5,
    MissingAttribute = 6,
}
pub const G_MARKUP_ERROR_BAD_UTF8: GMarkupError = GMarkupError::BadUtf8;
pub const G_MARKUP_ERROR_EMPTY: GMarkupError = GMarkupError::Empty;
pub const G_MARKUP_ERROR_PARSE: GMarkupError = GMarkupError::Parse;
pub const G_MARKUP_ERROR_UNKNOWN_ELEMENT: GMarkupError = GMarkupError::UnknownElement;
pub const G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE: GMarkupError = GMarkupError::UnknownAttribute;
pub const G_MARKUP_ERROR_INVALID_CONTENT: GMarkupError = GMarkupError::InvalidContent;
pub const G_MARKUP_ERROR_MISSING_ATTRIBUTE: GMarkupError = GMarkupError::MissingAttribute;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GNormalizeMode {
    Default = 0,
    DefaultCompose = 1,
    All = 2,
    AllCompose = 3,
}
pub const G_NORMALIZE_DEFAULT: GNormalizeMode = GNormalizeMode::Default;
pub const G_NORMALIZE_NFD: GNormalizeMode = GNormalizeMode::Default;
pub const G_NORMALIZE_DEFAULT_COMPOSE: GNormalizeMode = GNormalizeMode::DefaultCompose;
pub const G_NORMALIZE_NFC: GNormalizeMode = GNormalizeMode::DefaultCompose;
pub const G_NORMALIZE_ALL: GNormalizeMode = GNormalizeMode::All;
pub const G_NORMALIZE_NFKD: GNormalizeMode = GNormalizeMode::All;
pub const G_NORMALIZE_ALL_COMPOSE: GNormalizeMode = GNormalizeMode::AllCompose;
pub const G_NORMALIZE_NFKC: GNormalizeMode = GNormalizeMode::AllCompose;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GOnceStatus {
    Notcalled = 0,
    Progress = 1,
    Ready = 2,
}
pub const G_ONCE_STATUS_NOTCALLED: GOnceStatus = GOnceStatus::Notcalled;
pub const G_ONCE_STATUS_PROGRESS: GOnceStatus = GOnceStatus::Progress;
pub const G_ONCE_STATUS_READY: GOnceStatus = GOnceStatus::Ready;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GOptionArg {
    None = 0,
    String = 1,
    Int = 2,
    Callback = 3,
    Filename = 4,
    StringArray = 5,
    FilenameArray = 6,
    Double = 7,
    Int64 = 8,
}
pub const G_OPTION_ARG_NONE: GOptionArg = GOptionArg::None;
pub const G_OPTION_ARG_STRING: GOptionArg = GOptionArg::String;
pub const G_OPTION_ARG_INT: GOptionArg = GOptionArg::Int;
pub const G_OPTION_ARG_CALLBACK: GOptionArg = GOptionArg::Callback;
pub const G_OPTION_ARG_FILENAME: GOptionArg = GOptionArg::Filename;
pub const G_OPTION_ARG_STRING_ARRAY: GOptionArg = GOptionArg::StringArray;
pub const G_OPTION_ARG_FILENAME_ARRAY: GOptionArg = GOptionArg::FilenameArray;
pub const G_OPTION_ARG_DOUBLE: GOptionArg = GOptionArg::Double;
pub const G_OPTION_ARG_INT64: GOptionArg = GOptionArg::Int64;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GOptionError {
    UnknownOption = 0,
    BadValue = 1,
    Failed = 2,
}
pub const G_OPTION_ERROR_UNKNOWN_OPTION: GOptionError = GOptionError::UnknownOption;
pub const G_OPTION_ERROR_BAD_VALUE: GOptionError = GOptionError::BadValue;
pub const G_OPTION_ERROR_FAILED: GOptionError = GOptionError::Failed;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GRegexError {
    Compile = 0,
    Optimize = 1,
    Replace = 2,
    Match = 3,
    Internal = 4,
    StrayBackslash = 101,
    MissingControlChar = 102,
    UnrecognizedEscape = 103,
    QuantifiersOutOfOrder = 104,
    QuantifierTooBig = 105,
    UnterminatedCharacterClass = 106,
    InvalidEscapeInCharacterClass = 107,
    RangeOutOfOrder = 108,
    NothingToRepeat = 109,
    UnrecognizedCharacter = 112,
    PosixNamedClassOutsideClass = 113,
    UnmatchedParenthesis = 114,
    InexistentSubpatternReference = 115,
    UnterminatedComment = 118,
    ExpressionTooLarge = 120,
    MemoryError = 121,
    VariableLengthLookbehind = 125,
    MalformedCondition = 126,
    TooManyConditionalBranches = 127,
    AssertionExpected = 128,
    UnknownPosixClassName = 130,
    PosixCollatingElementsNotSupported = 131,
    HexCodeTooLarge = 134,
    InvalidCondition = 135,
    SingleByteMatchInLookbehind = 136,
    InfiniteLoop = 140,
    MissingSubpatternNameTerminator = 142,
    DuplicateSubpatternName = 143,
    MalformedProperty = 146,
    UnknownProperty = 147,
    SubpatternNameTooLong = 148,
    TooManySubpatterns = 149,
    InvalidOctalValue = 151,
    TooManyBranchesInDefine = 154,
    DefineRepetion = 155,
    InconsistentNewlineOptions = 156,
    MissingBackReference = 157,
    InvalidRelativeReference = 158,
    BacktrackingControlVerbArgumentForbidden = 159,
    UnknownBacktrackingControlVerb = 160,
    NumberTooBig = 161,
    MissingSubpatternName = 162,
    MissingDigit = 163,
    InvalidDataCharacter = 164,
    ExtraSubpatternName = 165,
    BacktrackingControlVerbArgumentRequired = 166,
    InvalidControlChar = 168,
    MissingName = 169,
    NotSupportedInClass = 171,
    TooManyForwardReferences = 172,
    NameTooLong = 175,
    CharacterValueTooLarge = 176,
}
pub const G_REGEX_ERROR_COMPILE: GRegexError = GRegexError::Compile;
pub const G_REGEX_ERROR_OPTIMIZE: GRegexError = GRegexError::Optimize;
pub const G_REGEX_ERROR_REPLACE: GRegexError = GRegexError::Replace;
pub const G_REGEX_ERROR_MATCH: GRegexError = GRegexError::Match;
pub const G_REGEX_ERROR_INTERNAL: GRegexError = GRegexError::Internal;
pub const G_REGEX_ERROR_STRAY_BACKSLASH: GRegexError = GRegexError::StrayBackslash;
pub const G_REGEX_ERROR_MISSING_CONTROL_CHAR: GRegexError = GRegexError::MissingControlChar;
pub const G_REGEX_ERROR_UNRECOGNIZED_ESCAPE: GRegexError = GRegexError::UnrecognizedEscape;
pub const G_REGEX_ERROR_QUANTIFIERS_OUT_OF_ORDER: GRegexError = GRegexError::QuantifiersOutOfOrder;
pub const G_REGEX_ERROR_QUANTIFIER_TOO_BIG: GRegexError = GRegexError::QuantifierTooBig;
pub const G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS: GRegexError = GRegexError::UnterminatedCharacterClass;
pub const G_REGEX_ERROR_INVALID_ESCAPE_IN_CHARACTER_CLASS: GRegexError = GRegexError::InvalidEscapeInCharacterClass;
pub const G_REGEX_ERROR_RANGE_OUT_OF_ORDER: GRegexError = GRegexError::RangeOutOfOrder;
pub const G_REGEX_ERROR_NOTHING_TO_REPEAT: GRegexError = GRegexError::NothingToRepeat;
pub const G_REGEX_ERROR_UNRECOGNIZED_CHARACTER: GRegexError = GRegexError::UnrecognizedCharacter;
pub const G_REGEX_ERROR_POSIX_NAMED_CLASS_OUTSIDE_CLASS: GRegexError = GRegexError::PosixNamedClassOutsideClass;
pub const G_REGEX_ERROR_UNMATCHED_PARENTHESIS: GRegexError = GRegexError::UnmatchedParenthesis;
pub const G_REGEX_ERROR_INEXISTENT_SUBPATTERN_REFERENCE: GRegexError = GRegexError::InexistentSubpatternReference;
pub const G_REGEX_ERROR_UNTERMINATED_COMMENT: GRegexError = GRegexError::UnterminatedComment;
pub const G_REGEX_ERROR_EXPRESSION_TOO_LARGE: GRegexError = GRegexError::ExpressionTooLarge;
pub const G_REGEX_ERROR_MEMORY_ERROR: GRegexError = GRegexError::MemoryError;
pub const G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND: GRegexError = GRegexError::VariableLengthLookbehind;
pub const G_REGEX_ERROR_MALFORMED_CONDITION: GRegexError = GRegexError::MalformedCondition;
pub const G_REGEX_ERROR_TOO_MANY_CONDITIONAL_BRANCHES: GRegexError = GRegexError::TooManyConditionalBranches;
pub const G_REGEX_ERROR_ASSERTION_EXPECTED: GRegexError = GRegexError::AssertionExpected;
pub const G_REGEX_ERROR_UNKNOWN_POSIX_CLASS_NAME: GRegexError = GRegexError::UnknownPosixClassName;
pub const G_REGEX_ERROR_POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED: GRegexError = GRegexError::PosixCollatingElementsNotSupported;
pub const G_REGEX_ERROR_HEX_CODE_TOO_LARGE: GRegexError = GRegexError::HexCodeTooLarge;
pub const G_REGEX_ERROR_INVALID_CONDITION: GRegexError = GRegexError::InvalidCondition;
pub const G_REGEX_ERROR_SINGLE_BYTE_MATCH_IN_LOOKBEHIND: GRegexError = GRegexError::SingleByteMatchInLookbehind;
pub const G_REGEX_ERROR_INFINITE_LOOP: GRegexError = GRegexError::InfiniteLoop;
pub const G_REGEX_ERROR_MISSING_SUBPATTERN_NAME_TERMINATOR: GRegexError = GRegexError::MissingSubpatternNameTerminator;
pub const G_REGEX_ERROR_DUPLICATE_SUBPATTERN_NAME: GRegexError = GRegexError::DuplicateSubpatternName;
pub const G_REGEX_ERROR_MALFORMED_PROPERTY: GRegexError = GRegexError::MalformedProperty;
pub const G_REGEX_ERROR_UNKNOWN_PROPERTY: GRegexError = GRegexError::UnknownProperty;
pub const G_REGEX_ERROR_SUBPATTERN_NAME_TOO_LONG: GRegexError = GRegexError::SubpatternNameTooLong;
pub const G_REGEX_ERROR_TOO_MANY_SUBPATTERNS: GRegexError = GRegexError::TooManySubpatterns;
pub const G_REGEX_ERROR_INVALID_OCTAL_VALUE: GRegexError = GRegexError::InvalidOctalValue;
pub const G_REGEX_ERROR_TOO_MANY_BRANCHES_IN_DEFINE: GRegexError = GRegexError::TooManyBranchesInDefine;
pub const G_REGEX_ERROR_DEFINE_REPETION: GRegexError = GRegexError::DefineRepetion;
pub const G_REGEX_ERROR_INCONSISTENT_NEWLINE_OPTIONS: GRegexError = GRegexError::InconsistentNewlineOptions;
pub const G_REGEX_ERROR_MISSING_BACK_REFERENCE: GRegexError = GRegexError::MissingBackReference;
pub const G_REGEX_ERROR_INVALID_RELATIVE_REFERENCE: GRegexError = GRegexError::InvalidRelativeReference;
pub const G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_FORBIDDEN: GRegexError = GRegexError::BacktrackingControlVerbArgumentForbidden;
pub const G_REGEX_ERROR_UNKNOWN_BACKTRACKING_CONTROL_VERB: GRegexError = GRegexError::UnknownBacktrackingControlVerb;
pub const G_REGEX_ERROR_NUMBER_TOO_BIG: GRegexError = GRegexError::NumberTooBig;
pub const G_REGEX_ERROR_MISSING_SUBPATTERN_NAME: GRegexError = GRegexError::MissingSubpatternName;
pub const G_REGEX_ERROR_MISSING_DIGIT: GRegexError = GRegexError::MissingDigit;
pub const G_REGEX_ERROR_INVALID_DATA_CHARACTER: GRegexError = GRegexError::InvalidDataCharacter;
pub const G_REGEX_ERROR_EXTRA_SUBPATTERN_NAME: GRegexError = GRegexError::ExtraSubpatternName;
pub const G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED: GRegexError = GRegexError::BacktrackingControlVerbArgumentRequired;
pub const G_REGEX_ERROR_INVALID_CONTROL_CHAR: GRegexError = GRegexError::InvalidControlChar;
pub const G_REGEX_ERROR_MISSING_NAME: GRegexError = GRegexError::MissingName;
pub const G_REGEX_ERROR_NOT_SUPPORTED_IN_CLASS: GRegexError = GRegexError::NotSupportedInClass;
pub const G_REGEX_ERROR_TOO_MANY_FORWARD_REFERENCES: GRegexError = GRegexError::TooManyForwardReferences;
pub const G_REGEX_ERROR_NAME_TOO_LONG: GRegexError = GRegexError::NameTooLong;
pub const G_REGEX_ERROR_CHARACTER_VALUE_TOO_LARGE: GRegexError = GRegexError::CharacterValueTooLarge;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GSeekType {
    Cur = 0,
    Set = 1,
    End = 2,
}
pub const G_SEEK_CUR: GSeekType = GSeekType::Cur;
pub const G_SEEK_SET: GSeekType = GSeekType::Set;
pub const G_SEEK_END: GSeekType = GSeekType::End;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GShellError {
    BadQuoting = 0,
    EmptyString = 1,
    Failed = 2,
}
pub const G_SHELL_ERROR_BAD_QUOTING: GShellError = GShellError::BadQuoting;
pub const G_SHELL_ERROR_EMPTY_STRING: GShellError = GShellError::EmptyString;
pub const G_SHELL_ERROR_FAILED: GShellError = GShellError::Failed;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GSliceConfig {
    AlwaysMalloc = 1,
    BypassMagazines = 2,
    WorkingSetMsecs = 3,
    ColorIncrement = 4,
    ChunkSizes = 5,
    ContentionCounter = 6,
}
pub const G_SLICE_CONFIG_ALWAYS_MALLOC: GSliceConfig = GSliceConfig::AlwaysMalloc;
pub const G_SLICE_CONFIG_BYPASS_MAGAZINES: GSliceConfig = GSliceConfig::BypassMagazines;
pub const G_SLICE_CONFIG_WORKING_SET_MSECS: GSliceConfig = GSliceConfig::WorkingSetMsecs;
pub const G_SLICE_CONFIG_COLOR_INCREMENT: GSliceConfig = GSliceConfig::ColorIncrement;
pub const G_SLICE_CONFIG_CHUNK_SIZES: GSliceConfig = GSliceConfig::ChunkSizes;
pub const G_SLICE_CONFIG_CONTENTION_COUNTER: GSliceConfig = GSliceConfig::ContentionCounter;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GSpawnError {
    Fork = 0,
    Read = 1,
    Chdir = 2,
    Acces = 3,
    Perm = 4,
    TooBig = 5,
    Noexec = 6,
    Nametoolong = 7,
    Noent = 8,
    Nomem = 9,
    Notdir = 10,
    Loop = 11,
    Txtbusy = 12,
    Io = 13,
    Nfile = 14,
    Mfile = 15,
    Inval = 16,
    Isdir = 17,
    Libbad = 18,
    Failed = 19,
}
pub const G_SPAWN_ERROR_FORK: GSpawnError = GSpawnError::Fork;
pub const G_SPAWN_ERROR_READ: GSpawnError = GSpawnError::Read;
pub const G_SPAWN_ERROR_CHDIR: GSpawnError = GSpawnError::Chdir;
pub const G_SPAWN_ERROR_ACCES: GSpawnError = GSpawnError::Acces;
pub const G_SPAWN_ERROR_PERM: GSpawnError = GSpawnError::Perm;
pub const G_SPAWN_ERROR_TOO_BIG: GSpawnError = GSpawnError::TooBig;
pub const G_SPAWN_ERROR_2BIG: GSpawnError = GSpawnError::TooBig;
pub const G_SPAWN_ERROR_NOEXEC: GSpawnError = GSpawnError::Noexec;
pub const G_SPAWN_ERROR_NAMETOOLONG: GSpawnError = GSpawnError::Nametoolong;
pub const G_SPAWN_ERROR_NOENT: GSpawnError = GSpawnError::Noent;
pub const G_SPAWN_ERROR_NOMEM: GSpawnError = GSpawnError::Nomem;
pub const G_SPAWN_ERROR_NOTDIR: GSpawnError = GSpawnError::Notdir;
pub const G_SPAWN_ERROR_LOOP: GSpawnError = GSpawnError::Loop;
pub const G_SPAWN_ERROR_TXTBUSY: GSpawnError = GSpawnError::Txtbusy;
pub const G_SPAWN_ERROR_IO: GSpawnError = GSpawnError::Io;
pub const G_SPAWN_ERROR_NFILE: GSpawnError = GSpawnError::Nfile;
pub const G_SPAWN_ERROR_MFILE: GSpawnError = GSpawnError::Mfile;
pub const G_SPAWN_ERROR_INVAL: GSpawnError = GSpawnError::Inval;
pub const G_SPAWN_ERROR_ISDIR: GSpawnError = GSpawnError::Isdir;
pub const G_SPAWN_ERROR_LIBBAD: GSpawnError = GSpawnError::Libbad;
pub const G_SPAWN_ERROR_FAILED: GSpawnError = GSpawnError::Failed;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GTestFileType {
    Dist = 0,
    Built = 1,
}
pub const G_TEST_DIST: GTestFileType = GTestFileType::Dist;
pub const G_TEST_BUILT: GTestFileType = GTestFileType::Built;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GTestLogType {
    None = 0,
    Error = 1,
    StartBinary = 2,
    ListCase = 3,
    SkipCase = 4,
    StartCase = 5,
    StopCase = 6,
    MinResult = 7,
    MaxResult = 8,
    Message = 9,
    StartSuite = 10,
    StopSuite = 11,
}
pub const G_TEST_LOG_NONE: GTestLogType = GTestLogType::None;
pub const G_TEST_LOG_ERROR: GTestLogType = GTestLogType::Error;
pub const G_TEST_LOG_START_BINARY: GTestLogType = GTestLogType::StartBinary;
pub const G_TEST_LOG_LIST_CASE: GTestLogType = GTestLogType::ListCase;
pub const G_TEST_LOG_SKIP_CASE: GTestLogType = GTestLogType::SkipCase;
pub const G_TEST_LOG_START_CASE: GTestLogType = GTestLogType::StartCase;
pub const G_TEST_LOG_STOP_CASE: GTestLogType = GTestLogType::StopCase;
pub const G_TEST_LOG_MIN_RESULT: GTestLogType = GTestLogType::MinResult;
pub const G_TEST_LOG_MAX_RESULT: GTestLogType = GTestLogType::MaxResult;
pub const G_TEST_LOG_MESSAGE: GTestLogType = GTestLogType::Message;
pub const G_TEST_LOG_START_SUITE: GTestLogType = GTestLogType::StartSuite;
pub const G_TEST_LOG_STOP_SUITE: GTestLogType = GTestLogType::StopSuite;

pub type ThreadError = c_int;
pub const G_THREAD_ERROR_AGAIN: ThreadError = 0;
pub type GThreadError = ThreadError;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GTimeType {
    Standard = 0,
    Daylight = 1,
    Universal = 2,
}
pub const G_TIME_TYPE_STANDARD: GTimeType = GTimeType::Standard;
pub const G_TIME_TYPE_DAYLIGHT: GTimeType = GTimeType::Daylight;
pub const G_TIME_TYPE_UNIVERSAL: GTimeType = GTimeType::Universal;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GTokenType {
    Eof = 0,
    LeftParen = 40,
    RightParen = 41,
    LeftCurly = 123,
    RightCurly = 125,
    LeftBrace = 91,
    RightBrace = 93,
    EqualSign = 61,
    Comma = 44,
    None = 256,
    Error = 257,
    Char = 258,
    Binary = 259,
    Octal = 260,
    Int = 261,
    Hex = 262,
    Float = 263,
    String = 264,
    Symbol = 265,
    Identifier = 266,
    IdentifierNull = 267,
    CommentSingle = 268,
    CommentMulti = 269,
}
pub const G_TOKEN_EOF: GTokenType = GTokenType::Eof;
pub const G_TOKEN_LEFT_PAREN: GTokenType = GTokenType::LeftParen;
pub const G_TOKEN_RIGHT_PAREN: GTokenType = GTokenType::RightParen;
pub const G_TOKEN_LEFT_CURLY: GTokenType = GTokenType::LeftCurly;
pub const G_TOKEN_RIGHT_CURLY: GTokenType = GTokenType::RightCurly;
pub const G_TOKEN_LEFT_BRACE: GTokenType = GTokenType::LeftBrace;
pub const G_TOKEN_RIGHT_BRACE: GTokenType = GTokenType::RightBrace;
pub const G_TOKEN_EQUAL_SIGN: GTokenType = GTokenType::EqualSign;
pub const G_TOKEN_COMMA: GTokenType = GTokenType::Comma;
pub const G_TOKEN_NONE: GTokenType = GTokenType::None;
pub const G_TOKEN_ERROR: GTokenType = GTokenType::Error;
pub const G_TOKEN_CHAR: GTokenType = GTokenType::Char;
pub const G_TOKEN_BINARY: GTokenType = GTokenType::Binary;
pub const G_TOKEN_OCTAL: GTokenType = GTokenType::Octal;
pub const G_TOKEN_INT: GTokenType = GTokenType::Int;
pub const G_TOKEN_HEX: GTokenType = GTokenType::Hex;
pub const G_TOKEN_FLOAT: GTokenType = GTokenType::Float;
pub const G_TOKEN_STRING: GTokenType = GTokenType::String;
pub const G_TOKEN_SYMBOL: GTokenType = GTokenType::Symbol;
pub const G_TOKEN_IDENTIFIER: GTokenType = GTokenType::Identifier;
pub const G_TOKEN_IDENTIFIER_NULL: GTokenType = GTokenType::IdentifierNull;
pub const G_TOKEN_COMMENT_SINGLE: GTokenType = GTokenType::CommentSingle;
pub const G_TOKEN_COMMENT_MULTI: GTokenType = GTokenType::CommentMulti;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GTraverseType {
    InOrder = 0,
    PreOrder = 1,
    PostOrder = 2,
    LevelOrder = 3,
}
pub const G_IN_ORDER: GTraverseType = GTraverseType::InOrder;
pub const G_PRE_ORDER: GTraverseType = GTraverseType::PreOrder;
pub const G_POST_ORDER: GTraverseType = GTraverseType::PostOrder;
pub const G_LEVEL_ORDER: GTraverseType = GTraverseType::LevelOrder;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GUnicodeBreakType {
    Mandatory = 0,
    CarriageReturn = 1,
    LineFeed = 2,
    CombiningMark = 3,
    Surrogate = 4,
    ZeroWidthSpace = 5,
    Inseparable = 6,
    NonBreakingGlue = 7,
    Contingent = 8,
    Space = 9,
    After = 10,
    Before = 11,
    BeforeAndAfter = 12,
    Hyphen = 13,
    NonStarter = 14,
    OpenPunctuation = 15,
    ClosePunctuation = 16,
    Quotation = 17,
    Exclamation = 18,
    Ideographic = 19,
    Numeric = 20,
    InfixSeparator = 21,
    Symbol = 22,
    Alphabetic = 23,
    Prefix = 24,
    Postfix = 25,
    ComplexContext = 26,
    Ambiguous = 27,
    Unknown = 28,
    NextLine = 29,
    WordJoiner = 30,
    HangulLJamo = 31,
    HangulVJamo = 32,
    HangulTJamo = 33,
    HangulLvSyllable = 34,
    HangulLvtSyllable = 35,
    CloseParanthesis = 36,
    ConditionalJapaneseStarter = 37,
    HebrewLetter = 38,
    RegionalIndicator = 39,
}
pub const G_UNICODE_BREAK_MANDATORY: GUnicodeBreakType = GUnicodeBreakType::Mandatory;
pub const G_UNICODE_BREAK_CARRIAGE_RETURN: GUnicodeBreakType = GUnicodeBreakType::CarriageReturn;
pub const G_UNICODE_BREAK_LINE_FEED: GUnicodeBreakType = GUnicodeBreakType::LineFeed;
pub const G_UNICODE_BREAK_COMBINING_MARK: GUnicodeBreakType = GUnicodeBreakType::CombiningMark;
pub const G_UNICODE_BREAK_SURROGATE: GUnicodeBreakType = GUnicodeBreakType::Surrogate;
pub const G_UNICODE_BREAK_ZERO_WIDTH_SPACE: GUnicodeBreakType = GUnicodeBreakType::ZeroWidthSpace;
pub const G_UNICODE_BREAK_INSEPARABLE: GUnicodeBreakType = GUnicodeBreakType::Inseparable;
pub const G_UNICODE_BREAK_NON_BREAKING_GLUE: GUnicodeBreakType = GUnicodeBreakType::NonBreakingGlue;
pub const G_UNICODE_BREAK_CONTINGENT: GUnicodeBreakType = GUnicodeBreakType::Contingent;
pub const G_UNICODE_BREAK_SPACE: GUnicodeBreakType = GUnicodeBreakType::Space;
pub const G_UNICODE_BREAK_AFTER: GUnicodeBreakType = GUnicodeBreakType::After;
pub const G_UNICODE_BREAK_BEFORE: GUnicodeBreakType = GUnicodeBreakType::Before;
pub const G_UNICODE_BREAK_BEFORE_AND_AFTER: GUnicodeBreakType = GUnicodeBreakType::BeforeAndAfter;
pub const G_UNICODE_BREAK_HYPHEN: GUnicodeBreakType = GUnicodeBreakType::Hyphen;
pub const G_UNICODE_BREAK_NON_STARTER: GUnicodeBreakType = GUnicodeBreakType::NonStarter;
pub const G_UNICODE_BREAK_OPEN_PUNCTUATION: GUnicodeBreakType = GUnicodeBreakType::OpenPunctuation;
pub const G_UNICODE_BREAK_CLOSE_PUNCTUATION: GUnicodeBreakType = GUnicodeBreakType::ClosePunctuation;
pub const G_UNICODE_BREAK_QUOTATION: GUnicodeBreakType = GUnicodeBreakType::Quotation;
pub const G_UNICODE_BREAK_EXCLAMATION: GUnicodeBreakType = GUnicodeBreakType::Exclamation;
pub const G_UNICODE_BREAK_IDEOGRAPHIC: GUnicodeBreakType = GUnicodeBreakType::Ideographic;
pub const G_UNICODE_BREAK_NUMERIC: GUnicodeBreakType = GUnicodeBreakType::Numeric;
pub const G_UNICODE_BREAK_INFIX_SEPARATOR: GUnicodeBreakType = GUnicodeBreakType::InfixSeparator;
pub const G_UNICODE_BREAK_SYMBOL: GUnicodeBreakType = GUnicodeBreakType::Symbol;
pub const G_UNICODE_BREAK_ALPHABETIC: GUnicodeBreakType = GUnicodeBreakType::Alphabetic;
pub const G_UNICODE_BREAK_PREFIX: GUnicodeBreakType = GUnicodeBreakType::Prefix;
pub const G_UNICODE_BREAK_POSTFIX: GUnicodeBreakType = GUnicodeBreakType::Postfix;
pub const G_UNICODE_BREAK_COMPLEX_CONTEXT: GUnicodeBreakType = GUnicodeBreakType::ComplexContext;
pub const G_UNICODE_BREAK_AMBIGUOUS: GUnicodeBreakType = GUnicodeBreakType::Ambiguous;
pub const G_UNICODE_BREAK_UNKNOWN: GUnicodeBreakType = GUnicodeBreakType::Unknown;
pub const G_UNICODE_BREAK_NEXT_LINE: GUnicodeBreakType = GUnicodeBreakType::NextLine;
pub const G_UNICODE_BREAK_WORD_JOINER: GUnicodeBreakType = GUnicodeBreakType::WordJoiner;
pub const G_UNICODE_BREAK_HANGUL_L_JAMO: GUnicodeBreakType = GUnicodeBreakType::HangulLJamo;
pub const G_UNICODE_BREAK_HANGUL_V_JAMO: GUnicodeBreakType = GUnicodeBreakType::HangulVJamo;
pub const G_UNICODE_BREAK_HANGUL_T_JAMO: GUnicodeBreakType = GUnicodeBreakType::HangulTJamo;
pub const G_UNICODE_BREAK_HANGUL_LV_SYLLABLE: GUnicodeBreakType = GUnicodeBreakType::HangulLvSyllable;
pub const G_UNICODE_BREAK_HANGUL_LVT_SYLLABLE: GUnicodeBreakType = GUnicodeBreakType::HangulLvtSyllable;
pub const G_UNICODE_BREAK_CLOSE_PARANTHESIS: GUnicodeBreakType = GUnicodeBreakType::CloseParanthesis;
pub const G_UNICODE_BREAK_CONDITIONAL_JAPANESE_STARTER: GUnicodeBreakType = GUnicodeBreakType::ConditionalJapaneseStarter;
pub const G_UNICODE_BREAK_HEBREW_LETTER: GUnicodeBreakType = GUnicodeBreakType::HebrewLetter;
pub const G_UNICODE_BREAK_REGIONAL_INDICATOR: GUnicodeBreakType = GUnicodeBreakType::RegionalIndicator;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GUnicodeScript {
    InvalidCode = -1,
    Common = 0,
    Inherited = 1,
    Arabic = 2,
    Armenian = 3,
    Bengali = 4,
    Bopomofo = 5,
    Cherokee = 6,
    Coptic = 7,
    Cyrillic = 8,
    Deseret = 9,
    Devanagari = 10,
    Ethiopic = 11,
    Georgian = 12,
    Gothic = 13,
    Greek = 14,
    Gujarati = 15,
    Gurmukhi = 16,
    Han = 17,
    Hangul = 18,
    Hebrew = 19,
    Hiragana = 20,
    Kannada = 21,
    Katakana = 22,
    Khmer = 23,
    Lao = 24,
    Latin = 25,
    Malayalam = 26,
    Mongolian = 27,
    Myanmar = 28,
    Ogham = 29,
    OldItalic = 30,
    Oriya = 31,
    Runic = 32,
    Sinhala = 33,
    Syriac = 34,
    Tamil = 35,
    Telugu = 36,
    Thaana = 37,
    Thai = 38,
    Tibetan = 39,
    CanadianAboriginal = 40,
    Yi = 41,
    Tagalog = 42,
    Hanunoo = 43,
    Buhid = 44,
    Tagbanwa = 45,
    Braille = 46,
    Cypriot = 47,
    Limbu = 48,
    Osmanya = 49,
    Shavian = 50,
    LinearB = 51,
    TaiLe = 52,
    Ugaritic = 53,
    NewTaiLue = 54,
    Buginese = 55,
    Glagolitic = 56,
    Tifinagh = 57,
    SylotiNagri = 58,
    OldPersian = 59,
    Kharoshthi = 60,
    Unknown = 61,
    Balinese = 62,
    Cuneiform = 63,
    Phoenician = 64,
    PhagsPa = 65,
    Nko = 66,
    KayahLi = 67,
    Lepcha = 68,
    Rejang = 69,
    Sundanese = 70,
    Saurashtra = 71,
    Cham = 72,
    OlChiki = 73,
    Vai = 74,
    Carian = 75,
    Lycian = 76,
    Lydian = 77,
    Avestan = 78,
    Bamum = 79,
    EgyptianHieroglyphs = 80,
    ImperialAramaic = 81,
    InscriptionalPahlavi = 82,
    InscriptionalParthian = 83,
    Javanese = 84,
    Kaithi = 85,
    Lisu = 86,
    MeeteiMayek = 87,
    OldSouthArabian = 88,
    OldTurkic = 89,
    Samaritan = 90,
    TaiTham = 91,
    TaiViet = 92,
    Batak = 93,
    Brahmi = 94,
    Mandaic = 95,
    Chakma = 96,
    MeroiticCursive = 97,
    MeroiticHieroglyphs = 98,
    Miao = 99,
    Sharada = 100,
    SoraSompeng = 101,
    Takri = 102,
    BassaVah = 103,
    CaucasianAlbanian = 104,
    Duployan = 105,
    Elbasan = 106,
    Grantha = 107,
    Khojki = 108,
    Khudawadi = 109,
    LinearA = 110,
    Mahajani = 111,
    Manichaean = 112,
    MendeKikakui = 113,
    Modi = 114,
    Mro = 115,
    Nabataean = 116,
    OldNorthArabian = 117,
    OldPermic = 118,
    PahawhHmong = 119,
    Palmyrene = 120,
    PauCinHau = 121,
    PsalterPahlavi = 122,
    Siddham = 123,
    Tirhuta = 124,
    WarangCiti = 125,
    Ahom = 126,
    AnatolianHieroglyphs = 127,
    Hatran = 128,
    Multani = 129,
    OldHungarian = 130,
    Signwriting = 131,
}
pub const G_UNICODE_SCRIPT_INVALID_CODE: GUnicodeScript = GUnicodeScript::InvalidCode;
pub const G_UNICODE_SCRIPT_COMMON: GUnicodeScript = GUnicodeScript::Common;
pub const G_UNICODE_SCRIPT_INHERITED: GUnicodeScript = GUnicodeScript::Inherited;
pub const G_UNICODE_SCRIPT_ARABIC: GUnicodeScript = GUnicodeScript::Arabic;
pub const G_UNICODE_SCRIPT_ARMENIAN: GUnicodeScript = GUnicodeScript::Armenian;
pub const G_UNICODE_SCRIPT_BENGALI: GUnicodeScript = GUnicodeScript::Bengali;
pub const G_UNICODE_SCRIPT_BOPOMOFO: GUnicodeScript = GUnicodeScript::Bopomofo;
pub const G_UNICODE_SCRIPT_CHEROKEE: GUnicodeScript = GUnicodeScript::Cherokee;
pub const G_UNICODE_SCRIPT_COPTIC: GUnicodeScript = GUnicodeScript::Coptic;
pub const G_UNICODE_SCRIPT_CYRILLIC: GUnicodeScript = GUnicodeScript::Cyrillic;
pub const G_UNICODE_SCRIPT_DESERET: GUnicodeScript = GUnicodeScript::Deseret;
pub const G_UNICODE_SCRIPT_DEVANAGARI: GUnicodeScript = GUnicodeScript::Devanagari;
pub const G_UNICODE_SCRIPT_ETHIOPIC: GUnicodeScript = GUnicodeScript::Ethiopic;
pub const G_UNICODE_SCRIPT_GEORGIAN: GUnicodeScript = GUnicodeScript::Georgian;
pub const G_UNICODE_SCRIPT_GOTHIC: GUnicodeScript = GUnicodeScript::Gothic;
pub const G_UNICODE_SCRIPT_GREEK: GUnicodeScript = GUnicodeScript::Greek;
pub const G_UNICODE_SCRIPT_GUJARATI: GUnicodeScript = GUnicodeScript::Gujarati;
pub const G_UNICODE_SCRIPT_GURMUKHI: GUnicodeScript = GUnicodeScript::Gurmukhi;
pub const G_UNICODE_SCRIPT_HAN: GUnicodeScript = GUnicodeScript::Han;
pub const G_UNICODE_SCRIPT_HANGUL: GUnicodeScript = GUnicodeScript::Hangul;
pub const G_UNICODE_SCRIPT_HEBREW: GUnicodeScript = GUnicodeScript::Hebrew;
pub const G_UNICODE_SCRIPT_HIRAGANA: GUnicodeScript = GUnicodeScript::Hiragana;
pub const G_UNICODE_SCRIPT_KANNADA: GUnicodeScript = GUnicodeScript::Kannada;
pub const G_UNICODE_SCRIPT_KATAKANA: GUnicodeScript = GUnicodeScript::Katakana;
pub const G_UNICODE_SCRIPT_KHMER: GUnicodeScript = GUnicodeScript::Khmer;
pub const G_UNICODE_SCRIPT_LAO: GUnicodeScript = GUnicodeScript::Lao;
pub const G_UNICODE_SCRIPT_LATIN: GUnicodeScript = GUnicodeScript::Latin;
pub const G_UNICODE_SCRIPT_MALAYALAM: GUnicodeScript = GUnicodeScript::Malayalam;
pub const G_UNICODE_SCRIPT_MONGOLIAN: GUnicodeScript = GUnicodeScript::Mongolian;
pub const G_UNICODE_SCRIPT_MYANMAR: GUnicodeScript = GUnicodeScript::Myanmar;
pub const G_UNICODE_SCRIPT_OGHAM: GUnicodeScript = GUnicodeScript::Ogham;
pub const G_UNICODE_SCRIPT_OLD_ITALIC: GUnicodeScript = GUnicodeScript::OldItalic;
pub const G_UNICODE_SCRIPT_ORIYA: GUnicodeScript = GUnicodeScript::Oriya;
pub const G_UNICODE_SCRIPT_RUNIC: GUnicodeScript = GUnicodeScript::Runic;
pub const G_UNICODE_SCRIPT_SINHALA: GUnicodeScript = GUnicodeScript::Sinhala;
pub const G_UNICODE_SCRIPT_SYRIAC: GUnicodeScript = GUnicodeScript::Syriac;
pub const G_UNICODE_SCRIPT_TAMIL: GUnicodeScript = GUnicodeScript::Tamil;
pub const G_UNICODE_SCRIPT_TELUGU: GUnicodeScript = GUnicodeScript::Telugu;
pub const G_UNICODE_SCRIPT_THAANA: GUnicodeScript = GUnicodeScript::Thaana;
pub const G_UNICODE_SCRIPT_THAI: GUnicodeScript = GUnicodeScript::Thai;
pub const G_UNICODE_SCRIPT_TIBETAN: GUnicodeScript = GUnicodeScript::Tibetan;
pub const G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL: GUnicodeScript = GUnicodeScript::CanadianAboriginal;
pub const G_UNICODE_SCRIPT_YI: GUnicodeScript = GUnicodeScript::Yi;
pub const G_UNICODE_SCRIPT_TAGALOG: GUnicodeScript = GUnicodeScript::Tagalog;
pub const G_UNICODE_SCRIPT_HANUNOO: GUnicodeScript = GUnicodeScript::Hanunoo;
pub const G_UNICODE_SCRIPT_BUHID: GUnicodeScript = GUnicodeScript::Buhid;
pub const G_UNICODE_SCRIPT_TAGBANWA: GUnicodeScript = GUnicodeScript::Tagbanwa;
pub const G_UNICODE_SCRIPT_BRAILLE: GUnicodeScript = GUnicodeScript::Braille;
pub const G_UNICODE_SCRIPT_CYPRIOT: GUnicodeScript = GUnicodeScript::Cypriot;
pub const G_UNICODE_SCRIPT_LIMBU: GUnicodeScript = GUnicodeScript::Limbu;
pub const G_UNICODE_SCRIPT_OSMANYA: GUnicodeScript = GUnicodeScript::Osmanya;
pub const G_UNICODE_SCRIPT_SHAVIAN: GUnicodeScript = GUnicodeScript::Shavian;
pub const G_UNICODE_SCRIPT_LINEAR_B: GUnicodeScript = GUnicodeScript::LinearB;
pub const G_UNICODE_SCRIPT_TAI_LE: GUnicodeScript = GUnicodeScript::TaiLe;
pub const G_UNICODE_SCRIPT_UGARITIC: GUnicodeScript = GUnicodeScript::Ugaritic;
pub const G_UNICODE_SCRIPT_NEW_TAI_LUE: GUnicodeScript = GUnicodeScript::NewTaiLue;
pub const G_UNICODE_SCRIPT_BUGINESE: GUnicodeScript = GUnicodeScript::Buginese;
pub const G_UNICODE_SCRIPT_GLAGOLITIC: GUnicodeScript = GUnicodeScript::Glagolitic;
pub const G_UNICODE_SCRIPT_TIFINAGH: GUnicodeScript = GUnicodeScript::Tifinagh;
pub const G_UNICODE_SCRIPT_SYLOTI_NAGRI: GUnicodeScript = GUnicodeScript::SylotiNagri;
pub const G_UNICODE_SCRIPT_OLD_PERSIAN: GUnicodeScript = GUnicodeScript::OldPersian;
pub const G_UNICODE_SCRIPT_KHAROSHTHI: GUnicodeScript = GUnicodeScript::Kharoshthi;
pub const G_UNICODE_SCRIPT_UNKNOWN: GUnicodeScript = GUnicodeScript::Unknown;
pub const G_UNICODE_SCRIPT_BALINESE: GUnicodeScript = GUnicodeScript::Balinese;
pub const G_UNICODE_SCRIPT_CUNEIFORM: GUnicodeScript = GUnicodeScript::Cuneiform;
pub const G_UNICODE_SCRIPT_PHOENICIAN: GUnicodeScript = GUnicodeScript::Phoenician;
pub const G_UNICODE_SCRIPT_PHAGS_PA: GUnicodeScript = GUnicodeScript::PhagsPa;
pub const G_UNICODE_SCRIPT_NKO: GUnicodeScript = GUnicodeScript::Nko;
pub const G_UNICODE_SCRIPT_KAYAH_LI: GUnicodeScript = GUnicodeScript::KayahLi;
pub const G_UNICODE_SCRIPT_LEPCHA: GUnicodeScript = GUnicodeScript::Lepcha;
pub const G_UNICODE_SCRIPT_REJANG: GUnicodeScript = GUnicodeScript::Rejang;
pub const G_UNICODE_SCRIPT_SUNDANESE: GUnicodeScript = GUnicodeScript::Sundanese;
pub const G_UNICODE_SCRIPT_SAURASHTRA: GUnicodeScript = GUnicodeScript::Saurashtra;
pub const G_UNICODE_SCRIPT_CHAM: GUnicodeScript = GUnicodeScript::Cham;
pub const G_UNICODE_SCRIPT_OL_CHIKI: GUnicodeScript = GUnicodeScript::OlChiki;
pub const G_UNICODE_SCRIPT_VAI: GUnicodeScript = GUnicodeScript::Vai;
pub const G_UNICODE_SCRIPT_CARIAN: GUnicodeScript = GUnicodeScript::Carian;
pub const G_UNICODE_SCRIPT_LYCIAN: GUnicodeScript = GUnicodeScript::Lycian;
pub const G_UNICODE_SCRIPT_LYDIAN: GUnicodeScript = GUnicodeScript::Lydian;
pub const G_UNICODE_SCRIPT_AVESTAN: GUnicodeScript = GUnicodeScript::Avestan;
pub const G_UNICODE_SCRIPT_BAMUM: GUnicodeScript = GUnicodeScript::Bamum;
pub const G_UNICODE_SCRIPT_EGYPTIAN_HIEROGLYPHS: GUnicodeScript = GUnicodeScript::EgyptianHieroglyphs;
pub const G_UNICODE_SCRIPT_IMPERIAL_ARAMAIC: GUnicodeScript = GUnicodeScript::ImperialAramaic;
pub const G_UNICODE_SCRIPT_INSCRIPTIONAL_PAHLAVI: GUnicodeScript = GUnicodeScript::InscriptionalPahlavi;
pub const G_UNICODE_SCRIPT_INSCRIPTIONAL_PARTHIAN: GUnicodeScript = GUnicodeScript::InscriptionalParthian;
pub const G_UNICODE_SCRIPT_JAVANESE: GUnicodeScript = GUnicodeScript::Javanese;
pub const G_UNICODE_SCRIPT_KAITHI: GUnicodeScript = GUnicodeScript::Kaithi;
pub const G_UNICODE_SCRIPT_LISU: GUnicodeScript = GUnicodeScript::Lisu;
pub const G_UNICODE_SCRIPT_MEETEI_MAYEK: GUnicodeScript = GUnicodeScript::MeeteiMayek;
pub const G_UNICODE_SCRIPT_OLD_SOUTH_ARABIAN: GUnicodeScript = GUnicodeScript::OldSouthArabian;
pub const G_UNICODE_SCRIPT_OLD_TURKIC: GUnicodeScript = GUnicodeScript::OldTurkic;
pub const G_UNICODE_SCRIPT_SAMARITAN: GUnicodeScript = GUnicodeScript::Samaritan;
pub const G_UNICODE_SCRIPT_TAI_THAM: GUnicodeScript = GUnicodeScript::TaiTham;
pub const G_UNICODE_SCRIPT_TAI_VIET: GUnicodeScript = GUnicodeScript::TaiViet;
pub const G_UNICODE_SCRIPT_BATAK: GUnicodeScript = GUnicodeScript::Batak;
pub const G_UNICODE_SCRIPT_BRAHMI: GUnicodeScript = GUnicodeScript::Brahmi;
pub const G_UNICODE_SCRIPT_MANDAIC: GUnicodeScript = GUnicodeScript::Mandaic;
pub const G_UNICODE_SCRIPT_CHAKMA: GUnicodeScript = GUnicodeScript::Chakma;
pub const G_UNICODE_SCRIPT_MEROITIC_CURSIVE: GUnicodeScript = GUnicodeScript::MeroiticCursive;
pub const G_UNICODE_SCRIPT_MEROITIC_HIEROGLYPHS: GUnicodeScript = GUnicodeScript::MeroiticHieroglyphs;
pub const G_UNICODE_SCRIPT_MIAO: GUnicodeScript = GUnicodeScript::Miao;
pub const G_UNICODE_SCRIPT_SHARADA: GUnicodeScript = GUnicodeScript::Sharada;
pub const G_UNICODE_SCRIPT_SORA_SOMPENG: GUnicodeScript = GUnicodeScript::SoraSompeng;
pub const G_UNICODE_SCRIPT_TAKRI: GUnicodeScript = GUnicodeScript::Takri;
pub const G_UNICODE_SCRIPT_BASSA_VAH: GUnicodeScript = GUnicodeScript::BassaVah;
pub const G_UNICODE_SCRIPT_CAUCASIAN_ALBANIAN: GUnicodeScript = GUnicodeScript::CaucasianAlbanian;
pub const G_UNICODE_SCRIPT_DUPLOYAN: GUnicodeScript = GUnicodeScript::Duployan;
pub const G_UNICODE_SCRIPT_ELBASAN: GUnicodeScript = GUnicodeScript::Elbasan;
pub const G_UNICODE_SCRIPT_GRANTHA: GUnicodeScript = GUnicodeScript::Grantha;
pub const G_UNICODE_SCRIPT_KHOJKI: GUnicodeScript = GUnicodeScript::Khojki;
pub const G_UNICODE_SCRIPT_KHUDAWADI: GUnicodeScript = GUnicodeScript::Khudawadi;
pub const G_UNICODE_SCRIPT_LINEAR_A: GUnicodeScript = GUnicodeScript::LinearA;
pub const G_UNICODE_SCRIPT_MAHAJANI: GUnicodeScript = GUnicodeScript::Mahajani;
pub const G_UNICODE_SCRIPT_MANICHAEAN: GUnicodeScript = GUnicodeScript::Manichaean;
pub const G_UNICODE_SCRIPT_MENDE_KIKAKUI: GUnicodeScript = GUnicodeScript::MendeKikakui;
pub const G_UNICODE_SCRIPT_MODI: GUnicodeScript = GUnicodeScript::Modi;
pub const G_UNICODE_SCRIPT_MRO: GUnicodeScript = GUnicodeScript::Mro;
pub const G_UNICODE_SCRIPT_NABATAEAN: GUnicodeScript = GUnicodeScript::Nabataean;
pub const G_UNICODE_SCRIPT_OLD_NORTH_ARABIAN: GUnicodeScript = GUnicodeScript::OldNorthArabian;
pub const G_UNICODE_SCRIPT_OLD_PERMIC: GUnicodeScript = GUnicodeScript::OldPermic;
pub const G_UNICODE_SCRIPT_PAHAWH_HMONG: GUnicodeScript = GUnicodeScript::PahawhHmong;
pub const G_UNICODE_SCRIPT_PALMYRENE: GUnicodeScript = GUnicodeScript::Palmyrene;
pub const G_UNICODE_SCRIPT_PAU_CIN_HAU: GUnicodeScript = GUnicodeScript::PauCinHau;
pub const G_UNICODE_SCRIPT_PSALTER_PAHLAVI: GUnicodeScript = GUnicodeScript::PsalterPahlavi;
pub const G_UNICODE_SCRIPT_SIDDHAM: GUnicodeScript = GUnicodeScript::Siddham;
pub const G_UNICODE_SCRIPT_TIRHUTA: GUnicodeScript = GUnicodeScript::Tirhuta;
pub const G_UNICODE_SCRIPT_WARANG_CITI: GUnicodeScript = GUnicodeScript::WarangCiti;
pub const G_UNICODE_SCRIPT_AHOM: GUnicodeScript = GUnicodeScript::Ahom;
pub const G_UNICODE_SCRIPT_ANATOLIAN_HIEROGLYPHS: GUnicodeScript = GUnicodeScript::AnatolianHieroglyphs;
pub const G_UNICODE_SCRIPT_HATRAN: GUnicodeScript = GUnicodeScript::Hatran;
pub const G_UNICODE_SCRIPT_MULTANI: GUnicodeScript = GUnicodeScript::Multani;
pub const G_UNICODE_SCRIPT_OLD_HUNGARIAN: GUnicodeScript = GUnicodeScript::OldHungarian;
pub const G_UNICODE_SCRIPT_SIGNWRITING: GUnicodeScript = GUnicodeScript::Signwriting;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GUnicodeType {
    Control = 0,
    Format = 1,
    Unassigned = 2,
    PrivateUse = 3,
    Surrogate = 4,
    LowercaseLetter = 5,
    ModifierLetter = 6,
    OtherLetter = 7,
    TitlecaseLetter = 8,
    UppercaseLetter = 9,
    SpacingMark = 10,
    EnclosingMark = 11,
    NonSpacingMark = 12,
    DecimalNumber = 13,
    LetterNumber = 14,
    OtherNumber = 15,
    ConnectPunctuation = 16,
    DashPunctuation = 17,
    ClosePunctuation = 18,
    FinalPunctuation = 19,
    InitialPunctuation = 20,
    OtherPunctuation = 21,
    OpenPunctuation = 22,
    CurrencySymbol = 23,
    ModifierSymbol = 24,
    MathSymbol = 25,
    OtherSymbol = 26,
    LineSeparator = 27,
    ParagraphSeparator = 28,
    SpaceSeparator = 29,
}
pub const G_UNICODE_CONTROL: GUnicodeType = GUnicodeType::Control;
pub const G_UNICODE_FORMAT: GUnicodeType = GUnicodeType::Format;
pub const G_UNICODE_UNASSIGNED: GUnicodeType = GUnicodeType::Unassigned;
pub const G_UNICODE_PRIVATE_USE: GUnicodeType = GUnicodeType::PrivateUse;
pub const G_UNICODE_SURROGATE: GUnicodeType = GUnicodeType::Surrogate;
pub const G_UNICODE_LOWERCASE_LETTER: GUnicodeType = GUnicodeType::LowercaseLetter;
pub const G_UNICODE_MODIFIER_LETTER: GUnicodeType = GUnicodeType::ModifierLetter;
pub const G_UNICODE_OTHER_LETTER: GUnicodeType = GUnicodeType::OtherLetter;
pub const G_UNICODE_TITLECASE_LETTER: GUnicodeType = GUnicodeType::TitlecaseLetter;
pub const G_UNICODE_UPPERCASE_LETTER: GUnicodeType = GUnicodeType::UppercaseLetter;
pub const G_UNICODE_SPACING_MARK: GUnicodeType = GUnicodeType::SpacingMark;
pub const G_UNICODE_ENCLOSING_MARK: GUnicodeType = GUnicodeType::EnclosingMark;
pub const G_UNICODE_NON_SPACING_MARK: GUnicodeType = GUnicodeType::NonSpacingMark;
pub const G_UNICODE_DECIMAL_NUMBER: GUnicodeType = GUnicodeType::DecimalNumber;
pub const G_UNICODE_LETTER_NUMBER: GUnicodeType = GUnicodeType::LetterNumber;
pub const G_UNICODE_OTHER_NUMBER: GUnicodeType = GUnicodeType::OtherNumber;
pub const G_UNICODE_CONNECT_PUNCTUATION: GUnicodeType = GUnicodeType::ConnectPunctuation;
pub const G_UNICODE_DASH_PUNCTUATION: GUnicodeType = GUnicodeType::DashPunctuation;
pub const G_UNICODE_CLOSE_PUNCTUATION: GUnicodeType = GUnicodeType::ClosePunctuation;
pub const G_UNICODE_FINAL_PUNCTUATION: GUnicodeType = GUnicodeType::FinalPunctuation;
pub const G_UNICODE_INITIAL_PUNCTUATION: GUnicodeType = GUnicodeType::InitialPunctuation;
pub const G_UNICODE_OTHER_PUNCTUATION: GUnicodeType = GUnicodeType::OtherPunctuation;
pub const G_UNICODE_OPEN_PUNCTUATION: GUnicodeType = GUnicodeType::OpenPunctuation;
pub const G_UNICODE_CURRENCY_SYMBOL: GUnicodeType = GUnicodeType::CurrencySymbol;
pub const G_UNICODE_MODIFIER_SYMBOL: GUnicodeType = GUnicodeType::ModifierSymbol;
pub const G_UNICODE_MATH_SYMBOL: GUnicodeType = GUnicodeType::MathSymbol;
pub const G_UNICODE_OTHER_SYMBOL: GUnicodeType = GUnicodeType::OtherSymbol;
pub const G_UNICODE_LINE_SEPARATOR: GUnicodeType = GUnicodeType::LineSeparator;
pub const G_UNICODE_PARAGRAPH_SEPARATOR: GUnicodeType = GUnicodeType::ParagraphSeparator;
pub const G_UNICODE_SPACE_SEPARATOR: GUnicodeType = GUnicodeType::SpaceSeparator;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GUserDirectory {
    DirectoryDesktop = 0,
    DirectoryDocuments = 1,
    DirectoryDownload = 2,
    DirectoryMusic = 3,
    DirectoryPictures = 4,
    DirectoryPublicShare = 5,
    DirectoryTemplates = 6,
    DirectoryVideos = 7,
    NDirectories = 8,
}
pub const G_USER_DIRECTORY_DESKTOP: GUserDirectory = GUserDirectory::DirectoryDesktop;
pub const G_USER_DIRECTORY_DOCUMENTS: GUserDirectory = GUserDirectory::DirectoryDocuments;
pub const G_USER_DIRECTORY_DOWNLOAD: GUserDirectory = GUserDirectory::DirectoryDownload;
pub const G_USER_DIRECTORY_MUSIC: GUserDirectory = GUserDirectory::DirectoryMusic;
pub const G_USER_DIRECTORY_PICTURES: GUserDirectory = GUserDirectory::DirectoryPictures;
pub const G_USER_DIRECTORY_PUBLIC_SHARE: GUserDirectory = GUserDirectory::DirectoryPublicShare;
pub const G_USER_DIRECTORY_TEMPLATES: GUserDirectory = GUserDirectory::DirectoryTemplates;
pub const G_USER_DIRECTORY_VIDEOS: GUserDirectory = GUserDirectory::DirectoryVideos;
pub const G_USER_N_DIRECTORIES: GUserDirectory = GUserDirectory::NDirectories;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GVariantClass {
    Boolean = 98,
    Byte = 121,
    Int16 = 110,
    Uint16 = 113,
    Int32 = 105,
    Uint32 = 117,
    Int64 = 120,
    Uint64 = 116,
    Handle = 104,
    Double = 100,
    String = 115,
    ObjectPath = 111,
    Signature = 103,
    Variant = 118,
    Maybe = 109,
    Array = 97,
    Tuple = 40,
    DictEntry = 123,
}
pub const G_VARIANT_CLASS_BOOLEAN: GVariantClass = GVariantClass::Boolean;
pub const G_VARIANT_CLASS_BYTE: GVariantClass = GVariantClass::Byte;
pub const G_VARIANT_CLASS_INT16: GVariantClass = GVariantClass::Int16;
pub const G_VARIANT_CLASS_UINT16: GVariantClass = GVariantClass::Uint16;
pub const G_VARIANT_CLASS_INT32: GVariantClass = GVariantClass::Int32;
pub const G_VARIANT_CLASS_UINT32: GVariantClass = GVariantClass::Uint32;
pub const G_VARIANT_CLASS_INT64: GVariantClass = GVariantClass::Int64;
pub const G_VARIANT_CLASS_UINT64: GVariantClass = GVariantClass::Uint64;
pub const G_VARIANT_CLASS_HANDLE: GVariantClass = GVariantClass::Handle;
pub const G_VARIANT_CLASS_DOUBLE: GVariantClass = GVariantClass::Double;
pub const G_VARIANT_CLASS_STRING: GVariantClass = GVariantClass::String;
pub const G_VARIANT_CLASS_OBJECT_PATH: GVariantClass = GVariantClass::ObjectPath;
pub const G_VARIANT_CLASS_SIGNATURE: GVariantClass = GVariantClass::Signature;
pub const G_VARIANT_CLASS_VARIANT: GVariantClass = GVariantClass::Variant;
pub const G_VARIANT_CLASS_MAYBE: GVariantClass = GVariantClass::Maybe;
pub const G_VARIANT_CLASS_ARRAY: GVariantClass = GVariantClass::Array;
pub const G_VARIANT_CLASS_TUPLE: GVariantClass = GVariantClass::Tuple;
pub const G_VARIANT_CLASS_DICT_ENTRY: GVariantClass = GVariantClass::DictEntry;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(C)]
pub enum GVariantParseError {
    Failed = 0,
    BasicTypeExpected = 1,
    CannotInferType = 2,
    DefiniteTypeExpected = 3,
    InputNotAtEnd = 4,
    InvalidCharacter = 5,
    InvalidFormatString = 6,
    InvalidObjectPath = 7,
    InvalidSignature = 8,
    InvalidTypeString = 9,
    NoCommonType = 10,
    NumberOutOfRange = 11,
    NumberTooBig = 12,
    TypeError = 13,
    UnexpectedToken = 14,
    UnknownKeyword = 15,
    UnterminatedStringConstant = 16,
    ValueExpected = 17,
}
pub const G_VARIANT_PARSE_ERROR_FAILED: GVariantParseError = GVariantParseError::Failed;
pub const G_VARIANT_PARSE_ERROR_BASIC_TYPE_EXPECTED: GVariantParseError = GVariantParseError::BasicTypeExpected;
pub const G_VARIANT_PARSE_ERROR_CANNOT_INFER_TYPE: GVariantParseError = GVariantParseError::CannotInferType;
pub const G_VARIANT_PARSE_ERROR_DEFINITE_TYPE_EXPECTED: GVariantParseError = GVariantParseError::DefiniteTypeExpected;
pub const G_VARIANT_PARSE_ERROR_INPUT_NOT_AT_END: GVariantParseError = GVariantParseError::InputNotAtEnd;
pub const G_VARIANT_PARSE_ERROR_INVALID_CHARACTER: GVariantParseError = GVariantParseError::InvalidCharacter;
pub const G_VARIANT_PARSE_ERROR_INVALID_FORMAT_STRING: GVariantParseError = GVariantParseError::InvalidFormatString;
pub const G_VARIANT_PARSE_ERROR_INVALID_OBJECT_PATH: GVariantParseError = GVariantParseError::InvalidObjectPath;
pub const G_VARIANT_PARSE_ERROR_INVALID_SIGNATURE: GVariantParseError = GVariantParseError::InvalidSignature;
pub const G_VARIANT_PARSE_ERROR_INVALID_TYPE_STRING: GVariantParseError = GVariantParseError::InvalidTypeString;
pub const G_VARIANT_PARSE_ERROR_NO_COMMON_TYPE: GVariantParseError = GVariantParseError::NoCommonType;
pub const G_VARIANT_PARSE_ERROR_NUMBER_OUT_OF_RANGE: GVariantParseError = GVariantParseError::NumberOutOfRange;
pub const G_VARIANT_PARSE_ERROR_NUMBER_TOO_BIG: GVariantParseError = GVariantParseError::NumberTooBig;
pub const G_VARIANT_PARSE_ERROR_TYPE_ERROR: GVariantParseError = GVariantParseError::TypeError;
pub const G_VARIANT_PARSE_ERROR_UNEXPECTED_TOKEN: GVariantParseError = GVariantParseError::UnexpectedToken;
pub const G_VARIANT_PARSE_ERROR_UNKNOWN_KEYWORD: GVariantParseError = GVariantParseError::UnknownKeyword;
pub const G_VARIANT_PARSE_ERROR_UNTERMINATED_STRING_CONSTANT: GVariantParseError = GVariantParseError::UnterminatedStringConstant;
pub const G_VARIANT_PARSE_ERROR_VALUE_EXPECTED: GVariantParseError = GVariantParseError::ValueExpected;

// Constants
pub const G_ANALYZER_ANALYZING: c_int = 1;
pub const G_ASCII_DTOSTR_BUF_SIZE: c_int = 39;
pub const G_BIG_ENDIAN: c_int = 4321;
pub const G_CSET_A_2_Z: *const c_char = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\0" as *const u8 as *const c_char;
pub const G_CSET_DIGITS: *const c_char = b"0123456789\0" as *const u8 as *const c_char;
pub const G_CSET_a_2_z: *const c_char = b"abcdefghijklmnopqrstuvwxyz\0" as *const u8 as *const c_char;
pub const G_DATALIST_FLAGS_MASK: c_int = 3;
pub const G_DATE_BAD_DAY: c_int = 0;
pub const G_DATE_BAD_JULIAN: c_int = 0;
pub const G_DATE_BAD_YEAR: c_int = 0;
pub const G_DIR_SEPARATOR: c_int = 92;
pub const G_DIR_SEPARATOR_S: *const c_char = b"\\\0" as *const u8 as *const c_char;
pub const G_E: c_double = 2.718282;
pub const G_GINT16_FORMAT: *const c_char = b"hi\0" as *const u8 as *const c_char;
pub const G_GINT16_MODIFIER: *const c_char = b"h\0" as *const u8 as *const c_char;
pub const G_GINT32_FORMAT: *const c_char = b"i\0" as *const u8 as *const c_char;
pub const G_GINT32_MODIFIER: *const c_char = b"\0" as *const u8 as *const c_char;
//pub const G_GINT64_FORMAT: *const c_char = b"li\0" as *const u8 as *const c_char;
//pub const G_GINT64_MODIFIER: *const c_char = b"l\0" as *const u8 as *const c_char;
//pub const G_GINTPTR_FORMAT: *const c_char = b"li\0" as *const u8 as *const c_char;
//pub const G_GINTPTR_MODIFIER: *const c_char = b"l\0" as *const u8 as *const c_char;
pub const G_GNUC_FUNCTION: *const c_char = b"\0" as *const u8 as *const c_char;
pub const G_GNUC_PRETTY_FUNCTION: *const c_char = b"\0" as *const u8 as *const c_char;
//pub const G_GSIZE_FORMAT: *const c_char = b"lu\0" as *const u8 as *const c_char;
//pub const G_GSIZE_MODIFIER: *const c_char = b"l\0" as *const u8 as *const c_char;
//pub const G_GSSIZE_FORMAT: *const c_char = b"li\0" as *const u8 as *const c_char;
//pub const G_GSSIZE_MODIFIER: *const c_char = b"l\0" as *const u8 as *const c_char;
pub const G_GUINT16_FORMAT: *const c_char = b"hu\0" as *const u8 as *const c_char;
pub const G_GUINT32_FORMAT: *const c_char = b"u\0" as *const u8 as *const c_char;
//pub const G_GUINT64_FORMAT: *const c_char = b"lu\0" as *const u8 as *const c_char;
//pub const G_GUINTPTR_FORMAT: *const c_char = b"lu\0" as *const u8 as *const c_char;
pub const G_HAVE_GINT64: c_int = 1;
pub const G_HAVE_GNUC_VARARGS: c_int = 1;
pub const G_HAVE_GNUC_VISIBILITY: c_int = 1;
pub const G_HAVE_GROWING_STACK: c_int = 0;
pub const G_HAVE_ISO_VARARGS: c_int = 1;
pub const G_HOOK_FLAG_USER_SHIFT: c_int = 4;
pub const G_IEEE754_DOUBLE_BIAS: c_int = 1023;
pub const G_IEEE754_FLOAT_BIAS: c_int = 127;
pub const G_KEY_FILE_DESKTOP_GROUP: *const c_char = b"Desktop Entry\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_ACTIONS: *const c_char = b"Actions\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_CATEGORIES: *const c_char = b"Categories\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_COMMENT: *const c_char = b"Comment\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_DBUS_ACTIVATABLE: *const c_char = b"DBusActivatable\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_EXEC: *const c_char = b"Exec\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_FULLNAME: *const c_char = b"X-GNOME-FullName\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_GENERIC_NAME: *const c_char = b"GenericName\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_GETTEXT_DOMAIN: *const c_char = b"X-GNOME-Gettext-Domain\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_HIDDEN: *const c_char = b"Hidden\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_ICON: *const c_char = b"Icon\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_KEYWORDS: *const c_char = b"Keywords\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_MIME_TYPE: *const c_char = b"MimeType\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_NAME: *const c_char = b"Name\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_NOT_SHOW_IN: *const c_char = b"NotShowIn\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_NO_DISPLAY: *const c_char = b"NoDisplay\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_ONLY_SHOW_IN: *const c_char = b"OnlyShowIn\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_PATH: *const c_char = b"Path\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY: *const c_char = b"StartupNotify\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_STARTUP_WM_CLASS: *const c_char = b"StartupWMClass\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_TERMINAL: *const c_char = b"Terminal\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_TRY_EXEC: *const c_char = b"TryExec\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_TYPE: *const c_char = b"Type\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_URL: *const c_char = b"URL\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_KEY_VERSION: *const c_char = b"Version\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_TYPE_APPLICATION: *const c_char = b"Application\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_TYPE_DIRECTORY: *const c_char = b"Directory\0" as *const u8 as *const c_char;
pub const G_KEY_FILE_DESKTOP_TYPE_LINK: *const c_char = b"Link\0" as *const u8 as *const c_char;
pub const G_LITTLE_ENDIAN: c_int = 1234;
pub const G_LN10: c_double = 2.302585;
pub const G_LN2: c_double = 0.693147;
pub const G_LOG_2_BASE_10: c_double = 0.301030;
pub const G_LOG_DOMAIN: c_char = 0;
pub const G_LOG_FATAL_MASK: c_int = 0;
pub const G_LOG_LEVEL_USER_SHIFT: c_int = 8;
pub const GLIB_MAJOR_VERSION: c_int = 2;
pub const G_MAXINT16: i16 = 32767;
pub const G_MAXINT32: i32 = 2147483647;
pub const G_MAXINT64: i64 = 9223372036854775807;
pub const G_MAXINT8: i8 = 127;
pub const G_MAXUINT16: u16 = 65535;
pub const G_MAXUINT32: u32 = 4294967295;
pub const G_MAXUINT64: u64 = 18446744073709551615;
pub const G_MAXUINT8: u8 = 255;
pub const GLIB_MICRO_VERSION: c_int = 0;
//pub const G_MININT16: i16 = -32768;
//pub const G_MININT32: i32 = -2147483648;
pub const G_MININT64: i64 = -9223372036854775808;
//pub const G_MININT8: i8 = -128;
pub const GLIB_MINOR_VERSION: c_int = 50;
pub const G_MODULE_SUFFIX: *const c_char = b"so\0" as *const u8 as *const c_char;
pub const G_OPTION_REMAINING: *const c_char = b"\0" as *const u8 as *const c_char;
pub const G_PDP_ENDIAN: c_int = 3412;
pub const G_PI: c_double = 3.141593;
pub const G_PID_FORMAT: *const c_char = b"i\0" as *const u8 as *const c_char;
pub const G_PI_2: c_double = 1.570796;
pub const G_PI_4: c_double = 0.785398;
pub const G_POLLFD_FORMAT: *const c_char = b"%d\0" as *const u8 as *const c_char;
pub const G_PRIORITY_DEFAULT: c_int = 0;
pub const G_PRIORITY_DEFAULT_IDLE: c_int = 200;
pub const G_PRIORITY_HIGH: c_int = -100;
pub const G_PRIORITY_HIGH_IDLE: c_int = 100;
pub const G_PRIORITY_LOW: c_int = 300;
pub const G_SEARCHPATH_SEPARATOR: c_int = 59;
pub const G_SEARCHPATH_SEPARATOR_S: *const c_char = b";\0" as *const u8 as *const c_char;
//pub const GLIB_SIZEOF_LONG: c_int = 8;
//pub const GLIB_SIZEOF_SIZE_T: c_int = 8;
//pub const GLIB_SIZEOF_SSIZE_T: c_int = 8;
//pub const GLIB_SIZEOF_VOID_P: c_int = 8;
pub const G_SOURCE_CONTINUE: gboolean = GTRUE;
pub const G_SOURCE_REMOVE: gboolean = GFALSE;
pub const G_SQRT2: c_double = 1.414214;
pub const G_STR_DELIMITERS: *const c_char = b"_-|> <.\0" as *const u8 as *const c_char;
pub const GLIB_SYSDEF_AF_INET: c_int = 2;
pub const GLIB_SYSDEF_AF_INET6: c_int = 10;
pub const GLIB_SYSDEF_AF_UNIX: c_int = 1;
pub const GLIB_SYSDEF_MSG_DONTROUTE: c_int = 4;
pub const GLIB_SYSDEF_MSG_OOB: c_int = 1;
pub const GLIB_SYSDEF_MSG_PEEK: c_int = 2;
pub const G_TIME_SPAN_DAY: i64 = 86400000000;
pub const G_TIME_SPAN_HOUR: i64 = 3600000000;
pub const G_TIME_SPAN_MILLISECOND: i64 = 1000;
pub const G_TIME_SPAN_MINUTE: i64 = 60000000;
pub const G_TIME_SPAN_SECOND: i64 = 1000000;
pub const G_UNICHAR_MAX_DECOMPOSITION_LENGTH: c_int = 18;
pub const G_URI_RESERVED_CHARS_GENERIC_DELIMITERS: *const c_char = b":/?#[]@\0" as *const u8 as *const c_char;
pub const G_URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS: *const c_char = b"!$&\'()*+,;=\0" as *const u8 as *const c_char;
pub const G_USEC_PER_SEC: c_int = 1000000;
//pub const G_VA_COPY_AS_ARRAY: c_int = 1;
pub const GLIB_VERSION_MIN_REQUIRED: c_int = 2;
pub const G_WIN32_MSG_HANDLE: c_int = 19981206;

// Flags
bitflags! {
    #[repr(C)]
    pub struct GAsciiType: c_uint {
        const G_ASCII_ALNUM = 1;
        const G_ASCII_ALPHA = 2;
        const G_ASCII_CNTRL = 4;
        const G_ASCII_DIGIT = 8;
        const G_ASCII_GRAPH = 16;
        const G_ASCII_LOWER = 32;
        const G_ASCII_PRINT = 64;
        const G_ASCII_PUNCT = 128;
        const G_ASCII_SPACE = 256;
        const G_ASCII_UPPER = 512;
        const G_ASCII_XDIGIT = 1024;
    }
}

bitflags! {
    #[repr(C)]
    pub struct GFileTest: c_uint {
        const G_FILE_TEST_IS_REGULAR = 1;
        const G_FILE_TEST_IS_SYMLINK = 2;
        const G_FILE_TEST_IS_DIR = 4;
        const G_FILE_TEST_IS_EXECUTABLE = 8;
        const G_FILE_TEST_EXISTS = 16;
    }
}

bitflags! {
    #[repr(C)]
    pub struct GFormatSizeFlags: c_uint {
        const G_FORMAT_SIZE_DEFAULT = 0;
        const G_FORMAT_SIZE_LONG_FORMAT = 1;
        const G_FORMAT_SIZE_IEC_UNITS = 2;
    }
}

bitflags! {
    #[repr(C)]
    pub struct GHookFlagMask: c_uint {
        const G_HOOK_FLAG_ACTIVE = 1;
        const G_HOOK_FLAG_IN_CALL = 2;
        const G_HOOK_FLAG_MASK = 15;
    }
}

bitflags! {
    #[repr(C)]
    pub struct GIOCondition: c_uint {
        const G_IO_IN = 1;
        const G_IO_OUT = 4;
        const G_IO_PRI = 2;
        const G_IO_ERR = 8;
        const G_IO_HUP = 16;
        const G_IO_NVAL = 32;
    }
}

bitflags! {
    #[repr(C)]
    pub struct GIOFlags: c_uint {
        const G_IO_FLAG_APPEND = 1;
        const G_IO_FLAG_NONBLOCK = 2;
        const G_IO_FLAG_IS_READABLE = 4;
        const G_IO_FLAG_IS_WRITABLE = 8;
        const G_IO_FLAG_IS_WRITEABLE = 8;
        const G_IO_FLAG_IS_SEEKABLE = 16;
        const G_IO_FLAG_MASK = 31;
        const G_IO_FLAG_GET_MASK = 31;
        const G_IO_FLAG_SET_MASK = 3;
    }
}

bitflags! {
    #[repr(C)]
    pub struct GKeyFileFlags: c_uint {
        const G_KEY_FILE_NONE = 0;
        const G_KEY_FILE_KEEP_COMMENTS = 1;
        const G_KEY_FILE_KEEP_TRANSLATIONS = 2;
    }
}

bitflags! {
    #[repr(C)]
    pub struct GLogLevelFlags: c_uint {
        const G_LOG_FLAG_RECURSION = 1;
        const G_LOG_FLAG_FATAL = 2;
        const G_LOG_LEVEL_ERROR = 4;
        const G_LOG_LEVEL_CRITICAL = 8;
        const G_LOG_LEVEL_WARNING = 16;
        const G_LOG_LEVEL_MESSAGE = 32;
        const G_LOG_LEVEL_INFO = 64;
        const G_LOG_LEVEL_DEBUG = 128;
        const G_LOG_LEVEL_MASK = 4294967292;
    }
}

bitflags! {
    #[repr(C)]
    pub struct GMarkupCollectType: c_uint {
        const G_MARKUP_COLLECT_INVALID = 0;
        const G_MARKUP_COLLECT_STRING = 1;
        const G_MARKUP_COLLECT_STRDUP = 2;
        const G_MARKUP_COLLECT_BOOLEAN = 3;
        const G_MARKUP_COLLECT_TRISTATE = 4;
        const G_MARKUP_COLLECT_OPTIONAL = 65536;
    }
}

bitflags! {
    #[repr(C)]
    pub struct GMarkupParseFlags: c_uint {
        const G_MARKUP_DO_NOT_USE_THIS_UNSUPPORTED_FLAG = 1;
        const G_MARKUP_TREAT_CDATA_AS_TEXT = 2;
        const G_MARKUP_PREFIX_ERROR_POSITION = 4;
        const G_MARKUP_IGNORE_QUALIFIED = 8;
    }
}

bitflags! {
    #[repr(C)]
    pub struct GOptionFlags: c_uint {
        const G_OPTION_FLAG_NONE = 0;
        const G_OPTION_FLAG_HIDDEN = 1;
        const G_OPTION_FLAG_IN_MAIN = 2;
        const G_OPTION_FLAG_REVERSE = 4;
        const G_OPTION_FLAG_NO_ARG = 8;
        const G_OPTION_FLAG_FILENAME = 16;
        const G_OPTION_FLAG_OPTIONAL_ARG = 32;
        const G_OPTION_FLAG_NOALIAS = 64;
    }
}

bitflags! {
    #[repr(C)]
    pub struct GRegexCompileFlags: c_uint {
        const G_REGEX_CASELESS = 1;
        const G_REGEX_MULTILINE = 2;
        const G_REGEX_DOTALL = 4;
        const G_REGEX_EXTENDED = 8;
        const G_REGEX_ANCHORED = 16;
        const G_REGEX_DOLLAR_ENDONLY = 32;
        const G_REGEX_UNGREEDY = 512;
        const G_REGEX_RAW = 2048;
        const G_REGEX_NO_AUTO_CAPTURE = 4096;
        const G_REGEX_OPTIMIZE = 8192;
        const G_REGEX_FIRSTLINE = 262144;
        const G_REGEX_DUPNAMES = 524288;
        const G_REGEX_NEWLINE_CR = 1048576;
        const G_REGEX_NEWLINE_LF = 2097152;
        const G_REGEX_NEWLINE_CRLF = 3145728;
        const G_REGEX_NEWLINE_ANYCRLF = 5242880;
        const G_REGEX_BSR_ANYCRLF = 8388608;
        const G_REGEX_JAVASCRIPT_COMPAT = 33554432;
    }
}

bitflags! {
    #[repr(C)]
    pub struct GRegexMatchFlags: c_uint {
        const G_REGEX_MATCH_ANCHORED = 16;
        const G_REGEX_MATCH_NOTBOL = 128;
        const G_REGEX_MATCH_NOTEOL = 256;
        const G_REGEX_MATCH_NOTEMPTY = 1024;
        const G_REGEX_MATCH_PARTIAL = 32768;
        const G_REGEX_MATCH_NEWLINE_CR = 1048576;
        const G_REGEX_MATCH_NEWLINE_LF = 2097152;
        const G_REGEX_MATCH_NEWLINE_CRLF = 3145728;
        const G_REGEX_MATCH_NEWLINE_ANY = 4194304;
        const G_REGEX_MATCH_NEWLINE_ANYCRLF = 5242880;
        const G_REGEX_MATCH_BSR_ANYCRLF = 8388608;
        const G_REGEX_MATCH_BSR_ANY = 16777216;
        const G_REGEX_MATCH_PARTIAL_SOFT = 32768;
        const G_REGEX_MATCH_PARTIAL_HARD = 134217728;
        const G_REGEX_MATCH_NOTEMPTY_ATSTART = 268435456;
    }
}

bitflags! {
    #[repr(C)]
    pub struct GSpawnFlags: c_uint {
        const G_SPAWN_DEFAULT = 0;
        const G_SPAWN_LEAVE_DESCRIPTORS_OPEN = 1;
        const G_SPAWN_DO_NOT_REAP_CHILD = 2;
        const G_SPAWN_SEARCH_PATH = 4;
        const G_SPAWN_STDOUT_TO_DEV_NULL = 8;
        const G_SPAWN_STDERR_TO_DEV_NULL = 16;
        const G_SPAWN_CHILD_INHERITS_STDIN = 32;
        const G_SPAWN_FILE_AND_ARGV_ZERO = 64;
        const G_SPAWN_SEARCH_PATH_FROM_ENVP = 128;
        const G_SPAWN_CLOEXEC_PIPES = 256;
    }
}

bitflags! {
    #[repr(C)]
    pub struct GTestSubprocessFlags: c_uint {
        const G_TEST_SUBPROCESS_INHERIT_STDIN = 1;
        const G_TEST_SUBPROCESS_INHERIT_STDOUT = 2;
        const G_TEST_SUBPROCESS_INHERIT_STDERR = 4;
    }
}

bitflags! {
    #[repr(C)]
    pub struct GTestTrapFlags: c_uint {
        const G_TEST_TRAP_SILENCE_STDOUT = 128;
        const G_TEST_TRAP_SILENCE_STDERR = 256;
        const G_TEST_TRAP_INHERIT_STDIN = 512;
    }
}

bitflags! {
    #[repr(C)]
    pub struct GTraverseFlags: c_uint {
        const G_TRAVERSE_LEAVES = 1;
        const G_TRAVERSE_NON_LEAVES = 2;
        const G_TRAVERSE_ALL = 3;
        const G_TRAVERSE_MASK = 3;
        const G_TRAVERSE_LEAFS = 1;
        const G_TRAVERSE_NON_LEAFS = 2;
    }
}

// Unions
pub type GDoubleIEEE754 = c_void; // union
pub type GFloatIEEE754 = c_void; // union
#[cfg(target_pointer_width = "32")]
#[repr(C)]
pub struct GMutex([u32; 2]);
#[cfg(target_pointer_width = "64")]
#[repr(C)]
pub struct GMutex(*mut c_void);
pub type GTokenValue = c_void; // union

// Callbacks
pub type GChildWatchFunc = Option<unsafe extern "C" fn(GPid, c_int, gpointer)>;
pub type GCompareDataFunc = Option<unsafe extern "C" fn(gconstpointer, gconstpointer, gpointer) -> c_int>;
pub type GCompareFunc = Option<unsafe extern "C" fn(gconstpointer, gconstpointer) -> c_int>;
pub type GCopyFunc = Option<unsafe extern "C" fn(gconstpointer, gpointer) -> gpointer>;
pub type GDataForeachFunc = Option<unsafe extern "C" fn(GQuark, gpointer, gpointer)>;
pub type GDestroyNotify = Option<unsafe extern "C" fn(gpointer)>;
pub type GDuplicateFunc = Option<unsafe extern "C" fn(gpointer, gpointer) -> gpointer>;
pub type GEqualFunc = Option<unsafe extern "C" fn(gconstpointer, gconstpointer) -> gboolean>;
pub type GFreeFunc = Option<unsafe extern "C" fn(gpointer)>;
pub type GFunc = Option<unsafe extern "C" fn(gpointer, gpointer)>;
pub type GHFunc = Option<unsafe extern "C" fn(gpointer, gpointer, gpointer)>;
pub type GHRFunc = Option<unsafe extern "C" fn(gpointer, gpointer, gpointer) -> gboolean>;
pub type GHashFunc = Option<unsafe extern "C" fn(gconstpointer) -> c_uint>;
pub type GHookCheckFunc = Option<unsafe extern "C" fn(gpointer) -> gboolean>;
pub type GHookCheckMarshaller = Option<unsafe extern "C" fn(*mut GHook, gpointer) -> gboolean>;
pub type GHookCompareFunc = Option<unsafe extern "C" fn(*mut GHook, *mut GHook) -> c_int>;
pub type GHookFinalizeFunc = Option<unsafe extern "C" fn(*mut GHookList, *mut GHook)>;
pub type GHookFindFunc = Option<unsafe extern "C" fn(*mut GHook, gpointer) -> gboolean>;
pub type GHookFunc = Option<unsafe extern "C" fn(gpointer)>;
pub type GHookMarshaller = Option<unsafe extern "C" fn(*mut GHook, gpointer)>;
pub type GIOFunc = Option<unsafe extern "C" fn(*mut GIOChannel, GIOCondition, gpointer) -> gboolean>;
pub type GLogFunc = Option<unsafe extern "C" fn(*const c_char, GLogLevelFlags, *const c_char, gpointer)>;
pub type GLogWriterFunc = Option<unsafe extern "C" fn(GLogLevelFlags, *mut GLogField, size_t, gpointer) -> GLogWriterOutput>;
pub type GNodeForeachFunc = Option<unsafe extern "C" fn(*mut GNode, gpointer)>;
pub type GNodeTraverseFunc = Option<unsafe extern "C" fn(*mut GNode, gpointer) -> gboolean>;
pub type GOptionArgFunc = Option<unsafe extern "C" fn(*const c_char, *const c_char, gpointer, *mut *mut GError) -> gboolean>;
pub type GOptionErrorFunc = Option<unsafe extern "C" fn(*mut GOptionContext, *mut GOptionGroup, gpointer, *mut *mut GError)>;
pub type GOptionParseFunc = Option<unsafe extern "C" fn(*mut GOptionContext, *mut GOptionGroup, gpointer, *mut *mut GError) -> gboolean>;
pub type GPollFunc = Option<unsafe extern "C" fn(*mut GPollFD, c_uint, c_int) -> c_int>;
pub type GPrintFunc = Option<unsafe extern "C" fn(*const c_char)>;
pub type GRegexEvalCallback = Option<unsafe extern "C" fn(*const GMatchInfo, *mut GString, gpointer) -> gboolean>;
pub type GScannerMsgFunc = Option<unsafe extern "C" fn(*mut GScanner, *mut c_char, gboolean)>;
pub type GSequenceIterCompareFunc = Option<unsafe extern "C" fn(*mut GSequenceIter, *mut GSequenceIter, gpointer) -> c_int>;
pub type GSourceDummyMarshal = Option<unsafe extern "C" fn()>;
pub type GSourceFunc = Option<unsafe extern "C" fn(gpointer) -> gboolean>;
pub type GSpawnChildSetupFunc = Option<unsafe extern "C" fn(gpointer)>;
pub type GTestDataFunc = Option<unsafe extern "C" fn(gconstpointer)>;
pub type GTestFixtureFunc = Option<unsafe extern "C" fn(gpointer, gconstpointer)>;
pub type GTestFunc = Option<unsafe extern "C" fn()>;
pub type GTestLogFatalFunc = Option<unsafe extern "C" fn(*const c_char, GLogLevelFlags, *const c_char, gpointer) -> gboolean>;
pub type GThreadFunc = Option<unsafe extern "C" fn(gpointer) -> gpointer>;
pub type GTranslateFunc = Option<unsafe extern "C" fn(*const c_char, gpointer) -> *const c_char>;
pub type GTraverseFunc = Option<unsafe extern "C" fn(gpointer, gpointer, gpointer) -> gboolean>;
pub type GUnixFDSourceFunc = Option<unsafe extern "C" fn(c_int, GIOCondition, gpointer) -> gboolean>;
pub type GVoidFunc = Option<unsafe extern "C" fn()>;

// Records
#[repr(C)]
pub struct GArray {
    pub data: *mut c_char,
    pub len: c_uint,
}

#[repr(C)]
pub struct GAsyncQueue(c_void);

#[repr(C)]
pub struct GBookmarkFile(c_void);

#[repr(C)]
pub struct GByteArray {
    pub data: *mut u8,
    pub len: c_uint,
}

#[repr(C)]
pub struct GBytes(c_void);

#[repr(C)]
pub struct GChecksum(c_void);

#[repr(C)]
pub struct GCond {
    pub p: gpointer,
    pub i: [c_uint; 2],
}

#[repr(C)]
pub struct GData(c_void);

#[repr(C)]
pub struct GDate {
    _truncated_record_marker: c_void,
    //julian_days: guint: 32,
    //julian: guint: 1,
    //dmy: guint: 1,
    //day: guint: 6,
    //month: guint: 4,
    //year: guint: 16,
}

#[repr(C)]
pub struct GDateTime(c_void);

#[repr(C)]
pub struct GDebugKey {
    pub key: *const c_char,
    pub value: c_uint,
}

#[repr(C)]
pub struct GDir(c_void);

#[repr(C)]
pub struct GError {
    pub domain: GQuark,
    pub code: c_int,
    pub message: *mut c_char,
}

#[repr(C)]
pub struct GHashTable(c_void);

#[repr(C)]
pub struct GHashTableIter {
    pub dummy1: gpointer,
    pub dummy2: gpointer,
    pub dummy3: gpointer,
    pub dummy4: c_int,
    pub dummy5: gboolean,
    pub dummy6: gpointer,
}

#[repr(C)]
pub struct GHmac(c_void);

#[repr(C)]
pub struct GHook {
    pub data: gpointer,
    pub next: *mut GHook,
    pub prev: *mut GHook,
    pub ref_count: c_uint,
    pub hook_id: c_ulong,
    pub flags: c_uint,
    pub func: gpointer,
    pub destroy: GDestroyNotify,
}

#[repr(C)]
pub struct GHookList {
    pub seq_id: c_ulong,
    _truncated_record_marker: c_void,
    //hook_size: guint: 16,
    //is_setup: guint: 1,
    //hooks: GHook*,
    //dummy3: gpointer,
    //finalize_hook: GHookFinalizeFunc,
    //dummy: gpointer,
}

#[repr(C)]
pub struct GIConv(c_void);

#[repr(C)]
pub struct GIOChannel {
    pub ref_count: c_int,
    pub funcs: *mut GIOFuncs,
    pub encoding: *mut c_char,
    pub read_cd: GIConv,
    pub write_cd: GIConv,
    pub line_term: *mut c_char,
    pub line_term_len: c_uint,
    pub buf_size: size_t,
    pub read_buf: *mut GString,
    pub encoded_read_buf: *mut GString,
    pub write_buf: *mut GString,
    pub partial_write_buf: [c_char; 6],
    _truncated_record_marker: c_void,
    //use_buffer: guint: 1,
    //do_encode: guint: 1,
    //close_on_unref: guint: 1,
    //is_readable: guint: 1,
    //is_writeable: guint: 1,
    //is_seekable: guint: 1,
    //reserved1: gpointer,
    //reserved2: gpointer,
}

#[repr(C)]
pub struct GIOFuncs {
    pub io_read: Option<unsafe extern "C" fn(*mut GIOChannel, *const c_char, size_t, *mut size_t, *mut *mut GError) -> GIOStatus>,
    pub io_write: Option<unsafe extern "C" fn(*mut GIOChannel, *const c_char, size_t, *mut size_t, *mut *mut GError) -> GIOStatus>,
    pub io_seek: Option<unsafe extern "C" fn(*mut GIOChannel, i64, GSeekType, *mut *mut GError) -> GIOStatus>,
    pub io_close: Option<unsafe extern "C" fn(*mut GIOChannel, *mut *mut GError) -> GIOStatus>,
    pub io_create_watch: Option<unsafe extern "C" fn(*mut GIOChannel, GIOCondition) -> *mut GSource>,
    pub io_free: Option<unsafe extern "C" fn(*mut GIOChannel)>,
    pub io_set_flags: Option<unsafe extern "C" fn(*mut GIOChannel, GIOFlags, *mut *mut GError) -> GIOStatus>,
    pub io_get_flags: Option<unsafe extern "C" fn(*mut GIOChannel) -> GIOFlags>,
}

#[repr(C)]
pub struct GKeyFile(c_void);

#[repr(C)]
pub struct GList {
    pub data: gpointer,
    pub next: *mut GList,
    pub prev: *mut GList,
}

#[repr(C)]
pub struct GLogField {
    pub key: *const c_char,
    pub value: gconstpointer,
    pub length: ssize_t,
}

#[repr(C)]
pub struct GMainContext(c_void);

#[repr(C)]
pub struct GMainLoop(c_void);

#[repr(C)]
pub struct GMappedFile(c_void);

#[repr(C)]
pub struct GMarkupParseContext(c_void);

#[repr(C)]
pub struct GMarkupParser {
    pub start_element: Option<unsafe extern "C" fn(*mut GMarkupParseContext, *const c_char, *mut *const c_char, *mut *const c_char, gpointer, *mut *mut GError)>,
    pub end_element: Option<unsafe extern "C" fn(*mut GMarkupParseContext, *const c_char, gpointer, *mut *mut GError)>,
    pub text: Option<unsafe extern "C" fn(*mut GMarkupParseContext, *const c_char, size_t, gpointer, *mut *mut GError)>,
    pub passthrough: Option<unsafe extern "C" fn(*mut GMarkupParseContext, *const c_char, size_t, gpointer, *mut *mut GError)>,
    pub error: Option<unsafe extern "C" fn(*mut GMarkupParseContext, *mut GError, gpointer)>,
}

#[repr(C)]
pub struct GMatchInfo(c_void);

#[repr(C)]
pub struct GMemVTable {
    pub malloc: Option<unsafe extern "C" fn(size_t) -> gpointer>,
    pub realloc: Option<unsafe extern "C" fn(gpointer, size_t) -> gpointer>,
    pub free: Option<unsafe extern "C" fn(gpointer)>,
    pub calloc: Option<unsafe extern "C" fn(size_t, size_t) -> gpointer>,
    pub try_malloc: Option<unsafe extern "C" fn(size_t) -> gpointer>,
    pub try_realloc: Option<unsafe extern "C" fn(gpointer, size_t) -> gpointer>,
}

#[repr(C)]
pub struct GNode {
    pub data: gpointer,
    pub next: *mut GNode,
    pub prev: *mut GNode,
    pub parent: *mut GNode,
    pub children: *mut GNode,
}

#[repr(C)]
pub struct GOnce {
    pub status: Volatile<GOnceStatus>,
    pub retval: Volatile<gpointer>,
}

#[repr(C)]
pub struct GOptionContext(c_void);

#[repr(C)]
pub struct GOptionEntry {
    pub long_name: *const c_char,
    pub short_name: c_char,
    pub flags: c_int,
    pub arg: GOptionArg,
    pub arg_data: gpointer,
    pub description: *const c_char,
    pub arg_description: *const c_char,
}

#[repr(C)]
pub struct GOptionGroup(c_void);

#[repr(C)]
pub struct GPatternSpec(c_void);

#[repr(C)]
pub struct GPollFD {
    pub fd: c_int,
    pub events: c_ushort,
    pub revents: c_ushort,
}

#[repr(C)]
pub struct GPrivate {
    pub p: gpointer,
    pub notify: GDestroyNotify,
    pub future: [gpointer; 2],
}

#[repr(C)]
pub struct GPtrArray {
    pub pdata: *mut gpointer,
    pub len: c_uint,
}

#[repr(C)]
pub struct GQueue {
    pub head: *mut GList,
    pub tail: *mut GList,
    pub length: c_uint,
}

#[repr(C)]
pub struct GRWLock {
    pub p: gpointer,
    pub i: [c_uint; 2],
}

#[repr(C)]
pub struct GRand(c_void);

#[repr(C)]
pub struct GRecMutex {
    pub p: gpointer,
    pub i: [c_uint; 2],
}

#[repr(C)]
pub struct GRegex(c_void);

#[repr(C)]
pub struct GSList {
    pub data: gpointer,
    pub next: *mut GSList,
}

#[repr(C)]
pub struct GScanner {
    pub user_data: gpointer,
    pub max_parse_errors: c_uint,
    pub parse_errors: c_uint,
    pub input_name: *const c_char,
    pub qdata: *mut GData,
    pub config: *mut GScannerConfig,
    pub token: GTokenType,
    _truncated_record_marker: c_void,
    //union,
    //line: guint,
    //position: guint,
    //next_token: GTokenType,
    //union,
    //next_line: guint,
    //next_position: guint,
    //symbol_table: GHashTable*,
    //input_fd: gint,
    //text: const gchar*,
    //text_end: const gchar*,
    //buffer: gchar*,
    //scope_id: guint,
    //msg_handler: GScannerMsgFunc,
}

#[repr(C)]
pub struct GScannerConfig {
    pub cset_skip_characters: *mut c_char,
    pub cset_identifier_first: *mut c_char,
    pub cset_identifier_nth: *mut c_char,
    pub cpair_comment_single: *mut c_char,
    _truncated_record_marker: c_void,
    //case_sensitive: guint: 1,
    //skip_comment_multi: guint: 1,
    //skip_comment_single: guint: 1,
    //scan_comment_multi: guint: 1,
    //scan_identifier: guint: 1,
    //scan_identifier_1char: guint: 1,
    //scan_identifier_NULL: guint: 1,
    //scan_symbols: guint: 1,
    //scan_binary: guint: 1,
    //scan_octal: guint: 1,
    //scan_float: guint: 1,
    //scan_hex: guint: 1,
    //scan_hex_dollar: guint: 1,
    //scan_string_sq: guint: 1,
    //scan_string_dq: guint: 1,
    //numbers_2_int: guint: 1,
    //int_2_float: guint: 1,
    //identifier_2_string: guint: 1,
    //char_2_token: guint: 1,
    //symbol_2_token: guint: 1,
    //scope_0_fallback: guint: 1,
    //store_int64: guint: 1,
    //padding_dummy: guint,
}

#[repr(C)]
pub struct GSequence(c_void);

#[repr(C)]
pub struct GSequenceIter(c_void);

#[repr(C)]
pub struct GSource {
    pub callback_data: gpointer,
    pub callback_funcs: *mut GSourceCallbackFuncs,
    pub source_funcs: *const GSourceFuncs,
    pub ref_count: c_uint,
    pub context: *mut GMainContext,
    pub priority: c_int,
    pub flags: c_uint,
    pub source_id: c_uint,
    pub poll_fds: *mut GSList,
    pub prev: *mut GSource,
    pub next: *mut GSource,
    pub name: *mut c_char,
    pub priv_: *mut GSourcePrivate,
}

#[repr(C)]
pub struct GSourceCallbackFuncs {
    pub ref_: Option<unsafe extern "C" fn(gpointer)>,
    pub unref: Option<unsafe extern "C" fn(gpointer)>,
    pub get: Option<unsafe extern "C" fn(gpointer, *mut GSource, *mut GSourceFunc, *mut gpointer)>,
}

#[repr(C)]
pub struct GSourceFuncs {
    pub prepare: Option<unsafe extern "C" fn(*mut GSource, *mut c_int) -> gboolean>,
    pub check: Option<unsafe extern "C" fn(*mut GSource) -> gboolean>,
    pub dispatch: Option<unsafe extern "C" fn(*mut GSource, GSourceFunc, gpointer) -> gboolean>,
    pub finalize: Option<unsafe extern "C" fn(*mut GSource)>,
    pub closure_callback: GSourceFunc,
    pub closure_marshal: GSourceDummyMarshal,
}

#[repr(C)]
pub struct GSourcePrivate(c_void);

#[repr(C)]
pub struct GStatBuf(c_void);

#[repr(C)]
pub struct GString {
    pub str: *mut c_char,
    pub len: size_t,
    pub allocated_len: size_t,
}

#[repr(C)]
pub struct GStringChunk(c_void);

#[repr(C)]
pub struct GTestCase(c_void);

#[repr(C)]
pub struct GTestConfig {
    pub test_initialized: gboolean,
    pub test_quick: gboolean,
    pub test_perf: gboolean,
    pub test_verbose: gboolean,
    pub test_quiet: gboolean,
    pub test_undefined: gboolean,
}

#[repr(C)]
pub struct GTestLogBuffer {
    pub data: *mut GString,
    pub msgs: *mut GSList,
}

#[repr(C)]
pub struct GTestLogMsg {
    pub log_type: GTestLogType,
    pub n_strings: c_uint,
    pub strings: *mut *mut c_char,
    pub n_nums: c_uint,
    pub nums: *mut c_long,
}

#[repr(C)]
pub struct GTestSuite(c_void);

#[repr(C)]
pub struct GThread(c_void);

#[repr(C)]
pub struct GThreadPool {
    pub func: GFunc,
    pub user_data: gpointer,
    pub exclusive: gboolean,
}

#[repr(C)]
pub struct GTimeVal {
    pub tv_sec: c_long,
    pub tv_usec: c_long,
}

#[repr(C)]
pub struct GTimeZone(c_void);

#[repr(C)]
pub struct GTimer(c_void);

#[repr(C)]
pub struct GTrashStack {
    pub next: *mut GTrashStack,
}

#[repr(C)]
pub struct GTree(c_void);

#[repr(C)]
pub struct GVariant(c_void);

#[repr(C)]
pub struct GVariantBuilder {
    _truncated_record_marker: c_void,
    //union,
}

#[repr(C)]
pub struct GVariantDict {
    _truncated_record_marker: c_void,
    //union,
}

#[repr(C)]
pub struct GVariantIter {
    pub x: [size_t; 16],
}

#[repr(C)]
pub struct GVariantType(c_void);

extern "C" {

    //=========================================================================
    // GMutex
    //=========================================================================
    pub fn g_mutex_clear(mutex: *mut GMutex);
    pub fn g_mutex_init(mutex: *mut GMutex);
    pub fn g_mutex_lock(mutex: *mut GMutex);
    pub fn g_mutex_trylock(mutex: *mut GMutex) -> gboolean;
    pub fn g_mutex_unlock(mutex: *mut GMutex);

    //=========================================================================
    // GArray
    //=========================================================================
    pub fn g_array_get_type() -> GType;
    pub fn g_array_append_vals(array: *mut GArray, data: gconstpointer, len: c_uint) -> *mut GArray;
    pub fn g_array_free(array: *mut GArray, free_segment: gboolean) -> *mut c_char;
    pub fn g_array_get_element_size(array: *mut GArray) -> c_uint;
    pub fn g_array_insert_vals(array: *mut GArray, index_: c_uint, data: gconstpointer, len: c_uint) -> *mut GArray;
    pub fn g_array_new(zero_terminated: gboolean, clear_: gboolean, element_size: c_uint) -> *mut GArray;
    pub fn g_array_prepend_vals(array: *mut GArray, data: gconstpointer, len: c_uint) -> *mut GArray;
    pub fn g_array_ref(array: *mut GArray) -> *mut GArray;
    pub fn g_array_remove_index(array: *mut GArray, index_: c_uint) -> *mut GArray;
    pub fn g_array_remove_index_fast(array: *mut GArray, index_: c_uint) -> *mut GArray;
    pub fn g_array_remove_range(array: *mut GArray, index_: c_uint, length: c_uint) -> *mut GArray;
    pub fn g_array_set_clear_func(array: *mut GArray, clear_func: GDestroyNotify);
    pub fn g_array_set_size(array: *mut GArray, length: c_uint) -> *mut GArray;
    pub fn g_array_sized_new(zero_terminated: gboolean, clear_: gboolean, element_size: c_uint, reserved_size: c_uint) -> *mut GArray;
    pub fn g_array_sort(array: *mut GArray, compare_func: GCompareFunc);
    pub fn g_array_sort_with_data(array: *mut GArray, compare_func: GCompareDataFunc, user_data: gpointer);
    pub fn g_array_unref(array: *mut GArray);

    //=========================================================================
    // GAsyncQueue
    //=========================================================================
    pub fn g_async_queue_length(queue: *mut GAsyncQueue) -> c_int;
    pub fn g_async_queue_length_unlocked(queue: *mut GAsyncQueue) -> c_int;
    pub fn g_async_queue_lock(queue: *mut GAsyncQueue);
    pub fn g_async_queue_pop(queue: *mut GAsyncQueue) -> gpointer;
    pub fn g_async_queue_pop_unlocked(queue: *mut GAsyncQueue) -> gpointer;
    pub fn g_async_queue_push(queue: *mut GAsyncQueue, data: gpointer);
    #[cfg(feature = "v2_46")]
    pub fn g_async_queue_push_front(queue: *mut GAsyncQueue, item: gpointer);
    #[cfg(feature = "v2_46")]
    pub fn g_async_queue_push_front_unlocked(queue: *mut GAsyncQueue, item: gpointer);
    pub fn g_async_queue_push_sorted(queue: *mut GAsyncQueue, data: gpointer, func: GCompareDataFunc, user_data: gpointer);
    pub fn g_async_queue_push_sorted_unlocked(queue: *mut GAsyncQueue, data: gpointer, func: GCompareDataFunc, user_data: gpointer);
    pub fn g_async_queue_push_unlocked(queue: *mut GAsyncQueue, data: gpointer);
    pub fn g_async_queue_ref(queue: *mut GAsyncQueue) -> *mut GAsyncQueue;
    pub fn g_async_queue_ref_unlocked(queue: *mut GAsyncQueue);
    #[cfg(feature = "v2_46")]
    pub fn g_async_queue_remove(queue: *mut GAsyncQueue, item: gpointer) -> gboolean;
    #[cfg(feature = "v2_46")]
    pub fn g_async_queue_remove_unlocked(queue: *mut GAsyncQueue, item: gpointer) -> gboolean;
    pub fn g_async_queue_sort(queue: *mut GAsyncQueue, func: GCompareDataFunc, user_data: gpointer);
    pub fn g_async_queue_sort_unlocked(queue: *mut GAsyncQueue, func: GCompareDataFunc, user_data: gpointer);
    pub fn g_async_queue_timed_pop(queue: *mut GAsyncQueue, end_time: *mut GTimeVal) -> gpointer;
    pub fn g_async_queue_timed_pop_unlocked(queue: *mut GAsyncQueue, end_time: *mut GTimeVal) -> gpointer;
    pub fn g_async_queue_timeout_pop(queue: *mut GAsyncQueue, timeout: u64) -> gpointer;
    pub fn g_async_queue_timeout_pop_unlocked(queue: *mut GAsyncQueue, timeout: u64) -> gpointer;
    pub fn g_async_queue_try_pop(queue: *mut GAsyncQueue) -> gpointer;
    pub fn g_async_queue_try_pop_unlocked(queue: *mut GAsyncQueue) -> gpointer;
    pub fn g_async_queue_unlock(queue: *mut GAsyncQueue);
    pub fn g_async_queue_unref(queue: *mut GAsyncQueue);
    pub fn g_async_queue_unref_and_unlock(queue: *mut GAsyncQueue);
    pub fn g_async_queue_new() -> *mut GAsyncQueue;
    pub fn g_async_queue_new_full(item_free_func: GDestroyNotify) -> *mut GAsyncQueue;

    //=========================================================================
    // GBookmarkFile
    //=========================================================================
    pub fn g_bookmark_file_add_application(bookmark: *mut GBookmarkFile, uri: *const c_char, name: *const c_char, exec: *const c_char);
    pub fn g_bookmark_file_add_group(bookmark: *mut GBookmarkFile, uri: *const c_char, group: *const c_char);
    pub fn g_bookmark_file_free(bookmark: *mut GBookmarkFile);
    pub fn g_bookmark_file_get_added(bookmark: *mut GBookmarkFile, uri: *const c_char, error: *mut *mut GError) -> c_long;
    pub fn g_bookmark_file_get_app_info(bookmark: *mut GBookmarkFile, uri: *const c_char, name: *const c_char, exec: *mut *mut c_char, count: *mut c_uint, stamp: *mut c_long, error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_get_applications(bookmark: *mut GBookmarkFile, uri: *const c_char, length: *mut size_t, error: *mut *mut GError) -> *mut *mut c_char;
    pub fn g_bookmark_file_get_description(bookmark: *mut GBookmarkFile, uri: *const c_char, error: *mut *mut GError) -> *mut c_char;
    pub fn g_bookmark_file_get_groups(bookmark: *mut GBookmarkFile, uri: *const c_char, length: *mut size_t, error: *mut *mut GError) -> *mut *mut c_char;
    pub fn g_bookmark_file_get_icon(bookmark: *mut GBookmarkFile, uri: *const c_char, href: *mut *mut c_char, mime_type: *mut *mut c_char, error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_get_is_private(bookmark: *mut GBookmarkFile, uri: *const c_char, error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_get_mime_type(bookmark: *mut GBookmarkFile, uri: *const c_char, error: *mut *mut GError) -> *mut c_char;
    pub fn g_bookmark_file_get_modified(bookmark: *mut GBookmarkFile, uri: *const c_char, error: *mut *mut GError) -> c_long;
    pub fn g_bookmark_file_get_size(bookmark: *mut GBookmarkFile) -> c_int;
    pub fn g_bookmark_file_get_title(bookmark: *mut GBookmarkFile, uri: *const c_char, error: *mut *mut GError) -> *mut c_char;
    pub fn g_bookmark_file_get_uris(bookmark: *mut GBookmarkFile, length: *mut size_t) -> *mut *mut c_char;
    pub fn g_bookmark_file_get_visited(bookmark: *mut GBookmarkFile, uri: *const c_char, error: *mut *mut GError) -> c_long;
    pub fn g_bookmark_file_has_application(bookmark: *mut GBookmarkFile, uri: *const c_char, name: *const c_char, error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_has_group(bookmark: *mut GBookmarkFile, uri: *const c_char, group: *const c_char, error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_has_item(bookmark: *mut GBookmarkFile, uri: *const c_char) -> gboolean;
    pub fn g_bookmark_file_load_from_data(bookmark: *mut GBookmarkFile, data: *const c_char, length: size_t, error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_load_from_data_dirs(bookmark: *mut GBookmarkFile, file: *mut c_char, full_path: *mut *mut c_char, error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_load_from_file(bookmark: *mut GBookmarkFile, filename: *mut c_char, error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_move_item(bookmark: *mut GBookmarkFile, old_uri: *const c_char, new_uri: *const c_char, error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_remove_application(bookmark: *mut GBookmarkFile, uri: *const c_char, name: *const c_char, error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_remove_group(bookmark: *mut GBookmarkFile, uri: *const c_char, group: *const c_char, error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_remove_item(bookmark: *mut GBookmarkFile, uri: *const c_char, error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_set_added(bookmark: *mut GBookmarkFile, uri: *const c_char, added: c_long);
    pub fn g_bookmark_file_set_app_info(bookmark: *mut GBookmarkFile, uri: *const c_char, name: *const c_char, exec: *const c_char, count: c_int, stamp: c_long, error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_set_description(bookmark: *mut GBookmarkFile, uri: *const c_char, description: *const c_char);
    pub fn g_bookmark_file_set_groups(bookmark: *mut GBookmarkFile, uri: *const c_char, groups: *mut *const c_char, length: size_t);
    pub fn g_bookmark_file_set_icon(bookmark: *mut GBookmarkFile, uri: *const c_char, href: *const c_char, mime_type: *const c_char);
    pub fn g_bookmark_file_set_is_private(bookmark: *mut GBookmarkFile, uri: *const c_char, is_private: gboolean);
    pub fn g_bookmark_file_set_mime_type(bookmark: *mut GBookmarkFile, uri: *const c_char, mime_type: *const c_char);
    pub fn g_bookmark_file_set_modified(bookmark: *mut GBookmarkFile, uri: *const c_char, modified: c_long);
    pub fn g_bookmark_file_set_title(bookmark: *mut GBookmarkFile, uri: *const c_char, title: *const c_char);
    pub fn g_bookmark_file_set_visited(bookmark: *mut GBookmarkFile, uri: *const c_char, visited: c_long);
    pub fn g_bookmark_file_to_data(bookmark: *mut GBookmarkFile, length: *mut size_t, error: *mut *mut GError) -> *mut c_char;
    pub fn g_bookmark_file_to_file(bookmark: *mut GBookmarkFile, filename: *mut c_char, error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_error_quark() -> GQuark;
    pub fn g_bookmark_file_new() -> *mut GBookmarkFile;

    //=========================================================================
    // GByteArray
    //=========================================================================
    pub fn g_byte_array_get_type() -> GType;
    pub fn g_byte_array_append(array: *mut GByteArray, data: *const u8, len: c_uint) -> *mut GByteArray;
    pub fn g_byte_array_free(array: *mut GByteArray, free_segment: gboolean) -> *mut u8;
    pub fn g_byte_array_free_to_bytes(array: *mut GByteArray) -> *mut GBytes;
    pub fn g_byte_array_new() -> *mut GByteArray;
    pub fn g_byte_array_new_take(data: *mut u8, len: size_t) -> *mut GByteArray;
    pub fn g_byte_array_prepend(array: *mut GByteArray, data: *const u8, len: c_uint) -> *mut GByteArray;
    pub fn g_byte_array_ref(array: *mut GByteArray) -> *mut GByteArray;
    pub fn g_byte_array_remove_index(array: *mut GByteArray, index_: c_uint) -> *mut GByteArray;
    pub fn g_byte_array_remove_index_fast(array: *mut GByteArray, index_: c_uint) -> *mut GByteArray;
    pub fn g_byte_array_remove_range(array: *mut GByteArray, index_: c_uint, length: c_uint) -> *mut GByteArray;
    pub fn g_byte_array_set_size(array: *mut GByteArray, length: c_uint) -> *mut GByteArray;
    pub fn g_byte_array_sized_new(reserved_size: c_uint) -> *mut GByteArray;
    pub fn g_byte_array_sort(array: *mut GByteArray, compare_func: GCompareFunc);
    pub fn g_byte_array_sort_with_data(array: *mut GByteArray, compare_func: GCompareDataFunc, user_data: gpointer);
    pub fn g_byte_array_unref(array: *mut GByteArray);

    //=========================================================================
    // GBytes
    //=========================================================================
    pub fn g_bytes_get_type() -> GType;
    pub fn g_bytes_new(data: gconstpointer, size: size_t) -> *mut GBytes;
    pub fn g_bytes_new_static(data: gconstpointer, size: size_t) -> *mut GBytes;
    pub fn g_bytes_new_take(data: gpointer, size: size_t) -> *mut GBytes;
    pub fn g_bytes_new_with_free_func(data: gconstpointer, size: size_t, free_func: GDestroyNotify, user_data: gpointer) -> *mut GBytes;
    pub fn g_bytes_compare(bytes1: gconstpointer, bytes2: gconstpointer) -> c_int;
    pub fn g_bytes_equal(bytes1: gconstpointer, bytes2: gconstpointer) -> gboolean;
    pub fn g_bytes_get_data(bytes: *mut GBytes, size: *mut size_t) -> gconstpointer;
    pub fn g_bytes_get_size(bytes: *mut GBytes) -> size_t;
    pub fn g_bytes_hash(bytes: gconstpointer) -> c_uint;
    pub fn g_bytes_new_from_bytes(bytes: *mut GBytes, offset: size_t, length: size_t) -> *mut GBytes;
    pub fn g_bytes_ref(bytes: *mut GBytes) -> *mut GBytes;
    pub fn g_bytes_unref(bytes: *mut GBytes);
    pub fn g_bytes_unref_to_array(bytes: *mut GBytes) -> *mut GByteArray;
    pub fn g_bytes_unref_to_data(bytes: *mut GBytes, size: *mut size_t) -> gpointer;

    //=========================================================================
    // GChecksum
    //=========================================================================
    pub fn g_checksum_get_type() -> GType;
    pub fn g_checksum_new(checksum_type: GChecksumType) -> *mut GChecksum;
    pub fn g_checksum_copy(checksum: *const GChecksum) -> *mut GChecksum;
    pub fn g_checksum_free(checksum: *mut GChecksum);
    pub fn g_checksum_get_digest(checksum: *mut GChecksum, buffer: *mut u8, digest_len: *mut size_t);
    pub fn g_checksum_get_string(checksum: *mut GChecksum) -> *const c_char;
    pub fn g_checksum_reset(checksum: *mut GChecksum);
    pub fn g_checksum_update(checksum: *mut GChecksum, data: *mut u8, length: ssize_t);
    pub fn g_checksum_type_get_length(checksum_type: GChecksumType) -> ssize_t;

    //=========================================================================
    // GCond
    //=========================================================================
    pub fn g_cond_broadcast(cond: *mut GCond);
    pub fn g_cond_clear(cond: *mut GCond);
    pub fn g_cond_init(cond: *mut GCond);
    pub fn g_cond_signal(cond: *mut GCond);
    pub fn g_cond_wait(cond: *mut GCond, mutex: *mut GMutex);
    pub fn g_cond_wait_until(cond: *mut GCond, mutex: *mut GMutex, end_time: i64) -> gboolean;

    //=========================================================================
    // GDate
    //=========================================================================
    pub fn g_date_get_type() -> GType;
    pub fn g_date_new() -> *mut GDate;
    pub fn g_date_new_dmy(day: GDateDay, month: GDateMonth, year: GDateYear) -> *mut GDate;
    pub fn g_date_new_julian(julian_day: u32) -> *mut GDate;
    pub fn g_date_add_days(date: *mut GDate, n_days: c_uint);
    pub fn g_date_add_months(date: *mut GDate, n_months: c_uint);
    pub fn g_date_add_years(date: *mut GDate, n_years: c_uint);
    pub fn g_date_clamp(date: *mut GDate, min_date: *const GDate, max_date: *const GDate);
    pub fn g_date_clear(date: *mut GDate, n_dates: c_uint);
    pub fn g_date_compare(lhs: *const GDate, rhs: *const GDate) -> c_int;
    pub fn g_date_days_between(date1: *const GDate, date2: *const GDate) -> c_int;
    pub fn g_date_free(date: *mut GDate);
    pub fn g_date_get_day(date: *const GDate) -> GDateDay;
    pub fn g_date_get_day_of_year(date: *const GDate) -> c_uint;
    pub fn g_date_get_iso8601_week_of_year(date: *const GDate) -> c_uint;
    pub fn g_date_get_julian(date: *const GDate) -> u32;
    pub fn g_date_get_monday_week_of_year(date: *const GDate) -> c_uint;
    pub fn g_date_get_month(date: *const GDate) -> GDateMonth;
    pub fn g_date_get_sunday_week_of_year(date: *const GDate) -> c_uint;
    pub fn g_date_get_weekday(date: *const GDate) -> GDateWeekday;
    pub fn g_date_get_year(date: *const GDate) -> GDateYear;
    pub fn g_date_is_first_of_month(date: *const GDate) -> gboolean;
    pub fn g_date_is_last_of_month(date: *const GDate) -> gboolean;
    pub fn g_date_order(date1: *mut GDate, date2: *mut GDate);
    pub fn g_date_set_day(date: *mut GDate, day: GDateDay);
    pub fn g_date_set_dmy(date: *mut GDate, day: GDateDay, month: GDateMonth, y: GDateYear);
    pub fn g_date_set_julian(date: *mut GDate, julian_date: u32);
    pub fn g_date_set_month(date: *mut GDate, month: GDateMonth);
    pub fn g_date_set_parse(date: *mut GDate, str: *const c_char);
    pub fn g_date_set_time(date: *mut GDate, time_: GTime);
    pub fn g_date_set_time_t(date: *mut GDate, timet: c_long);
    pub fn g_date_set_time_val(date: *mut GDate, timeval: *mut GTimeVal);
    pub fn g_date_set_year(date: *mut GDate, year: GDateYear);
    pub fn g_date_subtract_days(date: *mut GDate, n_days: c_uint);
    pub fn g_date_subtract_months(date: *mut GDate, n_months: c_uint);
    pub fn g_date_subtract_years(date: *mut GDate, n_years: c_uint);
    //pub fn g_date_to_struct_tm(date: *const GDate, tm: /*Unimplemented*/*mut tm);
    pub fn g_date_valid(date: *const GDate) -> gboolean;
    pub fn g_date_get_days_in_month(month: GDateMonth, year: GDateYear) -> u8;
    pub fn g_date_get_monday_weeks_in_year(year: GDateYear) -> u8;
    pub fn g_date_get_sunday_weeks_in_year(year: GDateYear) -> u8;
    pub fn g_date_is_leap_year(year: GDateYear) -> gboolean;
    pub fn g_date_strftime(s: *mut c_char, slen: size_t, format: *const c_char, date: *const GDate) -> size_t;
    pub fn g_date_valid_day(day: GDateDay) -> gboolean;
    pub fn g_date_valid_dmy(day: GDateDay, month: GDateMonth, year: GDateYear) -> gboolean;
    pub fn g_date_valid_julian(julian_date: u32) -> gboolean;
    pub fn g_date_valid_month(month: GDateMonth) -> gboolean;
    pub fn g_date_valid_weekday(weekday: GDateWeekday) -> gboolean;
    pub fn g_date_valid_year(year: GDateYear) -> gboolean;

    //=========================================================================
    // GDateTime
    //=========================================================================
    pub fn g_date_time_get_type() -> GType;
    pub fn g_date_time_new(tz: *mut GTimeZone, year: c_int, month: c_int, day: c_int, hour: c_int, minute: c_int, seconds: c_double) -> *mut GDateTime;
    pub fn g_date_time_new_from_timeval_local(tv: *const GTimeVal) -> *mut GDateTime;
    pub fn g_date_time_new_from_timeval_utc(tv: *const GTimeVal) -> *mut GDateTime;
    pub fn g_date_time_new_from_unix_local(t: i64) -> *mut GDateTime;
    pub fn g_date_time_new_from_unix_utc(t: i64) -> *mut GDateTime;
    pub fn g_date_time_new_local(year: c_int, month: c_int, day: c_int, hour: c_int, minute: c_int, seconds: c_double) -> *mut GDateTime;
    pub fn g_date_time_new_now(tz: *mut GTimeZone) -> *mut GDateTime;
    pub fn g_date_time_new_now_local() -> *mut GDateTime;
    pub fn g_date_time_new_now_utc() -> *mut GDateTime;
    pub fn g_date_time_new_utc(year: c_int, month: c_int, day: c_int, hour: c_int, minute: c_int, seconds: c_double) -> *mut GDateTime;
    pub fn g_date_time_add(datetime: *mut GDateTime, timespan: GTimeSpan) -> *mut GDateTime;
    pub fn g_date_time_add_days(datetime: *mut GDateTime, days: c_int) -> *mut GDateTime;
    pub fn g_date_time_add_full(datetime: *mut GDateTime, years: c_int, months: c_int, days: c_int, hours: c_int, minutes: c_int, seconds: c_double) -> *mut GDateTime;
    pub fn g_date_time_add_hours(datetime: *mut GDateTime, hours: c_int) -> *mut GDateTime;
    pub fn g_date_time_add_minutes(datetime: *mut GDateTime, minutes: c_int) -> *mut GDateTime;
    pub fn g_date_time_add_months(datetime: *mut GDateTime, months: c_int) -> *mut GDateTime;
    pub fn g_date_time_add_seconds(datetime: *mut GDateTime, seconds: c_double) -> *mut GDateTime;
    pub fn g_date_time_add_weeks(datetime: *mut GDateTime, weeks: c_int) -> *mut GDateTime;
    pub fn g_date_time_add_years(datetime: *mut GDateTime, years: c_int) -> *mut GDateTime;
    pub fn g_date_time_difference(end: *mut GDateTime, begin: *mut GDateTime) -> GTimeSpan;
    pub fn g_date_time_format(datetime: *mut GDateTime, format: *const c_char) -> *mut c_char;
    pub fn g_date_time_get_day_of_month(datetime: *mut GDateTime) -> c_int;
    pub fn g_date_time_get_day_of_week(datetime: *mut GDateTime) -> c_int;
    pub fn g_date_time_get_day_of_year(datetime: *mut GDateTime) -> c_int;
    pub fn g_date_time_get_hour(datetime: *mut GDateTime) -> c_int;
    pub fn g_date_time_get_microsecond(datetime: *mut GDateTime) -> c_int;
    pub fn g_date_time_get_minute(datetime: *mut GDateTime) -> c_int;
    pub fn g_date_time_get_month(datetime: *mut GDateTime) -> c_int;
    pub fn g_date_time_get_second(datetime: *mut GDateTime) -> c_int;
    pub fn g_date_time_get_seconds(datetime: *mut GDateTime) -> c_double;
    pub fn g_date_time_get_timezone_abbreviation(datetime: *mut GDateTime) -> *const c_char;
    pub fn g_date_time_get_utc_offset(datetime: *mut GDateTime) -> GTimeSpan;
    pub fn g_date_time_get_week_numbering_year(datetime: *mut GDateTime) -> c_int;
    pub fn g_date_time_get_week_of_year(datetime: *mut GDateTime) -> c_int;
    pub fn g_date_time_get_year(datetime: *mut GDateTime) -> c_int;
    pub fn g_date_time_get_ymd(datetime: *mut GDateTime, year: *mut c_int, month: *mut c_int, day: *mut c_int);
    pub fn g_date_time_is_daylight_savings(datetime: *mut GDateTime) -> gboolean;
    pub fn g_date_time_ref(datetime: *mut GDateTime) -> *mut GDateTime;
    pub fn g_date_time_to_local(datetime: *mut GDateTime) -> *mut GDateTime;
    pub fn g_date_time_to_timeval(datetime: *mut GDateTime, tv: *mut GTimeVal) -> gboolean;
    pub fn g_date_time_to_timezone(datetime: *mut GDateTime, tz: *mut GTimeZone) -> *mut GDateTime;
    pub fn g_date_time_to_unix(datetime: *mut GDateTime) -> i64;
    pub fn g_date_time_to_utc(datetime: *mut GDateTime) -> *mut GDateTime;
    pub fn g_date_time_unref(datetime: *mut GDateTime);
    pub fn g_date_time_compare(dt1: gconstpointer, dt2: gconstpointer) -> c_int;
    pub fn g_date_time_equal(dt1: gconstpointer, dt2: gconstpointer) -> gboolean;
    pub fn g_date_time_hash(datetime: gconstpointer) -> c_uint;

    //=========================================================================
    // GDir
    //=========================================================================
    pub fn g_dir_close(dir: *mut GDir);
    #[cfg(windows)]
    pub fn g_dir_read_name_utf8(dir: *mut GDir) -> *mut c_char;
    pub fn g_dir_read_name(dir: *mut GDir) -> *mut c_char;
    pub fn g_dir_rewind(dir: *mut GDir);
    pub fn g_dir_make_tmp(tmpl: *mut c_char, error: *mut *mut GError) -> *mut c_char;
    #[cfg(windows)]
    pub fn g_dir_open_utf8(path: *const c_char, flags: c_uint, error: *mut *mut GError) -> *mut GDir;
    pub fn g_dir_open(path: *const c_char, flags: c_uint, error: *mut *mut GError) -> *mut GDir;

    //=========================================================================
    // GError
    //=========================================================================
    pub fn g_error_get_type() -> GType;
    pub fn g_error_new(domain: GQuark, code: c_int, format: *const c_char, ...) -> *mut GError;
    pub fn g_error_new_literal(domain: GQuark, code: c_int, message: *const c_char) -> *mut GError;
    //pub fn g_error_new_valist(domain: GQuark, code: c_int, format: *const c_char, args: /*Unimplemented*/va_list) -> *mut GError;
    pub fn g_error_copy(error: *const GError) -> *mut GError;
    pub fn g_error_free(error: *mut GError);
    pub fn g_error_matches(error: *const GError, domain: GQuark, code: c_int) -> gboolean;

    //=========================================================================
    // GHashTable
    //=========================================================================
    pub fn g_hash_table_get_type() -> GType;
    pub fn g_hash_table_add(hash_table: *mut GHashTable, key: gpointer) -> gboolean;
    pub fn g_hash_table_contains(hash_table: *mut GHashTable, key: gconstpointer) -> gboolean;
    pub fn g_hash_table_destroy(hash_table: *mut GHashTable);
    pub fn g_hash_table_find(hash_table: *mut GHashTable, predicate: GHRFunc, user_data: gpointer) -> gpointer;
    pub fn g_hash_table_foreach(hash_table: *mut GHashTable, func: GHFunc, user_data: gpointer);
    pub fn g_hash_table_foreach_remove(hash_table: *mut GHashTable, func: GHRFunc, user_data: gpointer) -> c_uint;
    pub fn g_hash_table_foreach_steal(hash_table: *mut GHashTable, func: GHRFunc, user_data: gpointer) -> c_uint;
    pub fn g_hash_table_get_keys(hash_table: *mut GHashTable) -> *mut GList;
    #[cfg(feature = "v2_40")]
    pub fn g_hash_table_get_keys_as_array(hash_table: *mut GHashTable, length: *mut c_uint) -> *mut gpointer;
    pub fn g_hash_table_get_values(hash_table: *mut GHashTable) -> *mut GList;
    pub fn g_hash_table_insert(hash_table: *mut GHashTable, key: gpointer, value: gpointer) -> gboolean;
    pub fn g_hash_table_lookup(hash_table: *mut GHashTable, key: gconstpointer) -> gpointer;
    pub fn g_hash_table_lookup_extended(hash_table: *mut GHashTable, lookup_key: gconstpointer, orig_key: *mut gpointer, value: *mut gpointer) -> gboolean;
    pub fn g_hash_table_new(hash_func: GHashFunc, key_equal_func: GEqualFunc) -> *mut GHashTable;
    pub fn g_hash_table_new_full(hash_func: GHashFunc, key_equal_func: GEqualFunc, key_destroy_func: GDestroyNotify, value_destroy_func: GDestroyNotify) -> *mut GHashTable;
    pub fn g_hash_table_ref(hash_table: *mut GHashTable) -> *mut GHashTable;
    pub fn g_hash_table_remove(hash_table: *mut GHashTable, key: gconstpointer) -> gboolean;
    pub fn g_hash_table_remove_all(hash_table: *mut GHashTable);
    pub fn g_hash_table_replace(hash_table: *mut GHashTable, key: gpointer, value: gpointer) -> gboolean;
    pub fn g_hash_table_size(hash_table: *mut GHashTable) -> c_uint;
    pub fn g_hash_table_steal(hash_table: *mut GHashTable, key: gconstpointer) -> gboolean;
    pub fn g_hash_table_steal_all(hash_table: *mut GHashTable);
    pub fn g_hash_table_unref(hash_table: *mut GHashTable);

    //=========================================================================
    // GHashTableIter
    //=========================================================================
    pub fn g_hash_table_iter_get_hash_table(iter: *mut GHashTableIter) -> *mut GHashTable;
    pub fn g_hash_table_iter_init(iter: *mut GHashTableIter, hash_table: *mut GHashTable);
    pub fn g_hash_table_iter_next(iter: *mut GHashTableIter, key: *mut gpointer, value: *mut gpointer) -> gboolean;
    pub fn g_hash_table_iter_remove(iter: *mut GHashTableIter);
    pub fn g_hash_table_iter_replace(iter: *mut GHashTableIter, value: gpointer);
    pub fn g_hash_table_iter_steal(iter: *mut GHashTableIter);

    //=========================================================================
    // GHmac
    //=========================================================================
    pub fn g_hmac_copy(hmac: *const GHmac) -> *mut GHmac;
    pub fn g_hmac_get_digest(hmac: *mut GHmac, buffer: *mut u8, digest_len: *mut size_t);
    pub fn g_hmac_get_string(hmac: *mut GHmac) -> *const c_char;
    pub fn g_hmac_ref(hmac: *mut GHmac) -> *mut GHmac;
    pub fn g_hmac_unref(hmac: *mut GHmac);
    pub fn g_hmac_update(hmac: *mut GHmac, data: *mut u8, length: ssize_t);
    pub fn g_hmac_new(digest_type: GChecksumType, key: *mut u8, key_len: size_t) -> *mut GHmac;

    //=========================================================================
    // GHook
    //=========================================================================
    pub fn g_hook_compare_ids(new_hook: *mut GHook, sibling: *mut GHook) -> c_int;
    pub fn g_hook_alloc(hook_list: *mut GHookList) -> *mut GHook;
    pub fn g_hook_destroy(hook_list: *mut GHookList, hook_id: c_ulong) -> gboolean;
    pub fn g_hook_destroy_link(hook_list: *mut GHookList, hook: *mut GHook);
    pub fn g_hook_find(hook_list: *mut GHookList, need_valids: gboolean, func: GHookFindFunc, data: gpointer) -> *mut GHook;
    pub fn g_hook_find_data(hook_list: *mut GHookList, need_valids: gboolean, data: gpointer) -> *mut GHook;
    pub fn g_hook_find_func(hook_list: *mut GHookList, need_valids: gboolean, func: gpointer) -> *mut GHook;
    pub fn g_hook_find_func_data(hook_list: *mut GHookList, need_valids: gboolean, func: gpointer, data: gpointer) -> *mut GHook;
    pub fn g_hook_first_valid(hook_list: *mut GHookList, may_be_in_call: gboolean) -> *mut GHook;
    pub fn g_hook_free(hook_list: *mut GHookList, hook: *mut GHook);
    pub fn g_hook_get(hook_list: *mut GHookList, hook_id: c_ulong) -> *mut GHook;
    pub fn g_hook_insert_before(hook_list: *mut GHookList, sibling: *mut GHook, hook: *mut GHook);
    pub fn g_hook_insert_sorted(hook_list: *mut GHookList, hook: *mut GHook, func: GHookCompareFunc);
    pub fn g_hook_next_valid(hook_list: *mut GHookList, hook: *mut GHook, may_be_in_call: gboolean) -> *mut GHook;
    pub fn g_hook_prepend(hook_list: *mut GHookList, hook: *mut GHook);
    pub fn g_hook_ref(hook_list: *mut GHookList, hook: *mut GHook) -> *mut GHook;
    pub fn g_hook_unref(hook_list: *mut GHookList, hook: *mut GHook);

    //=========================================================================
    // GHookList
    //=========================================================================
    pub fn g_hook_list_clear(hook_list: *mut GHookList);
    pub fn g_hook_list_init(hook_list: *mut GHookList, hook_size: c_uint);
    pub fn g_hook_list_invoke(hook_list: *mut GHookList, may_recurse: gboolean);
    pub fn g_hook_list_invoke_check(hook_list: *mut GHookList, may_recurse: gboolean);
    pub fn g_hook_list_marshal(hook_list: *mut GHookList, may_recurse: gboolean, marshaller: GHookMarshaller, marshal_data: gpointer);
    pub fn g_hook_list_marshal_check(hook_list: *mut GHookList, may_recurse: gboolean, marshaller: GHookCheckMarshaller, marshal_data: gpointer);

    //=========================================================================
    // GIConv
    //=========================================================================
    pub fn g_iconv_close(converter: GIConv) -> c_int;
    pub fn g_iconv_open(to_codeset: *const c_char, from_codeset: *const c_char) -> GIConv;

    //=========================================================================
    // GIOChannel
    //=========================================================================
    pub fn g_io_channel_get_type() -> GType;
    #[cfg(windows)]
    pub fn g_io_channel_new_file_utf8(filename: *mut c_char, mode: *const c_char, error: *mut *mut GError) -> *mut GIOChannel;
    pub fn g_io_channel_new_file(filename: *mut c_char, mode: *const c_char, error: *mut *mut GError) -> *mut GIOChannel;
    pub fn g_io_channel_unix_new(fd: c_int) -> *mut GIOChannel;
    pub fn g_io_channel_close(channel: *mut GIOChannel);
    pub fn g_io_channel_flush(channel: *mut GIOChannel, error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_get_buffer_condition(channel: *mut GIOChannel) -> GIOCondition;
    pub fn g_io_channel_get_buffer_size(channel: *mut GIOChannel) -> size_t;
    pub fn g_io_channel_get_buffered(channel: *mut GIOChannel) -> gboolean;
    pub fn g_io_channel_get_close_on_unref(channel: *mut GIOChannel) -> gboolean;
    pub fn g_io_channel_get_encoding(channel: *mut GIOChannel) -> *const c_char;
    pub fn g_io_channel_get_flags(channel: *mut GIOChannel) -> GIOFlags;
    pub fn g_io_channel_get_line_term(channel: *mut GIOChannel, length: *mut c_int) -> *const c_char;
    pub fn g_io_channel_init(channel: *mut GIOChannel);
    pub fn g_io_channel_read(channel: *mut GIOChannel, buf: *mut c_char, count: size_t, bytes_read: *mut size_t) -> GIOError;
    pub fn g_io_channel_read_chars(channel: *mut GIOChannel, buf: *mut u8, count: size_t, bytes_read: *mut size_t, error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_read_line(channel: *mut GIOChannel, str_return: *mut *mut c_char, length: *mut size_t, terminator_pos: *mut size_t, error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_read_line_string(channel: *mut GIOChannel, buffer: *mut GString, terminator_pos: *mut size_t, error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_read_to_end(channel: *mut GIOChannel, str_return: *mut *mut u8, length: *mut size_t, error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_read_unichar(channel: *mut GIOChannel, thechar: *mut u32, error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_ref(channel: *mut GIOChannel) -> *mut GIOChannel;
    pub fn g_io_channel_seek(channel: *mut GIOChannel, offset: i64, type_: GSeekType) -> GIOError;
    pub fn g_io_channel_seek_position(channel: *mut GIOChannel, offset: i64, type_: GSeekType, error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_set_buffer_size(channel: *mut GIOChannel, size: size_t);
    pub fn g_io_channel_set_buffered(channel: *mut GIOChannel, buffered: gboolean);
    pub fn g_io_channel_set_close_on_unref(channel: *mut GIOChannel, do_close: gboolean);
    pub fn g_io_channel_set_encoding(channel: *mut GIOChannel, encoding: *const c_char, error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_set_flags(channel: *mut GIOChannel, flags: GIOFlags, error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_set_line_term(channel: *mut GIOChannel, line_term: *const c_char, length: c_int);
    pub fn g_io_channel_shutdown(channel: *mut GIOChannel, flush: gboolean, error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_unix_get_fd(channel: *mut GIOChannel) -> c_int;
    pub fn g_io_channel_unref(channel: *mut GIOChannel);
    pub fn g_io_channel_write(channel: *mut GIOChannel, buf: *const c_char, count: size_t, bytes_written: *mut size_t) -> GIOError;
    pub fn g_io_channel_write_chars(channel: *mut GIOChannel, buf: *mut u8, count: ssize_t, bytes_written: *mut size_t, error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_write_unichar(channel: *mut GIOChannel, thechar: u32, error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_error_from_errno(en: c_int) -> GIOChannelError;
    pub fn g_io_channel_error_quark() -> GQuark;

    //=========================================================================
    // GKeyFile
    //=========================================================================
    pub fn g_key_file_get_type() -> GType;
    pub fn g_key_file_new() -> *mut GKeyFile;
    pub fn g_key_file_free(key_file: *mut GKeyFile);
    pub fn g_key_file_get_boolean(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, error: *mut *mut GError) -> gboolean;
    pub fn g_key_file_get_boolean_list(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, length: *mut size_t, error: *mut *mut GError) -> *mut gboolean;
    pub fn g_key_file_get_comment(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, error: *mut *mut GError) -> *mut c_char;
    pub fn g_key_file_get_double(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, error: *mut *mut GError) -> c_double;
    pub fn g_key_file_get_double_list(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, length: *mut size_t, error: *mut *mut GError) -> *mut c_double;
    pub fn g_key_file_get_groups(key_file: *mut GKeyFile, length: *mut size_t) -> *mut *mut c_char;
    pub fn g_key_file_get_int64(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, error: *mut *mut GError) -> i64;
    pub fn g_key_file_get_integer(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, error: *mut *mut GError) -> c_int;
    pub fn g_key_file_get_integer_list(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, length: *mut size_t, error: *mut *mut GError) -> *mut c_int;
    pub fn g_key_file_get_keys(key_file: *mut GKeyFile, group_name: *const c_char, length: *mut size_t, error: *mut *mut GError) -> *mut *mut c_char;
    pub fn g_key_file_get_locale_string(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, locale: *const c_char, error: *mut *mut GError) -> *mut c_char;
    pub fn g_key_file_get_locale_string_list(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, locale: *const c_char, length: *mut size_t, error: *mut *mut GError) -> *mut *mut c_char;
    pub fn g_key_file_get_start_group(key_file: *mut GKeyFile) -> *mut c_char;
    pub fn g_key_file_get_string(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, error: *mut *mut GError) -> *mut c_char;
    pub fn g_key_file_get_string_list(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, length: *mut size_t, error: *mut *mut GError) -> *mut *mut c_char;
    pub fn g_key_file_get_uint64(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, error: *mut *mut GError) -> u64;
    pub fn g_key_file_get_value(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, error: *mut *mut GError) -> *mut c_char;
    pub fn g_key_file_has_group(key_file: *mut GKeyFile, group_name: *const c_char) -> gboolean;
    pub fn g_key_file_has_key(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, error: *mut *mut GError) -> gboolean;
    #[cfg(feature = "v2_50")]
    pub fn g_key_file_load_from_bytes(key_file: *mut GKeyFile, bytes: *mut GBytes, flags: GKeyFileFlags, error: *mut *mut GError) -> gboolean;
    pub fn g_key_file_load_from_data(key_file: *mut GKeyFile, data: *const c_char, length: size_t, flags: GKeyFileFlags, error: *mut *mut GError) -> gboolean;
    pub fn g_key_file_load_from_data_dirs(key_file: *mut GKeyFile, file: *mut c_char, full_path: *mut *mut c_char, flags: GKeyFileFlags, error: *mut *mut GError) -> gboolean;
    pub fn g_key_file_load_from_dirs(key_file: *mut GKeyFile, file: *mut c_char, search_dirs: *mut *mut c_char, full_path: *mut *mut c_char, flags: GKeyFileFlags, error: *mut *mut GError) -> gboolean;
    pub fn g_key_file_load_from_file(key_file: *mut GKeyFile, file: *mut c_char, flags: GKeyFileFlags, error: *mut *mut GError) -> gboolean;
    pub fn g_key_file_ref(key_file: *mut GKeyFile) -> *mut GKeyFile;
    pub fn g_key_file_remove_comment(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, error: *mut *mut GError) -> gboolean;
    pub fn g_key_file_remove_group(key_file: *mut GKeyFile, group_name: *const c_char, error: *mut *mut GError) -> gboolean;
    pub fn g_key_file_remove_key(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, error: *mut *mut GError) -> gboolean;
    #[cfg(feature = "v2_40")]
    pub fn g_key_file_save_to_file(key_file: *mut GKeyFile, filename: *const c_char, error: *mut *mut GError) -> gboolean;
    pub fn g_key_file_set_boolean(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, value: gboolean);
    pub fn g_key_file_set_boolean_list(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, list: gboolean, length: size_t);
    pub fn g_key_file_set_comment(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, comment: *const c_char, error: *mut *mut GError) -> gboolean;
    pub fn g_key_file_set_double(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, value: c_double);
    pub fn g_key_file_set_double_list(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, list: c_double, length: size_t);
    pub fn g_key_file_set_int64(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, value: i64);
    pub fn g_key_file_set_integer(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, value: c_int);
    pub fn g_key_file_set_integer_list(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, list: c_int, length: size_t);
    pub fn g_key_file_set_list_separator(key_file: *mut GKeyFile, separator: c_char);
    pub fn g_key_file_set_locale_string(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, locale: *const c_char, string: *const c_char);
    pub fn g_key_file_set_locale_string_list(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, locale: *const c_char, list: *mut c_char, length: size_t);
    pub fn g_key_file_set_string(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, string: *const c_char);
    pub fn g_key_file_set_string_list(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, list: *mut c_char, length: size_t);
    pub fn g_key_file_set_uint64(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, value: u64);
    pub fn g_key_file_set_value(key_file: *mut GKeyFile, group_name: *const c_char, key: *const c_char, value: *const c_char);
    pub fn g_key_file_to_data(key_file: *mut GKeyFile, length: *mut size_t, error: *mut *mut GError) -> *mut c_char;
    pub fn g_key_file_unref(key_file: *mut GKeyFile);
    pub fn g_key_file_error_quark() -> GQuark;

    //=========================================================================
    // GList
    //=========================================================================
    pub fn g_list_alloc() -> *mut GList;
    pub fn g_list_append(list: *mut GList, data: gpointer) -> *mut GList;
    pub fn g_list_concat(list1: *mut GList, list2: *mut GList) -> *mut GList;
    pub fn g_list_copy(list: *mut GList) -> *mut GList;
    #[cfg(feature = "v2_34")]
    pub fn g_list_copy_deep(list: *mut GList, func: GCopyFunc, user_data: gpointer) -> *mut GList;
    pub fn g_list_delete_link(list: *mut GList, link_: *mut GList) -> *mut GList;
    pub fn g_list_find(list: *mut GList, data: gconstpointer) -> *mut GList;
    pub fn g_list_find_custom(list: *mut GList, data: gconstpointer, func: GCompareFunc) -> *mut GList;
    pub fn g_list_first(list: *mut GList) -> *mut GList;
    pub fn g_list_foreach(list: *mut GList, func: GFunc, user_data: gpointer);
    pub fn g_list_free(list: *mut GList);
    pub fn g_list_free_1(list: *mut GList);
    pub fn g_list_free_full(list: *mut GList, free_func: GDestroyNotify);
    pub fn g_list_index(list: *mut GList, data: gconstpointer) -> c_int;
    pub fn g_list_insert(list: *mut GList, data: gpointer, position: c_int) -> *mut GList;
    pub fn g_list_insert_before(list: *mut GList, sibling: *mut GList, data: gpointer) -> *mut GList;
    pub fn g_list_insert_sorted(list: *mut GList, data: gpointer, func: GCompareFunc) -> *mut GList;
    pub fn g_list_insert_sorted_with_data(list: *mut GList, data: gpointer, func: GCompareDataFunc, user_data: gpointer) -> *mut GList;
    pub fn g_list_last(list: *mut GList) -> *mut GList;
    pub fn g_list_length(list: *mut GList) -> c_uint;
    pub fn g_list_nth(list: *mut GList, n: c_uint) -> *mut GList;
    pub fn g_list_nth_data(list: *mut GList, n: c_uint) -> gpointer;
    pub fn g_list_nth_prev(list: *mut GList, n: c_uint) -> *mut GList;
    pub fn g_list_position(list: *mut GList, llink: *mut GList) -> c_int;
    pub fn g_list_prepend(list: *mut GList, data: gpointer) -> *mut GList;
    pub fn g_list_remove(list: *mut GList, data: gconstpointer) -> *mut GList;
    pub fn g_list_remove_all(list: *mut GList, data: gconstpointer) -> *mut GList;
    pub fn g_list_remove_link(list: *mut GList, llink: *mut GList) -> *mut GList;
    pub fn g_list_reverse(list: *mut GList) -> *mut GList;
    pub fn g_list_sort(list: *mut GList, compare_func: GCompareFunc) -> *mut GList;
    pub fn g_list_sort_with_data(list: *mut GList, compare_func: GCompareDataFunc, user_data: gpointer) -> *mut GList;

    //=========================================================================
    // GMainContext
    //=========================================================================
    pub fn g_main_context_get_type() -> GType;
    pub fn g_main_context_new() -> *mut GMainContext;
    pub fn g_main_context_acquire(context: *mut GMainContext) -> gboolean;
    pub fn g_main_context_add_poll(context: *mut GMainContext, fd: *mut GPollFD, priority: c_int);
    pub fn g_main_context_check(context: *mut GMainContext, max_priority: c_int, fds: *mut GPollFD, n_fds: c_int) -> c_int;
    pub fn g_main_context_dispatch(context: *mut GMainContext);
    pub fn g_main_context_find_source_by_funcs_user_data(context: *mut GMainContext, funcs: *mut GSourceFuncs, user_data: gpointer) -> *mut GSource;
    pub fn g_main_context_find_source_by_id(context: *mut GMainContext, source_id: c_uint) -> *mut GSource;
    pub fn g_main_context_find_source_by_user_data(context: *mut GMainContext, user_data: gpointer) -> *mut GSource;
    pub fn g_main_context_get_poll_func(context: *mut GMainContext) -> GPollFunc;
    pub fn g_main_context_invoke(context: *mut GMainContext, function: GSourceFunc, data: gpointer);
    pub fn g_main_context_invoke_full(context: *mut GMainContext, priority: c_int, function: GSourceFunc, data: gpointer, notify: GDestroyNotify);
    pub fn g_main_context_is_owner(context: *mut GMainContext) -> gboolean;
    pub fn g_main_context_iteration(context: *mut GMainContext, may_block: gboolean) -> gboolean;
    pub fn g_main_context_pending(context: *mut GMainContext) -> gboolean;
    pub fn g_main_context_pop_thread_default(context: *mut GMainContext);
    pub fn g_main_context_prepare(context: *mut GMainContext, priority: *mut c_int) -> gboolean;
    pub fn g_main_context_push_thread_default(context: *mut GMainContext);
    pub fn g_main_context_query(context: *mut GMainContext, max_priority: c_int, timeout_: *mut c_int, fds: *mut GPollFD, n_fds: c_int) -> c_int;
    pub fn g_main_context_ref(context: *mut GMainContext) -> *mut GMainContext;
    pub fn g_main_context_release(context: *mut GMainContext);
    pub fn g_main_context_remove_poll(context: *mut GMainContext, fd: *mut GPollFD);
    pub fn g_main_context_set_poll_func(context: *mut GMainContext, func: GPollFunc);
    pub fn g_main_context_unref(context: *mut GMainContext);
    pub fn g_main_context_wait(context: *mut GMainContext, cond: *mut GCond, mutex: *mut GMutex) -> gboolean;
    pub fn g_main_context_wakeup(context: *mut GMainContext);
    pub fn g_main_context_default() -> *mut GMainContext;
    pub fn g_main_context_get_thread_default() -> *mut GMainContext;
    pub fn g_main_context_ref_thread_default() -> *mut GMainContext;

    //=========================================================================
    // GMainLoop
    //=========================================================================
    pub fn g_main_loop_get_type() -> GType;
    pub fn g_main_loop_new(context: *mut GMainContext, is_running: gboolean) -> *mut GMainLoop;
    pub fn g_main_loop_get_context(loop_: *mut GMainLoop) -> *mut GMainContext;
    pub fn g_main_loop_is_running(loop_: *mut GMainLoop) -> gboolean;
    pub fn g_main_loop_quit(loop_: *mut GMainLoop);
    pub fn g_main_loop_ref(loop_: *mut GMainLoop) -> *mut GMainLoop;
    pub fn g_main_loop_run(loop_: *mut GMainLoop);
    pub fn g_main_loop_unref(loop_: *mut GMainLoop);

    //=========================================================================
    // GMappedFile
    //=========================================================================
    pub fn g_mapped_file_get_type() -> GType;
    pub fn g_mapped_file_new(filename: *mut c_char, writable: gboolean, error: *mut *mut GError) -> *mut GMappedFile;
    pub fn g_mapped_file_new_from_fd(fd: c_int, writable: gboolean, error: *mut *mut GError) -> *mut GMappedFile;
    pub fn g_mapped_file_free(file: *mut GMappedFile);
    #[cfg(feature = "v2_34")]
    pub fn g_mapped_file_get_bytes(file: *mut GMappedFile) -> *mut GBytes;
    pub fn g_mapped_file_get_contents(file: *mut GMappedFile) -> *mut c_char;
    pub fn g_mapped_file_get_length(file: *mut GMappedFile) -> size_t;
    pub fn g_mapped_file_ref(file: *mut GMappedFile) -> *mut GMappedFile;
    pub fn g_mapped_file_unref(file: *mut GMappedFile);

    //=========================================================================
    // GMarkupParseContext
    //=========================================================================
    pub fn g_markup_parse_context_get_type() -> GType;
    pub fn g_markup_parse_context_new(parser: *const GMarkupParser, flags: GMarkupParseFlags, user_data: gpointer, user_data_dnotify: GDestroyNotify) -> *mut GMarkupParseContext;
    pub fn g_markup_parse_context_end_parse(context: *mut GMarkupParseContext, error: *mut *mut GError) -> gboolean;
    pub fn g_markup_parse_context_free(context: *mut GMarkupParseContext);
    pub fn g_markup_parse_context_get_element(context: *mut GMarkupParseContext) -> *const c_char;
    pub fn g_markup_parse_context_get_element_stack(context: *mut GMarkupParseContext) -> *const GSList;
    pub fn g_markup_parse_context_get_position(context: *mut GMarkupParseContext, line_number: *mut c_int, char_number: *mut c_int);
    pub fn g_markup_parse_context_get_user_data(context: *mut GMarkupParseContext) -> gpointer;
    pub fn g_markup_parse_context_parse(context: *mut GMarkupParseContext, text: *const c_char, text_len: ssize_t, error: *mut *mut GError) -> gboolean;
    pub fn g_markup_parse_context_pop(context: *mut GMarkupParseContext) -> gpointer;
    pub fn g_markup_parse_context_push(context: *mut GMarkupParseContext, parser: *const GMarkupParser, user_data: gpointer);
    #[cfg(feature = "v2_36")]
    pub fn g_markup_parse_context_ref(context: *mut GMarkupParseContext) -> *mut GMarkupParseContext;
    #[cfg(feature = "v2_36")]
    pub fn g_markup_parse_context_unref(context: *mut GMarkupParseContext);

    //=========================================================================
    // GMatchInfo
    //=========================================================================
    pub fn g_match_info_get_type() -> GType;
    pub fn g_match_info_expand_references(match_info: *const GMatchInfo, string_to_expand: *const c_char, error: *mut *mut GError) -> *mut c_char;
    pub fn g_match_info_fetch(match_info: *const GMatchInfo, match_num: c_int) -> *mut c_char;
    pub fn g_match_info_fetch_all(match_info: *const GMatchInfo) -> *mut *mut c_char;
    pub fn g_match_info_fetch_named(match_info: *const GMatchInfo, name: *const c_char) -> *mut c_char;
    pub fn g_match_info_fetch_named_pos(match_info: *const GMatchInfo, name: *const c_char, start_pos: *mut c_int, end_pos: *mut c_int) -> gboolean;
    pub fn g_match_info_fetch_pos(match_info: *const GMatchInfo, match_num: c_int, start_pos: *mut c_int, end_pos: *mut c_int) -> gboolean;
    pub fn g_match_info_free(match_info: *mut GMatchInfo);
    pub fn g_match_info_get_match_count(match_info: *const GMatchInfo) -> c_int;
    pub fn g_match_info_get_regex(match_info: *const GMatchInfo) -> *mut GRegex;
    pub fn g_match_info_get_string(match_info: *const GMatchInfo) -> *const c_char;
    pub fn g_match_info_is_partial_match(match_info: *const GMatchInfo) -> gboolean;
    pub fn g_match_info_matches(match_info: *const GMatchInfo) -> gboolean;
    pub fn g_match_info_next(match_info: *mut GMatchInfo, error: *mut *mut GError) -> gboolean;
    pub fn g_match_info_ref(match_info: *mut GMatchInfo) -> *mut GMatchInfo;
    pub fn g_match_info_unref(match_info: *mut GMatchInfo);

    //=========================================================================
    // GNode
    //=========================================================================
    pub fn g_node_child_index(node: *mut GNode, data: gpointer) -> c_int;
    pub fn g_node_child_position(node: *mut GNode, child: *mut GNode) -> c_int;
    pub fn g_node_children_foreach(node: *mut GNode, flags: GTraverseFlags, func: GNodeForeachFunc, data: gpointer);
    pub fn g_node_copy(node: *mut GNode) -> *mut GNode;
    pub fn g_node_copy_deep(node: *mut GNode, copy_func: GCopyFunc, data: gpointer) -> *mut GNode;
    pub fn g_node_depth(node: *mut GNode) -> c_uint;
    pub fn g_node_destroy(root: *mut GNode);
    pub fn g_node_find(root: *mut GNode, order: GTraverseType, flags: GTraverseFlags, data: gpointer) -> *mut GNode;
    pub fn g_node_find_child(node: *mut GNode, flags: GTraverseFlags, data: gpointer) -> *mut GNode;
    pub fn g_node_first_sibling(node: *mut GNode) -> *mut GNode;
    pub fn g_node_get_root(node: *mut GNode) -> *mut GNode;
    pub fn g_node_insert(parent: *mut GNode, position: c_int, node: *mut GNode) -> *mut GNode;
    pub fn g_node_insert_after(parent: *mut GNode, sibling: *mut GNode, node: *mut GNode) -> *mut GNode;
    pub fn g_node_insert_before(parent: *mut GNode, sibling: *mut GNode, node: *mut GNode) -> *mut GNode;
    pub fn g_node_is_ancestor(node: *mut GNode, descendant: *mut GNode) -> gboolean;
    pub fn g_node_last_child(node: *mut GNode) -> *mut GNode;
    pub fn g_node_last_sibling(node: *mut GNode) -> *mut GNode;
    pub fn g_node_max_height(root: *mut GNode) -> c_uint;
    pub fn g_node_n_children(node: *mut GNode) -> c_uint;
    pub fn g_node_n_nodes(root: *mut GNode, flags: GTraverseFlags) -> c_uint;
    pub fn g_node_nth_child(node: *mut GNode, n: c_uint) -> *mut GNode;
    pub fn g_node_prepend(parent: *mut GNode, node: *mut GNode) -> *mut GNode;
    pub fn g_node_reverse_children(node: *mut GNode);
    pub fn g_node_traverse(root: *mut GNode, order: GTraverseType, flags: GTraverseFlags, max_depth: c_int, func: GNodeTraverseFunc, data: gpointer);
    pub fn g_node_unlink(node: *mut GNode);
    pub fn g_node_new(data: gpointer) -> *mut GNode;

    //=========================================================================
    // GOnce
    //=========================================================================
    pub fn g_once_impl(once: *mut GOnce, func: GThreadFunc, arg: gpointer) -> gpointer;
    pub fn g_once_init_enter(location: *mut c_void) -> gboolean;
    pub fn g_once_init_leave(location: *mut c_void, result: size_t);

    //=========================================================================
    // GOptionContext
    //=========================================================================
    pub fn g_option_context_add_group(context: *mut GOptionContext, group: *mut GOptionGroup);
    pub fn g_option_context_add_main_entries(context: *mut GOptionContext, entries: *const GOptionEntry, translation_domain: *const c_char);
    pub fn g_option_context_free(context: *mut GOptionContext);
    pub fn g_option_context_get_description(context: *mut GOptionContext) -> *const c_char;
    pub fn g_option_context_get_help(context: *mut GOptionContext, main_help: gboolean, group: *mut GOptionGroup) -> *mut c_char;
    pub fn g_option_context_get_help_enabled(context: *mut GOptionContext) -> gboolean;
    pub fn g_option_context_get_ignore_unknown_options(context: *mut GOptionContext) -> gboolean;
    pub fn g_option_context_get_main_group(context: *mut GOptionContext) -> *mut GOptionGroup;
    #[cfg(feature = "v2_44")]
    pub fn g_option_context_get_strict_posix(context: *mut GOptionContext) -> gboolean;
    pub fn g_option_context_get_summary(context: *mut GOptionContext) -> *const c_char;
    pub fn g_option_context_parse(context: *mut GOptionContext, argc: *mut c_int, argv: *mut *mut *mut c_char, error: *mut *mut GError) -> gboolean;
    #[cfg(feature = "v2_40")]
    pub fn g_option_context_parse_strv(context: *mut GOptionContext, arguments: *mut *mut *mut c_char, error: *mut *mut GError) -> gboolean;
    pub fn g_option_context_set_description(context: *mut GOptionContext, description: *const c_char);
    pub fn g_option_context_set_help_enabled(context: *mut GOptionContext, help_enabled: gboolean);
    pub fn g_option_context_set_ignore_unknown_options(context: *mut GOptionContext, ignore_unknown: gboolean);
    pub fn g_option_context_set_main_group(context: *mut GOptionContext, group: *mut GOptionGroup);
    #[cfg(feature = "v2_44")]
    pub fn g_option_context_set_strict_posix(context: *mut GOptionContext, strict_posix: gboolean);
    pub fn g_option_context_set_summary(context: *mut GOptionContext, summary: *const c_char);
    pub fn g_option_context_set_translate_func(context: *mut GOptionContext, func: GTranslateFunc, data: gpointer, destroy_notify: GDestroyNotify);
    pub fn g_option_context_set_translation_domain(context: *mut GOptionContext, domain: *const c_char);
    pub fn g_option_context_new(parameter_string: *const c_char) -> *mut GOptionContext;

    //=========================================================================
    // GOptionGroup
    //=========================================================================
    pub fn g_option_group_get_type() -> GType;
    pub fn g_option_group_new(name: *const c_char, description: *const c_char, help_description: *const c_char, user_data: gpointer, destroy: GDestroyNotify) -> *mut GOptionGroup;
    pub fn g_option_group_add_entries(group: *mut GOptionGroup, entries: *const GOptionEntry);
    pub fn g_option_group_free(group: *mut GOptionGroup);
    #[cfg(feature = "v2_44")]
    pub fn g_option_group_ref(group: *mut GOptionGroup) -> *mut GOptionGroup;
    pub fn g_option_group_set_error_hook(group: *mut GOptionGroup, error_func: GOptionErrorFunc);
    pub fn g_option_group_set_parse_hooks(group: *mut GOptionGroup, pre_parse_func: GOptionParseFunc, post_parse_func: GOptionParseFunc);
    pub fn g_option_group_set_translate_func(group: *mut GOptionGroup, func: GTranslateFunc, data: gpointer, destroy_notify: GDestroyNotify);
    pub fn g_option_group_set_translation_domain(group: *mut GOptionGroup, domain: *const c_char);
    #[cfg(feature = "v2_44")]
    pub fn g_option_group_unref(group: *mut GOptionGroup);

    //=========================================================================
    // GPatternSpec
    //=========================================================================
    pub fn g_pattern_spec_equal(pspec1: *mut GPatternSpec, pspec2: *mut GPatternSpec) -> gboolean;
    pub fn g_pattern_spec_free(pspec: *mut GPatternSpec);
    pub fn g_pattern_spec_new(pattern: *const c_char) -> *mut GPatternSpec;

    //=========================================================================
    // GPollFD
    //=========================================================================
    pub fn g_pollfd_get_type() -> GType;

    //=========================================================================
    // GPrivate
    //=========================================================================
    pub fn g_private_get(key: *mut GPrivate) -> gpointer;
    pub fn g_private_replace(key: *mut GPrivate, value: gpointer);
    pub fn g_private_set(key: *mut GPrivate, value: gpointer);

    //=========================================================================
    // GPtrArray
    //=========================================================================
    pub fn g_ptr_array_get_type() -> GType;
    pub fn g_ptr_array_add(array: *mut GPtrArray, data: gpointer);
    pub fn g_ptr_array_foreach(array: *mut GPtrArray, func: GFunc, user_data: gpointer);
    pub fn g_ptr_array_free(array: *mut GPtrArray, free_seg: gboolean) -> *mut gpointer;
    #[cfg(feature = "v2_40")]
    pub fn g_ptr_array_insert(array: *mut GPtrArray, index_: c_int, data: gpointer);
    pub fn g_ptr_array_new() -> *mut GPtrArray;
    pub fn g_ptr_array_new_full(reserved_size: c_uint, element_free_func: GDestroyNotify) -> *mut GPtrArray;
    pub fn g_ptr_array_new_with_free_func(element_free_func: GDestroyNotify) -> *mut GPtrArray;
    pub fn g_ptr_array_ref(array: *mut GPtrArray) -> *mut GPtrArray;
    pub fn g_ptr_array_remove(array: *mut GPtrArray, data: gpointer) -> gboolean;
    pub fn g_ptr_array_remove_fast(array: *mut GPtrArray, data: gpointer) -> gboolean;
    pub fn g_ptr_array_remove_index(array: *mut GPtrArray, index_: c_uint) -> gpointer;
    pub fn g_ptr_array_remove_index_fast(array: *mut GPtrArray, index_: c_uint) -> gpointer;
    pub fn g_ptr_array_remove_range(array: *mut GPtrArray, index_: c_uint, length: c_uint) -> *mut GPtrArray;
    pub fn g_ptr_array_set_free_func(array: *mut GPtrArray, element_free_func: GDestroyNotify);
    pub fn g_ptr_array_set_size(array: *mut GPtrArray, length: c_int);
    pub fn g_ptr_array_sized_new(reserved_size: c_uint) -> *mut GPtrArray;
    pub fn g_ptr_array_sort(array: *mut GPtrArray, compare_func: GCompareFunc);
    pub fn g_ptr_array_sort_with_data(array: *mut GPtrArray, compare_func: GCompareDataFunc, user_data: gpointer);
    pub fn g_ptr_array_unref(array: *mut GPtrArray);

    //=========================================================================
    // GQueue
    //=========================================================================
    pub fn g_queue_clear(queue: *mut GQueue);
    pub fn g_queue_copy(queue: *mut GQueue) -> *mut GQueue;
    pub fn g_queue_delete_link(queue: *mut GQueue, link_: *mut GList);
    pub fn g_queue_find(queue: *mut GQueue, data: gconstpointer) -> *mut GList;
    pub fn g_queue_find_custom(queue: *mut GQueue, data: gconstpointer, func: GCompareFunc) -> *mut GList;
    pub fn g_queue_foreach(queue: *mut GQueue, func: GFunc, user_data: gpointer);
    pub fn g_queue_free(queue: *mut GQueue);
    pub fn g_queue_free_full(queue: *mut GQueue, free_func: GDestroyNotify);
    pub fn g_queue_get_length(queue: *mut GQueue) -> c_uint;
    pub fn g_queue_index(queue: *mut GQueue, data: gconstpointer) -> c_int;
    pub fn g_queue_init(queue: *mut GQueue);
    pub fn g_queue_insert_after(queue: *mut GQueue, sibling: *mut GList, data: gpointer);
    pub fn g_queue_insert_before(queue: *mut GQueue, sibling: *mut GList, data: gpointer);
    pub fn g_queue_insert_sorted(queue: *mut GQueue, data: gpointer, func: GCompareDataFunc, user_data: gpointer);
    pub fn g_queue_is_empty(queue: *mut GQueue) -> gboolean;
    pub fn g_queue_link_index(queue: *mut GQueue, link_: *mut GList) -> c_int;
    pub fn g_queue_peek_head(queue: *mut GQueue) -> gpointer;
    pub fn g_queue_peek_head_link(queue: *mut GQueue) -> *mut GList;
    pub fn g_queue_peek_nth(queue: *mut GQueue, n: c_uint) -> gpointer;
    pub fn g_queue_peek_nth_link(queue: *mut GQueue, n: c_uint) -> *mut GList;
    pub fn g_queue_peek_tail(queue: *mut GQueue) -> gpointer;
    pub fn g_queue_peek_tail_link(queue: *mut GQueue) -> *mut GList;
    pub fn g_queue_pop_head(queue: *mut GQueue) -> gpointer;
    pub fn g_queue_pop_head_link(queue: *mut GQueue) -> *mut GList;
    pub fn g_queue_pop_nth(queue: *mut GQueue, n: c_uint) -> gpointer;
    pub fn g_queue_pop_nth_link(queue: *mut GQueue, n: c_uint) -> *mut GList;
    pub fn g_queue_pop_tail(queue: *mut GQueue) -> gpointer;
    pub fn g_queue_pop_tail_link(queue: *mut GQueue) -> *mut GList;
    pub fn g_queue_push_head(queue: *mut GQueue, data: gpointer);
    pub fn g_queue_push_head_link(queue: *mut GQueue, link_: *mut GList);
    pub fn g_queue_push_nth(queue: *mut GQueue, data: gpointer, n: c_int);
    pub fn g_queue_push_nth_link(queue: *mut GQueue, n: c_int, link_: *mut GList);
    pub fn g_queue_push_tail(queue: *mut GQueue, data: gpointer);
    pub fn g_queue_push_tail_link(queue: *mut GQueue, link_: *mut GList);
    pub fn g_queue_remove(queue: *mut GQueue, data: gconstpointer) -> gboolean;
    pub fn g_queue_remove_all(queue: *mut GQueue, data: gconstpointer) -> c_uint;
    pub fn g_queue_reverse(queue: *mut GQueue);
    pub fn g_queue_sort(queue: *mut GQueue, compare_func: GCompareDataFunc, user_data: gpointer);
    pub fn g_queue_unlink(queue: *mut GQueue, link_: *mut GList);
    pub fn g_queue_new() -> *mut GQueue;

    //=========================================================================
    // GRWLock
    //=========================================================================
    pub fn g_rw_lock_clear(rw_lock: *mut GRWLock);
    pub fn g_rw_lock_init(rw_lock: *mut GRWLock);
    pub fn g_rw_lock_reader_lock(rw_lock: *mut GRWLock);
    pub fn g_rw_lock_reader_trylock(rw_lock: *mut GRWLock) -> gboolean;
    pub fn g_rw_lock_reader_unlock(rw_lock: *mut GRWLock);
    pub fn g_rw_lock_writer_lock(rw_lock: *mut GRWLock);
    pub fn g_rw_lock_writer_trylock(rw_lock: *mut GRWLock) -> gboolean;
    pub fn g_rw_lock_writer_unlock(rw_lock: *mut GRWLock);

    //=========================================================================
    // GRand
    //=========================================================================
    pub fn g_rand_copy(rand_: *mut GRand) -> *mut GRand;
    pub fn g_rand_double(rand_: *mut GRand) -> c_double;
    pub fn g_rand_double_range(rand_: *mut GRand, begin: c_double, end: c_double) -> c_double;
    pub fn g_rand_free(rand_: *mut GRand);
    pub fn g_rand_int(rand_: *mut GRand) -> u32;
    pub fn g_rand_int_range(rand_: *mut GRand, begin: i32, end: i32) -> i32;
    pub fn g_rand_set_seed(rand_: *mut GRand, seed: u32);
    pub fn g_rand_set_seed_array(rand_: *mut GRand, seed: *const u32, seed_length: c_uint);
    pub fn g_rand_new() -> *mut GRand;
    pub fn g_rand_new_with_seed(seed: u32) -> *mut GRand;
    pub fn g_rand_new_with_seed_array(seed: *const u32, seed_length: c_uint) -> *mut GRand;

    //=========================================================================
    // GRecMutex
    //=========================================================================
    pub fn g_rec_mutex_clear(rec_mutex: *mut GRecMutex);
    pub fn g_rec_mutex_init(rec_mutex: *mut GRecMutex);
    pub fn g_rec_mutex_lock(rec_mutex: *mut GRecMutex);
    pub fn g_rec_mutex_trylock(rec_mutex: *mut GRecMutex) -> gboolean;
    pub fn g_rec_mutex_unlock(rec_mutex: *mut GRecMutex);

    //=========================================================================
    // GRegex
    //=========================================================================
    pub fn g_regex_get_type() -> GType;
    pub fn g_regex_new(pattern: *const c_char, compile_options: GRegexCompileFlags, match_options: GRegexMatchFlags, error: *mut *mut GError) -> *mut GRegex;
    pub fn g_regex_get_capture_count(regex: *const GRegex) -> c_int;
    pub fn g_regex_get_compile_flags(regex: *const GRegex) -> GRegexCompileFlags;
    #[cfg(feature = "v2_34")]
    pub fn g_regex_get_has_cr_or_lf(regex: *const GRegex) -> gboolean;
    pub fn g_regex_get_match_flags(regex: *const GRegex) -> GRegexMatchFlags;
    pub fn g_regex_get_max_backref(regex: *const GRegex) -> c_int;
    #[cfg(feature = "v2_38")]
    pub fn g_regex_get_max_lookbehind(regex: *const GRegex) -> c_int;
    pub fn g_regex_get_pattern(regex: *const GRegex) -> *const c_char;
    pub fn g_regex_get_string_number(regex: *const GRegex, name: *const c_char) -> c_int;
    pub fn g_regex_match(regex: *const GRegex, string: *const c_char, match_options: GRegexMatchFlags, match_info: *mut *mut GMatchInfo) -> gboolean;
    pub fn g_regex_match_all(regex: *const GRegex, string: *const c_char, match_options: GRegexMatchFlags, match_info: *mut *mut GMatchInfo) -> gboolean;
    pub fn g_regex_match_all_full(regex: *const GRegex, string: *mut c_char, string_len: ssize_t, start_position: c_int, match_options: GRegexMatchFlags, match_info: *mut *mut GMatchInfo, error: *mut *mut GError) -> gboolean;
    pub fn g_regex_match_full(regex: *const GRegex, string: *mut c_char, string_len: ssize_t, start_position: c_int, match_options: GRegexMatchFlags, match_info: *mut *mut GMatchInfo, error: *mut *mut GError) -> gboolean;
    pub fn g_regex_ref(regex: *mut GRegex) -> *mut GRegex;
    pub fn g_regex_replace(regex: *const GRegex, string: *mut c_char, string_len: ssize_t, start_position: c_int, replacement: *const c_char, match_options: GRegexMatchFlags, error: *mut *mut GError) -> *mut c_char;
    pub fn g_regex_replace_eval(regex: *const GRegex, string: *mut c_char, string_len: ssize_t, start_position: c_int, match_options: GRegexMatchFlags, eval: GRegexEvalCallback, user_data: gpointer, error: *mut *mut GError) -> *mut c_char;
    pub fn g_regex_replace_literal(regex: *const GRegex, string: *mut c_char, string_len: ssize_t, start_position: c_int, replacement: *const c_char, match_options: GRegexMatchFlags, error: *mut *mut GError) -> *mut c_char;
    pub fn g_regex_split(regex: *const GRegex, string: *const c_char, match_options: GRegexMatchFlags) -> *mut *mut c_char;
    pub fn g_regex_split_full(regex: *const GRegex, string: *mut c_char, string_len: ssize_t, start_position: c_int, match_options: GRegexMatchFlags, max_tokens: c_int, error: *mut *mut GError) -> *mut *mut c_char;
    pub fn g_regex_unref(regex: *mut GRegex);
    pub fn g_regex_check_replacement(replacement: *const c_char, has_references: *mut gboolean, error: *mut *mut GError) -> gboolean;
    pub fn g_regex_error_quark() -> GQuark;
    pub fn g_regex_escape_nul(string: *const c_char, length: c_int) -> *mut c_char;
    pub fn g_regex_escape_string(string: *mut c_char, length: c_int) -> *mut c_char;
    pub fn g_regex_match_simple(pattern: *const c_char, string: *const c_char, compile_options: GRegexCompileFlags, match_options: GRegexMatchFlags) -> gboolean;
    pub fn g_regex_split_simple(pattern: *const c_char, string: *const c_char, compile_options: GRegexCompileFlags, match_options: GRegexMatchFlags) -> *mut *mut c_char;

    //=========================================================================
    // GSList
    //=========================================================================
    pub fn g_slist_alloc() -> *mut GSList;
    pub fn g_slist_append(list: *mut GSList, data: gpointer) -> *mut GSList;
    pub fn g_slist_concat(list1: *mut GSList, list2: *mut GSList) -> *mut GSList;
    pub fn g_slist_copy(list: *mut GSList) -> *mut GSList;
    #[cfg(feature = "v2_34")]
    pub fn g_slist_copy_deep(list: *mut GSList, func: GCopyFunc, user_data: gpointer) -> *mut GSList;
    pub fn g_slist_delete_link(list: *mut GSList, link_: *mut GSList) -> *mut GSList;
    pub fn g_slist_find(list: *mut GSList, data: gconstpointer) -> *mut GSList;
    pub fn g_slist_find_custom(list: *mut GSList, data: gconstpointer, func: GCompareFunc) -> *mut GSList;
    pub fn g_slist_foreach(list: *mut GSList, func: GFunc, user_data: gpointer);
    pub fn g_slist_free(list: *mut GSList);
    pub fn g_slist_free_1(list: *mut GSList);
    pub fn g_slist_free_full(list: *mut GSList, free_func: GDestroyNotify);
    pub fn g_slist_index(list: *mut GSList, data: gconstpointer) -> c_int;
    pub fn g_slist_insert(list: *mut GSList, data: gpointer, position: c_int) -> *mut GSList;
    pub fn g_slist_insert_before(slist: *mut GSList, sibling: *mut GSList, data: gpointer) -> *mut GSList;
    pub fn g_slist_insert_sorted(list: *mut GSList, data: gpointer, func: GCompareFunc) -> *mut GSList;
    pub fn g_slist_insert_sorted_with_data(list: *mut GSList, data: gpointer, func: GCompareDataFunc, user_data: gpointer) -> *mut GSList;
    pub fn g_slist_last(list: *mut GSList) -> *mut GSList;
    pub fn g_slist_length(list: *mut GSList) -> c_uint;
    pub fn g_slist_nth(list: *mut GSList, n: c_uint) -> *mut GSList;
    pub fn g_slist_nth_data(list: *mut GSList, n: c_uint) -> gpointer;
    pub fn g_slist_position(list: *mut GSList, llink: *mut GSList) -> c_int;
    pub fn g_slist_prepend(list: *mut GSList, data: gpointer) -> *mut GSList;
    pub fn g_slist_remove(list: *mut GSList, data: gconstpointer) -> *mut GSList;
    pub fn g_slist_remove_all(list: *mut GSList, data: gconstpointer) -> *mut GSList;
    pub fn g_slist_remove_link(list: *mut GSList, link_: *mut GSList) -> *mut GSList;
    pub fn g_slist_reverse(list: *mut GSList) -> *mut GSList;
    pub fn g_slist_sort(list: *mut GSList, compare_func: GCompareFunc) -> *mut GSList;
    pub fn g_slist_sort_with_data(list: *mut GSList, compare_func: GCompareDataFunc, user_data: gpointer) -> *mut GSList;

    //=========================================================================
    // GScanner
    //=========================================================================
    pub fn g_scanner_cur_line(scanner: *mut GScanner) -> c_uint;
    pub fn g_scanner_cur_position(scanner: *mut GScanner) -> c_uint;
    pub fn g_scanner_cur_token(scanner: *mut GScanner) -> GTokenType;
    pub fn g_scanner_cur_value(scanner: *mut GScanner) -> GTokenValue;
    pub fn g_scanner_destroy(scanner: *mut GScanner);
    pub fn g_scanner_eof(scanner: *mut GScanner) -> gboolean;
    pub fn g_scanner_error(scanner: *mut GScanner, format: *const c_char, ...);
    pub fn g_scanner_get_next_token(scanner: *mut GScanner) -> GTokenType;
    pub fn g_scanner_input_file(scanner: *mut GScanner, input_fd: c_int);
    pub fn g_scanner_input_text(scanner: *mut GScanner, text: *const c_char, text_len: c_uint);
    pub fn g_scanner_lookup_symbol(scanner: *mut GScanner, symbol: *const c_char) -> gpointer;
    pub fn g_scanner_peek_next_token(scanner: *mut GScanner) -> GTokenType;
    pub fn g_scanner_scope_add_symbol(scanner: *mut GScanner, scope_id: c_uint, symbol: *const c_char, value: gpointer);
    pub fn g_scanner_scope_foreach_symbol(scanner: *mut GScanner, scope_id: c_uint, func: GHFunc, user_data: gpointer);
    pub fn g_scanner_scope_lookup_symbol(scanner: *mut GScanner, scope_id: c_uint, symbol: *const c_char) -> gpointer;
    pub fn g_scanner_scope_remove_symbol(scanner: *mut GScanner, scope_id: c_uint, symbol: *const c_char);
    pub fn g_scanner_set_scope(scanner: *mut GScanner, scope_id: c_uint) -> c_uint;
    pub fn g_scanner_sync_file_offset(scanner: *mut GScanner);
    pub fn g_scanner_unexp_token(scanner: *mut GScanner, expected_token: GTokenType, identifier_spec: *const c_char, symbol_spec: *const c_char, symbol_name: *const c_char, message: *const c_char, is_error: c_int);
    pub fn g_scanner_warn(scanner: *mut GScanner, format: *const c_char, ...);
    pub fn g_scanner_new(config_templ: *const GScannerConfig) -> *mut GScanner;

    //=========================================================================
    // GSequence
    //=========================================================================
    pub fn g_sequence_append(seq: *mut GSequence, data: gpointer) -> *mut GSequenceIter;
    pub fn g_sequence_foreach(seq: *mut GSequence, func: GFunc, user_data: gpointer);
    pub fn g_sequence_free(seq: *mut GSequence);
    pub fn g_sequence_get_begin_iter(seq: *mut GSequence) -> *mut GSequenceIter;
    pub fn g_sequence_get_end_iter(seq: *mut GSequence) -> *mut GSequenceIter;
    pub fn g_sequence_get_iter_at_pos(seq: *mut GSequence, pos: c_int) -> *mut GSequenceIter;
    pub fn g_sequence_get_length(seq: *mut GSequence) -> c_int;
    pub fn g_sequence_insert_sorted(seq: *mut GSequence, data: gpointer, cmp_func: GCompareDataFunc, cmp_data: gpointer) -> *mut GSequenceIter;
    pub fn g_sequence_insert_sorted_iter(seq: *mut GSequence, data: gpointer, iter_cmp: GSequenceIterCompareFunc, cmp_data: gpointer) -> *mut GSequenceIter;
    #[cfg(feature = "v2_48")]
    pub fn g_sequence_is_empty(seq: *mut GSequence) -> gboolean;
    pub fn g_sequence_lookup(seq: *mut GSequence, data: gpointer, cmp_func: GCompareDataFunc, cmp_data: gpointer) -> *mut GSequenceIter;
    pub fn g_sequence_lookup_iter(seq: *mut GSequence, data: gpointer, iter_cmp: GSequenceIterCompareFunc, cmp_data: gpointer) -> *mut GSequenceIter;
    pub fn g_sequence_prepend(seq: *mut GSequence, data: gpointer) -> *mut GSequenceIter;
    pub fn g_sequence_search(seq: *mut GSequence, data: gpointer, cmp_func: GCompareDataFunc, cmp_data: gpointer) -> *mut GSequenceIter;
    pub fn g_sequence_search_iter(seq: *mut GSequence, data: gpointer, iter_cmp: GSequenceIterCompareFunc, cmp_data: gpointer) -> *mut GSequenceIter;
    pub fn g_sequence_sort(seq: *mut GSequence, cmp_func: GCompareDataFunc, cmp_data: gpointer);
    pub fn g_sequence_sort_iter(seq: *mut GSequence, cmp_func: GSequenceIterCompareFunc, cmp_data: gpointer);
    pub fn g_sequence_foreach_range(begin: *mut GSequenceIter, end: *mut GSequenceIter, func: GFunc, user_data: gpointer);
    pub fn g_sequence_get(iter: *mut GSequenceIter) -> gpointer;
    pub fn g_sequence_insert_before(iter: *mut GSequenceIter, data: gpointer) -> *mut GSequenceIter;
    pub fn g_sequence_move(src: *mut GSequenceIter, dest: *mut GSequenceIter);
    pub fn g_sequence_move_range(dest: *mut GSequenceIter, begin: *mut GSequenceIter, end: *mut GSequenceIter);
    pub fn g_sequence_new(data_destroy: GDestroyNotify) -> *mut GSequence;
    pub fn g_sequence_range_get_midpoint(begin: *mut GSequenceIter, end: *mut GSequenceIter) -> *mut GSequenceIter;
    pub fn g_sequence_remove(iter: *mut GSequenceIter);
    pub fn g_sequence_remove_range(begin: *mut GSequenceIter, end: *mut GSequenceIter);
    pub fn g_sequence_set(iter: *mut GSequenceIter, data: gpointer);
    pub fn g_sequence_sort_changed(iter: *mut GSequenceIter, cmp_func: GCompareDataFunc, cmp_data: gpointer);
    pub fn g_sequence_sort_changed_iter(iter: *mut GSequenceIter, iter_cmp: GSequenceIterCompareFunc, cmp_data: gpointer);
    pub fn g_sequence_swap(a: *mut GSequenceIter, b: *mut GSequenceIter);

    //=========================================================================
    // GSequenceIter
    //=========================================================================
    pub fn g_sequence_iter_compare(a: *mut GSequenceIter, b: *mut GSequenceIter) -> c_int;
    pub fn g_sequence_iter_get_position(iter: *mut GSequenceIter) -> c_int;
    pub fn g_sequence_iter_get_sequence(iter: *mut GSequenceIter) -> *mut GSequence;
    pub fn g_sequence_iter_is_begin(iter: *mut GSequenceIter) -> gboolean;
    pub fn g_sequence_iter_is_end(iter: *mut GSequenceIter) -> gboolean;
    pub fn g_sequence_iter_move(iter: *mut GSequenceIter, delta: c_int) -> *mut GSequenceIter;
    pub fn g_sequence_iter_next(iter: *mut GSequenceIter) -> *mut GSequenceIter;
    pub fn g_sequence_iter_prev(iter: *mut GSequenceIter) -> *mut GSequenceIter;

    //=========================================================================
    // GSource
    //=========================================================================
    pub fn g_source_get_type() -> GType;
    pub fn g_source_new(source_funcs: *mut GSourceFuncs, struct_size: c_uint) -> *mut GSource;
    pub fn g_source_add_child_source(source: *mut GSource, child_source: *mut GSource);
    pub fn g_source_add_poll(source: *mut GSource, fd: *mut GPollFD);
    #[cfg(feature = "v2_36")]
    pub fn g_source_add_unix_fd(source: *mut GSource, fd: c_int, events: GIOCondition) -> gpointer;
    pub fn g_source_attach(source: *mut GSource, context: *mut GMainContext) -> c_uint;
    pub fn g_source_destroy(source: *mut GSource);
    pub fn g_source_get_can_recurse(source: *mut GSource) -> gboolean;
    pub fn g_source_get_context(source: *mut GSource) -> *mut GMainContext;
    pub fn g_source_get_current_time(source: *mut GSource, timeval: *mut GTimeVal);
    pub fn g_source_get_id(source: *mut GSource) -> c_uint;
    pub fn g_source_get_name(source: *mut GSource) -> *const c_char;
    pub fn g_source_get_priority(source: *mut GSource) -> c_int;
    pub fn g_source_get_ready_time(source: *mut GSource) -> i64;
    pub fn g_source_get_time(source: *mut GSource) -> i64;
    pub fn g_source_is_destroyed(source: *mut GSource) -> gboolean;
    #[cfg(feature = "v2_36")]
    pub fn g_source_modify_unix_fd(source: *mut GSource, tag: gpointer, new_events: GIOCondition);
    #[cfg(feature = "v2_36")]
    pub fn g_source_query_unix_fd(source: *mut GSource, tag: gpointer) -> GIOCondition;
    pub fn g_source_ref(source: *mut GSource) -> *mut GSource;
    pub fn g_source_remove_child_source(source: *mut GSource, child_source: *mut GSource);
    pub fn g_source_remove_poll(source: *mut GSource, fd: *mut GPollFD);
    #[cfg(feature = "v2_36")]
    pub fn g_source_remove_unix_fd(source: *mut GSource, tag: gpointer);
    pub fn g_source_set_callback(source: *mut GSource, func: GSourceFunc, data: gpointer, notify: GDestroyNotify);
    pub fn g_source_set_callback_indirect(source: *mut GSource, callback_data: gpointer, callback_funcs: *mut GSourceCallbackFuncs);
    pub fn g_source_set_can_recurse(source: *mut GSource, can_recurse: gboolean);
    pub fn g_source_set_funcs(source: *mut GSource, funcs: *mut GSourceFuncs);
    pub fn g_source_set_name(source: *mut GSource, name: *const c_char);
    pub fn g_source_set_priority(source: *mut GSource, priority: c_int);
    #[cfg(feature = "v2_36")]
    pub fn g_source_set_ready_time(source: *mut GSource, ready_time: i64);
    pub fn g_source_unref(source: *mut GSource);
    pub fn g_source_remove(tag: c_uint) -> gboolean;
    pub fn g_source_remove_by_funcs_user_data(funcs: *mut GSourceFuncs, user_data: gpointer) -> gboolean;
    pub fn g_source_remove_by_user_data(user_data: gpointer) -> gboolean;
    pub fn g_source_set_name_by_id(tag: c_uint, name: *const c_char);

    //=========================================================================
    // GString
    //=========================================================================
    pub fn g_gstring_get_type() -> GType;
    pub fn g_string_append(string: *mut GString, val: *const c_char) -> *mut GString;
    pub fn g_string_append_c(string: *mut GString, c: c_char) -> *mut GString;
    pub fn g_string_append_len(string: *mut GString, val: *const c_char, len: ssize_t) -> *mut GString;
    pub fn g_string_append_printf(string: *mut GString, format: *const c_char, ...);
    pub fn g_string_append_unichar(string: *mut GString, wc: u32) -> *mut GString;
    pub fn g_string_append_uri_escaped(string: *mut GString, unescaped: *const c_char, reserved_chars_allowed: *const c_char, allow_utf8: gboolean) -> *mut GString;
    //pub fn g_string_append_vprintf(string: *mut GString, format: *const c_char, args: /*Unimplemented*/va_list);
    pub fn g_string_ascii_down(string: *mut GString) -> *mut GString;
    pub fn g_string_ascii_up(string: *mut GString) -> *mut GString;
    pub fn g_string_assign(string: *mut GString, rval: *const c_char) -> *mut GString;
    pub fn g_string_down(string: *mut GString) -> *mut GString;
    pub fn g_string_equal(v: *const GString, v2: *const GString) -> gboolean;
    pub fn g_string_erase(string: *mut GString, pos: ssize_t, len: ssize_t) -> *mut GString;
    pub fn g_string_free(string: *mut GString, free_segment: gboolean) -> *mut c_char;
    #[cfg(feature = "v2_34")]
    pub fn g_string_free_to_bytes(string: *mut GString) -> *mut GBytes;
    pub fn g_string_hash(str: *const GString) -> c_uint;
    pub fn g_string_insert(string: *mut GString, pos: ssize_t, val: *const c_char) -> *mut GString;
    pub fn g_string_insert_c(string: *mut GString, pos: ssize_t, c: c_char) -> *mut GString;
    pub fn g_string_insert_len(string: *mut GString, pos: ssize_t, val: *const c_char, len: ssize_t) -> *mut GString;
    pub fn g_string_insert_unichar(string: *mut GString, pos: ssize_t, wc: u32) -> *mut GString;
    pub fn g_string_overwrite(string: *mut GString, pos: size_t, val: *const c_char) -> *mut GString;
    pub fn g_string_overwrite_len(string: *mut GString, pos: size_t, val: *const c_char, len: ssize_t) -> *mut GString;
    pub fn g_string_prepend(string: *mut GString, val: *const c_char) -> *mut GString;
    pub fn g_string_prepend_c(string: *mut GString, c: c_char) -> *mut GString;
    pub fn g_string_prepend_len(string: *mut GString, val: *const c_char, len: ssize_t) -> *mut GString;
    pub fn g_string_prepend_unichar(string: *mut GString, wc: u32) -> *mut GString;
    pub fn g_string_printf(string: *mut GString, format: *const c_char, ...);
    pub fn g_string_set_size(string: *mut GString, len: size_t) -> *mut GString;
    pub fn g_string_truncate(string: *mut GString, len: size_t) -> *mut GString;
    pub fn g_string_up(string: *mut GString) -> *mut GString;
    //pub fn g_string_vprintf(string: *mut GString, format: *const c_char, args: /*Unimplemented*/va_list);

    //=========================================================================
    // GStringChunk
    //=========================================================================
    pub fn g_string_chunk_clear(chunk: *mut GStringChunk);
    pub fn g_string_chunk_free(chunk: *mut GStringChunk);
    pub fn g_string_chunk_insert(chunk: *mut GStringChunk, string: *const c_char) -> *mut c_char;
    pub fn g_string_chunk_insert_const(chunk: *mut GStringChunk, string: *const c_char) -> *mut c_char;
    pub fn g_string_chunk_insert_len(chunk: *mut GStringChunk, string: *const c_char, len: ssize_t) -> *mut c_char;
    pub fn g_string_chunk_new(size: size_t) -> *mut GStringChunk;

    //=========================================================================
    // GTestLogBuffer
    //=========================================================================
    pub fn g_test_log_buffer_free(tbuffer: *mut GTestLogBuffer);
    pub fn g_test_log_buffer_pop(tbuffer: *mut GTestLogBuffer) -> *mut GTestLogMsg;
    pub fn g_test_log_buffer_push(tbuffer: *mut GTestLogBuffer, n_bytes: c_uint, bytes: *const u8);
    pub fn g_test_log_buffer_new() -> *mut GTestLogBuffer;

    //=========================================================================
    // GTestLogMsg
    //=========================================================================
    pub fn g_test_log_msg_free(tmsg: *mut GTestLogMsg);

    //=========================================================================
    // GTestSuite
    //=========================================================================
    pub fn g_test_suite_add(suite: *mut GTestSuite, test_case: *mut GTestCase);
    pub fn g_test_suite_add_suite(suite: *mut GTestSuite, nestedsuite: *mut GTestSuite);

    //=========================================================================
    // GThread
    //=========================================================================
    pub fn g_thread_get_type() -> GType;
    pub fn g_thread_new(name: *const c_char, func: GThreadFunc, data: gpointer) -> *mut GThread;
    pub fn g_thread_try_new(name: *const c_char, func: GThreadFunc, data: gpointer, error: *mut *mut GError) -> *mut GThread;
    pub fn g_thread_join(thread: *mut GThread) -> gpointer;
    pub fn g_thread_ref(thread: *mut GThread) -> *mut GThread;
    pub fn g_thread_unref(thread: *mut GThread);
    pub fn g_thread_error_quark() -> GQuark;
    pub fn g_thread_exit(retval: gpointer);
    pub fn g_thread_self() -> *mut GThread;
    pub fn g_thread_yield();

    //=========================================================================
    // GThreadPool
    //=========================================================================
    pub fn g_thread_pool_free(pool: *mut GThreadPool, immediate: gboolean, wait_: gboolean);
    pub fn g_thread_pool_get_max_threads(pool: *mut GThreadPool) -> c_int;
    pub fn g_thread_pool_get_num_threads(pool: *mut GThreadPool) -> c_uint;
    #[cfg(feature = "v2_46")]
    pub fn g_thread_pool_move_to_front(pool: *mut GThreadPool, data: gpointer) -> gboolean;
    pub fn g_thread_pool_push(pool: *mut GThreadPool, data: gpointer, error: *mut *mut GError) -> gboolean;
    pub fn g_thread_pool_set_max_threads(pool: *mut GThreadPool, max_threads: c_int, error: *mut *mut GError) -> gboolean;
    pub fn g_thread_pool_set_sort_function(pool: *mut GThreadPool, func: GCompareDataFunc, user_data: gpointer);
    pub fn g_thread_pool_unprocessed(pool: *mut GThreadPool) -> c_uint;
    pub fn g_thread_pool_get_max_idle_time() -> c_uint;
    pub fn g_thread_pool_get_max_unused_threads() -> c_int;
    pub fn g_thread_pool_get_num_unused_threads() -> c_uint;
    pub fn g_thread_pool_new(func: GFunc, user_data: gpointer, max_threads: c_int, exclusive: gboolean, error: *mut *mut GError) -> *mut GThreadPool;
    pub fn g_thread_pool_set_max_idle_time(interval: c_uint);
    pub fn g_thread_pool_set_max_unused_threads(max_threads: c_int);
    pub fn g_thread_pool_stop_unused_threads();

    //=========================================================================
    // GTimeVal
    //=========================================================================
    pub fn g_time_val_add(time_: *mut GTimeVal, microseconds: c_long);
    pub fn g_time_val_to_iso8601(time_: *mut GTimeVal) -> *mut c_char;
    pub fn g_time_val_from_iso8601(iso_date: *const c_char, time_: *mut GTimeVal) -> gboolean;

    //=========================================================================
    // GTimeZone
    //=========================================================================
    pub fn g_time_zone_get_type() -> GType;
    pub fn g_time_zone_new(identifier: *const c_char) -> *mut GTimeZone;
    pub fn g_time_zone_new_local() -> *mut GTimeZone;
    pub fn g_time_zone_new_utc() -> *mut GTimeZone;
    pub fn g_time_zone_adjust_time(tz: *mut GTimeZone, type_: GTimeType, time_: *mut i64) -> c_int;
    pub fn g_time_zone_find_interval(tz: *mut GTimeZone, type_: GTimeType, time_: i64) -> c_int;
    pub fn g_time_zone_get_abbreviation(tz: *mut GTimeZone, interval: c_int) -> *const c_char;
    pub fn g_time_zone_get_offset(tz: *mut GTimeZone, interval: c_int) -> i32;
    pub fn g_time_zone_is_dst(tz: *mut GTimeZone, interval: c_int) -> gboolean;
    pub fn g_time_zone_ref(tz: *mut GTimeZone) -> *mut GTimeZone;
    pub fn g_time_zone_unref(tz: *mut GTimeZone);

    //=========================================================================
    // GTimer
    //=========================================================================
    pub fn g_timer_continue(timer: *mut GTimer);
    pub fn g_timer_destroy(timer: *mut GTimer);
    pub fn g_timer_elapsed(timer: *mut GTimer, microseconds: *mut c_ulong) -> c_double;
    pub fn g_timer_reset(timer: *mut GTimer);
    pub fn g_timer_start(timer: *mut GTimer);
    pub fn g_timer_stop(timer: *mut GTimer);
    pub fn g_timer_new() -> *mut GTimer;

    //=========================================================================
    // GTrashStack
    //=========================================================================
    pub fn g_trash_stack_height(stack_p: *mut *mut GTrashStack) -> c_uint;
    pub fn g_trash_stack_peek(stack_p: *mut *mut GTrashStack) -> gpointer;
    pub fn g_trash_stack_pop(stack_p: *mut *mut GTrashStack) -> gpointer;
    pub fn g_trash_stack_push(stack_p: *mut *mut GTrashStack, data_p: gpointer);

    //=========================================================================
    // GTree
    //=========================================================================
    pub fn g_tree_destroy(tree: *mut GTree);
    pub fn g_tree_foreach(tree: *mut GTree, func: GTraverseFunc, user_data: gpointer);
    pub fn g_tree_height(tree: *mut GTree) -> c_int;
    pub fn g_tree_insert(tree: *mut GTree, key: gpointer, value: gpointer);
    pub fn g_tree_lookup(tree: *mut GTree, key: gconstpointer) -> gpointer;
    pub fn g_tree_lookup_extended(tree: *mut GTree, lookup_key: gconstpointer, orig_key: *mut gpointer, value: *mut gpointer) -> gboolean;
    pub fn g_tree_nnodes(tree: *mut GTree) -> c_int;
    pub fn g_tree_ref(tree: *mut GTree) -> *mut GTree;
    pub fn g_tree_remove(tree: *mut GTree, key: gconstpointer) -> gboolean;
    pub fn g_tree_replace(tree: *mut GTree, key: gpointer, value: gpointer);
    pub fn g_tree_search(tree: *mut GTree, search_func: GCompareFunc, user_data: gconstpointer) -> gpointer;
    pub fn g_tree_steal(tree: *mut GTree, key: gconstpointer) -> gboolean;
    pub fn g_tree_traverse(tree: *mut GTree, traverse_func: GTraverseFunc, traverse_type: GTraverseType, user_data: gpointer);
    pub fn g_tree_unref(tree: *mut GTree);
    pub fn g_tree_new(key_compare_func: GCompareFunc) -> *mut GTree;
    pub fn g_tree_new_full(key_compare_func: GCompareDataFunc, key_compare_data: gpointer, key_destroy_func: GDestroyNotify, value_destroy_func: GDestroyNotify) -> *mut GTree;
    pub fn g_tree_new_with_data(key_compare_func: GCompareDataFunc, key_compare_data: gpointer) -> *mut GTree;

    //=========================================================================
    // GVariant
    //=========================================================================
    pub fn g_variant_new(format_string: *const c_char, ...) -> *mut GVariant;
    pub fn g_variant_new_array(child_type: *const GVariantType, children: *mut *mut GVariant, n_children: size_t) -> *mut GVariant;
    pub fn g_variant_new_boolean(value: gboolean) -> *mut GVariant;
    pub fn g_variant_new_byte(value: c_uchar) -> *mut GVariant;
    pub fn g_variant_new_bytestring(string: *mut u8) -> *mut GVariant;
    pub fn g_variant_new_bytestring_array(strv: *mut *mut c_char, length: ssize_t) -> *mut GVariant;
    pub fn g_variant_new_dict_entry(key: *mut GVariant, value: *mut GVariant) -> *mut GVariant;
    pub fn g_variant_new_double(value: c_double) -> *mut GVariant;
    pub fn g_variant_new_fixed_array(element_type: *const GVariantType, elements: gconstpointer, n_elements: size_t, element_size: size_t) -> *mut GVariant;
    #[cfg(feature = "v2_36")]
    pub fn g_variant_new_from_bytes(type_: *const GVariantType, bytes: *mut GBytes, trusted: gboolean) -> *mut GVariant;
    pub fn g_variant_new_from_data(type_: *const GVariantType, data: gconstpointer, size: size_t, trusted: gboolean, notify: GDestroyNotify, user_data: gpointer) -> *mut GVariant;
    pub fn g_variant_new_handle(value: i32) -> *mut GVariant;
    pub fn g_variant_new_int16(value: i16) -> *mut GVariant;
    pub fn g_variant_new_int32(value: i32) -> *mut GVariant;
    pub fn g_variant_new_int64(value: i64) -> *mut GVariant;
    pub fn g_variant_new_maybe(child_type: *const GVariantType, child: *mut GVariant) -> *mut GVariant;
    pub fn g_variant_new_object_path(object_path: *const c_char) -> *mut GVariant;
    pub fn g_variant_new_objv(strv: *mut *mut c_char, length: ssize_t) -> *mut GVariant;
    pub fn g_variant_new_parsed(format: *const c_char, ...) -> *mut GVariant;
    //pub fn g_variant_new_parsed_va(format: *const c_char, app: /*Unimplemented*/*mut va_list) -> *mut GVariant;
    #[cfg(feature = "v2_38")]
    pub fn g_variant_new_printf(format_string: *const c_char, ...) -> *mut GVariant;
    pub fn g_variant_new_signature(signature: *const c_char) -> *mut GVariant;
    pub fn g_variant_new_string(string: *const c_char) -> *mut GVariant;
    pub fn g_variant_new_strv(strv: *mut *mut c_char, length: ssize_t) -> *mut GVariant;
    #[cfg(feature = "v2_38")]
    pub fn g_variant_new_take_string(string: *mut c_char) -> *mut GVariant;
    pub fn g_variant_new_tuple(children: *mut *mut GVariant, n_children: size_t) -> *mut GVariant;
    pub fn g_variant_new_uint16(value: u16) -> *mut GVariant;
    pub fn g_variant_new_uint32(value: u32) -> *mut GVariant;
    pub fn g_variant_new_uint64(value: u64) -> *mut GVariant;
    //pub fn g_variant_new_va(format_string: *const c_char, endptr: *mut *const c_char, app: /*Unimplemented*/*mut va_list) -> *mut GVariant;
    pub fn g_variant_new_variant(value: *mut GVariant) -> *mut GVariant;
    pub fn g_variant_byteswap(value: *mut GVariant) -> *mut GVariant;
    #[cfg(feature = "v2_34")]
    pub fn g_variant_check_format_string(value: *mut GVariant, format_string: *const c_char, copy_only: gboolean) -> gboolean;
    pub fn g_variant_classify(value: *mut GVariant) -> GVariantClass;
    pub fn g_variant_compare(one: gconstpointer, two: gconstpointer) -> c_int;
    pub fn g_variant_dup_bytestring(value: *mut GVariant, length: *mut size_t) -> *mut u8;
    pub fn g_variant_dup_bytestring_array(value: *mut GVariant, length: *mut size_t) -> *mut *mut c_char;
    pub fn g_variant_dup_objv(value: *mut GVariant, length: *mut size_t) -> *mut *mut c_char;
    pub fn g_variant_dup_string(value: *mut GVariant, length: *mut size_t) -> *mut c_char;
    pub fn g_variant_dup_strv(value: *mut GVariant, length: *mut size_t) -> *mut *mut c_char;
    pub fn g_variant_equal(one: gconstpointer, two: gconstpointer) -> gboolean;
    pub fn g_variant_get(value: *mut GVariant, format_string: *const c_char, ...);
    pub fn g_variant_get_boolean(value: *mut GVariant) -> gboolean;
    pub fn g_variant_get_byte(value: *mut GVariant) -> c_uchar;
    pub fn g_variant_get_bytestring(value: *mut GVariant) -> *mut u8;
    pub fn g_variant_get_bytestring_array(value: *mut GVariant, length: *mut size_t) -> *mut *mut c_char;
    pub fn g_variant_get_child(value: *mut GVariant, index_: size_t, format_string: *const c_char, ...);
    pub fn g_variant_get_child_value(value: *mut GVariant, index_: size_t) -> *mut GVariant;
    pub fn g_variant_get_data(value: *mut GVariant) -> gconstpointer;
    #[cfg(feature = "v2_36")]
    pub fn g_variant_get_data_as_bytes(value: *mut GVariant) -> *mut GBytes;
    pub fn g_variant_get_double(value: *mut GVariant) -> c_double;
    pub fn g_variant_get_fixed_array(value: *mut GVariant, n_elements: *mut size_t, element_size: size_t) -> gconstpointer;
    pub fn g_variant_get_handle(value: *mut GVariant) -> i32;
    pub fn g_variant_get_int16(value: *mut GVariant) -> i16;
    pub fn g_variant_get_int32(value: *mut GVariant) -> i32;
    pub fn g_variant_get_int64(value: *mut GVariant) -> i64;
    pub fn g_variant_get_maybe(value: *mut GVariant) -> *mut GVariant;
    pub fn g_variant_get_normal_form(value: *mut GVariant) -> *mut GVariant;
    pub fn g_variant_get_objv(value: *mut GVariant, length: *mut size_t) -> *mut *mut c_char;
    pub fn g_variant_get_size(value: *mut GVariant) -> size_t;
    pub fn g_variant_get_string(value: *mut GVariant, length: *mut size_t) -> *const c_char;
    pub fn g_variant_get_strv(value: *mut GVariant, length: *mut size_t) -> *mut *mut c_char;
    pub fn g_variant_get_type(value: *mut GVariant) -> *const GVariantType;
    pub fn g_variant_get_type_string(value: *mut GVariant) -> *const c_char;
    pub fn g_variant_get_uint16(value: *mut GVariant) -> u16;
    pub fn g_variant_get_uint32(value: *mut GVariant) -> u32;
    pub fn g_variant_get_uint64(value: *mut GVariant) -> u64;
    //pub fn g_variant_get_va(value: *mut GVariant, format_string: *const c_char, endptr: *mut *const c_char, app: /*Unimplemented*/*mut va_list);
    pub fn g_variant_get_variant(value: *mut GVariant) -> *mut GVariant;
    pub fn g_variant_hash(value: gconstpointer) -> c_uint;
    pub fn g_variant_is_container(value: *mut GVariant) -> gboolean;
    pub fn g_variant_is_floating(value: *mut GVariant) -> gboolean;
    pub fn g_variant_is_normal_form(value: *mut GVariant) -> gboolean;
    pub fn g_variant_is_of_type(value: *mut GVariant, type_: *const GVariantType) -> gboolean;
    pub fn g_variant_iter_new(value: *mut GVariant) -> *mut GVariantIter;
    pub fn g_variant_lookup(dictionary: *mut GVariant, key: *const c_char, format_string: *const c_char, ...) -> gboolean;
    pub fn g_variant_lookup_value(dictionary: *mut GVariant, key: *const c_char, expected_type: *const GVariantType) -> *mut GVariant;
    pub fn g_variant_n_children(value: *mut GVariant) -> size_t;
    pub fn g_variant_print(value: *mut GVariant, type_annotate: gboolean) -> *mut c_char;
    pub fn g_variant_print_string(value: *mut GVariant, string: *mut GString, type_annotate: gboolean) -> *mut GString;
    pub fn g_variant_ref(value: *mut GVariant) -> *mut GVariant;
    pub fn g_variant_ref_sink(value: *mut GVariant) -> *mut GVariant;
    pub fn g_variant_store(value: *mut GVariant, data: gpointer);
    pub fn g_variant_take_ref(value: *mut GVariant) -> *mut GVariant;
    pub fn g_variant_unref(value: *mut GVariant);
    pub fn g_variant_is_object_path(string: *const c_char) -> gboolean;
    pub fn g_variant_is_signature(string: *const c_char) -> gboolean;
    pub fn g_variant_parse(type_: *const GVariantType, text: *const c_char, limit: *const c_char, endptr: *mut *const c_char, error: *mut *mut GError) -> *mut GVariant;
    #[cfg(feature = "v2_40")]
    pub fn g_variant_parse_error_print_context(error: *mut GError, source_str: *const c_char) -> *mut c_char;
    pub fn g_variant_parse_error_quark() -> GQuark;
    pub fn g_variant_parser_get_error_quark() -> GQuark;

    //=========================================================================
    // GVariantBuilder
    //=========================================================================
    pub fn g_variant_builder_get_type() -> GType;
    pub fn g_variant_builder_new(type_: *const GVariantType) -> *mut GVariantBuilder;
    pub fn g_variant_builder_add(builder: *mut GVariantBuilder, format_string: *const c_char, ...);
    pub fn g_variant_builder_add_parsed(builder: *mut GVariantBuilder, format: *const c_char, ...);
    pub fn g_variant_builder_add_value(builder: *mut GVariantBuilder, value: *mut GVariant);
    pub fn g_variant_builder_clear(builder: *mut GVariantBuilder);
    pub fn g_variant_builder_close(builder: *mut GVariantBuilder);
    pub fn g_variant_builder_end(builder: *mut GVariantBuilder) -> *mut GVariant;
    pub fn g_variant_builder_init(builder: *mut GVariantBuilder, type_: *const GVariantType);
    pub fn g_variant_builder_open(builder: *mut GVariantBuilder, type_: *const GVariantType);
    pub fn g_variant_builder_ref(builder: *mut GVariantBuilder) -> *mut GVariantBuilder;
    pub fn g_variant_builder_unref(builder: *mut GVariantBuilder);

    //=========================================================================
    // GVariantDict
    //=========================================================================
    pub fn g_variant_dict_get_type() -> GType;
    #[cfg(feature = "v2_40")]
    pub fn g_variant_dict_new(from_asv: *mut GVariant) -> *mut GVariantDict;
    #[cfg(feature = "v2_40")]
    pub fn g_variant_dict_clear(dict: *mut GVariantDict);
    #[cfg(feature = "v2_40")]
    pub fn g_variant_dict_contains(dict: *mut GVariantDict, key: *const c_char) -> gboolean;
    #[cfg(feature = "v2_40")]
    pub fn g_variant_dict_end(dict: *mut GVariantDict) -> *mut GVariant;
    #[cfg(feature = "v2_40")]
    pub fn g_variant_dict_init(dict: *mut GVariantDict, from_asv: *mut GVariant);
    #[cfg(feature = "v2_40")]
    pub fn g_variant_dict_insert(dict: *mut GVariantDict, key: *const c_char, format_string: *const c_char, ...);
    #[cfg(feature = "v2_40")]
    pub fn g_variant_dict_insert_value(dict: *mut GVariantDict, key: *const c_char, value: *mut GVariant);
    #[cfg(feature = "v2_40")]
    pub fn g_variant_dict_lookup(dict: *mut GVariantDict, key: *const c_char, format_string: *const c_char, ...) -> gboolean;
    #[cfg(feature = "v2_40")]
    pub fn g_variant_dict_lookup_value(dict: *mut GVariantDict, key: *const c_char, expected_type: *const GVariantType) -> *mut GVariant;
    #[cfg(feature = "v2_40")]
    pub fn g_variant_dict_ref(dict: *mut GVariantDict) -> *mut GVariantDict;
    #[cfg(feature = "v2_40")]
    pub fn g_variant_dict_remove(dict: *mut GVariantDict, key: *const c_char) -> gboolean;
    #[cfg(feature = "v2_40")]
    pub fn g_variant_dict_unref(dict: *mut GVariantDict);

    //=========================================================================
    // GVariantIter
    //=========================================================================
    pub fn g_variant_iter_copy(iter: *mut GVariantIter) -> *mut GVariantIter;
    pub fn g_variant_iter_free(iter: *mut GVariantIter);
    pub fn g_variant_iter_init(iter: *mut GVariantIter, value: *mut GVariant) -> size_t;
    pub fn g_variant_iter_loop(iter: *mut GVariantIter, format_string: *const c_char, ...) -> gboolean;
    pub fn g_variant_iter_n_children(iter: *mut GVariantIter) -> size_t;
    pub fn g_variant_iter_next(iter: *mut GVariantIter, format_string: *const c_char, ...) -> gboolean;
    pub fn g_variant_iter_next_value(iter: *mut GVariantIter) -> *mut GVariant;

    //=========================================================================
    // GVariantType
    //=========================================================================
    pub fn g_variant_type_get_gtype() -> GType;
    pub fn g_variant_type_new(type_string: *const c_char) -> *mut GVariantType;
    pub fn g_variant_type_new_array(element: *const GVariantType) -> *mut GVariantType;
    pub fn g_variant_type_new_dict_entry(key: *const GVariantType, value: *const GVariantType) -> *mut GVariantType;
    pub fn g_variant_type_new_maybe(element: *const GVariantType) -> *mut GVariantType;
    pub fn g_variant_type_new_tuple(items: *mut *mut GVariantType, length: c_int) -> *mut GVariantType;
    pub fn g_variant_type_copy(type_: *const GVariantType) -> *mut GVariantType;
    pub fn g_variant_type_dup_string(type_: *const GVariantType) -> *mut c_char;
    pub fn g_variant_type_element(type_: *const GVariantType) -> *const GVariantType;
    pub fn g_variant_type_equal(type1: gconstpointer, type2: gconstpointer) -> gboolean;
    pub fn g_variant_type_first(type_: *const GVariantType) -> *const GVariantType;
    pub fn g_variant_type_free(type_: *mut GVariantType);
    pub fn g_variant_type_get_string_length(type_: *const GVariantType) -> size_t;
    pub fn g_variant_type_hash(type_: gconstpointer) -> c_uint;
    pub fn g_variant_type_is_array(type_: *const GVariantType) -> gboolean;
    pub fn g_variant_type_is_basic(type_: *const GVariantType) -> gboolean;
    pub fn g_variant_type_is_container(type_: *const GVariantType) -> gboolean;
    pub fn g_variant_type_is_definite(type_: *const GVariantType) -> gboolean;
    pub fn g_variant_type_is_dict_entry(type_: *const GVariantType) -> gboolean;
    pub fn g_variant_type_is_maybe(type_: *const GVariantType) -> gboolean;
    pub fn g_variant_type_is_subtype_of(type_: *const GVariantType, supertype: *const GVariantType) -> gboolean;
    pub fn g_variant_type_is_tuple(type_: *const GVariantType) -> gboolean;
    pub fn g_variant_type_is_variant(type_: *const GVariantType) -> gboolean;
    pub fn g_variant_type_key(type_: *const GVariantType) -> *const GVariantType;
    pub fn g_variant_type_n_items(type_: *const GVariantType) -> size_t;
    pub fn g_variant_type_next(type_: *const GVariantType) -> *const GVariantType;
    pub fn g_variant_type_peek_string(type_: *const GVariantType) -> *const c_char;
    pub fn g_variant_type_value(type_: *const GVariantType) -> *const GVariantType;
    pub fn g_variant_type_checked_(arg0: *const c_char) -> *const GVariantType;
    pub fn g_variant_type_string_is_valid(type_string: *const c_char) -> gboolean;
    pub fn g_variant_type_string_scan(string: *const c_char, limit: *const c_char, endptr: *mut *const c_char) -> gboolean;

    //=========================================================================
    // Other functions
    //=========================================================================
    pub fn g_access(filename: *mut c_char, mode: c_int) -> c_int;
    pub fn g_ascii_digit_value(c: c_char) -> c_int;
    pub fn g_ascii_dtostr(buffer: *mut c_char, buf_len: c_int, d: c_double) -> *mut c_char;
    pub fn g_ascii_formatd(buffer: *mut c_char, buf_len: c_int, format: *const c_char, d: c_double) -> *mut c_char;
    pub fn g_ascii_strcasecmp(s1: *const c_char, s2: *const c_char) -> c_int;
    pub fn g_ascii_strdown(str: *const c_char, len: ssize_t) -> *mut c_char;
    pub fn g_ascii_strncasecmp(s1: *const c_char, s2: *const c_char, n: size_t) -> c_int;
    pub fn g_ascii_strtod(nptr: *const c_char, endptr: *mut *mut c_char) -> c_double;
    pub fn g_ascii_strtoll(nptr: *const c_char, endptr: *mut *mut c_char, base: c_uint) -> i64;
    pub fn g_ascii_strtoull(nptr: *const c_char, endptr: *mut *mut c_char, base: c_uint) -> u64;
    pub fn g_ascii_strup(str: *const c_char, len: ssize_t) -> *mut c_char;
    pub fn g_ascii_tolower(c: c_char) -> c_char;
    pub fn g_ascii_toupper(c: c_char) -> c_char;
    pub fn g_ascii_xdigit_value(c: c_char) -> c_int;
    pub fn g_assert_warning(log_domain: *const c_char, file: *const c_char, line: c_int, pretty_function: *const c_char, expression: *const c_char);
    pub fn g_assertion_message(domain: *const c_char, file: *const c_char, line: c_int, func: *const c_char, message: *const c_char);
    //pub fn g_assertion_message_cmpnum(domain: *const c_char, file: *const c_char, line: c_int, func: *const c_char, expr: *const c_char, arg1: /*Unimplemented*/long double, cmp: *const c_char, arg2: /*Unimplemented*/long double, numtype: c_char);
    pub fn g_assertion_message_cmpstr(domain: *const c_char, file: *const c_char, line: c_int, func: *const c_char, expr: *const c_char, arg1: *const c_char, cmp: *const c_char, arg2: *const c_char);
    pub fn g_assertion_message_error(domain: *const c_char, file: *const c_char, line: c_int, func: *const c_char, expr: *const c_char, error: *const GError, error_domain: GQuark, error_code: c_int);
    pub fn g_assertion_message_expr(domain: *const c_char, file: *const c_char, line: c_int, func: *const c_char, expr: *const c_char);
    pub fn g_atexit(func: GVoidFunc);
    pub fn g_atomic_int_add(atomic: *mut Volatile<c_int>, val: c_int) -> c_int;
    pub fn g_atomic_int_and(atomic: *mut Volatile<c_uint>, val: c_uint) -> c_uint;
    pub fn g_atomic_int_compare_and_exchange(atomic: *mut Volatile<c_int>, oldval: c_int, newval: c_int) -> gboolean;
    pub fn g_atomic_int_dec_and_test(atomic: *mut Volatile<c_int>) -> gboolean;
    pub fn g_atomic_int_exchange_and_add(atomic: *mut Volatile<c_int>, val: c_int) -> c_int;
    pub fn g_atomic_int_get(atomic: *const c_int) -> c_int;
    pub fn g_atomic_int_inc(atomic: *mut Volatile<c_int>);
    pub fn g_atomic_int_or(atomic: *mut Volatile<c_uint>, val: c_uint) -> c_uint;
    pub fn g_atomic_int_set(atomic: *mut Volatile<c_int>, newval: c_int);
    pub fn g_atomic_int_xor(atomic: *mut Volatile<c_uint>, val: c_uint) -> c_uint;
    pub fn g_atomic_pointer_add(atomic: *mut c_void, val: ssize_t) -> ssize_t;
    pub fn g_atomic_pointer_and(atomic: *mut c_void, val: size_t) -> size_t;
    pub fn g_atomic_pointer_compare_and_exchange(atomic: *mut c_void, oldval: gpointer, newval: gpointer) -> gboolean;
    pub fn g_atomic_pointer_get(atomic: *mut c_void) -> gpointer;
    pub fn g_atomic_pointer_or(atomic: *mut c_void, val: size_t) -> size_t;
    pub fn g_atomic_pointer_set(atomic: *mut c_void, newval: gpointer);
    pub fn g_atomic_pointer_xor(atomic: *mut c_void, val: size_t) -> size_t;
    pub fn g_base64_decode(text: *const c_char, out_len: *mut size_t) -> *mut u8;
    pub fn g_base64_decode_inplace(text: *mut u8, out_len: *mut size_t) -> *mut u8;
    pub fn g_base64_decode_step(in_: *mut u8, len: size_t, out: *mut u8, state: *mut c_int, save: *mut c_uint) -> size_t;
    pub fn g_base64_encode(data: *mut u8, len: size_t) -> *mut c_char;
    pub fn g_base64_encode_close(break_lines: gboolean, out: *mut u8, state: *mut c_int, save: *mut c_int) -> size_t;
    pub fn g_base64_encode_step(in_: *mut u8, len: size_t, break_lines: gboolean, out: *mut u8, state: *mut c_int, save: *mut c_int) -> size_t;
    pub fn g_basename(file_name: *mut c_char) -> *mut c_char;
    pub fn g_bit_lock(address: *mut Volatile<c_int>, lock_bit: c_int);
    pub fn g_bit_nth_lsf(mask: c_ulong, nth_bit: c_int) -> c_int;
    pub fn g_bit_nth_msf(mask: c_ulong, nth_bit: c_int) -> c_int;
    pub fn g_bit_storage(number: c_ulong) -> c_uint;
    pub fn g_bit_trylock(address: *mut Volatile<c_int>, lock_bit: c_int) -> gboolean;
    pub fn g_bit_unlock(address: *mut Volatile<c_int>, lock_bit: c_int);
    pub fn g_build_filename(first_element: *mut c_char, ...) -> *mut c_char;
    pub fn g_build_filenamev(args: *mut *mut c_char) -> *mut c_char;
    pub fn g_build_path(separator: *mut c_char, first_element: *mut c_char, ...) -> *mut c_char;
    pub fn g_build_pathv(separator: *const c_char, args: *mut *mut c_char) -> *mut c_char;
    pub fn g_chdir(path: *mut c_char) -> c_int;
    pub fn glib_check_version(required_major: c_uint, required_minor: c_uint, required_micro: c_uint) -> *const c_char;
    pub fn g_child_watch_add(pid: GPid, function: GChildWatchFunc, data: gpointer) -> c_uint;
    pub fn g_child_watch_add_full(priority: c_int, pid: GPid, function: GChildWatchFunc, data: gpointer, notify: GDestroyNotify) -> c_uint;
    pub fn g_child_watch_source_new(pid: GPid) -> *mut GSource;
    pub fn g_clear_error(error: *mut *mut GError);
    #[cfg(feature = "v2_34")]
    pub fn g_clear_pointer(pp: *mut gpointer, destroy: GDestroyNotify);
    #[cfg(feature = "v2_36")]
    pub fn g_close(fd: c_int, error: *mut *mut GError) -> gboolean;
    #[cfg(feature = "v2_34")]
    pub fn g_compute_checksum_for_bytes(checksum_type: GChecksumType, data: *mut GBytes) -> *mut c_char;
    pub fn g_compute_checksum_for_data(checksum_type: GChecksumType, data: *mut u8, length: size_t) -> *mut c_char;
    pub fn g_compute_checksum_for_string(checksum_type: GChecksumType, str: *const c_char, length: ssize_t) -> *mut c_char;
    #[cfg(feature = "v2_50")]
    pub fn g_compute_hmac_for_bytes(digest_type: GChecksumType, key: *mut GBytes, data: *mut GBytes) -> *mut c_char;
    pub fn g_compute_hmac_for_data(digest_type: GChecksumType, key: *mut u8, key_len: size_t, data: *mut u8, length: size_t) -> *mut c_char;
    pub fn g_compute_hmac_for_string(digest_type: GChecksumType, key: *mut u8, key_len: size_t, str: *const c_char, length: ssize_t) -> *mut c_char;
    pub fn g_convert(str: *const c_char, len: ssize_t, to_codeset: *const c_char, from_codeset: *const c_char, bytes_read: *mut size_t, bytes_written: *mut size_t, error: *mut *mut GError) -> *mut c_char;
    pub fn g_convert_error_quark() -> GQuark;
    pub fn g_convert_with_fallback(str: *const c_char, len: ssize_t, to_codeset: *const c_char, from_codeset: *const c_char, fallback: *const c_char, bytes_read: *mut size_t, bytes_written: *mut size_t, error: *mut *mut GError) -> *mut c_char;
    pub fn g_convert_with_iconv(str: *const c_char, len: ssize_t, converter: GIConv, bytes_read: *mut size_t, bytes_written: *mut size_t, error: *mut *mut GError) -> *mut c_char;
    pub fn g_datalist_clear(datalist: *mut *mut GData);
    pub fn g_datalist_foreach(datalist: *mut *mut GData, func: GDataForeachFunc, user_data: gpointer);
    pub fn g_datalist_get_data(datalist: *mut *mut GData, key: *const c_char) -> gpointer;
    pub fn g_datalist_get_flags(datalist: *mut *mut GData) -> c_uint;
    #[cfg(feature = "v2_34")]
    pub fn g_datalist_id_dup_data(datalist: *mut *mut GData, key_id: GQuark, dup_func: GDuplicateFunc, user_data: gpointer) -> gpointer;
    pub fn g_datalist_id_get_data(datalist: *mut *mut GData, key_id: GQuark) -> gpointer;
    pub fn g_datalist_id_remove_no_notify(datalist: *mut *mut GData, key_id: GQuark) -> gpointer;
    #[cfg(feature = "v2_34")]
    pub fn g_datalist_id_replace_data(datalist: *mut *mut GData, key_id: GQuark, oldval: gpointer, newval: gpointer, destroy: GDestroyNotify, old_destroy: *mut GDestroyNotify) -> gboolean;
    pub fn g_datalist_id_set_data_full(datalist: *mut *mut GData, key_id: GQuark, data: gpointer, destroy_func: GDestroyNotify);
    pub fn g_datalist_init(datalist: *mut *mut GData);
    pub fn g_datalist_set_flags(datalist: *mut *mut GData, flags: c_uint);
    pub fn g_datalist_unset_flags(datalist: *mut *mut GData, flags: c_uint);
    pub fn g_dataset_destroy(dataset_location: gconstpointer);
    pub fn g_dataset_foreach(dataset_location: gconstpointer, func: GDataForeachFunc, user_data: gpointer);
    pub fn g_dataset_id_get_data(dataset_location: gconstpointer, key_id: GQuark) -> gpointer;
    pub fn g_dataset_id_remove_no_notify(dataset_location: gconstpointer, key_id: GQuark) -> gpointer;
    pub fn g_dataset_id_set_data_full(dataset_location: gconstpointer, key_id: GQuark, data: gpointer, destroy_func: GDestroyNotify);
    pub fn g_dcgettext(domain: *const c_char, msgid: *const c_char, category: c_int) -> *const c_char;
    pub fn g_dgettext(domain: *const c_char, msgid: *const c_char) -> *const c_char;
    pub fn g_direct_equal(v1: gconstpointer, v2: gconstpointer) -> gboolean;
    pub fn g_direct_hash(v: gconstpointer) -> c_uint;
    pub fn g_dngettext(domain: *const c_char, msgid: *const c_char, msgid_plural: *const c_char, n: c_ulong) -> *const c_char;
    pub fn g_double_equal(v1: gconstpointer, v2: gconstpointer) -> gboolean;
    pub fn g_double_hash(v: gconstpointer) -> c_uint;
    pub fn g_dpgettext(domain: *const c_char, msgctxtid: *const c_char, msgidoffset: size_t) -> *const c_char;
    pub fn g_dpgettext2(domain: *const c_char, context: *const c_char, msgid: *const c_char) -> *const c_char;
    pub fn g_environ_getenv(envp: *mut *mut c_char, variable: *const c_char) -> *const c_char;
    pub fn g_environ_setenv(envp: *mut *mut c_char, variable: *const c_char, value: *const c_char, overwrite: gboolean) -> *mut *mut c_char;
    pub fn g_environ_unsetenv(envp: *mut *mut c_char, variable: *const c_char) -> *mut *mut c_char;
    pub fn g_file_error_from_errno(err_no: c_int) -> GFileError;
    pub fn g_file_error_quark() -> GQuark;
    #[cfg(windows)]
    pub fn g_file_get_contents_utf8(filename: *mut c_char, contents: *mut *mut u8, length: *mut size_t, error: *mut *mut GError) -> gboolean;
    pub fn g_file_get_contents(filename: *mut c_char, contents: *mut *mut u8, length: *mut size_t, error: *mut *mut GError) -> gboolean;
    #[cfg(windows)]
    pub fn g_file_open_tmp_utf8(tmpl: *mut c_char, name_used: *mut *mut c_char, error: *mut *mut GError) -> c_int;
    pub fn g_file_open_tmp(tmpl: *mut c_char, name_used: *mut *mut c_char, error: *mut *mut GError) -> c_int;
    pub fn g_file_read_link(filename: *mut c_char, error: *mut *mut GError) -> *mut c_char;
    pub fn g_file_set_contents(filename: *mut c_char, contents: *mut u8, length: ssize_t, error: *mut *mut GError) -> gboolean;
    #[cfg(windows)]
    pub fn g_file_test_utf8(filename: *mut c_char, test: GFileTest) -> gboolean;
    pub fn g_file_test(filename: *mut c_char, test: GFileTest) -> gboolean;
    pub fn g_filename_display_basename(filename: *mut c_char) -> *mut c_char;
    pub fn g_filename_display_name(filename: *mut c_char) -> *mut c_char;
    #[cfg(windows)]
    pub fn g_filename_from_uri_utf8(uri: *const c_char, hostname: *mut *mut c_char, error: *mut *mut GError) -> *mut c_char;
    pub fn g_filename_from_uri(uri: *const c_char, hostname: *mut *mut c_char, error: *mut *mut GError) -> *mut c_char;
    #[cfg(windows)]
    pub fn g_filename_from_utf8_utf8(utf8string: *const c_char, len: ssize_t, bytes_read: *mut size_t, bytes_written: *mut size_t, error: *mut *mut GError) -> *mut u8;
    pub fn g_filename_from_utf8(utf8string: *const c_char, len: ssize_t, bytes_read: *mut size_t, bytes_written: *mut size_t, error: *mut *mut GError) -> *mut u8;
    #[cfg(windows)]
    pub fn g_filename_to_uri_utf8(filename: *mut c_char, hostname: *const c_char, error: *mut *mut GError) -> *mut c_char;
    pub fn g_filename_to_uri(filename: *mut c_char, hostname: *const c_char, error: *mut *mut GError) -> *mut c_char;
    #[cfg(windows)]
    pub fn g_filename_to_utf8_utf8(opsysstring: *mut c_char, len: ssize_t, bytes_read: *mut size_t, bytes_written: *mut size_t, error: *mut *mut GError) -> *mut c_char;
    pub fn g_filename_to_utf8(opsysstring: *mut c_char, len: ssize_t, bytes_read: *mut size_t, bytes_written: *mut size_t, error: *mut *mut GError) -> *mut c_char;
    #[cfg(windows)]
    pub fn g_find_program_in_path_utf8(program: *mut c_char) -> *mut c_char;
    pub fn g_find_program_in_path(program: *mut c_char) -> *mut c_char;
    pub fn g_format_size(size: u64) -> *mut c_char;
    pub fn g_format_size_for_display(size: i64) -> *mut c_char;
    pub fn g_format_size_full(size: u64, flags: GFormatSizeFlags) -> *mut c_char;
    pub fn g_fprintf(file: *mut FILE, format: *mut c_char, ...) -> c_int;
    pub fn g_free(mem: gpointer);
    pub fn g_get_application_name() -> *const c_char;
    pub fn g_get_charset(charset: *mut *const c_char) -> gboolean;
    pub fn g_get_codeset() -> *mut c_char;
    #[cfg(windows)]
    pub fn g_get_current_dir_utf8() -> *mut c_char;
    pub fn g_get_current_dir() -> *mut c_char;
    pub fn g_get_current_time(result: *mut GTimeVal);
    pub fn g_get_environ() -> *mut *mut c_char;
    pub fn g_get_filename_charsets(charsets: *mut *mut *const c_char) -> gboolean;
    #[cfg(windows)]
    pub fn g_get_home_dir_utf8() -> *mut c_char;
    pub fn g_get_home_dir() -> *mut c_char;
    pub fn g_get_host_name() -> *const c_char;
    pub fn g_get_language_names() -> *mut *mut c_char;
    pub fn g_get_locale_variants(locale: *const c_char) -> *mut *mut c_char;
    pub fn g_get_monotonic_time() -> i64;
    #[cfg(feature = "v2_36")]
    pub fn g_get_num_processors() -> c_uint;
    pub fn g_get_prgname() -> *const c_char;
    #[cfg(windows)]
    pub fn g_get_real_name_utf8() -> *mut c_char;
    pub fn g_get_real_name() -> *mut c_char;
    pub fn g_get_real_time() -> i64;
    pub fn g_get_system_config_dirs() -> *mut *mut c_char;
    pub fn g_get_system_data_dirs() -> *mut *mut c_char;
    #[cfg(windows)]
    pub fn g_get_tmp_dir_utf8() -> *mut c_char;
    pub fn g_get_tmp_dir() -> *mut c_char;
    pub fn g_get_user_cache_dir() -> *mut c_char;
    pub fn g_get_user_config_dir() -> *mut c_char;
    pub fn g_get_user_data_dir() -> *mut c_char;
    #[cfg(windows)]
    pub fn g_get_user_name_utf8() -> *mut c_char;
    pub fn g_get_user_name() -> *mut c_char;
    pub fn g_get_user_runtime_dir() -> *mut c_char;
    pub fn g_get_user_special_dir(directory: GUserDirectory) -> *mut c_char;
    #[cfg(windows)]
    pub fn g_getenv_utf8(variable: *const c_char) -> *const c_char;
    pub fn g_getenv(variable: *const c_char) -> *const c_char;
    pub fn g_hostname_is_ascii_encoded(hostname: *const c_char) -> gboolean;
    pub fn g_hostname_is_ip_address(hostname: *const c_char) -> gboolean;
    pub fn g_hostname_is_non_ascii(hostname: *const c_char) -> gboolean;
    pub fn g_hostname_to_ascii(hostname: *const c_char) -> *mut c_char;
    pub fn g_hostname_to_unicode(hostname: *const c_char) -> *mut c_char;
    pub fn g_iconv(converter: GIConv, inbuf: *mut *mut c_char, inbytes_left: *mut size_t, outbuf: *mut *mut c_char, outbytes_left: *mut size_t) -> size_t;
    pub fn g_idle_add(function: GSourceFunc, data: gpointer) -> c_uint;
    pub fn g_idle_add_full(priority: c_int, function: GSourceFunc, data: gpointer, notify: GDestroyNotify) -> c_uint;
    pub fn g_idle_remove_by_data(data: gpointer) -> gboolean;
    pub fn g_idle_source_new() -> *mut GSource;
    pub fn g_int64_equal(v1: gconstpointer, v2: gconstpointer) -> gboolean;
    pub fn g_int64_hash(v: gconstpointer) -> c_uint;
    pub fn g_int_equal(v1: gconstpointer, v2: gconstpointer) -> gboolean;
    pub fn g_int_hash(v: gconstpointer) -> c_uint;
    pub fn g_intern_static_string(string: *const c_char) -> *const c_char;
    pub fn g_intern_string(string: *const c_char) -> *const c_char;
    pub fn g_io_add_watch(channel: *mut GIOChannel, condition: GIOCondition, func: GIOFunc, user_data: gpointer) -> c_uint;
    pub fn g_io_add_watch_full(channel: *mut GIOChannel, priority: c_int, condition: GIOCondition, func: GIOFunc, user_data: gpointer, notify: GDestroyNotify) -> c_uint;
    pub fn g_io_create_watch(channel: *mut GIOChannel, condition: GIOCondition) -> *mut GSource;
    pub fn g_listenv() -> *mut *mut c_char;
    pub fn g_locale_from_utf8(utf8string: *const c_char, len: ssize_t, bytes_read: *mut size_t, bytes_written: *mut size_t, error: *mut *mut GError) -> *mut c_char;
    pub fn g_locale_to_utf8(opsysstring: *const c_char, len: ssize_t, bytes_read: *mut size_t, bytes_written: *mut size_t, error: *mut *mut GError) -> *mut c_char;
    pub fn g_log(log_domain: *const c_char, log_level: GLogLevelFlags, format: *const c_char, ...);
    pub fn g_log_default_handler(log_domain: *const c_char, log_level: GLogLevelFlags, message: *const c_char, unused_data: gpointer);
    pub fn g_log_remove_handler(log_domain: *const c_char, handler_id: c_uint);
    pub fn g_log_set_always_fatal(fatal_mask: GLogLevelFlags) -> GLogLevelFlags;
    pub fn g_log_set_default_handler(log_func: GLogFunc, user_data: gpointer) -> GLogFunc;
    pub fn g_log_set_fatal_mask(log_domain: *const c_char, fatal_mask: GLogLevelFlags) -> GLogLevelFlags;
    pub fn g_log_set_handler(log_domain: *const c_char, log_levels: GLogLevelFlags, log_func: GLogFunc, user_data: gpointer) -> c_uint;
    #[cfg(feature = "v2_46")]
    pub fn g_log_set_handler_full(log_domain: *const c_char, log_levels: GLogLevelFlags, log_func: GLogFunc, user_data: gpointer, destroy: GDestroyNotify) -> c_uint;
    #[cfg(feature = "v2_50")]
    pub fn g_log_set_writer_func(func: GLogWriterFunc, user_data: gpointer, user_data_free: GDestroyNotify);
    #[cfg(feature = "v2_50")]
    pub fn g_log_structured(log_domain: *const c_char, log_level: GLogLevelFlags, ...);
    #[cfg(feature = "v2_50")]
    pub fn g_log_structured_array(log_level: GLogLevelFlags, fields: *mut GLogField, n_fields: size_t);
    #[cfg(feature = "v2_50")]
    pub fn g_log_variant(log_domain: *const c_char, log_level: GLogLevelFlags, fields: *mut GVariant);
    #[cfg(feature = "v2_50")]
    pub fn g_log_writer_default(log_level: GLogLevelFlags, fields: *mut GLogField, n_fields: size_t, user_data: gpointer) -> GLogWriterOutput;
    #[cfg(feature = "v2_50")]
    pub fn g_log_writer_format_fields(log_level: GLogLevelFlags, fields: *mut GLogField, n_fields: size_t, use_color: gboolean) -> *mut c_char;
    #[cfg(feature = "v2_50")]
    pub fn g_log_writer_is_journald(output_fd: c_int) -> gboolean;
    #[cfg(feature = "v2_50")]
    pub fn g_log_writer_journald(log_level: GLogLevelFlags, fields: *mut GLogField, n_fields: size_t, user_data: gpointer) -> GLogWriterOutput;
    #[cfg(feature = "v2_50")]
    pub fn g_log_writer_standard_streams(log_level: GLogLevelFlags, fields: *mut GLogField, n_fields: size_t, user_data: gpointer) -> GLogWriterOutput;
    #[cfg(feature = "v2_50")]
    pub fn g_log_writer_supports_color(output_fd: c_int) -> gboolean;
    //pub fn g_logv(log_domain: *const c_char, log_level: GLogLevelFlags, format: *const c_char, args: /*Unimplemented*/va_list);
    pub fn g_main_current_source() -> *mut GSource;
    pub fn g_main_depth() -> c_int;
    pub fn g_malloc(n_bytes: size_t) -> gpointer;
    pub fn g_malloc0(n_bytes: size_t) -> gpointer;
    pub fn g_malloc0_n(n_blocks: size_t, n_block_bytes: size_t) -> gpointer;
    pub fn g_malloc_n(n_blocks: size_t, n_block_bytes: size_t) -> gpointer;
    pub fn g_markup_collect_attributes(element_name: *const c_char, attribute_names: *mut *const c_char, attribute_values: *mut *const c_char, error: *mut *mut GError, first_type: GMarkupCollectType, first_attr: *const c_char, ...) -> gboolean;
    pub fn g_markup_error_quark() -> GQuark;
    pub fn g_markup_escape_text(text: *const c_char, length: ssize_t) -> *mut c_char;
    pub fn g_markup_printf_escaped(format: *const c_char, ...) -> *mut c_char;
    //pub fn g_markup_vprintf_escaped(format: *const c_char, args: /*Unimplemented*/va_list) -> *mut c_char;
    pub fn g_mem_is_system_malloc() -> gboolean;
    pub fn g_mem_profile();
    pub fn g_mem_set_vtable(vtable: *mut GMemVTable);
    pub fn g_memdup(mem: gconstpointer, byte_size: c_uint) -> gpointer;
    pub fn g_mkdir_with_parents(pathname: *mut c_char, mode: c_int) -> c_int;
    pub fn g_mkdtemp(tmpl: *mut c_char) -> *mut c_char;
    pub fn g_mkdtemp_full(tmpl: *mut c_char, mode: c_int) -> *mut c_char;
    #[cfg(windows)]
    pub fn g_mkstemp_utf8(tmpl: *mut c_char) -> c_int;
    pub fn g_mkstemp(tmpl: *mut c_char) -> c_int;
    pub fn g_mkstemp_full(tmpl: *mut c_char, flags: c_int, mode: c_int) -> c_int;
    pub fn g_nullify_pointer(nullify_location: *mut gpointer);
    pub fn g_on_error_query(prg_name: *const c_char);
    pub fn g_on_error_stack_trace(prg_name: *const c_char);
    pub fn g_option_error_quark() -> GQuark;
    pub fn g_parse_debug_string(string: *const c_char, keys: *mut GDebugKey, nkeys: c_uint) -> c_uint;
    pub fn g_path_get_basename(file_name: *mut c_char) -> *mut c_char;
    pub fn g_path_get_dirname(file_name: *mut c_char) -> *mut c_char;
    pub fn g_path_is_absolute(file_name: *mut c_char) -> gboolean;
    pub fn g_path_skip_root(file_name: *mut c_char) -> *mut c_char;
    pub fn g_pattern_match(pspec: *mut GPatternSpec, string_length: c_uint, string: *const c_char, string_reversed: *const c_char) -> gboolean;
    pub fn g_pattern_match_simple(pattern: *const c_char, string: *const c_char) -> gboolean;
    pub fn g_pattern_match_string(pspec: *mut GPatternSpec, string: *const c_char) -> gboolean;
    pub fn g_pointer_bit_lock(address: *mut c_void, lock_bit: c_int);
    pub fn g_pointer_bit_trylock(address: *mut c_void, lock_bit: c_int) -> gboolean;
    pub fn g_pointer_bit_unlock(address: *mut c_void, lock_bit: c_int);
    pub fn g_poll(fds: *mut GPollFD, nfds: c_uint, timeout: c_int) -> c_int;
    pub fn g_prefix_error(err: *mut *mut GError, format: *const c_char, ...);
    pub fn g_print(format: *const c_char, ...);
    pub fn g_printerr(format: *const c_char, ...);
    pub fn g_printf(format: *mut c_char, ...) -> c_int;
    //pub fn g_printf_string_upper_bound(format: *const c_char, args: /*Unimplemented*/va_list) -> size_t;
    pub fn g_propagate_error(dest: *mut *mut GError, src: *mut GError);
    pub fn g_propagate_prefixed_error(dest: *mut *mut GError, src: *mut GError, format: *const c_char, ...);
    pub fn g_qsort_with_data(pbase: gconstpointer, total_elems: c_int, size: size_t, compare_func: GCompareDataFunc, user_data: gpointer);
    pub fn g_quark_from_static_string(string: *const c_char) -> GQuark;
    pub fn g_quark_from_string(string: *const c_char) -> GQuark;
    pub fn g_quark_to_string(quark: GQuark) -> *const c_char;
    pub fn g_quark_try_string(string: *const c_char) -> GQuark;
    pub fn g_random_double() -> c_double;
    pub fn g_random_double_range(begin: c_double, end: c_double) -> c_double;
    pub fn g_random_int() -> u32;
    pub fn g_random_int_range(begin: i32, end: i32) -> i32;
    pub fn g_random_set_seed(seed: u32);
    pub fn g_realloc(mem: gpointer, n_bytes: size_t) -> gpointer;
    pub fn g_realloc_n(mem: gpointer, n_blocks: size_t, n_block_bytes: size_t) -> gpointer;
    pub fn g_reload_user_special_dirs_cache();
    pub fn g_return_if_fail_warning(log_domain: *const c_char, pretty_function: *const c_char, expression: *const c_char);
    pub fn g_rmdir(filename: *mut c_char) -> c_int;
    pub fn g_set_application_name(application_name: *const c_char);
    pub fn g_set_error(err: *mut *mut GError, domain: GQuark, code: c_int, format: *const c_char, ...);
    pub fn g_set_error_literal(err: *mut *mut GError, domain: GQuark, code: c_int, message: *const c_char);
    pub fn g_set_prgname(prgname: *const c_char);
    pub fn g_set_print_handler(func: GPrintFunc) -> GPrintFunc;
    pub fn g_set_printerr_handler(func: GPrintFunc) -> GPrintFunc;
    #[cfg(windows)]
    pub fn g_setenv_utf8(variable: *const c_char, value: *const c_char, overwrite: gboolean) -> gboolean;
    pub fn g_setenv(variable: *const c_char, value: *const c_char, overwrite: gboolean) -> gboolean;
    pub fn g_shell_error_quark() -> GQuark;
    pub fn g_shell_parse_argv(command_line: *const c_char, argcp: *mut c_int, argvp: *mut *mut *mut c_char, error: *mut *mut GError) -> gboolean;
    pub fn g_shell_quote(unquoted_string: *const c_char) -> *mut c_char;
    pub fn g_shell_unquote(quoted_string: *const c_char, error: *mut *mut GError) -> *mut c_char;
    pub fn g_slice_alloc(block_size: size_t) -> gpointer;
    pub fn g_slice_alloc0(block_size: size_t) -> gpointer;
    pub fn g_slice_copy(block_size: size_t, mem_block: gconstpointer) -> gpointer;
    pub fn g_slice_free1(block_size: size_t, mem_block: gpointer);
    pub fn g_slice_free_chain_with_offset(block_size: size_t, mem_chain: gpointer, next_offset: size_t);
    pub fn g_slice_get_config(ckey: GSliceConfig) -> i64;
    pub fn g_slice_get_config_state(ckey: GSliceConfig, address: i64, n_values: *mut c_uint) -> *mut i64;
    pub fn g_slice_set_config(ckey: GSliceConfig, value: i64);
    pub fn g_snprintf(string: *mut c_char, n: c_ulong, format: *mut c_char, ...) -> c_int;
    pub fn g_spaced_primes_closest(num: c_uint) -> c_uint;
    #[cfg(windows)]
    pub fn g_spawn_async_utf8(working_directory: *mut c_char, argv: *mut *mut c_char, envp: *mut *mut c_char, flags: GSpawnFlags, child_setup: GSpawnChildSetupFunc, user_data: gpointer, child_pid: *mut GPid, error: *mut *mut GError) -> gboolean;
    pub fn g_spawn_async(working_directory: *mut c_char, argv: *mut *mut c_char, envp: *mut *mut c_char, flags: GSpawnFlags, child_setup: GSpawnChildSetupFunc, user_data: gpointer, child_pid: *mut GPid, error: *mut *mut GError) -> gboolean;
    #[cfg(windows)]
    pub fn g_spawn_async_with_pipes_utf8(working_directory: *mut c_char, argv: *mut *mut c_char, envp: *mut *mut c_char, flags: GSpawnFlags, child_setup: GSpawnChildSetupFunc, user_data: gpointer, child_pid: *mut GPid, standard_input: *mut c_int, standard_output: *mut c_int, standard_error: *mut c_int, error: *mut *mut GError) -> gboolean;
    pub fn g_spawn_async_with_pipes(working_directory: *mut c_char, argv: *mut *mut c_char, envp: *mut *mut c_char, flags: GSpawnFlags, child_setup: GSpawnChildSetupFunc, user_data: gpointer, child_pid: *mut GPid, standard_input: *mut c_int, standard_output: *mut c_int, standard_error: *mut c_int, error: *mut *mut GError) -> gboolean;
    #[cfg(feature = "v2_34")]
    pub fn g_spawn_check_exit_status(exit_status: c_int, error: *mut *mut GError) -> gboolean;
    pub fn g_spawn_close_pid(pid: GPid);
    #[cfg(windows)]
    pub fn g_spawn_command_line_async_utf8(command_line: *const c_char, error: *mut *mut GError) -> gboolean;
    pub fn g_spawn_command_line_async(command_line: *const c_char, error: *mut *mut GError) -> gboolean;
    #[cfg(windows)]
    pub fn g_spawn_command_line_sync_utf8(command_line: *const c_char, standard_output: *mut *mut u8, standard_error: *mut *mut u8, exit_status: *mut c_int, error: *mut *mut GError) -> gboolean;
    pub fn g_spawn_command_line_sync(command_line: *const c_char, standard_output: *mut *mut u8, standard_error: *mut *mut u8, exit_status: *mut c_int, error: *mut *mut GError) -> gboolean;
    pub fn g_spawn_error_quark() -> GQuark;
    pub fn g_spawn_exit_error_quark() -> GQuark;
    #[cfg(windows)]
    pub fn g_spawn_sync_utf8(working_directory: *mut c_char, argv: *mut *mut c_char, envp: *mut *mut c_char, flags: GSpawnFlags, child_setup: GSpawnChildSetupFunc, user_data: gpointer, standard_output: *mut *mut u8, standard_error: *mut *mut u8, exit_status: *mut c_int, error: *mut *mut GError) -> gboolean;
    pub fn g_spawn_sync(working_directory: *mut c_char, argv: *mut *mut c_char, envp: *mut *mut c_char, flags: GSpawnFlags, child_setup: GSpawnChildSetupFunc, user_data: gpointer, standard_output: *mut *mut u8, standard_error: *mut *mut u8, exit_status: *mut c_int, error: *mut *mut GError) -> gboolean;
    pub fn g_sprintf(string: *mut c_char, format: *mut c_char, ...) -> c_int;
    pub fn g_stpcpy(dest: *mut c_char, src: *const c_char) -> *mut c_char;
    pub fn g_str_equal(v1: gconstpointer, v2: gconstpointer) -> gboolean;
    pub fn g_str_has_prefix(str: *const c_char, prefix: *const c_char) -> gboolean;
    pub fn g_str_has_suffix(str: *const c_char, suffix: *const c_char) -> gboolean;
    pub fn g_str_hash(v: gconstpointer) -> c_uint;
    #[cfg(feature = "v2_40")]
    pub fn g_str_is_ascii(str: *const c_char) -> gboolean;
    #[cfg(feature = "v2_40")]
    pub fn g_str_match_string(search_term: *const c_char, potential_hit: *const c_char, accept_alternates: gboolean) -> gboolean;
    #[cfg(feature = "v2_40")]
    pub fn g_str_to_ascii(str: *const c_char, from_locale: *const c_char) -> *mut c_char;
    #[cfg(feature = "v2_40")]
    pub fn g_str_tokenize_and_fold(string: *const c_char, translit_locale: *const c_char, ascii_alternates: *mut *mut *mut c_char) -> *mut *mut c_char;
    pub fn g_strcanon(string: *mut c_char, valid_chars: *const c_char, substitutor: c_char) -> *mut c_char;
    pub fn g_strcasecmp(s1: *const c_char, s2: *const c_char) -> c_int;
    pub fn g_strchomp(string: *mut c_char) -> *mut c_char;
    pub fn g_strchug(string: *mut c_char) -> *mut c_char;
    pub fn g_strcmp0(str1: *const c_char, str2: *const c_char) -> c_int;
    pub fn g_strcompress(source: *const c_char) -> *mut c_char;
    pub fn g_strconcat(string1: *const c_char, ...) -> *mut c_char;
    pub fn g_strdelimit(string: *mut c_char, delimiters: *const c_char, new_delimiter: c_char) -> *mut c_char;
    pub fn g_strdown(string: *mut c_char) -> *mut c_char;
    pub fn g_strdup(str: *const c_char) -> *mut c_char;
    pub fn g_strdup_printf(format: *const c_char, ...) -> *mut c_char;
    //pub fn g_strdup_vprintf(format: *const c_char, args: /*Unimplemented*/va_list) -> *mut c_char;
    pub fn g_strdupv(str_array: *mut *mut c_char) -> *mut *mut c_char;
    pub fn g_strerror(errnum: c_int) -> *const c_char;
    pub fn g_strescape(source: *const c_char, exceptions: *const c_char) -> *mut c_char;
    pub fn g_strfreev(str_array: *mut *mut c_char);
    pub fn g_string_new(init: *const c_char) -> *mut GString;
    pub fn g_string_new_len(init: *const c_char, len: ssize_t) -> *mut GString;
    pub fn g_string_sized_new(dfl_size: size_t) -> *mut GString;
    pub fn g_strip_context(msgid: *const c_char, msgval: *const c_char) -> *const c_char;
    pub fn g_strjoin(separator: *const c_char, ...) -> *mut c_char;
    pub fn g_strjoinv(separator: *const c_char, str_array: *mut *mut c_char) -> *mut c_char;
    pub fn g_strlcat(dest: *mut c_char, src: *const c_char, dest_size: size_t) -> size_t;
    pub fn g_strlcpy(dest: *mut c_char, src: *const c_char, dest_size: size_t) -> size_t;
    pub fn g_strncasecmp(s1: *const c_char, s2: *const c_char, n: c_uint) -> c_int;
    pub fn g_strndup(str: *const c_char, n: size_t) -> *mut c_char;
    pub fn g_strnfill(length: size_t, fill_char: c_char) -> *mut c_char;
    pub fn g_strreverse(string: *mut c_char) -> *mut c_char;
    pub fn g_strrstr(haystack: *const c_char, needle: *const c_char) -> *mut c_char;
    pub fn g_strrstr_len(haystack: *const c_char, haystack_len: ssize_t, needle: *const c_char) -> *mut c_char;
    pub fn g_strsignal(signum: c_int) -> *const c_char;
    pub fn g_strsplit(string: *const c_char, delimiter: *const c_char, max_tokens: c_int) -> *mut *mut c_char;
    pub fn g_strsplit_set(string: *const c_char, delimiters: *const c_char, max_tokens: c_int) -> *mut *mut c_char;
    pub fn g_strstr_len(haystack: *const c_char, haystack_len: ssize_t, needle: *const c_char) -> *mut c_char;
    pub fn g_strtod(nptr: *const c_char, endptr: *mut *mut c_char) -> c_double;
    pub fn g_strup(string: *mut c_char) -> *mut c_char;
    #[cfg(feature = "v2_44")]
    pub fn g_strv_contains(strv: *const *const c_char, str: *const c_char) -> gboolean;
    pub fn g_strv_get_type() -> GType;
    pub fn g_strv_length(str_array: *mut *mut c_char) -> c_uint;
    pub fn g_test_add_data_func(testpath: *const c_char, test_data: gconstpointer, test_func: GTestDataFunc);
    #[cfg(feature = "v2_34")]
    pub fn g_test_add_data_func_full(testpath: *const c_char, test_data: gpointer, test_func: GTestDataFunc, data_free_func: GDestroyNotify);
    pub fn g_test_add_func(testpath: *const c_char, test_func: GTestFunc);
    pub fn g_test_add_vtable(testpath: *const c_char, data_size: size_t, test_data: gconstpointer, data_setup: GTestFixtureFunc, data_test: GTestFixtureFunc, data_teardown: GTestFixtureFunc);
    pub fn g_test_assert_expected_messages_internal(domain: *const c_char, file: *const c_char, line: c_int, func: *const c_char);
    pub fn g_test_bug(bug_uri_snippet: *const c_char);
    pub fn g_test_bug_base(uri_pattern: *const c_char);
    #[cfg(feature = "v2_38")]
    pub fn g_test_build_filename(file_type: GTestFileType, first_path: *const c_char, ...) -> *mut c_char;
    pub fn g_test_create_case(test_name: *const c_char, data_size: size_t, test_data: gconstpointer, data_setup: GTestFixtureFunc, data_test: GTestFixtureFunc, data_teardown: GTestFixtureFunc) -> *mut GTestCase;
    pub fn g_test_create_suite(suite_name: *const c_char) -> *mut GTestSuite;
    #[cfg(feature = "v2_34")]
    pub fn g_test_expect_message(log_domain: *const c_char, log_level: GLogLevelFlags, pattern: *const c_char);
    pub fn g_test_fail();
    #[cfg(feature = "v2_38")]
    pub fn g_test_failed() -> gboolean;
    #[cfg(feature = "v2_38")]
    pub fn g_test_get_dir(file_type: GTestFileType) -> *mut c_char;
    #[cfg(feature = "v2_38")]
    pub fn g_test_get_filename(file_type: GTestFileType, first_path: *const c_char, ...) -> *const c_char;
    pub fn g_test_get_root() -> *mut GTestSuite;
    #[cfg(feature = "v2_38")]
    pub fn g_test_incomplete(msg: *const c_char);
    pub fn g_test_init(argc: *mut c_int, argv: *mut *mut *mut c_char, ...);
    pub fn g_test_log_set_fatal_handler(log_func: GTestLogFatalFunc, user_data: gpointer);
    pub fn g_test_log_type_name(log_type: GTestLogType) -> *const c_char;
    pub fn g_test_maximized_result(maximized_quantity: c_double, format: *const c_char, ...);
    pub fn g_test_message(format: *const c_char, ...);
    pub fn g_test_minimized_result(minimized_quantity: c_double, format: *const c_char, ...);
    pub fn g_test_queue_destroy(destroy_func: GDestroyNotify, destroy_data: gpointer);
    pub fn g_test_queue_free(gfree_pointer: gpointer);
    pub fn g_test_rand_double() -> c_double;
    pub fn g_test_rand_double_range(range_start: c_double, range_end: c_double) -> c_double;
    pub fn g_test_rand_int() -> i32;
    pub fn g_test_rand_int_range(begin: i32, end: i32) -> i32;
    pub fn g_test_run() -> c_int;
    pub fn g_test_run_suite(suite: *mut GTestSuite) -> c_int;
    #[cfg(feature = "v2_38")]
    pub fn g_test_set_nonfatal_assertions();
    #[cfg(feature = "v2_38")]
    pub fn g_test_skip(msg: *const c_char);
    #[cfg(feature = "v2_38")]
    pub fn g_test_subprocess() -> gboolean;
    pub fn g_test_timer_elapsed() -> c_double;
    pub fn g_test_timer_last() -> c_double;
    pub fn g_test_timer_start();
    pub fn g_test_trap_assertions(domain: *const c_char, file: *const c_char, line: c_int, func: *const c_char, assertion_flags: u64, pattern: *const c_char);
    pub fn g_test_trap_fork(usec_timeout: u64, test_trap_flags: GTestTrapFlags) -> gboolean;
    pub fn g_test_trap_has_passed() -> gboolean;
    pub fn g_test_trap_reached_timeout() -> gboolean;
    #[cfg(feature = "v2_38")]
    pub fn g_test_trap_subprocess(test_path: *const c_char, usec_timeout: u64, test_flags: GTestSubprocessFlags);
    pub fn g_timeout_add(interval: c_uint, function: GSourceFunc, data: gpointer) -> c_uint;
    pub fn g_timeout_add_full(priority: c_int, interval: c_uint, function: GSourceFunc, data: gpointer, notify: GDestroyNotify) -> c_uint;
    pub fn g_timeout_add_seconds(interval: c_uint, function: GSourceFunc, data: gpointer) -> c_uint;
    pub fn g_timeout_add_seconds_full(priority: c_int, interval: c_uint, function: GSourceFunc, data: gpointer, notify: GDestroyNotify) -> c_uint;
    pub fn g_timeout_source_new(interval: c_uint) -> *mut GSource;
    pub fn g_timeout_source_new_seconds(interval: c_uint) -> *mut GSource;
    pub fn g_try_malloc(n_bytes: size_t) -> gpointer;
    pub fn g_try_malloc0(n_bytes: size_t) -> gpointer;
    pub fn g_try_malloc0_n(n_blocks: size_t, n_block_bytes: size_t) -> gpointer;
    pub fn g_try_malloc_n(n_blocks: size_t, n_block_bytes: size_t) -> gpointer;
    pub fn g_try_realloc(mem: gpointer, n_bytes: size_t) -> gpointer;
    pub fn g_try_realloc_n(mem: gpointer, n_blocks: size_t, n_block_bytes: size_t) -> gpointer;
    pub fn g_ucs4_to_utf16(str: *const u32, len: c_long, items_read: *mut c_long, items_written: *mut c_long, error: *mut *mut GError) -> *mut u16;
    pub fn g_ucs4_to_utf8(str: *const u32, len: c_long, items_read: *mut c_long, items_written: *mut c_long, error: *mut *mut GError) -> *mut c_char;
    pub fn g_unichar_break_type(c: u32) -> GUnicodeBreakType;
    pub fn g_unichar_combining_class(uc: u32) -> c_int;
    pub fn g_unichar_compose(a: u32, b: u32, ch: *mut u32) -> gboolean;
    pub fn g_unichar_decompose(ch: u32, a: *mut u32, b: *mut u32) -> gboolean;
    pub fn g_unichar_digit_value(c: u32) -> c_int;
    pub fn g_unichar_fully_decompose(ch: u32, compat: gboolean, result: *mut u32, result_len: size_t) -> size_t;
    pub fn g_unichar_get_mirror_char(ch: u32, mirrored_ch: *mut u32) -> gboolean;
    pub fn g_unichar_get_script(ch: u32) -> GUnicodeScript;
    pub fn g_unichar_isalnum(c: u32) -> gboolean;
    pub fn g_unichar_isalpha(c: u32) -> gboolean;
    pub fn g_unichar_iscntrl(c: u32) -> gboolean;
    pub fn g_unichar_isdefined(c: u32) -> gboolean;
    pub fn g_unichar_isdigit(c: u32) -> gboolean;
    pub fn g_unichar_isgraph(c: u32) -> gboolean;
    pub fn g_unichar_islower(c: u32) -> gboolean;
    pub fn g_unichar_ismark(c: u32) -> gboolean;
    pub fn g_unichar_isprint(c: u32) -> gboolean;
    pub fn g_unichar_ispunct(c: u32) -> gboolean;
    pub fn g_unichar_isspace(c: u32) -> gboolean;
    pub fn g_unichar_istitle(c: u32) -> gboolean;
    pub fn g_unichar_isupper(c: u32) -> gboolean;
    pub fn g_unichar_iswide(c: u32) -> gboolean;
    pub fn g_unichar_iswide_cjk(c: u32) -> gboolean;
    pub fn g_unichar_isxdigit(c: u32) -> gboolean;
    pub fn g_unichar_iszerowidth(c: u32) -> gboolean;
    pub fn g_unichar_to_utf8(c: u32, outbuf: *mut c_char) -> c_int;
    pub fn g_unichar_tolower(c: u32) -> u32;
    pub fn g_unichar_totitle(c: u32) -> u32;
    pub fn g_unichar_toupper(c: u32) -> u32;
    pub fn g_unichar_type(c: u32) -> GUnicodeType;
    pub fn g_unichar_validate(ch: u32) -> gboolean;
    pub fn g_unichar_xdigit_value(c: u32) -> c_int;
    pub fn g_unicode_canonical_decomposition(ch: u32, result_len: *mut size_t) -> *mut u32;
    pub fn g_unicode_canonical_ordering(string: *mut u32, len: size_t);
    pub fn g_unicode_script_from_iso15924(iso15924: u32) -> GUnicodeScript;
    pub fn g_unicode_script_to_iso15924(script: GUnicodeScript) -> u32;
    pub fn g_unix_error_quark() -> GQuark;
    #[cfg(feature = "v2_36")]
    pub fn g_unix_fd_add(fd: c_int, condition: GIOCondition, function: GUnixFDSourceFunc, user_data: gpointer) -> c_uint;
    #[cfg(feature = "v2_36")]
    pub fn g_unix_fd_add_full(priority: c_int, fd: c_int, condition: GIOCondition, function: GUnixFDSourceFunc, user_data: gpointer, notify: GDestroyNotify) -> c_uint;
    #[cfg(feature = "v2_36")]
    pub fn g_unix_fd_source_new(fd: c_int, condition: GIOCondition) -> *mut GSource;
    pub fn g_unix_open_pipe(fds: *mut c_int, flags: c_int, error: *mut *mut GError) -> gboolean;
    pub fn g_unix_set_fd_nonblocking(fd: c_int, nonblock: gboolean, error: *mut *mut GError) -> gboolean;
    pub fn g_unix_signal_add(signum: c_int, handler: GSourceFunc, user_data: gpointer) -> c_uint;
    pub fn g_unix_signal_add_full(priority: c_int, signum: c_int, handler: GSourceFunc, user_data: gpointer, notify: GDestroyNotify) -> c_uint;
    pub fn g_unix_signal_source_new(signum: c_int) -> *mut GSource;
    pub fn g_unlink(filename: *mut c_char) -> c_int;
    #[cfg(windows)]
    pub fn g_unsetenv_utf8(variable: *const c_char);
    pub fn g_unsetenv(variable: *const c_char);
    pub fn g_uri_escape_string(unescaped: *const c_char, reserved_chars_allowed: *const c_char, allow_utf8: gboolean) -> *mut c_char;
    pub fn g_uri_list_extract_uris(uri_list: *const c_char) -> *mut *mut c_char;
    pub fn g_uri_parse_scheme(uri: *const c_char) -> *mut c_char;
    pub fn g_uri_unescape_segment(escaped_string: *const c_char, escaped_string_end: *const c_char, illegal_characters: *const c_char) -> *mut c_char;
    pub fn g_uri_unescape_string(escaped_string: *const c_char, illegal_characters: *const c_char) -> *mut c_char;
    pub fn g_usleep(microseconds: c_ulong);
    pub fn g_utf16_to_ucs4(str: *const u16, len: c_long, items_read: *mut c_long, items_written: *mut c_long, error: *mut *mut GError) -> *mut u32;
    pub fn g_utf16_to_utf8(str: *const u16, len: c_long, items_read: *mut c_long, items_written: *mut c_long, error: *mut *mut GError) -> *mut c_char;
    pub fn g_utf8_casefold(str: *const c_char, len: ssize_t) -> *mut c_char;
    pub fn g_utf8_collate(str1: *const c_char, str2: *const c_char) -> c_int;
    pub fn g_utf8_collate_key(str: *const c_char, len: ssize_t) -> *mut c_char;
    pub fn g_utf8_collate_key_for_filename(str: *const c_char, len: ssize_t) -> *mut c_char;
    pub fn g_utf8_find_next_char(p: *const c_char, end: *const c_char) -> *mut c_char;
    pub fn g_utf8_find_prev_char(str: *const c_char, p: *const c_char) -> *mut c_char;
    pub fn g_utf8_get_char(p: *const c_char) -> u32;
    pub fn g_utf8_get_char_validated(p: *const c_char, max_len: ssize_t) -> u32;
    pub fn g_utf8_normalize(str: *const c_char, len: ssize_t, mode: GNormalizeMode) -> *mut c_char;
    pub fn g_utf8_offset_to_pointer(str: *const c_char, offset: c_long) -> *mut c_char;
    pub fn g_utf8_pointer_to_offset(str: *const c_char, pos: *const c_char) -> c_long;
    pub fn g_utf8_prev_char(p: *const c_char) -> *mut c_char;
    pub fn g_utf8_strchr(p: *const c_char, len: ssize_t, c: u32) -> *mut c_char;
    pub fn g_utf8_strdown(str: *const c_char, len: ssize_t) -> *mut c_char;
    pub fn g_utf8_strlen(p: *const c_char, max: ssize_t) -> c_long;
    pub fn g_utf8_strncpy(dest: *mut c_char, src: *const c_char, n: size_t) -> *mut c_char;
    pub fn g_utf8_strrchr(p: *const c_char, len: ssize_t, c: u32) -> *mut c_char;
    pub fn g_utf8_strreverse(str: *const c_char, len: ssize_t) -> *mut c_char;
    pub fn g_utf8_strup(str: *const c_char, len: ssize_t) -> *mut c_char;
    pub fn g_utf8_substring(str: *const c_char, start_pos: c_long, end_pos: c_long) -> *mut c_char;
    pub fn g_utf8_to_ucs4(str: *const c_char, len: c_long, items_read: *mut c_long, items_written: *mut c_long, error: *mut *mut GError) -> *mut u32;
    pub fn g_utf8_to_ucs4_fast(str: *const c_char, len: c_long, items_written: *mut c_long) -> *mut u32;
    pub fn g_utf8_to_utf16(str: *const c_char, len: c_long, items_read: *mut c_long, items_written: *mut c_long, error: *mut *mut GError) -> *mut u16;
    pub fn g_utf8_validate(str: *mut u8, max_len: ssize_t, end: *mut *const c_char) -> gboolean;
    pub fn g_variant_get_gtype() -> GType;
    //pub fn g_vasprintf(string: *mut *mut c_char, format: *mut c_char, args: /*Unimplemented*/va_list) -> c_int;
    //pub fn g_vfprintf(file: *mut FILE, format: *mut c_char, args: /*Unimplemented*/va_list) -> c_int;
    //pub fn g_vprintf(format: *mut c_char, args: /*Unimplemented*/va_list) -> c_int;
    //pub fn g_vsnprintf(string: *mut c_char, n: c_ulong, format: *mut c_char, args: /*Unimplemented*/va_list) -> c_int;
    //pub fn g_vsprintf(string: *mut c_char, format: *mut c_char, args: /*Unimplemented*/va_list) -> c_int;
    pub fn g_warn_message(domain: *const c_char, file: *const c_char, line: c_int, func: *const c_char, warnexpr: *const c_char);

}